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 header file

    15 *

    16 */

    17 

    18 

    19 #ifndef CCASTORAGEMANAGER_H

    20 #define CCASTORAGEMANAGER_H

    21 

    22 #include "impsbuilddefinitions.h"

    23 

    24 //  INCLUDES

    25 #include <e32std.h>

    26 #include <f32file.h>

    27 #include <babackup.h>

    28 

    29 #include "MCAStoredContacts.h"

    30 #include "TCAStoragePanics.h"

    31 #include "TStorageManagerGlobals.h"

    32 #include "MCAStoredGroups.h"

    33 #include "MCAStoredContactsObserver.h"

    34 #include "MCAStoredGroupsObserver.h"

    35 #include "MCARefreshTimerObserver.h"

    36 #include "MCAStorageInfo.h"

    37 

    38 // FORWARD DECLARATIONS

    39 class CBaBackupSessionWrapper;

    40 class CCAContactList;

    41 class MCAStoredContactsObserver;

    42 class CCAStorage;

    43 class CCAGroup;

    44 class CCARefreshTimer;

    45 class CCAContactSorter;

    46 

    47 

    48 // CLASS DECLARATION

    49 /**

    50  * Storage Manager.

    51  *

    52  * Note! The following methods do not allow themselves to be called if backup

    53  * is in progress (use MBackupOperationObserver or CBaBackupSessionWrapper).

    54  * In such a case, the methods either leave or return without doing anything.

    55  *

    56  * - AddContactL (both variants)

    57  * - RemoveContactL

    58  * - PopulateContactsList

    59  * - CreateGroupL

    60  * - DeleteGroupL

    61  * - PopulateGroupsList

    62  *

    63  * After the backup has finished, an HandleListInvalidation event is sent to

    64  * observers.

    65  *

    66  * @lib CAStorage.dll

    67  * @since 3.0

    68  */

    69 class CCAStorageManager : public CBase,

    70             public MCAStoredContacts,

    71             public MCAStoredGroups,

    72             public MCAStoredContactsObserver,

    73             public MCAStoredGroupsObserver,

    74             public MCARefreshTimerObserver,

    75             public MCAStorageInfo

    76     {

    77     public:  // Constructors and destructor

    78 

    79         /**

    80          * Two-phased constructor.

    81          */

    82         IMPORT_C static CCAStorageManager* NewL();

    83 

    84         /**

    85          * Destructor.

    86          */

    87         ~CCAStorageManager();

    88 

    89     public: // New functions

    90         /**

    91          * Creates instance of storage

    92          * @return CCAStorageManager pointer

    93          */

    94         static CCAStorageManager* InstanceL();

    95 

    96         /**

    97          * Release instance of storage

    98          * @return KErrNone if released.

    99          */

   100         static TInt ReleaseL();

   101 

   102     public: // Functions from base classes

   103 

   104         /**

   105          * From MCAStoredContacts

   106          */

   107         void AddObserverL( MCAStoredContactsObserver* aObserver );

   108 

   109         /**

   110          * From MCAStoredContacts

   111          */

   112         void RemoveObserver( MCAStoredContactsObserver* aObserver );

   113 

   114         /**

   115          * From MCAStoredContacts

   116          */

   117         MCAContactList* AddContactListIdL( const TDesC& aContactListId,

   118                                            const TDesC& aDisplayName,

   119                                            TBool aNotify = ETrue );

   120 

   121         /**

   122          * From MCAStoredContacts

   123          */

   124         void RemoveContactList( const TDesC& aContactListId );

   125 

   126         /**

   127          * From MCAStoredContacts

   128          */

   129         void SetContactListCollapsed( const TDesC& aContactListId,

   130                                       TBool aCollapsed );

   131 

   132         /**

   133          * From MCAStoredContacts

   134          */

   135         void RemoveContact( const TDesC& aListId, const TDesC& aContactId );

   136 

   137         /**

   138          * From MCAStoredContacts

   139          */

   140         MCAStoredContact* FindContact( const TDesC& aContactListId,

   141                                        const TDesC& aId );

   142 

   143         MCAStoredContact* FindContact( const TDesC& aContactListId,

   144                                        const TDesC& aId,

   145                                        MCAContactList*& aContactList );

   146         /**

   147          * From MCAStoredContacts

   148          */

   149         MCAStoredContact* FindAnyContact( const TDesC& aContactId );

   150 

   151         /**

   152          * From MCAStoredContacts

   153          */

   154         MCAStoredContact* FindAnyContactByNick( const TDesC& aNick );

   155 

   156         /**

   157          * From MCAStoredContacts

   158          */

   159         TInt FindContact( const MCAStoredContact& aContact ) const;

   160 

   161         /**

   162          * From MCAStoredContacts

   163          */

   164         TBool ContactInAllLists( const TDesC& aContactId ) const;

   165 

   166         /**

   167          * From MCAStoredContacts

   168          */

   169         TInt ListCount() const;

   170 

   171         /**

   172          * From MCAStoredContacts

   173          */

   174         MCAContactList& ListAt( TInt aIndex ) const;

   175 

   176         /**

   177          * From MCAStoredContacts

   178          */

   179         void FindContacts( RPointerArray< MCAStoredContact >& aArray,

   180                            const TDesC& aContactId ) const;

   181 

   182         /**

   183          * From MCAStoredContacts

   184          */

   185         TInt ContactCount( TBool aSkipOfflineContacts = EFalse ) const;

   186 

   187         /**

   188          * From MCAStoredContacts

   189          */

   190         void SetWVHiding( TBool aHiding );

   191 

   192         /**

   193          * From MCAStoredContacts

   194          */

   195         TBool WVHiding();

   196         /**

   197          * From MCAStoredContacts

   198          */

   199         void SetWVHidingPrefixOnly( TBool aHidingPrefixOnly ); //  UI CR ID :101-39728: Show domain part of the user ID

   200 

   201 

   202         /**

   203          * From MCAStoredContacts

   204          */

   205         TBool WVHidingPrefixOnly();   // UI CR ID: 101-39728: Show domain part of the user ID

   206 

   207         /**

   208         * From MCAStoredContacts

   209         */

   210         void SetCapitalizingEnabled( TBool aCapital );  // UI CR ID: 101-39727

   211 

   212         /**

   213          * From MCAStoredContacts

   214          */

   215         TBool CapitalizingEnabled();  // UI CR ID: 101-39727

   216 

   217         /**

   218          * From MCAStoredContacts

   219          */

   220         void SetWatched( const TDesC& aContactId, TBool aStatus );

   221 

   222         /**

   223          * From MCAStoredContacts

   224          */

   225         void SetPendingMessages( const TDesC& aContactId, TInt aAmount );

   226 

   227         /**

   228          * From MCAStoredContacts

   229          */

   230         void SetBlocked( const TDesC& aContactId, TBool aStatus );

   231 

   232         /**

   233          * From MCAStoredContacts

   234          */

   235         void SetBlocked( const TDesC& aContactId,

   236                          const TDesC& aListId,

   237                          TBool aStatus );

   238 

   239         /**

   240          * From MCAStoredContacts

   241          */

   242         void Sort( const TDesC& aContactListId = KNullDesC );

   243 

   244         /**

   245          * Resort one contact, what ever contact list it is in

   246          */

   247         void ResortContactInAll( MCAStoredContact* aContact );

   248 

   249         /**

   250          * From MCAStoredContacts

   251          */

   252         void SetSortAlgorithm( MCAStoredContact::TSortAlgorithm aAlgorithm );

   253 

   254         /**

   255          * From MCAStoredContacts

   256          */

   257         TStorageManagerGlobals::TPresenceStatus OnlineStatus(

   258             const TDesC& aContactId );

   259 

   260         /**

   261          * From MCAStoredContacts

   262          */

   263         MCAStoredContact* UpdatePresenceL(   const TDesC& aContactId,

   264                                              TStorageManagerGlobals::TPresenceStatus aStatus,

   265                                              TStorageManagerGlobals::TClientType aType,

   266                                              const TDesC& aAlias,

   267                                              const TDesC& aStatusText,

   268                                              TStorageManagerGlobals::TPresenceStatus& aOldOnlineStatus );

   269         /**

   270          * From MCAStoredContacts

   271          */

   272         const TPtrC Identification( const TDesC& aContactId );

   273 

   274         /**

   275          * From MCAStoredContacts

   276          */

   277         MCAStoredContact& OwnStatus();

   278 

   279         /**

   280          * From MCAStoredContacts

   281          */

   282         void SetContactListLock( TBool aLocked );

   283 

   284         /**

   285          * From MCAStoredContacts

   286          */

   287         void ResetContactLists();

   288 

   289         /**

   290          * From MCAStoredContacts

   291          */

   292         void SetContactListProperty( TContactListProperty aProperty );

   293 

   294         /**

   295          * From MCAStoredContacts

   296          */

   297         TInt InitSynchroniseProcess();

   298 

   299         /**

   300          * From MCAStoredContacts

   301          */

   302         TInt SetNextForSynchroniseProcess();

   303 

   304         /**

   305          * From MCAStoredContacts

   306          */

   307         MCAContactList& ListInSyncProcessL();

   308 

   309         /**

   310          * From MCAStoredContacts

   311          */

   312         TBool IsAllSynchronised( TBool &aIsFailed ) const;

   313 

   314         /**

   315          * From MCAStoredGroups

   316          */

   317         void AddObserverL( MCAStoredGroupsObserver* aObserver );

   318 

   319         /**

   320          * From MCAStoredGroups

   321          */

   322         void RemoveObserver( MCAStoredGroupsObserver* aObserver );

   323 

   324         /**

   325          * From MCAStoredGroups

   326          */

   327         MCAExtendedStoredGroup* CreateGroupL();

   328 

   329         /**

   330          * From MCAStoredGroups

   331          */

   332         void DeleteGroupL( MCAStoredGroup* aGroup );

   333 

   334         /**

   335          * From MCAStoredGroups

   336          */

   337         MCAStoredGroup* FindGroup( const TDesC& aId );

   338 

   339         /**

   340          * From MCAStoredGroups

   341          */

   342         void PopulateGroupsListL( RPointerArray<MCAStoredGroup>& aList,

   343                                   TBool aReturnOnlyVisible );

   344 

   345         /**

   346          * From MCAStoredGroups

   347          */

   348         void SignalGroupChangedL( const TDesC& aGroupId );

   349 

   350         /**

   351          * From MCAStoredGroups

   352          */

   353         void SignalGroupAddedL( const TDesC& aGroupId );

   354 

   355         /**

   356          * From MCAStoredGroups

   357          */

   358         void SaveGroupL( const TDesC& aGroupId );

   359 

   360         /**

   361          * From MCAStoredGroups

   362          */

   363         virtual void HideAllGroups( TBool aAllGroups = EFalse );

   364 

   365         /**

   366          * From MCAStoredGroups

   367          */

   368         virtual void ShowAllGroups();

   369 

   370         /**

   371          *  Count of stored groups

   372          *  @return Count of groups

   373          */

   374         virtual TInt GroupCount( TBool aOnlyVisible ) const;

   375 

   376         /**

   377          * From MCAStoredGroups

   378          */

   379         virtual void CheckFreespaceLevelL( MCAExtendedStoredGroup* aGroup );

   380 

   381         /**

   382          * From MCAStoredContacts

   383          */

   384         void SetNotifyOnSave( TBool aStatus );

   385 

   386         /**

   387          * MCAStoredContactsObserver

   388          */

   389         void HandleContactDelete( const TDesC& aContact );

   390 

   391         /**

   392          * MCAStoredContactsObserver

   393          */

   394         void HandleAddition( MCAContactList& aList, MCAStoredContact& aContact );

   395 

   396         /**

   397          * MCAStoredContactsObserver

   398          */

   399         void HandleChange( MCAContactList* aList, MCAStoredContact* aContact,

   400                            TStorageManagerGlobals::TCAObserverEventType aEventType,

   401                            TBool aUserIdChanged );

   402 

   403         /**

   404          * MCAStoredContactsObserver

   405          * MCAStoredGroupsObserver

   406          * This method is unused.

   407          */

   408         void HandleBackupRestoreEvent(

   409             const TStorageManagerGlobals::TCAObserverEventType aEventType );

   410 

   411         /**

   412          * MCAStoredGroupsObserver

   413          */

   414         void HandleDelete( const TDesC& aId );

   415 

   416         /**

   417          * MCAStoredGroupsObserver

   418          */

   419         void HandleAddition( const TDesC& aId );

   420 

   421         /**

   422          * MCAStoredGroupsObserver

   423          */

   424         void HandleChange( const TDesC& aId );

   425 

   426         /**

   427          * MCAStoredContacts

   428          */

   429         MCAStoredContact* CreateContactL(

   430             const TDesC& aContactList,

   431             const TDesC& aNickname,

   432             const TDesC& aWVID );

   433 

   434         /**

   435          * MCAStoredContacts

   436          */

   437         MCAStoredContact* CreateContactL(

   438             MCAContactList& aContactList,

   439             const TDesC& aNickname,

   440             const TDesC& aWVID,

   441             TStorageManagerGlobals::TPresenceStatus aStatus,

   442             TStorageManagerGlobals::TClientType aType,

   443             const TDesC& aAlias,

   444             const TDesC& aStatusText );

   445 

   446         /**

   447          * MCAStoredContacts

   448          */

   449         void SendContactListUpdatedEvent( MCAContactList& aList );

   450 

   451 

   452         /**

   453          * From MCAStoredContacts

   454          */

   455         void RemoveAllContactsL();

   456 

   457         /**

   458          * From MCAStoredContacts

   459          */

   460         void SetShowNickname( TBool aShowNickname ) ;

   461 

   462         /**

   463          * Clears all selected-flags

   464          */

   465         void ClearSelected();

   466 

   467         /**

   468          * Gets all selected contacts

   469          */

   470         void GetSelectedL( RPointerArray<MCAStoredContact>& aSelected,

   471                            TStorageManagerGlobals::TFilterType aFilter );

   472 

   473         /**

   474          * From MCARefreshTimerObserver

   475          */

   476         void HandleTimeWaited( const TInt aError );

   477 

   478         /**

   479          * From MCAStorageInfo

   480          */

   481         TBool ShowNickname();

   482 

   483         /**

   484          * From MCAStorageInfo

   485          */

   486         TBool CollapseLocked();

   487 

   488         /**

   489          * From MCAStoredContacts

   490          */

   491         TBool IsContactValid( const MCAStoredContact* aContact ) const;

   492 

   493         /**

   494          * From MCAStoredContacts

   495          */

   496         void SortContactLists();

   497 

   498 

   499         /**

   500         * From MCAStoredContacts

   501         */

   502         TBool IsGroupDeleted();

   503 

   504         /**

   505          * From MCAStoredContacts

   506          */

   507         void SetGroupDeleted( TBool aValue );

   508 

   509     private:

   510 

   511         /**

   512          * C++ default constructor.

   513          */

   514         CCAStorageManager();

   515 

   516         /**

   517          * By default Symbian 2nd phase constructor is private.

   518          */

   519         void ConstructL();

   520 

   521         // internal contact list managing helper routines

   522 

   523         /**

   524          * Find the index of the list element in our list of groups that

   525          * has the given group id.

   526          * @since 2.1

   527          * @param aId The id to search

   528          * @return The index in the list, or KErrNotFound

   529          */

   530         TInt FindGroupIndexByGroupId( const TDesC& aId );

   531 

   532         /**

   533          * Helper routine for handling observer events for contacts

   534          * @param aType The type of observer event

   535          * @param aContact Event occured for contact.

   536          * @param aContactId, Id of contact

   537          * @param aList Contact list where contact can be found

   538          * @param aUserIdChanged, Is user id changed or not.

   539          */

   540         void SendObserverEvent(

   541             TStorageManagerGlobals::TCAObserverEventType aType,

   542             MCAStoredContact* aContact,

   543             const TDesC& aContactId,

   544             MCAContactList* aList = NULL,

   545             TBool aUserIdChanged = EFalse );

   546 

   547         /**

   548          * Helper routine for handling observer events for groups

   549          * @since 2.1

   550          * @param aType The type of observer event

   551          * @param aParameter The group id

   552          */

   553         void SendObserverEvent(

   554             TStorageManagerGlobals::TCAObserverEventType aType,

   555             const TDesC& aParameter );

   556 

   557         /**

   558          * Helper routine for backup and restore events

   559          * @param aType The event type

   560          * @param aParam The parameter

   561          */

   562         void SendBRObserverEvent(

   563             TStorageManagerGlobals::TCAObserverEventType aType );

   564 

   565         /**

   566          * Synchronize groups with persistent storage. Called from Constructor.

   567          * @since 2.1

   568          */

   569         void SynchronizeGroupsL();

   570 

   571         /**

   572          * Notify all the observers about the given event

   573          * @param aType The type of observer event

   574          * @param aContact The contact in question

   575          * (or -1 == KCAStorageDontKnowPos to force search for given contact id

   576          * in aParameter)

   577          * @param aFromPEC, ETrue, if event is coming from PEC

   578          * @since 2.1

   579          */

   580         void NotifyAllObservers( TStorageManagerGlobals::TCAObserverEventType aType,

   581                                  MCAStoredContact* aContact,

   582                                  const TDesC& aContactId,

   583                                  MCAContactList *aList,

   584                                  TBool aUserIdChanged );

   585 

   586         /**

   587          * Notify all the observer about the given event after small delay

   588          * If new notify events come during delay, then notify is "shifted"

   589          * with new delay time and notify event is change to "multiplechanges".

   590          * @param aType The type of observer event

   591          * @param aContact The contact in question

   592          * (or -1 == KCAStorageDontKnowPos to force search for given contact id

   593          * in aParameter)

   594          * @param aFromPEC, ETrue, if event is coming from PEC

   595          * @since 2.6

   596          */

   597         void NotifyAllObserversWithDelay(

   598             TStorageManagerGlobals::TCAObserverEventType aType,

   599             MCAStoredContact* aContact, const TDesC& aContactId,

   600             MCAContactList* aList,

   601             TBool aUserIdChanged );

   602 

   603         /**

   604          * Actual implementation for NotifyAllObserversWithDelay

   605          * @see NotifyAllObserversWithDelay

   606          */

   607         void DoNotifyAllObserversWithDelayL(

   608             TStorageManagerGlobals::TCAObserverEventType aType,

   609             MCAStoredContact* aContact, const TDesC& aContactId,

   610             MCAContactList* aList,

   611             TBool aUserIdChanged );

   612 

   613         // TLinearOrder

   614         static TInt ContactListOrderByDisplayName(

   615             const CCAContactList& aContactA,

   616             const CCAContactList& aContactB );

   617 

   618         static TBool ContactListFindByContactId(

   619             const CCAContactList& aContactA,

   620             const CCAContactList& aContactB );

   621 

   622         /**

   623          * Find contact list for internal use.

   624          * @param aListId. List to find.

   625          * @return Contact list if found. if not found return NULL

   626          */

   627         CCAContactList* FindContactListInternal( const TDesC& aListId );

   628 

   629         /**

   630          * Find contact list

   631          * @param aListId. List to find.

   632          * @return Contact list if found. If not found return NULL

   633          */

   634         MCAContactList* FindContactList( const TDesC& aListId );

   635 

   636         TInt FindContactListById( const TDesC& aListId );

   637 

   638         /**

   639          * Populate contact array

   640          * @param aArray. Array to be populated by contacts.

   641          * @param aContactId. Id of contacts which are appended to array.

   642          */

   643         void PopulateContactArrayL( RPointerArray< MCAContactList >& aListArray,

   644                                     RPointerArray< MCAStoredContact >& aContactArray,

   645                                     const TDesC& aContactId );

   646 

   647         /**

   648          * Find next list for sync

   649          * @param Offset for earlier item.

   650          */

   651         TInt FindNextForSynch( TInt aOffset );

   652 

   653     private:    // Data

   654 

   655         // observers list, used with MCAStoredContacts inherited methods

   656         RPointerArray< MCAStoredContactsObserver > iContactObservers;

   657         // owns the array, but not the observers

   658 

   659         // observers list, used with MCAStoredGroups inherited methods

   660         RPointerArray< MCAStoredGroupsObserver > iGroupObservers;

   661         // owns the array, but not the observers

   662 

   663         // list of contacts

   664         RPointerArray< CCAContactList > iContactList;   // owns

   665 

   666         // list of groups

   667         RPointerArray< CCAGroup > iGroupList;   // owns

   668 

   669         // the persistent storage

   670         CCAStorage* iStorage;   // owns

   671 

   672         // the backup server session

   673         CBaBackupSessionWrapper* iBackupSession; // owns

   674 

   675         // notify upon save or not

   676         TBool iNotifyUponSave;

   677 

   678         // hide "wv:" from contact identification (ETrue)

   679         TBool iWVHiding;

   680 

   681         // Timer used to wait before calling HandleChange to observers.

   682         CCARefreshTimer* iRefreshTimer; // owns

   683 

   684         // Helper variables for shifted change events.

   685         TInt iRefreshStartCounter;

   686         HBufC*  iLatestContactToRefresh; // WVID of latest contact

   687         MCAContactList* iLatestContactList; // latest contactlist

   688         TStorageManagerGlobals::TCAObserverEventType iRefreshEventType;

   689         TBool iRefreshUserIdChanged;

   690 

   691         /// Sorter for contacts. Owns

   692         CCAContactSorter* iContactSorter;

   693 

   694         /// Contact for own status

   695         MCAStoredContact* iOwnStatus;

   696 

   697         /// Operation error

   698         TInt iOperationError;

   699 

   700         /// Contact list lock status ETrue locked, EFalse unlocked.

   701         TBool iContactListLock;

   702 

   703         // To show nickname or not

   704         TBool iShowNickname;

   705 

   706         // Current contact list to be synchronised.

   707         TInt iCurrentListSync;

   708         // hide "wv:" from contact identification (ETrue) only wv: part

   709         TBool iWVHidingPrefixOnly;

   710         // capitalizig the listname

   711         TBool iCapital;

   712 

   713 

   714         TBool iGroupDeleted;

   715 

   716     };

   717 

   718 #endif      // CCASTORAGEMANAGER_H

   719 

   720 // End of File