diff -r 000000000000 -r e686773b3f54 logsui/logsserviceextension/src/clogspresencetablemanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/logsui/logsserviceextension/src/clogspresencetablemanager.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,779 @@ +/* +* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Used to collect various presence related information for the +* extension. +* +*/ + + + +// INCLUDE FILES +#include "clogspresencetablemanager.h" +#include "clogspresenceindextableentry.h" +#include "clogspresencestatustableentry.h" +#include "clogsextlogidpresidmapping.h" +#include "MLogsEventGetter.h" +#include "logsextconsts.h" +#include "MLogsModel.h" +#include "simpledebug.h" + +// --------------------------------------------------------------------------- +// NewL +// --------------------------------------------------------------------------- +// +CLogsPresenceTableManager* CLogsPresenceTableManager::NewL() + { + CLogsPresenceTableManager* self = CLogsPresenceTableManager::NewLC(); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------------------------- +// NewLC +// --------------------------------------------------------------------------- +// +CLogsPresenceTableManager* CLogsPresenceTableManager::NewLC() + { + CLogsPresenceTableManager* self = new( ELeave ) CLogsPresenceTableManager; + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CLogsPresenceTableManager::~CLogsPresenceTableManager() + { + _LOG("CLogsPresenceTableManager::~CLogsPresenceTableManager: begin") + + iPresenceStatusTable.ResetAndDestroy(); + iPresenceIndexTable.ResetAndDestroy(); + iLogIdPresIdMappingArray.ResetAndDestroy(); + + _LOG("CLogsPresenceTableManager::~CLogsPresenceTableManager: end") + } + + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::ConstructL() + { + _LOG("CLogsPresenceTableManager::ConstructL(): begin") + _LOG("CLogsPresenceTableManager::ConstructL(): end") + } + + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CLogsPresenceTableManager::CLogsPresenceTableManager(): + iPresenceStatusTable( KPresenceTableManagerGranularity ), + iPresenceIndexTable( KPresenceTableManagerGranularity ), + iLogIdPresIdMappingArray( KLogIdPresIdMappingArrayGranularity ) + { + _LOG("CLogsPresenceTableManager::CLogsPresenceTableManager(): begin") + _LOG("CLogsPresenceTableManager::CLogsPresenceTableManager(): end") + } + + + +// --------------------------------------------------------------------------- +// Gets the index of a certain icon in the listbox's icon array. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::GetIndex( + const TUint32 aServiceId, + const TDesC& aPresentityId, + TInt& aIndex ) + { + _LOG("CLogsPresenceTableManager::GetIndex: begin") + TInt error( KErrNotFound ); + + TDesC* status = GetStatusFromStatusTable( aServiceId, aPresentityId ); + + if ( status ) + { + TInt index( KErrNotFound ); + error = GetIndexFromIndexTable( aServiceId, *status, index ); + + if ( KErrNone == error ) + { + if ( index >= 0 ) + { + aIndex = index; + error = KErrNone; + } + else + { + error = KErrNotFound; + } + } + else if ( KErrNotFound == error ) + { + error = KErrNotReady; + } + } + + _LOGP("CLogsPresenceTableManager::GetIndex: end (error==%d)",error) + + return error; + } + +// --------------------------------------------------------------------------- +// Gets the index of a certain icon in the listbox's icon array from the +// index table. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::GetIndexFromIndexTable( + const TUint32 aServiceId, + const TDesC& aPresenceStatusString, + TInt& aIndex ) + { + _LOG("CLogsPresenceTableManager::GetIndexFromIndexTable: begin") + TInt error( KErrNotFound ); + + for ( TInt i( 0 ); i < IndexTableEntriesCount(); i++ ) + { + CLogsPresenceIndexTableEntry* entry = iPresenceIndexTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresenceStatusString() == aPresenceStatusString ) + { + aIndex = entry->PresenceIconIndex(); + error = KErrNone; + } + } + + _LOGP("CLogsPresenceTableManager::GetIndexFromIndexTable: end (error=%d)", + error) + + return error; + } + +// --------------------------------------------------------------------------- +// Gets the status of a status entry from the status table. +// --------------------------------------------------------------------------- +// +TDesC* CLogsPresenceTableManager::GetStatusFromStatusTable( + const TUint32 aServiceId, + const TDesC& aPresentityId ) + { + _LOG("CLogsPresenceTableManager::GetStatusFromStatusTable: begin") + + TDesC* presenceStatus = NULL; + + _LOGP("CLogsPresenceTableManager::GetStatusFromStatusTable: count=%d", + StatusTableEntriesCount()) + TBool found( EFalse ); + for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ ) + { + CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i]; + _LOGP("CLogsPresenceTableManager::GetStatusFromStatusTable: i=%d",i) + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresentityId() == aPresentityId + && entry->DisplayPresence() + && entry->PresenceStatusString() ) + { + _LOG("CLogsPresenceTableManager::GetStatusFromStatusTable:...") + _LOGPP("...INSIDE IF i=%d presenceString=%S", + i , entry->PresenceStatusString() ) + + presenceStatus = entry->PresenceStatusString(); + found = ETrue; + } + } + + return presenceStatus; + } + + +// --------------------------------------------------------------------------- +// Creates a new CLogsStatusTableEntry object and adds it to the manager's +// status table (which is iPresenceStatusTable). Before adding an entry to +// the table it is checked whether the entry already exists in the table +// to avoid duplicates. Entries with the same service id and presentity id +// are considered to be duplicates. +// Note: Since the presence status might not being known when adding the +// entry it is possible to leave it unspecified. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::AddEntryToStatusTable( + const TUint32 aServiceId, + const TDesC& aPresentityId, + TBool aShowStatus ) + { + _LOG("CLogsPresenceTableManager::AddEntryToStatusTable: begin") + TInt error( KErrNotFound ); + + // if entry does not exist -> create it. + if ( !StatusEntryExists( aServiceId, aPresentityId ) ) + { + CLogsPresenceStatusTableEntry* entry = NULL; + TRAP( error, entry = + CLogsPresenceStatusTableEntry::NewL( + aServiceId, + aPresentityId, + aShowStatus ); ); + + if ( KErrNone == error ) + { + error = iPresenceStatusTable.Append( entry ); + if ( KErrNone != error ) + { + delete entry; + entry = NULL; + error = KErrNoMemory; + } + } + } + // if entry already exists -> dont create it again. + else + { + //entry exists already + error = KErrAlreadyExists; + } + + _LOGP("CLogsPresenceTableManager::AddEntryToStatusTable: end (error=%d)", + error ) + return error; + } + + + +// --------------------------------------------------------------------------- +// Creates a new CLogsIndexTableEntry object and adds it to the manager's +// index table (which is iPresenceIndexTable). Before adding an entry to +// the table it is checked whether the entry already exists in the table +// to avoid duplicates. Entries with the same service id and presence +// status are considered to be duplicates. +// Note: Since the index might not being known when adding the +// entry it is possible to leave it unspecified. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::AddEntryToIndexTable( + const TUint32 aServiceId, + const TDesC& aPresenceStatusString ) + { + _LOGP("CLogsPresenceTableManager::AddEntryToIndexTable: aServiceId=%d", + aServiceId ) + + TInt error( KErrNotFound ); + + // if entry does not exist -> create it. + TBool entryexists( ETrue ); + entryexists = IndexEntryExists( aServiceId, aPresenceStatusString ); + if ( !entryexists ) + { + CLogsPresenceIndexTableEntry* entry = NULL; + TRAP( error, + entry = CLogsPresenceIndexTableEntry::NewL( aServiceId, + aPresenceStatusString ) ); + if ( KErrNone == error ) + { + error = iPresenceIndexTable.Append( entry ); + if ( KErrNone != error ) + { + delete entry; + entry = NULL; + error = KErrNoMemory; + } + } + } + // if entry already exists -> dont create it again. + else + { + //entry exists already + error = KErrAlreadyExists; + } + + _LOGP("CLogsPresenceTableManager::AddEntryToIndexTable: end (error==%d)", + error) + return error; + } + + +// --------------------------------------------------------------------------- +// Check whether the presence icon index is available or not. +// --------------------------------------------------------------------------- +// +TBool CLogsPresenceTableManager::PresenceIconIndexAvailable( + const TUint32 aServiceId, + const TDesC& aPresentityId ) + { + _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: begin") + TBool IsIndexAvailable( EFalse ); + + TInt index( KErrNotFound ); + TInt error ( GetIndex( aServiceId, aPresentityId, index ) ); + + switch( error ) + { + case KErrNone: + { + if ( index >= 0 ) + { + IsIndexAvailable = ETrue; + } + break; + } + case KErrNotReady: + case KErrNotFound: + default: + { + IsIndexAvailable = EFalse; + } + } + + if ( IsIndexAvailable ) + { + _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: end...") + _LOG("... PresenceIndex => available") + } + + else + { + _LOG("CLogsPresenceTableManager::PresenceIconIndexAvailable: end...") + _LOG("... PresenceIndex => NOT available") + } + + + + return IsIndexAvailable; + } + + +// --------------------------------------------------------------------------- +// Sets the status of a certain status entry of the status table. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::SetStatusInStatusTable( + const TUint32 aServiceId, + const TDesC& aPresentityId, + const TDesC& aPresenceStatusString, + TBool aShowStatus ) + { + _LOG("CLogsPresenceTableManager::SetStatusInStatusTable: begin") + TInt error( KErrGeneral ); + TBool found( EFalse ); + + for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ ) + { + CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresentityId() == aPresentityId ) + { + found = ETrue; + entry->SetDisplayPresence( aShowStatus ); + error = entry->SetPresenceStatusString( aPresenceStatusString ); + } + } + + _LOGP("CLogsPresenceTableManager::SetStatusInStatusTable: end (error=%d)", + error) + return error; + } + + +// --------------------------------------------------------------------------- +// Sets the status of a certain status entry of the status table to the +// initial value. Presense status is not displayed. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::UpdateStatusTableEntry( + const TUint32 aServiceId, + const TDesC& aPresentityId, + TBool aShowStatus ) + { + _LOG("CLogsPresenceTableManager::ResetStatusTableEntry: begin") + TInt error( KErrNotFound ); + TBool found( EFalse ); + + for ( TInt i( 0 ); !found && i < StatusTableEntriesCount(); i++ ) + { + CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresentityId() == aPresentityId ) + { + entry->SetDisplayPresence( aShowStatus ); + found = ETrue; + error = KErrNone; + } + } + + _LOGP("CLogsPresenceTableManager::ResetStatusTableEntry: end (error==%d)", + error) + return error; + } + + +// --------------------------------------------------------------------------- +// Sets the status of all status entries of the status table to the initial +// value. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::ResetStatusTableEntries() + { + _LOG("CLogsPresenceTableManager::ResetStatusTableEntries: begin") + + for ( TInt i( 0 ); i < StatusTableEntriesCount(); i++ ) + { + CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i]; + if ( entry ) + { + entry->ResetPresenceStatusString(); + entry->SetDisplayPresence( EFalse ); + } + } + + _LOG("CLogsPresenceTableManager::ResetStatusTableEntries: end") + } + +// --------------------------------------------------------------------------- +// Sets the presence icon index values to initial values. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::ResetState() + { + _LOG("CLogsPresenceTableManager::ResetIndexTableEntries: begin") + iPresenceIndexTable.ResetAndDestroy(); + iPresenceStatusTable.ResetAndDestroy(); + iLogIdPresIdMappingArray.ResetAndDestroy(); + _LOG("CLogsPresenceTableManager::ResetIndexTableEntries: end") + } + + +// --------------------------------------------------------------------------- +// Sets the index of a certain index entry of the index table. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::SetIndexInIndexTable( + const TUint32 aServiceId, + const TDesC& aPresenceStatusString, + const TInt aIndex ) + { + _LOG("CLogsPresenceTableManager::SetIndexInIndexTable: begin") + TInt error( KErrGeneral ); + TBool found( EFalse ); + + for ( TInt i( 0 ); !found && i < IndexTableEntriesCount() ; i++ ) + { + CLogsPresenceIndexTableEntry* entry = iPresenceIndexTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresenceStatusString() == aPresenceStatusString ) + { + found = ETrue; + error = entry->SetPresenceIconIndex( aIndex ); + } + } + + _LOGP("CLogsPresenceTableManager::SetIndexInIndexTable: end (error==%d)", + error) + return error; + } + +// --------------------------------------------------------------------------- +// Checks the existance of a status entry with the specified arguments. +// --------------------------------------------------------------------------- +// +TBool CLogsPresenceTableManager::StatusEntryExists( + const TUint32 aServiceId, + const TDesC& aPresentityId ) + { + _LOG("CLogsPresenceTableManager::StatusEntryExists: begin") + TBool exists( EFalse ); + + for ( TInt i( 0 ); !exists && i < StatusTableEntriesCount(); i++ ) + { + CLogsPresenceStatusTableEntry* entry = iPresenceStatusTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresentityId() == aPresentityId ) + { + _LOG("CLogsPresenceTableManager::StatusEntryExists: entry exists") + exists = ETrue; + } + } + + _LOG("CLogsPresenceTableManager::StatusEntryExists: end") + return exists; + } + + +// --------------------------------------------------------------------------- +// Checks the existance of a index entry with the specified arguments. +// --------------------------------------------------------------------------- +// +TBool CLogsPresenceTableManager::IndexEntryExists( + const TUint32 aServiceId, + const TDesC& aPresenceStatus ) + { + _LOG("CLogsPresenceTableManager::IndexEntryExists: begin") + TBool exists( EFalse ); + + for ( TInt i( 0 ); !exists && i < IndexTableEntriesCount() ; i++ ) + { + CLogsPresenceIndexTableEntry* entry = iPresenceIndexTable[i]; + if ( entry + && entry->ServiceId() == aServiceId + && entry->PresenceStatusString() == aPresenceStatus ) + { + _LOG("CLogsPresenceTableManager::IndexEntryExists: entry exists") + exists = ETrue; + } + } + + _LOG("CLogsPresenceTableManager::IndexEntryExists: end") + return exists; + } + + +// --------------------------------------------------------------------------- +// Returns the number of entries in the status table. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::StatusTableEntriesCount() + { + _LOGP("CLogsPresenceTableManager::StatusTableEntriesCount(): count=%d", + iPresenceStatusTable.Count()) + return iPresenceStatusTable.Count(); + } + + +// --------------------------------------------------------------------------- +// Returns the number of entries in the index table. +// --------------------------------------------------------------------------- +// +TInt CLogsPresenceTableManager::IndexTableEntriesCount() + { + _LOGP("CLogsPresenceTableManager::IndexTableEntriesCount()=%d", + iPresenceIndexTable.Count()) + return iPresenceIndexTable.Count(); + } + + +// --------------------------------------------------------------------------- +// Adds a mapping (Log Id is mapped to a presentity id). +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::AddMappingL( const TLogId aLogId, + const TDesC& aPresentityId ) + { + _LOG("CLogsPresenceTableManager::AddMappingL(): begin") + + // if a mapping for aLogId already exists and the two pres ids of both + // mappings are different, only then update the existing mapping with the + // new pres id + + const TDesC* presId = NULL; + presId = RetrievePresentityId( aLogId ); + + if ( presId && ( *presId != aPresentityId ) ) //update mapping + { + _LOG("CLogsPresenceTableManager::AddMappingL():...") + _LOG("... update existing mapping") + UpdateMappingL( aLogId, aPresentityId ); + } + else if( !presId ) // add mapping + { + _LOG("CLogsPresenceTableManager::AddMappingL(): create new mapping") + AppendMappingL( aLogId, aPresentityId ); + } + + _LOGP("CLogsPresenceTableManager::RetrievePresentityId(): #mappings=%d", + iLogIdPresIdMappingArray.Count() ) + + _LOG("CLogsPresenceTableManager::AddMappingL(): end") + } + + +// --------------------------------------------------------------------------- +// Updates the presentity id an existing mapping. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::UpdateMappingL( const TLogId aLogId, + const TDesC& aPresentityId ) + { + _LOG("CLogsPresenceTableManager::UpdateMappingL(): begin") + + // delete the mapping with aLogId + TBool mappingFound( EFalse ); + CLogsExtLogIdPresIdMapping* mapping = NULL; + for ( TInt i( 0 ); + i < iLogIdPresIdMappingArray.Count() && !mappingFound; + i++ ) + { + mapping = iLogIdPresIdMappingArray[i]; + if ( mapping && ( mapping->LogId() == aLogId ) ) + { + delete mapping; + mapping = NULL; + iLogIdPresIdMappingArray.Remove( i ); + mappingFound = ETrue; + } + } + iLogIdPresIdMappingArray.Compress(); + + // create a new mapping + AppendMappingL( aLogId, aPresentityId ); + + _LOG("CLogsPresenceTableManager::UpdateMappingL(): end") + } + + +// --------------------------------------------------------------------------- +// Creates a new mapping with the specified arguments. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::AppendMappingL( const TLogId aLogId, + const TDesC& aPresentitytId ) + { + _LOG("CLogsPresenceTableManager::AppendMappingL(): begin") + + CLogsExtLogIdPresIdMapping* mapping = + CLogsExtLogIdPresIdMapping::NewLC( aLogId, aPresentitytId ); + iLogIdPresIdMappingArray.AppendL( mapping ); + CleanupStack::Pop( mapping ); + + _LOG("CLogsPresenceTableManager::AppendMappingL(): end") + } + + + +// --------------------------------------------------------------------------- +// Returns the presentity id of a mapping using the log id to retrieve the +// mapping. +// --------------------------------------------------------------------------- +// +const TDesC* CLogsPresenceTableManager::RetrievePresentityId( + const TLogId aLogId ) + { + _LOG("CLogsPresenceTableManager::RetrievePresentityId(): begin") + + const TDesC* result = NULL; + CLogsExtLogIdPresIdMapping* mapping = NULL; + for ( TInt i( 0 ); i < iLogIdPresIdMappingArray.Count(); i++ ) + { + mapping = iLogIdPresIdMappingArray[i]; + if ( mapping && ( mapping->LogId() == aLogId ) ) + { + result = mapping->PresentityId(); + } + } + + _LOG("CLogsPresenceTableManager::RetrievePresentityId(): end") + return result; + } + + +// --------------------------------------------------------------------------- +// Removes unnecessary mappings by comparing the log ids of the current +// view to the log ids in the array of mappings. Those mappings which +// contain a log id that cannot be found from 'aModel' will be deleted. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::RemoveUnneededMappings( MLogsModel& aModel ) + { + _LOG("CLogsPresenceTableManager::RemoveUnneededMappings(): begin") + + CLogsExtLogIdPresIdMapping* mapping = NULL; + _LOG("CLogsPresenceTableManager::RemoveUnneededMappings():...") + _LOGP("... #mappingsBeforeCleanup=%d",iLogIdPresIdMappingArray.Count() ) + + for ( TInt i( 0 ); i < iLogIdPresIdMappingArray.Count(); i++ ) + { + mapping = iLogIdPresIdMappingArray[i]; + if ( mapping && !IsLogIdInMappingArray( aModel, mapping->LogId() ) ) + { + RemoveMapping( mapping->LogId() ); + } + } + + _LOG("CLogsPresenceTableManager::RemoveUnneededMappings():...") + _LOGP("... #mappingsAfterCleanup=%d",iLogIdPresIdMappingArray.Count() ) + + _LOG("CLogsPresenceTableManager::RemoveUnneededMappings(): end") + } + + +// --------------------------------------------------------------------------- +// Checks if one of the log events in 'aModel' has the same LogId as the one +// that is specified. +// --------------------------------------------------------------------------- +// +TBool CLogsPresenceTableManager::IsLogIdInMappingArray( MLogsModel& aModel, + TLogId aLogId ) + { + _LOG("CLogsPresenceTableManager::IsLogIdInMappingArray(): begin") + + TBool isLogIdInMappingArray( EFalse ); + TBool found( EFalse ); + + for ( TInt i( 0 ); i < aModel.Count() && !found; i++ ) + { + if ( aModel.At( i ) && aLogId == aModel.At( i )->LogId() ) + { + isLogIdInMappingArray = ETrue; + found = ETrue; + } + } + + _LOG("CLogsPresenceTableManager::IsLogIdInMappingArray(): end") + return isLogIdInMappingArray; + } + + +// --------------------------------------------------------------------------- +// Removes a mapping from the array that contains the pointer of all the +// mappings. This includes the deletion of the object whose pointer was +// stored in the mapping array. +// --------------------------------------------------------------------------- +// +void CLogsPresenceTableManager::RemoveMapping( TLogId aLogId ) + { + _LOG("CLogsPresenceTableManager::RemoveMapping(): begin ") + + _LOG("CLogsPresenceTableManager::RemoveMapping(): remove mapping...") + _LOGP("... with logId=%d", aLogId ) + + CLogsExtLogIdPresIdMapping* mapping = NULL; + TBool deleted( EFalse ); + for ( TInt i( 0 ); i < iLogIdPresIdMappingArray.Count(); i++ ) + { + mapping = iLogIdPresIdMappingArray[i]; + if ( mapping && ( mapping->LogId() == aLogId ) && !deleted ) + { + iLogIdPresIdMappingArray.Remove( i ); + iLogIdPresIdMappingArray.Compress(); + delete mapping; + mapping = NULL; + deleted = ETrue; + _LOG("CLogsPresenceTableManager::RemoveMapping(): mapping...") + _LOGP("... with logId=%d deleted from mapping array", aLogId ) + } + } + + _LOG("CLogsPresenceTableManager::RemoveMapping(): end") + } + +