diff -r 6ca72c0fe49a -r a941bc465d9f PECengine/ListLibrary2/AttrListSrc/CPEngAttributeListManager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/PECengine/ListLibrary2/AttrListSrc/CPEngAttributeListManager.cpp Wed Sep 01 12:31:13 2010 +0100 @@ -0,0 +1,939 @@ +/* +* Copyright (c) 2005 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: Attribute list manager +* +*/ + +// INCLUDE FILES +#include +#include "CPEngAttributeListManager.h" +#include "CPEngAttributeListItem.h" +#include "CPEngAttributeListModel.h" + +#include "PEngListLibTools.h" + +#include "MPEngStorageManager.h" +#include "PEngStorageGlobals.h" +#include "PEngStorageManager.h" +#include "MPEngListLibFactory.h" +#include "CPEngSessionSlotId.h" + +#include "PEngAttrLibFactory.h" +#include "MPEngPresenceAttrManager.h" + + +// CONSTANTS +// flag of the default attribute list + 3 counts, of 3 arrays +const TInt KIntEntrySize( 16 ); + +// storage ID of the attribute lists +_LIT( KAttributeListsStoreID, "AttributeListsStore" ); + +//Default granurality for ID lists +const TInt KAttributeListIdGranurality = 3; + +const TInt KWVIDMaxSize = 50; + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::CPEngAttributeListManager() +// ----------------------------------------------------------------------------- +// +CPEngAttributeListManager::CPEngAttributeListManager( + MPEngListLibFactory& aFactory ) + : CPEngStoreEntry( EPEngMixedPermanentVersionCon ), + iAccessCount( 1 ), // init count to 1 + iFactory( aFactory ), + iAttributeLists( KAttributeListIdGranurality ), + iDeleteAttrListContactIDs( KAttributeListIdGranurality ), + iDeleteAttrListContactLists( KAttributeListIdGranurality ), + iDeleteDefaultAttrList( EFalse ) + { + iSize = KIntEntrySize; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::ConstructL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::ConstructL( + const CPEngSessionSlotId& aSessionSlot ) + { + iSessionId = aSessionSlot.CloneL(); + MPEngStorageManager* storageManager = + PEngStorageManager::GetStorageManagerL( *iSessionId ); + CleanupClosePushL( *storageManager ); + CPEngStoreEntry::BaseConstructL( *storageManager ); + CleanupStack::PopAndDestroy(); + + iAttributeManager = PEngAttrLibFactory::AttributeManagerInstanceL( + *iSessionId ); + iStorageManager->RetrieveL( *this ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::NewL() +// ----------------------------------------------------------------------------- +// +CPEngAttributeListManager* CPEngAttributeListManager::NewL( + MPEngListLibFactory& aFactory, + const CPEngSessionSlotId& aSessionSlot ) + { + CPEngAttributeListManager* self = NewLC( aFactory, aSessionSlot ); + CleanupStack::Pop(); + return self; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::NewLC() +// ----------------------------------------------------------------------------- +// +CPEngAttributeListManager* CPEngAttributeListManager::NewLC( + MPEngListLibFactory& aFactory, + const CPEngSessionSlotId& aSessionSlot ) + { + CPEngAttributeListManager* self = + new( ELeave ) CPEngAttributeListManager( aFactory ); + + CleanupClosePushL( *self ); + self->ConstructL( aSessionSlot ); + + return self; + } + + +// Destructor +CPEngAttributeListManager::~CPEngAttributeListManager() + { + delete iSessionId; + if ( iAttributeManager ) + { + iAttributeManager->Close(); + } + + iAttributeLists.ResetAndDestroy(); + iDeleteAttrListContactIDs.Reset(); + iDeleteAttrListContactLists.Reset(); + } + + + +// ============================================================================= +// =============== From MPEngAttributeListManager ============================== +// ============================================================================= + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::SessionId() +// ----------------------------------------------------------------------------- +// +const CPEngSessionSlotId& CPEngAttributeListManager::SessionId() const + { + return *iSessionId; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::Open() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::Open() + { + iAccessCount++; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::Close() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::Close() + { + iAccessCount--; + if ( iAccessCount == 0 ) + { + iFactory.RemoveAttrListManager( this ); + delete this; + } + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::CreateEmptyAttributeListL() +// ----------------------------------------------------------------------------- +// +MPEngAttributeList2* CPEngAttributeListManager::CreateEmptyAttributeListL() + { + return CPEngAttributeListModel::NewL( iAttributeManager ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::GetDefaultAttributeListL() +// ----------------------------------------------------------------------------- +// +MPEngAttributeList2* CPEngAttributeListManager::GetDefaultAttributeListL( + TPEngAttributeListsSet2 aAttrListsSet ) + { + switch ( aAttrListsSet ) + { + case EPEngNetworkAttributeLists: + { + TInt index ( FindCurrentDefaultAttributeList() ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + // get list of attributes and create model with it + return CPEngAttributeListModel::NewL( iAttributeManager, + iAttributeLists[index]->PresenceAttributes() ); + } + + case EPEngLocalAttributeLists: + { + TInt index ( FindNewDefaultAttributeList() ); + if ( index == KErrNotFound ) + { + index = FindCurrentDefaultAttributeList(); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + } + + // get list of attributes and create model with it + return CPEngAttributeListModel::NewL( iAttributeManager, + iAttributeLists[index]->PresenceAttributes() ); + } + default: + { + User::Leave( KErrNotSupported ); + break; + } + } + + + // just for compiler + return NULL; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::SetAsDefaultAttributeListL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::SetAsDefaultAttributeListL( + MPEngAttributeList2& aAttrList ) + { + // set delete default attribute list to EFalse + iDeleteDefaultAttrList = EFalse; + CPEngAttributeListModel* model = + static_cast< CPEngAttributeListModel* >( &aAttrList ); + // first check if there is not any new default flag already and remove it + TInt index ( FindNewDefaultAttributeList() ); + if ( index != KErrNotFound ) + { + // set new default to zero and if attribute lists is no more needed + // delete it (0 == zero contacts in attr list) + if ( 0 == iAttributeLists[ index ]->SetNewDefault( EFalse ) ) + { + // attr. list empty delete it + iSize -= iAttributeLists[ index ]->SizeOfEntry(); + delete iAttributeLists[ index ]; + iAttributeLists.Remove( index ); + } + } + + // now find new one and set it, if it does not exist, create it + index = FindAttributeList( model->PresenceAttributes() ); + if ( index != KErrNotFound ) + { + // check if it is not already default, if not then set flag for new + // otherwise there is no need to do anything + if ( !iAttributeLists[ index ]->CurrentlyDefault() ) + { + // it exists, just set the flag + iAttributeLists[ index ]->SetNewDefault( ETrue ); + } + } + else + { + // it does not exist, create it and insert it in the array + // with parameter new Default on + CPEngAttributeListItem* newListItem = + CPEngAttributeListItem::NewLC( model->PresenceAttributes() ); + + // set it as new Default + newListItem->SetNewDefault( ETrue ); + iAttributeLists.AppendL( newListItem ); + CleanupStack::Pop(); // newListItem + iSize += newListItem->SizeOfEntry() ; + } + + + // store changes + StoreChangesL(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::DeleteDefaultAttributeListL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::DeleteDefaultAttributeListL() + { + // check if there is somewhere new default attribute list + TInt err ( FindNewDefaultAttributeList() ); + if ( err != KErrNotFound ) + { + // set new default to zero and if attribute lists is no more needed + // delete it (0 == zero contacts in attr list) + if ( 0 == iAttributeLists[ err ]->SetNewDefault( EFalse ) ) + { + // attr. list empty delete it + delete iAttributeLists[ err ]; + iAttributeLists.Remove( err ); + } + } + + // set flag to delete default attr list + iDeleteDefaultAttrList = ETrue; + StoreChangesL(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::GetAttributeListForUserL() +// ----------------------------------------------------------------------------- +// +MPEngAttributeList2* CPEngAttributeListManager::GetAttributeListForUserL( + const TDesC& aContactId, + TPEngAttributeListsSet2 aAttrListsSet ) + { + return GetAttributeListForContactL( + aContactId, + aAttrListsSet, + CPEngAttributeListItem::ECurrentContactIDs, + CPEngAttributeListItem::ENewContactIDs ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::GetAttributeListForContactListL() +// ----------------------------------------------------------------------------- +// +MPEngAttributeList2* CPEngAttributeListManager::GetAttributeListForContactListL( + const TDesC& aContactList, + TPEngAttributeListsSet2 aAttrListsSet ) + { + return GetAttributeListForContactL( + aContactList, + aAttrListsSet, + CPEngAttributeListItem::ECurrentContactLists, + CPEngAttributeListItem::ENewContactLists ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::AttachAttributeListToUserL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::AttachAttributeListToUserL( + const TDesC& aContactId, + MPEngAttributeList2& aList ) + { + AttachAttributeListToContactL( + aContactId, + aList, + CPEngAttributeListItem::ECurrentContactIDs, + CPEngAttributeListItem::ENewContactIDs, + iDeleteAttrListContactIDs ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::AttachAttributeListToContactListL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::AttachAttributeListToContactListL( + const TDesC& aContactList, + MPEngAttributeList2& aList ) + { + AttachAttributeListToContactL( + aContactList, + aList, + CPEngAttributeListItem::ECurrentContactLists, + CPEngAttributeListItem::ENewContactLists, + iDeleteAttrListContactLists ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::DeleteAttributeListFromUserL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::DeleteAttributeListFromUserL( + const TDesC& aContactId ) + { + DeleteAttributeListFromContactL( + aContactId, + CPEngAttributeListItem::ENewContactIDs, + iDeleteAttrListContactIDs ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::DeleteAttributeListFromContactListL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::DeleteAttributeListFromContactListL( + const TDesC& aContactList ) + { + DeleteAttributeListFromContactL( + aContactList, + CPEngAttributeListItem::ENewContactLists, + iDeleteAttrListContactLists ); + } + + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::ExternalizeL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::ExternalizeL( RWriteStream& aStream, + TPEngStorageType aStorageType ) const + { + if ( !( aStorageType & StorageType() ) ) + { + User::Leave( KErrGeneral ); + } + + // write delete default list flag + aStream.WriteInt32L( iDeleteDefaultAttrList ); + aStream.WriteInt32L( iSynchronized ); + + + // externalize list of to be delete wv IDs's attribute lists + TInt count ( iDeleteAttrListContactIDs.Count() ); + aStream.WriteInt32L( count ); + for ( TInt i( 0 ) ; i < count ; i++ ) + { + aStream << iDeleteAttrListContactIDs.MdcaPoint( i ); + } + + + // externalize list of to be deleted contact lists's attribute lists + count = iDeleteAttrListContactLists.Count(); + aStream.WriteInt32L( count ); + for ( TInt ii( 0 ) ; ii < count ; ii++ ) + { + aStream << iDeleteAttrListContactLists.MdcaPoint( ii ); + } + + + // externalize attribute lists + count = iAttributeLists.Count(); + aStream.WriteInt32L( count ); + for ( TInt x ( 0 ) ; x < count ; x++ ) + { + iAttributeLists[x]->ExternalizeL( aStream ); + } + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::InternalizeL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::InternalizeL( RReadStream& aStream, + TPEngStorageType aStorageType ) + { + if ( !( aStorageType & StorageType() ) ) + { + User::Leave( KErrGeneral ); + } + + + iSize = KIntEntrySize; + iDeleteDefaultAttrList = aStream.ReadInt32L(); + + // read synchronize flag + // member value isn't updated from stored data + // ==> full sync is performed each time when attribute lists + // are used for the first time during the session + // (if member variable would be updated from persisted data, sync would hapen + // only when atttribute lists are updated for the first time to account.) + aStream.ReadInt32L(); + + + // internalize list of to be delete wv IDs's attribute lists + TInt count ( aStream.ReadInt32L() ); + iDeleteAttrListContactIDs.Reset(); + for ( TInt i( 0 ) ; i < count ; i++ ) + { + // use max size as double of KWVIDMaxSize + HBufC16* newContact = HBufC16::NewLC( aStream, 2 * KWVIDMaxSize ); + iDeleteAttrListContactIDs.InsertIsqL( *newContact, ECmpFolded ); + iSize += newContact->Size(); + CleanupStack::PopAndDestroy(); // newContact + } + + + // internalize list of to be deleted contact lists's attribute lists + count = aStream.ReadInt32L(); + iDeleteAttrListContactLists.Reset(); + for ( TInt ii( 0 ) ; ii < count ; ii++ ) + { + // use max size as double of KWVIDMaxSize + HBufC16* newContact = HBufC16::NewLC( aStream, 2 * KWVIDMaxSize ); + iDeleteAttrListContactLists.InsertIsqL( *newContact, ECmpFolded ); + iSize += newContact->Size(); + CleanupStack::PopAndDestroy(); // newContact + } + + // reset array of the lists + iAttributeLists.ResetAndDestroy(); + + + // first read number of the Attribute lists + count = aStream.ReadInt32L(); + for ( TInt x ( 0 ) ; x < count ; x++ ) + { + CPEngAttributeListItem* newLists = + CPEngAttributeListItem::NewLC( aStream ); + iAttributeLists.AppendL( newLists ); + CleanupStack::Pop(); // newLists + iSize += newLists->SizeOfEntry(); + } + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::StorageId() +// ----------------------------------------------------------------------------- +// +const TDesC& CPEngAttributeListManager::StorageId() const + { + return KAttributeListsStoreID; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::EntrySize() +// ----------------------------------------------------------------------------- +// +TUint32 CPEngAttributeListManager::EntrySize() const + { + return iSize; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::HandleSIDsChangeL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::HandleSIDsChangeL( + CPtrCArray& /* aChangedSIDs */ ) + { + iStorageManager->RetrieveL( *this ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::HandleSIDNotifyError() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::HandleSIDNotifyError( + TInt /* aError */ ) + { + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindAttributeList() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindAttributeList( + const RArray& aAttributeList ) const + { + + // go through all attribute lists and look for the same attribute list + TInt count ( iAttributeLists.Count() ); + for ( TInt x ( 0 ) ; x < count ; x++ ) + { + if ( CompareAttributeLists( iAttributeLists[x]->PresenceAttributes() , + aAttributeList ) ) + { + // Lists of presence attributes matches, return index of + // the Attribute List Item + return x; + } + } + + // no list of attributes which matches was found + return KErrNotFound; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindCurrentDefaultAttributeList() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindCurrentDefaultAttributeList() const + { + return FindDefaultAttrList( &CPEngAttributeListItem::CurrentlyDefault ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindNewDefaultAttributeList() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindNewDefaultAttributeList() const + { + return FindDefaultAttrList( &CPEngAttributeListItem::NewDefault ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::StoreChangesL() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::StoreChangesL() + { + TRAPD( err, iStorageManager->StoreL( *this ) ); + if ( err == KErrAccessDenied ) + { + CPtrCArray* arr = NULL; + HandleSIDsChangeL( *arr ); + } + User::LeaveIfError( err ); + return err; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::CompareAttributeLists() +// ----------------------------------------------------------------------------- +// +TBool CPEngAttributeListManager::CompareAttributeLists( + const RArray& aListA , + const RArray& aListB ) const + { + TInt count( aListA.Count() ); + if ( count != aListB.Count() ) + { + // they do not even have same count of the presence attributes so + // they cannot be same + return EFalse; + } + + // array are in order without duplicates, so we can easily go through + for ( TInt x( 0 ) ; x < count ; x++ ) + { + if ( aListA[x] != aListB[x] ) + { + // do not match -> Attribute lists are not same + return EFalse; + } + } + + // it went all fine, then Attribute lists are same + return ETrue; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindItemInArray() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindItemInArray( const CDesCArray& aArray, + const TDesC& aItem ) const + { + TInt position( 0 ); + if ( aArray.FindIsq( aItem, position, ECmpFolded ) == KErrNone ) + { + return position; + } + + return KErrNotFound; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindContactInAttrLists() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindContactInAttrLists( + const TDesC& aContact, + CPEngAttributeListItem::TPEngAttrListItemArrays aArray ) const + { + // go through all attribute lists and look for the contact in Current ones + TInt count ( iAttributeLists.Count() ); + for ( TInt x ( 0 ) ; x < count ; x++ ) + { + if ( KErrNotFound != FindItemInArray( + iAttributeLists[x]->ArrayOfContacts( aArray ), + aContact ) ) + { + // contact was found, return index + return x; + } + } + + // contact was not found in any of the lists + return KErrNotFound; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::FindDefaultAttrList() +// ----------------------------------------------------------------------------- +// +TInt CPEngAttributeListManager::FindDefaultAttrList( + ItemDefaultSet aDefaultSetCall ) const + { + TInt count ( iAttributeLists.Count() ); + for ( TInt x ( 0 ) ; x < count ; x++ ) + { + if ( ( iAttributeLists[x]->*aDefaultSetCall )() ) + { + return x; + } + } + + // no default list + return KErrNotFound; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::GetAttributeListForContactL() +// ----------------------------------------------------------------------------- +// +MPEngAttributeList2* CPEngAttributeListManager::GetAttributeListForContactL( + const TDesC& aContact, + TPEngAttributeListsSet2 aAttrListsSet, + CPEngAttributeListItem::TPEngAttrListItemArrays aArrayCurrent, + CPEngAttributeListItem::TPEngAttrListItemArrays aArrayNew ) + { + switch ( aAttrListsSet ) + { + case EPEngNetworkAttributeLists: + { + TInt index( FindContactInAttrLists( aContact, aArrayCurrent ) ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + // get list of attributes and create model with it + return CPEngAttributeListModel::NewL( + iAttributeManager, + iAttributeLists[index]->PresenceAttributes() ); + } + + + case EPEngLocalAttributeLists: + { + TInt index( FindContactInAttrLists( aContact, aArrayNew ) ); + if ( index == KErrNotFound ) + { + //try to have a look in the published ones + index = FindContactInAttrLists( aContact, aArrayCurrent ); + if ( index == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + } + + // get list of attributes and create model with it + return CPEngAttributeListModel::NewL( + iAttributeManager, + iAttributeLists[index]->PresenceAttributes() ); + } + + default: + { + User::Leave( KErrNotSupported ); + break; + } + } + + // just for compiler + return NULL; + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::AttachAttributeListToContactL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::AttachAttributeListToContactL( + const TDesC& aContact, + MPEngAttributeList2& aList, + CPEngAttributeListItem::TPEngAttrListItemArrays aArrayCurrent, + CPEngAttributeListItem::TPEngAttrListItemArrays aArrayNew, + CDesCArray& aToDeleteContacts ) + { + TBool need2Store( EFalse ); + CPEngAttributeListModel* model = + static_cast< CPEngAttributeListModel* >( &aList ); + + // If defined contact is defined for some other Attribute list, + // it can be ignored, since WV server will remove that connection + // and link it to the new attribute list what has to be checked + // it that contact is not in new part of any attribute lists + // and as well delete part, form there it has to be deleted + + // first look in the new contacts of the attribute list + TInt index( FindContactInAttrLists( aContact, aArrayNew ) ); + if ( index != KErrNotFound ) + { + need2Store = ETrue; + // it was found in new, remove it from there + TInt count ( iAttributeLists[index]->DeleteContactFromList( aContact, + aArrayNew ) ); + + // check if there is still some contact in this attribute list, + // if not delete it + if ( count == 0 ) + { + // delete attribute list + iSize -= iAttributeLists[ index ]->SizeOfEntry(); + delete iAttributeLists[ index ]; + iAttributeLists.Remove( index ); + } + } + + // now look in delete contacts of the attribute list + index = FindItemInArray( aToDeleteContacts, aContact ); + if ( index != KErrNotFound ) + { + need2Store = ETrue; + // it was found in delete ones, remove it, it won't be neccesarry + aToDeleteContacts.Delete( index ); + iSize -= aContact.Size(); + } + + + // now find if list of attributes already somewhere exists + TInt listIndex ( FindAttributeList( model->PresenceAttributes() ) ); + if ( listIndex != KErrNotFound ) + { + // attribute list already exists, check current + // if it does not exists already, if not add it to the new ones + + if ( KErrNotFound != FindItemInArray( + iAttributeLists[listIndex]->ArrayOfContacts( aArrayCurrent ), + aContact ) ) + { + // contact is in current, no sense to do anything, + if ( need2Store ) + { + User::LeaveIfError( StoreChangesL() ); + } + return; + } + else + { + // not in current, add it to the new contact lists + iAttributeLists[ listIndex ]->AddContactToListL( aContact, + aArrayNew ); + iSize += aContact.Size(); + } + + // now store changes to the store in any case + User::LeaveIfError( StoreChangesL() ); + return; + } + + + // Attribute lists does not exist, create it + CPEngAttributeListItem* newListItem = CPEngAttributeListItem::NewLC( + model->PresenceAttributes() ); + + // add contact to the new ones and append it to the array + newListItem->AddContactToListL( aContact, aArrayNew ); + iAttributeLists.AppendL( newListItem ); + iSize += newListItem->SizeOfEntry() ; + CleanupStack::Pop(); // newListItem + User::LeaveIfError( StoreChangesL() ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAttributeListManager::DeleteAttributeListFromContactL() +// ----------------------------------------------------------------------------- +// +void CPEngAttributeListManager::DeleteAttributeListFromContactL( + const TDesC& aContact, + CPEngAttributeListItem::TPEngAttrListItemArrays aArrayNew, + CDesCArray& aToDeleteContacts ) + { + // there is now check if contact is in current, does not matter, + // just try if it is in new, and delete if from there and add it to the + // delete contacts queue + TInt indexNew ( FindContactInAttrLists( aContact, aArrayNew ) ); + if ( indexNew != KErrNotFound ) + { + TInt count ( iAttributeLists[indexNew]->DeleteContactFromList( aContact, + aArrayNew ) ); + // check if there is still some contact in this attribute list, + // if not delete it + if ( count == 0 ) + { + // delete attribute list, it's empty + iSize -= iAttributeLists[ indexNew ]->SizeOfEntry(); + delete iAttributeLists[ indexNew ]; + iAttributeLists.Remove( indexNew ); + } + } + + // now add contact to the delete contact lists queue, + // if it's already there silently ignore + TRAPD( e, aToDeleteContacts.InsertIsqL( aContact, ECmpFolded ) ); + iSize += aContact.Size(); + NListLibTools::LeaveIfMajorErrorL( e ); + User::LeaveIfError( StoreChangesL() ); + } + +// End of File + + + + + + + + + + + + + + + + + + + + +