1 /*

     2 * Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Storage manager implementation

    15  *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "CCAStorageManager.h"

    21 #include "CCAStorage.h"

    22 #include "CCARefreshTimer.h"

    23 #include "CCAContactList.h"

    24 #include "CCAGroup.h"

    25 #include "CCAContact.h"

    26 #include "CCAContactSorter.h"

    27 

    28 #include "CAUtils.h"

    29 

    30 #include "ChatDebugPrint.h"

    31 #include "chatdebugassert.h"

    32 

    33 #include <PEngPresenceEngineConsts2.h> // for KPEngUserOwnPresenceId

    34 

    35 // CONSTANTS

    36 // Own device type, default to mobile

    37 const TStorageManagerGlobals::TClientType KOwnDeviceType =

    38     TStorageManagerGlobals::EMobile;

    39 

    40 // ============================ MEMBER FUNCTIONS ===============================

    41 

    42 

    43 // -----------------------------------------------------------------------------

    44 // CCAStorageManager::InstanceL

    45 // Factory method to return the singleton instance of this class,

    46 // used by CCAStorageManagerFactory

    47 // -----------------------------------------------------------------------------

    48 //

    49 CCAStorageManager* CCAStorageManager::InstanceL()

    50     {

    51     CCAStorageManager *sm = NULL;

    52     sm = static_cast<CCAStorageManager*>( Dll::Tls() );

    53     if ( ! sm )

    54         {

    55         // no existing instance, create a new one

    56         CCAStorageManager *manager = CCAStorageManager::NewL();

    57         sm = manager;

    58         CleanupStack::PushL( manager );

    59         User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( sm ) ) );

    60         CleanupStack::Pop( manager );

    61         }

    62 

    63     return sm;

    64     }

    65 

    66 // -----------------------------------------------------------------------------

    67 // CCAStorageManager::ReleaseL

    68 // Factory method to release the singleton instance of this class,

    69 // -----------------------------------------------------------------------------

    70 //

    71 TInt CCAStorageManager::ReleaseL()

    72     {

    73     // about to unload, so kill the singleton instance

    74     if ( Dll::Tls() )

    75         {

    76         CCAStorageManager *storage = NULL;

    77         storage = static_cast<CCAStorageManager*>( Dll::Tls() );

    78         if ( storage )

    79             {

    80             delete storage;

    81             storage = NULL;

    82             }

    83         }

    84     // Ignore error

    85     Dll::SetTls( NULL );

    86     return KErrNone;

    87     }

    88 

    89 // panic handler

    90 GLDEF_C void Panic( TCAStoragePanics aPanic )

    91     {

    92     User::Panic( KChatStoragePanicString, aPanic );

    93     }

    94 

    95 // -----------------------------------------------------------------------------

    96 // CCAStorageManager::CCAStorageManager

    97 // C++ default constructor can NOT contain any code, that

    98 // might leave.

    99 // -----------------------------------------------------------------------------

   100 //

   101 CCAStorageManager::CCAStorageManager() :

   102         iNotifyUponSave( ETrue ),

   103         iRefreshStartCounter( 0 ),

   104         iShowNickname( ETrue ),

   105         iGroupDeleted( EFalse )

   106     {

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CCAStorageManager::ConstructL

   111 // Symbian 2nd phase constructor can leave.

   112 // The constructor also does synchronizing with Phone Book by removing the

   113 // deleted elements from the persistent storage

   114 // -----------------------------------------------------------------------------

   115 //

   116 void CCAStorageManager::ConstructL()

   117     {

   118     CHAT_DP_TXT( "CCAStorageManager::ConstructL" );

   119     CHAT_DP_TXT( "CCAStorageManager::Creating Storage" );

   120     iStorage = CCAStorage::NewL();

   121 

   122     iRefreshTimer = CCARefreshTimer::NewL( this );

   123 

   124     // create sorter for contacts

   125     iContactSorter = CCAContactSorter::NewL();

   126 

   127     // handle Groups

   128     CHAT_DP_TXT( "CCAStorageManager::ConstructL - Synching group data with \

   129                   persistent storage" );

   130     SynchronizeGroupsL();

   131 

   132     iOwnStatus = CCAContact::NewL( this, this );

   133     iOwnStatus->SetClientType( KOwnDeviceType );

   134 

   135     CHAT_DP_TXT( "CCAStorageManager::ConstructL - Done" );

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CCAStorageManager::SynchronizeGroups

   140 // -----------------------------------------------------------------------------

   141 //

   142 void CCAStorageManager::SynchronizeGroupsL()

   143     {

   144     // read the groups, if any

   145     TBool fetching( ETrue );

   146     for ( TInt i = 0; fetching ; i++ )

   147         {

   148         CCAGroup* group = CCAGroup::NewL( iStorage, this );

   149         CleanupStack::PushL( group );

   150 

   151         TInt storStatus( KErrNone );

   152         TInt err( KErrNone );

   153 

   154         if ( 0 == i )

   155             {

   156             // first iteration

   157             CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Loading \

   158                           first group" );

   159             // Load Leaves if storage has no more groups

   160             TRAP( err, storStatus = iStorage->LoadFirstL( group ) );

   161             }

   162         else

   163             {

   164             // subsequent iterations

   165             CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Loading next \

   166                           group" );

   167             // Load Leaves if storage has no more groups

   168             TRAP( err, storStatus = iStorage->LoadNextL( group ) );

   169             }

   170 

   171         if ( ( KErrNotFound == storStatus ) || ( KErrNone != err ) )

   172             {

   173             // no more groups, that's all

   174             CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - No groups in \

   175                           persistent storage" );

   176             fetching = EFalse;

   177             }

   178         else

   179             {

   180             // found some group, add to our list

   181             CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Found group, \

   182                           adding to list" );

   183 

   184             // valid group, add to our list

   185             group->SetStorageType( TStorageManagerGlobals::EStoragePersistent );

   186             TInt status = iGroupList.Append( group );

   187             User::LeaveIfError( status );

   188             }

   189 

   190         if ( fetching == EFalse )

   191             {

   192             // all done

   193             CleanupStack::PopAndDestroy( group ); // group

   194             }

   195         else

   196             {

   197             // going to next iteration

   198             CleanupStack::Pop( group ); // group

   199             }

   200         }

   201 

   202     CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Done" );

   203     }

   204 

   205 // -----------------------------------------------------------------------------

   206 // CCAStorageManager::NewL

   207 // Two-phased constructor.

   208 // -----------------------------------------------------------------------------

   209 //

   210 EXPORT_C CCAStorageManager* CCAStorageManager::NewL()

   211     {

   212     CCAStorageManager* self = new( ELeave ) CCAStorageManager;

   213     CleanupStack::PushL( self );

   214     self->ConstructL();

   215     CleanupStack::Pop( self );

   216     return self;

   217     }

   218 

   219 // Destructor

   220 CCAStorageManager::~CCAStorageManager()

   221     {

   222     CHAT_DP_TXT( "CCAStorageManager::~CCAStorageManager" );

   223 

   224     delete iRefreshTimer;

   225     delete iLatestContactToRefresh;

   226 

   227     iContactObservers.Reset();

   228     iContactObservers.Close();

   229 

   230     iGroupObservers.Reset();

   231     iGroupObservers.Close();

   232 

   233     iContactList.ResetAndDestroy();

   234     iGroupList.ResetAndDestroy();

   235 

   236     delete iStorage;

   237 

   238     delete iContactSorter;

   239 

   240     delete iOwnStatus;

   241 

   242     CHAT_DP_TXT( "CCAStorageManager::~CCAStorageManager - I am dead" );

   243     }

   244 

   245 // -----------------------------------------------------------------------------

   246 // CCAStorageManager::SendObserverEventL

   247 // If the changed/deleted contact is in our list, the observers are notified.

   248 // Otherwise the observers are not notified.

   249 // -----------------------------------------------------------------------------

   250 void CCAStorageManager::SendObserverEvent(

   251     TStorageManagerGlobals::TCAObserverEventType aType,

   252     MCAStoredContact* aContact,

   253     const TDesC& aContactId,

   254     MCAContactList* aList /*= NULL*/,

   255     TBool aUserIdChanged /*= EFalse*/ )

   256     {

   257     CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL (contact)" );

   258     CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL - Notifying \

   259                   MCAStoredContactsObserver observers" );

   260 

   261     if ( !iContactListLock )

   262         {

   263         switch ( aType )

   264             {

   265             case TStorageManagerGlobals::EStorageEventPostChange: // flowtrough

   266             case TStorageManagerGlobals::EStorageEventOwnStatusChange:

   267                 {

   268                 NotifyAllObserversWithDelay( aType, aContact, aContactId, aList,

   269                                              aUserIdChanged );

   270                 break;

   271                 }

   272             default:

   273                 {

   274                 NotifyAllObservers( aType, aContact, aContactId, aList, aUserIdChanged );

   275                 break;

   276                 }

   277             }

   278         }

   279     }

   280 

   281 // -----------------------------------------------------------------------------

   282 // CCAStorageManager::NotifyAllObservers

   283 // -----------------------------------------------------------------------------

   284 //

   285 void CCAStorageManager::NotifyAllObservers( TStorageManagerGlobals::TCAObserverEventType aType,

   286                                             MCAStoredContact* aContact, const TDesC& aContactId,

   287                                             MCAContactList* aList,

   288                                             TBool aUserIdChanged )

   289     {

   290     CHAT_DP_FUNC_ENTER( "NotifyAllObservers" );

   291 

   292     // tell all of the observers about the event.

   293     // the amount of observers might change during the loop,

   294     // so the count MUST be taken in every round

   295     for ( TInt i = 0; i < iContactObservers.Count(); i++ )

   296         {

   297         MCAStoredContactsObserver* obs = iContactObservers[i];

   298         switch ( aType )

   299             {

   300             case TStorageManagerGlobals::EStorageEventPreChange:

   301             case TStorageManagerGlobals::EStorageEventPostChange:

   302                 {

   303                 obs->HandleChange( aList, aContact, aType, aUserIdChanged );

   304                 break;

   305                 }

   306             case TStorageManagerGlobals::EStorageEventContactDelete:

   307                 {

   308                 obs->HandleContactDelete( aContactId );

   309                 break;

   310                 }

   311             case TStorageManagerGlobals::EStorageEventContactAddition:

   312                 {

   313                 if ( aList )

   314                     {

   315                     obs->HandleAddition( *aList, *aContact );

   316                     }

   317                 break;

   318                 }

   319             case TStorageManagerGlobals::EStorageEventOwnStatusChange:

   320             case TStorageManagerGlobals::EStorageEventMultipleChanges:

   321             case TStorageManagerGlobals::EStorageEventListAddition:

   322             case TStorageManagerGlobals::EStorageEventListDelete:

   323             case TStorageManagerGlobals::EStorageEventListChanged:

   324                 {

   325                 obs->HandleChange( aList, NULL, aType, EFalse );

   326                 break;

   327                 }

   328             default:

   329                 {

   330                 break;

   331                 }

   332             }

   333         }

   334 

   335     CHAT_DP_FUNC_DONE( "NotifyAllObservers" );

   336     }

   337 

   338 // -----------------------------------------------------------------------------

   339 // CCAStorageManager::NotifyAllObserversWithDelay

   340 // -----------------------------------------------------------------------------

   341 //

   342 void CCAStorageManager::NotifyAllObserversWithDelay(

   343     TStorageManagerGlobals::TCAObserverEventType aType,

   344     MCAStoredContact* aContact, const TDesC& aContactId,

   345     MCAContactList* aList,

   346     TBool aUserIdChanged )

   347     {

   348     TRAPD( err, DoNotifyAllObserversWithDelayL( aType, aContact, aContactId,

   349                                                 aList, aUserIdChanged ) );

   350     if ( err )

   351         {

   352         CActiveScheduler::Current()->Error( err );

   353         }

   354     }

   355 

   356 // -----------------------------------------------------------------------------

   357 // CCAStorageManager::DoNotifyAllObserversWithDelayL

   358 // -----------------------------------------------------------------------------

   359 //

   360 void CCAStorageManager::DoNotifyAllObserversWithDelayL(

   361     TStorageManagerGlobals::TCAObserverEventType aType,

   362     MCAStoredContact* /*aContact*/, const TDesC& aContactId,

   363     MCAContactList* aList, TBool aUserIdChanged )

   364     {

   365     HBufC* tmpID = aContactId.AllocL();

   366     delete iLatestContactToRefresh;

   367     iLatestContactToRefresh = tmpID;

   368     iLatestContactList = aList;

   369     tmpID = NULL;

   370     iRefreshEventType = aType;

   371     iRefreshUserIdChanged = aUserIdChanged;

   372     ++iRefreshStartCounter;

   373     if ( iRefreshTimer->IsActive() )

   374         {

   375         iRefreshTimer->Cancel();

   376         }

   377     iRefreshTimer->Start();

   378     }

   379 

   380 // -----------------------------------------------------------------------------

   381 // CCAStorageManager::SendObserverEventL (overridden for group)

   382 // -----------------------------------------------------------------------------

   383 //

   384 void CCAStorageManager::SendObserverEvent(

   385     TStorageManagerGlobals::TCAObserverEventType aType,

   386     const TDesC& aParameter )

   387     {

   388     CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL (group)" );

   389 

   390     TInt pos( FindGroupIndexByGroupId( aParameter ) );

   391     if ( KErrNotFound == pos )

   392         {

   393         return;     // not found in the list

   394         }

   395 

   396     CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL - Notifying \

   397                   MCAStoredGroupsObserver observers" );

   398 

   399     // tell all of the observers about the event

   400     const TInt count( iGroupObservers.Count() );

   401     for ( TInt i = 0; i < count; i++ )

   402         {

   403         MCAStoredGroupsObserver* obs = iGroupObservers[i];

   404 

   405         switch ( aType )

   406             {

   407             case TStorageManagerGlobals::EStorageEventGroupChange:

   408                 {

   409                 obs->HandleChange( aParameter );

   410                 break;

   411                 }

   412 

   413             case TStorageManagerGlobals::EStorageEventContactDelete:

   414                 {

   415                 obs->HandleDelete( aParameter );

   416                 break;

   417                 }

   418 

   419             case TStorageManagerGlobals::EStorageEventContactAddition:

   420                 {

   421                 obs->HandleAddition( aParameter );

   422                 break;

   423                 }

   424             default:

   425                 {

   426                 break;

   427                 }

   428             }

   429         }

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // CCAStorageManager::AddObserverL

   434 // From MCAStoredContacts

   435 // -----------------------------------------------------------------------------

   436 //

   437 void CCAStorageManager::AddObserverL( MCAStoredContactsObserver*

   438                                       aObserver )

   439     {

   440     __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

   441 

   442     TInt status( iContactObservers.Append( aObserver ) );

   443     User::LeaveIfError( status );

   444     }

   445 

   446 // -----------------------------------------------------------------------------

   447 // CCAStorageManager::RemoveObserverL

   448 // From MCAStoredContacts

   449 // -----------------------------------------------------------------------------

   450 void CCAStorageManager::RemoveObserver( MCAStoredContactsObserver*

   451                                         aObserver )

   452     {

   453     __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

   454 

   455     const TInt status( iContactObservers.Find( aObserver ) );

   456     if ( status != KErrNotFound )

   457         {

   458         iContactObservers.Remove( status );

   459         iContactObservers.Compress();

   460         }

   461     }

   462 

   463 // -----------------------------------------------------------------------------

   464 // CCAStorageManager::AddObserverL

   465 // From MCAStoredGroups

   466 // -----------------------------------------------------------------------------

   467 //

   468 void CCAStorageManager::AddObserverL( MCAStoredGroupsObserver*

   469                                       aObserver )

   470     {

   471     __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

   472 

   473     TInt status( iGroupObservers.Append( aObserver ) );

   474     User::LeaveIfError( status );

   475     }

   476 

   477 // -----------------------------------------------------------------------------

   478 // CCAStorageManager::RemoveObserverL

   479 // From MCAStoredGroups

   480 // -----------------------------------------------------------------------------

   481 //

   482 void CCAStorageManager::RemoveObserver( MCAStoredGroupsObserver*

   483                                         aObserver )

   484     {

   485     __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

   486 

   487     const TInt status( iGroupObservers.Find( aObserver ) );

   488     if ( status != KErrNotFound )

   489         {

   490         iGroupObservers.Remove( status );

   491         iGroupObservers.Compress();

   492         }

   493     }

   494 

   495 // -----------------------------------------------------------------------------

   496 // CCAStorageManager::AddContactListIdL

   497 // -----------------------------------------------------------------------------

   498 //

   499 MCAContactList* CCAStorageManager::AddContactListIdL(

   500     const TDesC& aContactListId,

   501     const TDesC& aDisplayName,

   502     TBool aNotify )

   503     {

   504     CCAContactList* contactList = CCAContactList::NewLC( *this,

   505                                                          *iContactSorter,

   506                                                          *this,

   507                                                          aContactListId,

   508                                                          aDisplayName );

   509     TIdentityRelation< CCAContactList > findBy(

   510         CCAStorageManager::ContactListFindByContactId );

   511     TInt indexOfList( iContactList.Find( contactList, findBy ) );

   512     if ( indexOfList == KErrNotFound )

   513         {

   514         TLinearOrder< CCAContactList > order(

   515             CCAStorageManager::ContactListOrderByDisplayName );

   516         iContactList.InsertInOrderAllowRepeats( contactList, order );

   517         CleanupStack::Pop( contactList );

   518         }

   519     else

   520         {

   521         CleanupStack::PopAndDestroy( contactList );

   522         contactList = iContactList[ indexOfList ];

   523         }

   524     // Inform observers

   525     if ( aNotify )

   526         {

   527         SendObserverEvent( TStorageManagerGlobals::EStorageEventListAddition,

   528                            NULL,

   529                            KNullDesC, contactList, EFalse );

   530         }

   531     return contactList;

   532     }

   533 

   534 // -----------------------------------------------------------------------------

   535 // CCAStorageManager::SetContactListCollapsed

   536 // -----------------------------------------------------------------------------

   537 //

   538 void CCAStorageManager::SetContactListCollapsed( const TDesC& aContactListId,

   539                                                  TBool aCollapsed )

   540     {

   541     TInt pos( FindContactListById( aContactListId ) );

   542     if ( pos >= 0 )

   543         {

   544         MCAContactList& list = *iContactList[ pos ];

   545         list.SetCollapsed( aCollapsed );

   546         }

   547     }

   548 

   549 // -----------------------------------------------------------------------------

   550 // CCAStorageManager::RemoveContactList

   551 // -----------------------------------------------------------------------------

   552 //

   553 void CCAStorageManager::RemoveContactList( const TDesC& aContactListId )

   554     {

   555     TInt pos( FindContactListById( aContactListId ) );

   556     if ( pos >= 0 )

   557         {

   558         delete iContactList[ pos ];

   559         iContactList.Remove( pos );

   560         }

   561     }

   562 

   563 // -----------------------------------------------------------------------------

   564 // CCAStorageManager::RemoveContact

   565 // From MCAStoredContacts.

   566 // -----------------------------------------------------------------------------

   567 void CCAStorageManager::RemoveContact( const TDesC& aListId,

   568                                        const TDesC& aContactId )

   569     {

   570     CCAContactList* list = FindContactListInternal( aListId );

   571     if ( list )

   572         {

   573         if ( KErrNone == list->RemoveContact( aContactId ) )

   574             {

   575             SendObserverEvent( TStorageManagerGlobals::EStorageEventContactDelete,

   576                                NULL,

   577                                aContactId );

   578             }

   579         }

   580     }

   581 

   582 // -----------------------------------------------------------------------------

   583 // CCAStorageManager::FindContact

   584 // From MCAStoredContacts.

   585 // Try to load with given ID, return NULL if not found.

   586 // -----------------------------------------------------------------------------

   587 MCAStoredContact* CCAStorageManager::FindContact( const TDesC& aContactListId,

   588                                                   const TDesC& aId )

   589     {

   590     CCAContactList* list = FindContactListInternal( aContactListId );

   591     if ( list )

   592         {

   593         return list->FindContact( aId );

   594         }

   595     CHAT_DP_FUNC_DONE( "CCAStorageManager::FindContact" );

   596     return NULL;

   597     }

   598 

   599 MCAStoredContact* CCAStorageManager::FindContact( const TDesC& aContactListId,

   600                                                   const TDesC& aId,

   601                                                   MCAContactList*& aContactList )

   602     {

   603     CCAContactList* list = FindContactListInternal( aContactListId );

   604     aContactList = list;

   605     if ( list )

   606         {

   607         return list->FindContact( aId );

   608         }

   609     CHAT_DP_FUNC_DONE( "CCAStorageManager::FindContact" );

   610     return NULL;

   611     }

   612 

   613 // -----------------------------------------------------------------------------

   614 // CCAStorageManager::ContactInAnyList

   615 // From MCAStoredContacts.

   616 // -----------------------------------------------------------------------------

   617 TBool CCAStorageManager::ContactInAllLists( const TDesC& aContactId ) const

   618     {

   619     TInt listCount( iContactList.Count() );

   620     for ( TInt a( 0 ); a < listCount; ++a )

   621         {

   622         if ( !iContactList[ a ]->FindContact( aContactId ) )

   623             {

   624             return EFalse;

   625             }

   626         }

   627     return ETrue;

   628     }

   629 

   630 // -----------------------------------------------------------------------------

   631 // CCAStorageManager::FindContact

   632 // From MCAStoredContacts.

   633 // Try to load with given ID, return NULL if not found.

   634 // -----------------------------------------------------------------------------

   635 MCAStoredContact* CCAStorageManager::FindAnyContact( const TDesC& aContactId )

   636     {

   637     if ( aContactId.Compare( KPEngUserOwnPresenceId ) == 0 )

   638         {

   639         return iOwnStatus;

   640         }

   641 

   642     TInt count( iContactList.Count() );

   643     for ( TInt a( 0 ); a < count; ++a )

   644         {

   645         MCAStoredContact* contact = iContactList[ a ]->FindContact( aContactId );

   646         if ( contact )

   647             {

   648             return contact;

   649             }

   650         }

   651     return NULL;

   652     }

   653 

   654 // -----------------------------------------------------------------------------

   655 // CCAStorageManager::FindAnyContactByNick

   656 // From MCAStoredContacts.

   657 // Try to load with given nick, return NULL if not found.

   658 // -----------------------------------------------------------------------------

   659 MCAStoredContact* CCAStorageManager::FindAnyContactByNick( const TDesC& aNick )

   660     {

   661     TInt count( iContactList.Count() );

   662     for ( TInt a( 0 ); a < count; ++a )

   663         {

   664         MCAStoredContact* contact =

   665             iContactList[ a ]->FindContactByNick( aNick );

   666         if ( contact )

   667             {

   668             return contact;

   669             }

   670         }

   671     return NULL;

   672     }

   673 

   674 // -----------------------------------------------------------------------------

   675 // CCAStorageManager::ListCount

   676 // Count of contactlists

   677 // -----------------------------------------------------------------------------

   678 //

   679 TInt CCAStorageManager::ListCount() const

   680     {

   681     return iContactList.Count();

   682     }

   683 

   684 

   685 // -----------------------------------------------------------------------------

   686 // CCAStorageManager::ListAt

   687 // Reference to contact list

   688 // -----------------------------------------------------------------------------

   689 //

   690 MCAContactList& CCAStorageManager::ListAt( TInt aIndex ) const

   691     {

   692 

   693     return *iContactList[ aIndex ];

   694     }

   695 

   696 // -----------------------------------------------------------------------------

   697 // CCAStorageManager::ListAt

   698 // Reference to contact list

   699 // -----------------------------------------------------------------------------

   700 //

   701 void CCAStorageManager::FindContacts( RPointerArray< MCAStoredContact >& aArray,

   702                                       const TDesC& aContactId ) const

   703     {

   704     TInt count( iContactList.Count() );

   705     for ( TInt a( 0 ); a < count; ++a )

   706         {

   707         MCAStoredContact* contact = iContactList[a]->FindContact( aContactId );

   708         if ( contact )

   709             {

   710             TInt err( aArray.Append( contact ) );

   711             if ( err != KErrNone )

   712                 {

   713                 CActiveScheduler::Current()->Error( err );

   714                 return;

   715                 }

   716             }

   717         }

   718     }

   719 

   720 // -----------------------------------------------------------------------------

   721 // CCAStorageManager::ContactCount

   722 // Count of contacts

   723 // -----------------------------------------------------------------------------

   724 //

   725 TInt CCAStorageManager::ContactCount( TBool aSkipOfflineContacts ) const

   726     {

   727     TInt contactCount( 0 );

   728     TInt count( iContactList.Count() );

   729     for ( TInt a( 0 ); a < count; ++a )

   730         {

   731         contactCount += iContactList[ a ]->ContactCount( aSkipOfflineContacts,

   732                                                          EFalse );

   733         }

   734     return contactCount;

   735     }

   736 

   737 // -----------------------------------------------------------------------------

   738 // CCAStorageManager::SetWVHiding

   739 // From MCAStoredContacts

   740 // -----------------------------------------------------------------------------

   741 //

   742 void CCAStorageManager::SetWVHiding( TBool aHiding )

   743     {

   744     iWVHiding = aHiding;

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CCAStorageManager::WVHiding

   749 // From MCAStoredContacts

   750 // -----------------------------------------------------------------------------

   751 //

   752 TBool CCAStorageManager::WVHiding()

   753     {

   754     return iWVHiding;

   755     }

   756 // -----------------------------------------------------------------------------

   757 // CCAStorageManager::SetWVHidingPrefixOnly  UI CR : 101-39728

   758 // From MCAStoredContacts

   759 // -----------------------------------------------------------------------------

   760 //

   761 void CCAStorageManager::SetWVHidingPrefixOnly( TBool aHidingPrefixOnly )

   762     {

   763     iWVHidingPrefixOnly = aHidingPrefixOnly;

   764     }

   765 // -----------------------------------------------------------------------------

   766 // -----------------------------------------------------------------------------

   767 // CCAStorageManager::CapitalizingEnabled  UI CR : 101-39727

   768 // From MCAStoredContacts

   769 // -----------------------------------------------------------------------------

   770 //

   771 void CCAStorageManager::SetCapitalizingEnabled( TBool aCapital )

   772     {

   773     iCapital = aCapital;

   774     }

   775 // CCAStorageManager::WVHidingPrefixOnly    UI CR : 101-39728

   776 // From MCAStoredContacts

   777 // -----------------------------------------------------------------------------

   778 //

   779 TBool CCAStorageManager::WVHidingPrefixOnly()

   780     {

   781     return iWVHidingPrefixOnly;

   782     }

   783 

   784 // -----------------------------------------------------------------------------

   785 // CCAStorageManager::CapitalizingEnabled   UI CR : 101-39727

   786 // From MCAStoredContacts

   787 // -----------------------------------------------------------------------------

   788 //

   789 TBool CCAStorageManager::CapitalizingEnabled()

   790     {

   791     return iCapital;

   792     }

   793 // -----------------------------------------------------------------------------

   794 // CCAStorageManager::CreateGroupL

   795 // From MCAStoredGroups

   796 // -----------------------------------------------------------------------------

   797 //

   798 MCAExtendedStoredGroup* CCAStorageManager::CreateGroupL()

   799     {

   800     CHAT_DP_FUNC_ENTER( "CreateGroupL" );

   801 

   802     if ( ! iStorage )

   803         {

   804         CHAT_DP_FUNC_DP( "CreateGroupL", "No Storage Manager" );

   805         User::Leave( KErrNotReady );

   806         }

   807 

   808     CCAGroup* group = CCAGroup::NewL( iStorage, this );

   809 

   810     // add to our list

   811     TInt status( iGroupList.Append( group ) ); // takes ownership (RPointerArray)

   812     if ( status != KErrNone )

   813         {

   814         delete group;

   815         User::Leave( status );

   816         }

   817 

   818     CHAT_DP_FUNC_DONE( "CreateGroupL" );

   819     return group;

   820     }

   821 

   822 // -----------------------------------------------------------------------------

   823 // CCAStorageManager::DeleteGroup

   824 // From MCAStoredGroups

   825 // -----------------------------------------------------------------------------

   826 //

   827 void CCAStorageManager::DeleteGroupL( MCAStoredGroup* aGroup )

   828     {

   829     CHAT_DP_FUNC_ENTER( "DeleteGroupL" );

   830 

   831     if ( ! iStorage )

   832         {

   833         CHAT_DP_FUNC_DP( "DeleteGroupL", "No Storage Manager" );

   834         User::Leave( KErrNotReady );

   835         }

   836 

   837     const TInt pos( FindGroupIndexByGroupId( aGroup->GroupId() ) );

   838 

   839     if ( KErrNotFound == pos )

   840         {

   841         // not in the list

   842         CHAT_DP_FUNC_DP( "DeleteGroupL", "Group not in the list, not deleting" );

   843         return;

   844         }

   845 

   846     // notify observers BEFORE deleting group

   847     SendObserverEvent( TStorageManagerGlobals::EStorageEventContactDelete,

   848                        aGroup->GroupId() );

   849 

   850     if ( aGroup->StorageType() == TStorageManagerGlobals::EStoragePersistent )

   851         {

   852         // is saved to persistent storage, so we can delete from

   853         // persistent storage

   854         CHAT_DP_FUNC_DP( "DeleteGroupL", "Deleting from persistent storage" );

   855         iStorage->DeleteL( ( MCAExtendedStoredGroup* ) aGroup );

   856         }

   857     // otherwise it's just in the internal list,

   858     // so delete from internal list

   859     CHAT_DP_FUNC_DP( "DeleteGroupL", "Deleting from internal list" );

   860 

   861     delete iGroupList[ pos ];

   862     iGroupList.Remove( pos );

   863     iGroupList.Compress();

   864 

   865     CHAT_DP_FUNC_DONE( "DeleteGroupL" );

   866     }

   867 

   868 // -----------------------------------------------------------------------------

   869 // CCAStorageManager::FindGroup

   870 // From MCAStoredGroups

   871 // -----------------------------------------------------------------------------

   872 //

   873 MCAStoredGroup* CCAStorageManager::FindGroup( const TDesC& aId )

   874     {

   875     const TInt pos( FindGroupIndexByGroupId( aId ) );

   876     return KErrNotFound == pos ? NULL : iGroupList[ pos ];

   877     }

   878 

   879 // -----------------------------------------------------------------------------

   880 // CCAStorageManager::PopulateGroupsList

   881 // From MCAStoredGroups

   882 // -----------------------------------------------------------------------------

   883 //

   884 void CCAStorageManager::PopulateGroupsListL(

   885     RPointerArray<MCAStoredGroup>& aList,

   886     TBool aReturnOnlyVisible )

   887     {

   888     aList.Reset();

   889 

   890     if ( ! iStorage )

   891         {

   892         return;

   893         }

   894 

   895     const TInt count( iGroupList.Count() );

   896     for ( int i = 0; i < count; i++ )

   897         {

   898         if ( aReturnOnlyVisible )

   899             {

   900             if ( iGroupList[ i ]->IsVisible() )

   901                 {

   902                 // only add visible groups

   903                 TInt status( aList.Append( iGroupList[ i ] ) );

   904                 User::LeaveIfError( status );

   905                 }

   906             }

   907         else

   908             {

   909             // add all groups

   910             TInt status( aList.Append( iGroupList[ i ] ) );

   911             User::LeaveIfError( status );

   912             }

   913         }

   914     }

   915 

   916 // -----------------------------------------------------------------------------

   917 // CCAStorageManager::SignalGroupChangedL

   918 // From MCAStoredGroups

   919 // -----------------------------------------------------------------------------

   920 //

   921 void CCAStorageManager::SignalGroupChangedL( const TDesC& aGroupId )

   922     {

   923     SendObserverEvent( TStorageManagerGlobals::EStorageEventGroupChange, aGroupId );

   924     }

   925 

   926 // -----------------------------------------------------------------------------

   927 // CCAStorageManager::SignalGroupAddedL

   928 // From MCAStoredGroups

   929 // -----------------------------------------------------------------------------

   930 //

   931 void CCAStorageManager::SignalGroupAddedL( const TDesC& aGroupId )

   932     {

   933     SendObserverEvent( TStorageManagerGlobals::EStorageEventContactAddition, aGroupId );

   934     }

   935 

   936 // -----------------------------------------------------------------------------

   937 // CCAStorageManager::SaveGroupL

   938 // From MCAStoredGroups

   939 // -----------------------------------------------------------------------------

   940 //

   941 void CCAStorageManager::SaveGroupL( const TDesC& aGroupId )

   942     {

   943     const TInt pos( FindGroupIndexByGroupId( aGroupId ) );

   944 

   945     if ( pos == KErrNotFound )

   946         {

   947         // no such group

   948         User::Leave( KErrNotFound );

   949         }

   950 

   951     iGroupList[ pos ]->SaveChangesL();

   952     SignalGroupAddedL( aGroupId );

   953     }

   954 

   955 // -----------------------------------------------------------------------------

   956 // CCAStorageManager::HideAllGroupsL

   957 // From MCAStoredGroups

   958 // -----------------------------------------------------------------------------

   959 //

   960 void CCAStorageManager::HideAllGroups( TBool aAllGroups /*= EFalse*/ )

   961     {

   962     CHAT_DP_FUNC_ENTER( "HideAllGroups" );

   963 

   964     const TInt count( iGroupList.Count() );

   965     for ( TInt i = 0; i < count; i++ )

   966         {

   967         CCAGroup * group = iGroupList[i];

   968         if ( aAllGroups || group->IsOwnGroup() )

   969             {

   970             // only OWN groups are set to invisible if aAllGroups is EFalse..

   971             group->SetVisible( EFalse );

   972             }

   973         }

   974 

   975     CHAT_DP_FUNC_DONE( "HideAllGroups" );

   976     }

   977 

   978 // -----------------------------------------------------------------------------

   979 // CCAStorageManager::ShowAllGroups

   980 // From MCAStoredGroups

   981 // -----------------------------------------------------------------------------

   982 //

   983 void CCAStorageManager::ShowAllGroups()

   984     {

   985     CHAT_DP_FUNC_ENTER( "ShowAllGroups" );

   986 

   987     const TInt count( iGroupList.Count() );

   988     for ( TInt i = 0; i < count; i++ )

   989         {

   990         CCAGroup * group = iGroupList[i];

   991         // ALL groups are set to visible...

   992         group->SetVisible( ETrue );

   993         }

   994 

   995     CHAT_DP_FUNC_DONE( "ShowAllGroups" );

   996     }

   997 

   998 // -----------------------------------------------------------------------------

   999 // CCAStorageManager::GroupCount

  1000 // From MCAStoredGroups

  1001 // -----------------------------------------------------------------------------

  1002 //

  1003 TInt CCAStorageManager::GroupCount( TBool aOnlyVisible ) const

  1004     {

  1005     if ( ! aOnlyVisible )

  1006         {

  1007         return iGroupList.Count();

  1008         }

  1009 

  1010     // find out number of visible groups

  1011     TInt count = iGroupList.Count();

  1012     TInt grCount = 0;

  1013     for ( TInt i = 0; i < count; i++ )

  1014         {

  1015         grCount += iGroupList[ i ]->IsVisible() ? 1 : 0;

  1016         }

  1017 

  1018     return grCount;

  1019     }

  1020 

  1021 // -----------------------------------------------------------------------------

  1022 // CCAStorageManager::CheckFreespaceLevelL

  1023 // From MCAStoredGroups

  1024 // -----------------------------------------------------------------------------

  1025 //

  1026 void CCAStorageManager::CheckFreespaceLevelL( MCAExtendedStoredGroup* aGroup )

  1027     {

  1028     iStorage->CheckFreespaceLevelL( aGroup );

  1029     }

  1030 

  1031 // -----------------------------------------------------------------------------

  1032 // CCAStorageManager::SetNotifyOnSave

  1033 // From MCAStoredContacts

  1034 // -----------------------------------------------------------------------------

  1035 //

  1036 void CCAStorageManager::SetNotifyOnSave( TBool aStatus )

  1037     {

  1038     iNotifyUponSave = aStatus;

  1039     }

  1040 

  1041 // -----------------------------------------------------------------------------

  1042 // CCAStorageManager::HandleDelete

  1043 // From MCAStoredContactsObserver

  1044 // We know when the contact is deleted, because it happens

  1045 // via Storage Manager, so this method unused.

  1046 // -----------------------------------------------------------------------------

  1047 //

  1048 void CCAStorageManager::HandleContactDelete( const TDesC& /* aContact */ )

  1049     {

  1050     // unused

  1051     }

  1052 

  1053 // -----------------------------------------------------------------------------

  1054 // CCAStorageManager::HandleAddition

  1055 // From MCAStoredContactsObserver

  1056 // We know when the contact is added, because it happens

  1057 // via Storage Manager, so this method unused.

  1058 // -----------------------------------------------------------------------------

  1059 //

  1060 void CCAStorageManager::HandleAddition( MCAContactList& /*aList*/,

  1061                                         MCAStoredContact& /* aContact */ )

  1062     {

  1063     // unused

  1064     }

  1065 

  1066 // -----------------------------------------------------------------------------

  1067 // CCAStorageManager::HandleChange

  1068 // From MCAStoredContactsObserver

  1069 // The contact might be saved via CCAContact::SaveChangesL call,

  1070 // in which case we wouldn't know about it. But this observer

  1071 // call is invoked if the contact was SaveChangesL'd AND there was

  1072 // changed information.

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 void CCAStorageManager::HandleChange( MCAContactList* aList,

  1076                                       MCAStoredContact* aContact,

  1077                                       TStorageManagerGlobals::TCAObserverEventType aEventType,

  1078                                       TBool aUserIdChanged )

  1079     {

  1080     // contact was changed, possibly the contact WVID has changed (which is the

  1081     // key).  keep our lists sorted. we do it by removing the old from the

  1082     // list, then adding it again. it's faster (2*O(logN)) than sorting

  1083     // (O(NlogN)).

  1084     if ( !aContact && !aList )

  1085         {

  1086         return;

  1087         }

  1088 

  1089     if ( iNotifyUponSave )

  1090         {

  1091         // ignore the event type.

  1092         // this is a post-change as it comes directly from the CCAContact

  1093         if ( aContact ) // contact

  1094             {

  1095             NotifyAllObserversWithDelay(

  1096                 TStorageManagerGlobals::EStorageEventPostChange,

  1097                 aContact, aContact->UserId(),

  1098                 NULL, aUserIdChanged );

  1099             }

  1100         else if ( aList )

  1101             {

  1102             NotifyAllObserversWithDelay(

  1103                 aEventType,

  1104                 NULL, KNullDesC,

  1105                 aList, aUserIdChanged );

  1106             }

  1107         else //own status

  1108             {

  1109             NotifyAllObserversWithDelay(

  1110                 TStorageManagerGlobals::EStorageEventOwnStatusChange,

  1111                 NULL, KPEngUserOwnPresenceId,

  1112                 NULL, aUserIdChanged );

  1113             }

  1114         }

  1115     }

  1116 

  1117 // -----------------------------------------------------------------------------

  1118 // CCAStorageManager::HandleBackupRestoreEvent

  1119 // From MCAStoredContactsObserver, MCAStoredGroupsObserver

  1120 // -----------------------------------------------------------------------------

  1121 //

  1122 void CCAStorageManager::HandleBackupRestoreEvent(

  1123     const TStorageManagerGlobals::TCAObserverEventType /* aEventType */ )

  1124     {

  1125     // unused

  1126     }

  1127 

  1128 

  1129 // -----------------------------------------------------------------------------

  1130 // CCAStorageManager::HandleDelete

  1131 // From MCAStoredGroupsObserver

  1132 // All deletions happen via Storage Manager.

  1133 // But group hiding is handled as deletion from UI point of view.

  1134 // -----------------------------------------------------------------------------

  1135 //