--- /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")
+ }
+
+