1 /*

     2 * Copyright (c) 2006 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:  Implementation class for MCAMainViewArrayPC, to decide how to fill the

    15 *				 single view array decorator

    16 *

    17 */

    18 

    19 

    20 

    21 #ifndef CCAMAINVIEWARRAYPC_H

    22 #define CCAMAINVIEWARRAYPC_H

    23 

    24 #include <e32base.h>

    25 

    26 

    27 //Forward Declaration

    28 class MCAContactListModel;

    29 class MCAArrayItemPC;

    30 class CCAEngine;

    31 class MCAInvite;

    32 class MCAInvitation;

    33 class MCAServerContactsArrayPC;

    34 class MCAStoredGroup;

    35 class CCAGroupListArrayPC;

    36 class MCASingleListViewCB;

    37 class MCAStoredGroups;

    38 

    39 #include "MCAMainViewObserverManagerPC.h"

    40 #include "MCAMainViewObserverPC.h"

    41 #include "MCAStoredContactsObserver.h"

    42 #include "MCAMainViewArrayPC.h"

    43 #include "MCAWatcherObserver.h"

    44 #include "MCAStoredContacts.h"

    45 #include "MCAChatInterface.h"

    46 #include "ChatDefinitions.h"

    47 #include "MCASettingsObserver.h"

    48 #include "MCAInviteObserver.h"

    49 #include "MCASettingsPC.h"

    50 #include "MCAChatObserver.h"

    51 #include "MWVSettingsObserverng.h"

    52 #include "MCAStoredGroupsObserver.h"

    53 #include "MCASyncObserverPC.h"

    54 

    55 #include <MIMPSSAPObserver.h>

    56 #include <CIMPSSAPSettingsStore.h>

    57 #include <cimpspresenceconnectionuing.h>

    58 

    59 #include "MCAListInitObserver.h"

    60 

    61 class CCAMainViewArrayPC:   public CBase,

    62             public MCAMainViewArrayPC,  // this class own interface.

    63             public MCASettingsObserver,	// events from engine.

    64             public MCAStoredGroupsObserver, // events from engine.

    65             public MCAMainViewObserverManagerPC,

    66             public MCAWatcherObserver,

    67             public MCAInviteObserver,

    68             public MCAChatObserver,

    69 

    70             // This callback is required when ever the server is added or deleted

    71             // we get a callback and update the singlelist

    72             public MIMPSSAPObserver,

    73             public MCAListInitObserver,

    74             public MCAStoredContactsObserver

    75 

    76     {

    77     public:

    78         struct TArrayPairs // Struct to hold identification and buffer

    79             {

    80             TBuf<KMaxWVIDLength> iIdentification;

    81             MCAMessagesReadInterface* iReadInterface;

    82             };

    83 

    84         struct TInvitationArray // Struct to hold identification and buffer

    85             {

    86             TDesC* iUserID;

    87             TDesC* iMessage;

    88             };

    89     public: //Constructor and Destructors

    90         /**

    91         * construction

    92         */

    93         void ConstructL();

    94         /**

    95         * construction

    96         * @param aContactListModel : a reference to the contact list model object at the chat engine

    97         */

    98         static CCAMainViewArrayPC* NewL( CCAEngine& aEngine,

    99                                          MCAContactListModel& aContactListModel,

   100                                          MCAChatInterface& aChatInterface );

   101 

   102     private:

   103         /**

   104         * default constructor

   105         * @param aContactListModel : a reference to the contact

   106         * list model object at the chat engine

   107         */

   108         CCAMainViewArrayPC( CCAEngine& aEngine,

   109                             MCAContactListModel& aContactListModel,

   110                             MCAChatInterface& aChatInterface );

   111 

   112     public:

   113         /**

   114          * virtual destructor

   115          */

   116         virtual ~CCAMainViewArrayPC();

   117 

   118 

   119     public: // From MCAMainViewArrayPC

   120 

   121         /**

   122          * Gets the details of the given index

   123          * like aItemId, aListId,aItemType.

   124          * @return the structure filled with tha above details.

   125          */

   126         TCAItemDetails GetArrayItemIdDetails( TInt aIndex );

   127 

   128         /**

   129          * Gets the Index, given item details

   130          * like aItemId, aListId,aItemType.

   131          * @return the index

   132          */

   133         TInt GetArrayItemIdIndexL( const TCAItemDetails& aItemDetails );

   134         /**

   135          * @return returns ETrue if any contact is found in contactlists

   136          * else returns EFalse if no contact is found

   137          */

   138         TBool IsAnyContactFound();

   139 

   140         /**

   141          * Populate the group array iGroupArray with groups

   142          */

   143         void  PopulateGroupsListL();

   144 

   145         /**

   146         * SetSkipStorageEvents: Called by UI component to set flag for skipping storage events

   147         * @param aSkip : A flag to check whether to skip strage events or not

   148         * @return void

   149         */

   150         virtual void SetSkipStorageEvents( TBool aSkip );

   151 

   152         /**

   153         * GetSkipStorageEvents: Called by UI component to get the flag for skipping storage events

   154         * @return boolean

   155         */

   156         virtual TBool GetSkipStorageEvents();

   157 

   158         /**

   159         * Count: Called by UI components to get total count of array

   160         * @return integer: Count of array

   161         */

   162         virtual TInt Count() const;

   163 

   164         /**

   165         * GetType: Function to get the type of list item

   166         * @param aIndex: index of the list item

   167         * @return TEnumsPC::TItem: type of the list item as EContactItem, EOwnStatusItem etc

   168         */

   169         virtual TEnumsPC::TItem GetType( TInt aIndex ) const;

   170 

   171         /**

   172         * IsCollapsed: To find if the list box item is collapsed

   173         * @param aIndex: index of the list item

   174         * @return bool: True if the list item is collapsed else false.

   175         */

   176         virtual TBool IsCollapsed( TInt aIndex ) const;

   177 

   178         /**

   179         * IsMsgPending: To find if there are any pending messages to

   180         *				decide the icons for display

   181         * @param aIndex: index of the list item

   182         * @return bool: True if there are pending messages else false.

   183         */

   184         virtual TBool IsMsgPending( TInt aIndex ) ;

   185 

   186         /**

   187         * IsBlocked: To find if the list item is a blocked contact

   188         * @param aIndex: index of the list item

   189         * @return bool: True if the list item is a blocked contact else false

   190         */

   191         virtual TBool IsBlocked( TInt aIndex ) const;

   192 

   193         /**

   194         * ForceExpanded: To expand or collapse all the list items

   195         * @param aAllExpanded: True if all items have to be expanded else false

   196         * @return bool: True if there are pending messages else false.

   197         */

   198         virtual void ForceExpanded( TBool aAllExpanded );

   199 

   200         /**

   201         * IsForceExpanded: To find if all the list items have been force expanded

   202         * @return bool: True if all the list items are force expanded else false

   203         */

   204         virtual TBool IsForceExpanded() const;

   205 

   206         /**

   207         * GetOnlineStatus: To get the online status of the list item as Online, Away, Busy etc

   208         * @param aIndex: Index of the list item

   209         * @return TEnumsPC::TOnlineStatus

   210         */

   211         virtual TEnumsPC::TOnlineStatus GetOnlineStatus( TInt aIndex );

   212 

   213         /**

   214         * SetCollapsed: To set the list item to a collapsed or expanded state

   215         * @param aStatus: The collapsed or expanded state to be set for the list item

   216         * @param aIndex: Index of the list item whose state has to be set

   217         * @return void

   218         */

   219         virtual void SetCollapsed( TBool aStatus, TInt aIndex );

   220 

   221         /**

   222         * SetSelected:

   223         * @param aSelected: selected or not

   224         * @return aIndex ,given index

   225         */

   226         virtual void SetSelected( TBool aSelected, TInt aIndex );

   227 

   228         /**

   229         * GetSelectedL: get the selcetd

   230         * @param aSelectedContact: selected conatct

   231         * @param aSelectedIdentifications

   232         * @return aFilter

   233         */

   234         virtual void GetSelectedL( CDesCArray& aSelectedContact,

   235                                    CDesCArray* aSelectedIdentifications,

   236                                    TEnumsPC::TFilterType aFilter );

   237 

   238         /**

   239          * Sets the selectionmode

   240          * @param aSelectionMode to be set

   241          * @param aSelectedListIndex - selected contactlist index - used for

   242          * group creation using existing contact list to get all the contacts in that

   243          * contact list

   244          */

   245 

   246         void SetContactSelectionL( TEnumsPC::TListSelectionType aSelectionMode,

   247                                    TInt aSelectedListIndex );

   248 

   249         /**

   250          * Resets the selectionmode

   251          */

   252         void ResetContactSelectionL();

   253 

   254         /**

   255          * Returns index for given invitation

   256          * @param aIndex

   257          * @return index of invitation

   258          */

   259         TInt GetItemEngineIndex( TInt aIndex ) const;

   260 

   261         /**

   262          * Sets the focus to the owndata on logout.

   263          */

   264         virtual void SetCurrentItemIndexL( TBool aFreshLogin = EFalse  );

   265 

   266         /**

   267         * Find any contact which id is aContactId

   268         * @param aContactId Contactid to recognize contact.

   269         * @return ETrue if contact found else EFalse

   270         */

   271         TBool FindAnyContactL( const TDesC& aContactId );

   272 

   273 

   274         /**

   275          * Appends the received invitation to the top of the array

   276          * @param aInvitation

   277          */

   278         void AddInvitation( const MCAInvitation* aInvitation );

   279 

   280         /**

   281          * Returns index of invitation for given wvid and

   282          * Deletes item from array.

   283          * @since 3.2

   284          * @param Index of invitation

   285          * @return index at which the invite has been deleted.

   286          */

   287         virtual TInt FindInvitationAndDelete( const TDesC& aInviteID /*TInt aIndex*/ );

   288 

   289 

   290         virtual TInt FindInvitationAndDelete( TInt aIndex );

   291 

   292 

   293 

   294         /**

   295          * SetMsgPending: To set the pending messages for a list item

   296          * @param aPendingMsgs: The no. of pending messages to be set for the list item

   297          * @param aIndex: Index of the list item

   298          * @return void

   299          */

   300         virtual void SetMsgPending( TInt aPendingMsgs, TInt aIndex );

   301 

   302         /**

   303          * SetBlocked: To set the blocked status of a list item of type contact

   304          * @param aStatus: The blocked status  to be set for the list item

   305          * @param aIndex: Index of the list item whose status has to be set

   306          * @return void

   307          */

   308         virtual void SetBlocked( TBool aStatus, TInt aIndex );

   309 

   310         /**

   311          * SetOnlineStatus: To set the online status of a list item

   312          * @param aStatus: The online status to be set for the list item

   313          * @param aIndex: Index of the list item whose status has to be set

   314          * @return void

   315          */

   316         virtual void SetOnlineStatus( TEnumsPC::TOnlineStatus aStatus, TInt aIndex );

   317 

   318         /**

   319          * GetItemNameText: To get item name of each list item

   320          * @param aIndex: Index of the list item whose name is to be returned

   321          * @return TPtrC: Name of the list item

   322          */

   323         virtual TPtrC GetItemNameText( TInt aIndex );

   324 

   325         /**

   326          * GetFormattedItemNameTextL: To set/rename item name of each list item

   327          * @param aIndex: Index of the list item whose name is to be changed/set

   328          * @return TPtr: Error code to check if the name has been set

   329          */

   330         virtual TPtr GetFormattedItemNameTextL( TInt aIndex );

   331 

   332         /**

   333          * ClearArray: clear everything in the array

   334          * @return void

   335          */

   336         virtual void ClearArray( TBool aClearOpenChatsArray );

   337 

   338 

   339         /** ResetArray: reset the array,clear and fill with the new data in the array

   340          * @return void

   341          */

   342         virtual void ResetArray( TBool aClearOpenChatsArray );

   343 

   344         /**

   345          * SetDefaultFilter: To set the default filters of each item

   346          * @param aMyFilter: TEnumsPC::TFilterType to be set

   347          * @return void

   348          */

   349         virtual void SetDefaultFilter( TEnumsPC::TFilterType aMyFilter );

   350 

   351         /**

   352         * ResetDefaultFilter: To reset the default filters of each item

   353         * @return void

   354         */

   355         virtual void ResetDefaultFilter();

   356 

   357         /**

   358          * GetDefaultFilter: To get the default filters of list item

   359          * @return TEnumsPC::TFilterType: type of filter

   360          */

   361         virtual TEnumsPC::TFilterType GetDefaultFilter() const;

   362 

   363         /**

   364          * Should the model show "All" item in beginning

   365          * of each contact list.

   366          * @param aShow If ETrue, first item in every contact list is "All"

   367          */

   368         void ShowAll( TBool aShow );

   369 

   370 

   371         /**

   372         * ClientType: To get the client type of list item at given index

   373         * @return TEnumsPC::TClientType: type of client

   374         */

   375         virtual TEnumsPC::TClientType ClientType( TInt aIndex );

   376 

   377         /**

   378         * Selected: To know if the list item at given index is selected currently

   379         * @param aIndex: index of list item

   380         * @return bool: true if the list item at given index is selected currently else false

   381         */

   382         virtual TBool Selected( TInt aIndex );

   383 

   384         /**

   385         * IsWatched: To get the status on whether the list item at given index is

   386         * being watched for notifications on that contacts online status changes

   387         * @param aIndex: index of list item

   388         * @return bool: true if the contact is being watched else false

   389         */

   390         virtual TBool IsWatched( TInt aIndex );

   391 

   392         /**

   393         * AddWatcher: To add watcher to presence

   394            */

   395         virtual void AddWatcherL( TPtrC contact/*wvid*/ );

   396 

   397 

   398         /**

   399         * RemoveWatcher: To remove watcher from presence

   400         *

   401         */

   402         virtual void RemoveWatcherL( TPtrC contact/*wvid*/ );

   403 

   404         /**

   405         * Refreshes friends-storage presence data.

   406         */

   407         virtual void RefreshFriendsL();

   408 

   409         /**

   410          * Clears all selected-flags

   411          */

   412         virtual void ClearSelectedL( );

   413 

   414         /**

   415         * Places all friends to aUsers array

   416         */

   417 

   418         /* Places all friends (from aUserList) that are online to aOnlineList

   419         * and users that are offline to aOfflineList.

   420         * @param aUserList List of users, whose presence data is to be fetched.

   421         * @param aOnlineList List of users, that are online, can be NULL.

   422         * @param aOfflineList List of users, that are offline, can be NULL.

   423         * @param aUpdateStorage If ETrue, contact storage flags are updated

   424         */

   425         virtual void GetOnlineUsersL(

   426             const CDesCArray *aUsers,

   427             CDesCArray* aOnlineList,

   428             CDesCArray* aOfflineList,

   429             TBool aUpdateStorage = EFalse ) ;

   430 

   431         /**

   432         * Synchronised: To get the synchronised status for the list item

   433         * @param aIndex: index of list item

   434         * @return TEnumsPC::TSyncStatus: the synchronization status of the list item

   435         */

   436         virtual TEnumsPC::TSyncStatus Synchronised( TInt aIndex );

   437 

   438         /**

   439         * IsAllSynchronised: To get the synchronised status of all the list items

   440         * @return TEnumsPC::TSyncStatus: the synchronization status of all the items

   441         */

   442         virtual TEnumsPC::TSyncStatus IsAllSynchronised();

   443 

   444         /**

   445          * Changes client own presence status, and sets status message

   446          * @param aStatus Presence status -online,oflline etc

   447          * @param aStatusMessage Presence status message

   448          * @return Error code.

   449          */

   450         TInt ChangeStatusL( TEnumsPC::TOnlineStatus aStatus,

   451                             const TDesC& aStatusMessage ) ;

   452 

   453         /**

   454          * Changes presence status message

   455          * @param aStatusMessage Presence status message

   456          * @return Operation error.

   457          */

   458         TInt ChangeStatusMessageL( const TDesC& aStatusMessage ) ;

   459 

   460         /**

   461         * StatusL: To get the own status like Online, Away, Busy etc

   462         * @return TEnumsPC::TOnlineStatus

   463         */

   464         TEnumsPC::TOnlineStatus StatusL();

   465 

   466         /**

   467         * GetOwnStatusConverter: To get TEnumsPC:TOnlineStatus type of enum from

   468         * the presence side MCAPresence::TPresenceStatus enums for own status

   469         * @param aPresenceStatus: presence side MCAPresence::TPresenceStatus enums

   470         * @return TEnumsPC::TOnlineStatus

   471         */

   472         TEnumsPC::TOnlineStatus GetOwnStatusConverter(

   473             MCAPresence::TPresenceStatus  aPresenceStatus );

   474         /**

   475          * Fills aOnlineList with the user id's from friends-list that are

   476          * online.

   477          * @param aOnlineList List that will be populated with online friends.

   478          * @param aFetchFromNetwork Fetch presence information from network

   479          */

   480         void GetOnlineContactsL( CDesCArray& aOnlineList,

   481                                  TBool aFetchFromNetwork = EFalse );

   482 

   483 

   484 

   485         /**

   486          * RegisterObserverL: To add the UI component as an observer to listen to the

   487          * event from the MainViewArrayPC

   488          * @see MCAListInitObserver

   489          * @return void

   490          */

   491         void RegisterObserverL( MCAListInitObserver* aObserver ) ;

   492 

   493         /**

   494         * UnRegisterObserverL: To remove form the listener

   495         * @see MCAListInitObserver

   496         * @return void

   497         */

   498         void UnRegisterObserverL() ;

   499 

   500         /**

   501         * AIsListInitializationCompleteL:

   502         * @return Bool value

   503         */

   504         TBool IsListInitializationCompletedL() ;

   505 

   506 

   507 

   508         /**

   509          * Refresh the conversation item in openchats to

   510          * reflect the changes upon addation/chang/deletion of a contact

   511          * @param aContactId: userId whose nickname is changed.

   512          */

   513         void RefreshConversationItemText( const TDesC& aContactId );

   514 

   515         /**

   516          * Refresh the Invitation item in openchats to

   517          * reflect the changes upon addation/chang/deletion of a contact

   518          * @param aContactId: userId whose nickname is changed.

   519          */

   520         void RefreshInvitationItemTextL( const TDesC& aContactId );

   521 

   522     public: // From MCAMainViewObserverManagerPC

   523 

   524         /**

   525         * AddObserverL: To add the UI component as an observer to listen to the

   526         *               event from the MainViewArrayPC

   527         * @see MCAMainViewObserverManagerPC

   528         * @return void

   529         */

   530         void AddObserverL( MCAMainViewObserverPC* aObserver );

   531 

   532         /**

   533         * RemoveObserver: To remove the UI component as an observer to the

   534         *               events from the MainViewArrayPC

   535         * @see MCAMainViewObserverManagerPC

   536         * @return void

   537         */

   538         void RemoveObserver( MCAMainViewObserverPC* aObserver );

   539 

   540         /**

   541          * AddObserverL: To add the UI component as an observer to listen to the

   542          *               event from the MainViewArrayPC

   543          * @see MCAMainViewObserverManagerPC

   544          * @return void

   545          */

   546         void AddObserver( MCASyncObserverPC* aObserver );

   547 

   548         /**

   549          * RemoveObserver: To remove the UI component as an observer to the

   550          *               events from the MainViewArrayPC

   551          * @see MCAMainViewObserverManagerPC

   552          * @return void

   553          */

   554         void RemoveObserver( );

   555 

   556     public: //MCAChatObserver

   557         /**

   558         * Handle events.

   559         * @param aEvent Event to handle.

   560         * @param aMessage, Event occurred because of message

   561         */

   562         virtual void HandleChatEvent( TChatEventType aEvent,

   563                                       MCAMessage* aMessage = NULL );

   564 

   565     public: //MCAsyncObserverPC

   566 

   567         virtual void NotifySyncCompleted();

   568     public: //From MCAStoredContactsObserver

   569 

   570         /**

   571         * HandleContactDelete: To handle the contact delete event from the MCAStoredContactsObserver

   572         * @see MCAStoredContactsObserver

   573         * @param aContactId: contact whihc has been deleted

   574         * @return void

   575         */

   576         virtual void HandleContactDelete( const TDesC& aContactId );

   577 

   578         /**

   579         * HandleAddition: To handle the contact addition event from the MCAStoredContactsObserver

   580         * @see MCAStoredContactsObserver

   581         * @param aList: reference to the list to which the contact has been added

   582         * @param aContact:  reference to the contact which has been added

   583         * @return void

   584         */

   585         virtual void HandleAddition( MCAContactList& aList, MCAStoredContact& aContact );

   586 

   587         /**

   588         * HandleChange: To handle the Chnage event from the MCAStoredContactsObserver

   589         * @see MCAStoredContactsObserver

   590         * @param aList: reference to the list at which a change has occured

   591         * @param aContact:  reference to the contact at which a change has occured

   592         * @param aEventType: TStorageManagerGlobals::TCAObserverEventType :

   593         * type of change event that has occured

   594         * @return void

   595         */

   596         virtual void HandleChange( MCAContactList* aList,

   597                                    MCAStoredContact* aContact,

   598                                    TStorageManagerGlobals::TCAObserverEventType aEventType,

   599                                    TBool aUserIdChanged );

   600 

   601 

   602     public: //From MCASettingsObserver

   603 

   604         /**

   605         * HandleSettingsChangeL: To handle the change events in settings

   606         * @see MCASettingsObserver

   607         * @param aChangedSettingEnum: enumeration of the type of settings change

   608         * @return void

   609         */

   610         virtual void HandleSettingsChangeL( TInt aChangedSettingEnum );

   611 

   612     public: //From MCAWatcherObserver

   613 

   614         /**

   615         * HandleWatcherEvent: To handle the watch events for a contact

   616         * @see MCAWatcherObserver

   617         * @param aContact:  reference to the contact at which a watch event has occured

   618         */

   619         void HandleWatcherEvent( const MCAStoredContact* aContact );

   620 

   621     public: // From MCAInviteObserver

   622 

   623         /**

   624          * @see MCAInviteObserver

   625          */

   626         void HandleInvitationEventL( TInviteEventType aEvent,

   627                                      const MCAInvitation* aInvitation );

   628 

   629         /**

   630          * @see MCAInviteObserver

   631          */

   632         void HandleInvitationResponse( TBool aAcceptance,

   633                                        const TDesC& aUserId,

   634                                        const TDesC& aGroupName,

   635                                        const TDesC& aResponse );

   636     public://for CallBacks.

   637 

   638         void RegisterCallBack( MCASingleListViewCB* aSingleViewCB );

   639 

   640         void UnRegisterCallBack( );

   641     public:

   642 

   643         /*

   644         * gets the alias of the specified contact at aIndex

   645         * @param aIndex: index of contact

   646         * @return the alias

   647         */

   648         virtual const TDesC& GetSelectedContactAlias( TInt aIndex );

   649 

   650         /*

   651         * gets the nickname of the specified contact at aIndex

   652         * @param aIndex: index of contact

   653         * @return the nickname

   654         */

   655         virtual const TDesC& GetSelectedContactNickname( TInt aIndex );

   656 

   657         /*

   658         * gets the user id of the specified contact at aIndex

   659         * @param aIndex: index of contact

   660         * @return the user id

   661         */

   662         virtual const TDesC& GetSelectedContactUserId( TInt aIndex );

   663 

   664         /*

   665         * gets the identification of the specified contact at aIndex

   666         * @param aIndex: index of contact

   667         * @return the identification

   668         */

   669         virtual const TDesC& GetSelectedContactIdentification( TInt aIndex );

   670 

   671 

   672         /*

   673         * Gets the MCAStoredContact type for the specified contact at aIndex

   674         * This method is for use by the CCAContactEditor class and is not exposed

   675         * via the MCAMainViewArrayPC interface

   676         * @param aIndex: index of contact

   677         * @return the alias

   678         */

   679         MCAStoredContact* GetContactForContactEditor( TInt aIndex );

   680 

   681         // See the comment @MCAMainViewArrayPC

   682 

   683         virtual void MapContactListPositions( RArray<TInt>& aPositionArray );

   684 

   685         /*

   686         * gets the displayname of the specified List at aIndex

   687         * @param aIndex: index of list

   688         * @return the displayname

   689         */

   690 

   691         virtual TPtrC DisplayName( TInt aIndex );

   692 

   693         /**

   694         * SetDisplayName: To set/rename item name of each list item

   695         * @param aIndex: Index of the list item whose name is to be changed/set

   696         * @param aItemName: name to be set for the list item at specified index

   697         * @return TInt: Error code to check if the name has been set

   698         */

   699         virtual TInt SetDisplayNameL( TInt aIndex, const TPtrC aItemName );

   700 

   701         /*

   702          * gets the FilteredCount

   703          * @param aFilter: type of filetr

   704          * @param aIndex: index of list

   705          * @return the count

   706          */

   707         virtual TInt GetFilteredCount( TEnumsPC::TFilterType aFilter, TInt aIndex );

   708         /**

   709         * Set a separate filter for the single list view array items

   710         * @param aFilter: filter to be set

   711         */

   712         virtual void SetSingleListArrayFilter( TEnumsPC::TFilterType aFilter );

   713 

   714         /**

   715         * Get a separate filter for the single list view array items

   716         * @return filter

   717         */

   718         virtual TEnumsPC::TFilterType GetSingleListArrayFilter( );

   719 

   720 

   721     public:

   722         /**

   723         * Find a contact from the store by wv User ID

   724         * @param aContactListId List which contains contact.

   725         * @param aId the User ID of the contact to find

   726         * @return The contact

   727         */

   728         virtual TInt FindContactL( const TDesC& aContactListId,

   729                                    const TDesC& aId );

   730 

   731         /**

   732         * Find a contact list from the store by wv User ID

   733         * @param aContactListId List which contains contact list id.

   734         * @return The contact list index

   735         */

   736         virtual TInt FindContactListIndexL( const TDesC& aListId );

   737         /* gets the list id of the specified list at aIndex

   738         * @param aIndex: index of list

   739         * @return the list id

   740         */

   741         virtual const TDesC& GetSelectedListId( TInt aIndex );

   742 

   743         /**

   744         * Checks status of aContact and shows needed notes accordign to variation.

   745         * @param aIndex: index of contact to be checked.

   746         * @return Integer value, negative if offline status is not ignored or

   747         *              allowed by variation, positive if contact is online

   748         *              or user decides to ignore offline status. See possible

   749         *              return values from IMUtils::TIgnoreOfflineStatus enum.

   750         */

   751         virtual TInt IgnoreOfflineStatusL( TInt aIndex );

   752 

   753         /**

   754         * SetMessageReadInterfaceL: Calls the MessageReadInterface() of engine component

   755         * to set the read interface

   756         * @param aIndex: index of contact for whom the read interface (conversation) has

   757         * to be set

   758         * @return void

   759         */

   760         virtual void SetMessageReadInterfaceL( TInt aIndex );

   761 

   762         /**

   763         * ChatExistsL: Checks if there is an existing chat for the contact

   764         * at index

   765         * @param aIndex: index of contact for which the existing

   766         * conversation has to be checked

   767         * @return bool: If chat exists for contact at aIndex return true

   768         * else return false

   769         */

   770         virtual TBool ChatExistsL( TInt aIndex );

   771 

   772         /**

   773          * Get index for list

   774          * @param aIndex: index of Contact item to be found.

   775          * @param aIgnoreOwnItem. If ETrue own item is not taken into account

   776          *                        when resolving index.

   777          * @param aIgnoreEmptyLists If ETrue, empty lists are ignored.

   778          * @return Index of list. If list not found returns KErrNotFound

   779          */

   780         virtual TInt IndexOfList( TInt aIndex,

   781                                   TBool aIgnoreOwnItem = EFalse,

   782                                   TBool aIgnoreEmptyLists = ETrue ) const;

   783 

   784 

   785         /**

   786          * Check if synchronization of contact lists is done

   787          * @return ETrue if done

   788          */

   789         virtual TBool IsSyncDoneL();

   790 

   791 

   792         /**

   793         * To create a contact list with given name

   794         * @param aDisplayName: name of the list to be created

   795         * @return KErrNone if list is created else retrun KErrAlreadyExists

   796         */

   797 

   798         virtual TInt CreateContactListL( const TDesC& aDisplayName , TInt& aIndex ) ;

   799 

   800         /**

   801         * To sort the contact list in alphbetical order

   802         * @param alistId: list id of renamed contact list

   803         */

   804         virtual TInt SortContactListAfterRenameL( const TDesC& alistId ) ;

   805 

   806         /**

   807         * Find if there is a list with given name already

   808         * @param aNamePtr: name of the list to be searched

   809         * @return KErrNone if theres no list with the name aNamePtr else return KErrAlreadyExists

   810         */

   811 

   812         virtual TInt ListAlreadyExistsL( const TPtr aNamePtr );

   813 

   814         /**

   815         * Check if there are any contact list in the contact lists

   816         * @return KErrGeneral if no contact list is available else return KErrNone

   817         */

   818         virtual TInt ContactListsExistL();

   819 

   820 

   821         /**

   822          * Find the no. of contact items in the contact list

   823          * @param aIndex: the index of contact list

   824          * @return TInt: the no. of contact items in the list at aIndex

   825          */

   826         virtual TInt CountOfContactsInList( TInt aIndex );

   827 

   828         /**

   829          * Count of lists.

   830          * @return Count of lists.

   831          */

   832         virtual TInt ListCountL() const;

   833 

   834         /**

   835          * Delete the contact list

   836          * @param aIndex:    ID of the list

   837          * @return Error code

   838          */

   839         virtual TInt DeleteContactListL( TInt aIndex );

   840         /**

   841         * Deletes one contact from server side contact list

   842         * @param aIndex: Index of list to be updated

   843         * @return Error code

   844         */

   845         virtual TInt DeleteServerContactL( TInt aIndex );

   846 

   847         /**

   848         * Get the status text for the contact

   849         * @param aIndex: Index of contact item

   850         * @return Error code

   851         */

   852         virtual const TDesC& StatusText( TInt aIndex ) const;

   853 

   854         /**

   855         * Invoke the fetch contacts method from presence component

   856         */

   857         virtual void FetchContactsL();

   858         /**

   859          * to convert engine enum value to PC enum values

   860          * @param aStatus: value of engine value

   861          */

   862         TEnumsPC::TCASettingValues ConvertToEnumsPC( TInt aStatus );

   863 

   864 

   865     public:

   866 

   867         const RPointerArray<MCAArrayItemPC>& GetOpenChatsArray() const ;

   868 

   869         /**

   870         * @returns the index of the given item W.R.T singlelistview.

   871         */

   872         TInt FindIndexOfOpenChatsItem( TEnumsPC::TItem aItemType,

   873                                        const TDesC& aId );

   874 

   875         TInt GetOpenChatsActiveIndex()const;

   876 

   877     private:

   878         /**

   879         * FillArray: fill up the complete array

   880         * @return void

   881         */

   882         void FillArrayL( TBool aFillOpenChatsArray );

   883 

   884 

   885         /**

   886         * FillOwnDataL: fill up fill the owndata item

   887         * @return void

   888         */

   889         TBool  FillOwnDataL();

   890 

   891         /**

   892         * FillOpenChatsL: then fill the conversations..or open chats....

   893         * @return void

   894         */

   895         //

   896         void FillOpenChatsL();

   897 

   898         /**

   899         * FillContactListsL: then fill the contacts lists/contacts..etc..

   900         * @return void

   901         */

   902         void FillContactListsL();

   903 

   904         void FillSelectedContactListL( );

   905 

   906 

   907 

   908         /**

   909         * FillItemL: fill up the individual item in the array

   910         * @param aIndex: index of the list item for which the array has to be filled

   911         * @return void

   912         */

   913         void FillItemL( TInt aIndex );

   914 

   915         /**

   916         * GetResourceValueL: To get the integer equivalent of resource string

   917         * @param aResourceID: id of the resource string

   918         * @return TInt: integer equivalent of resource string

   919         */

   920         TInt GetResourceValueL( TInt aResourceID );

   921 

   922         /**

   923         * GetOnlineStatusConverter: To get TEnumsPC:TOnlineStatus type of enum from

   924         * the engine /storage side TStorageManagerGlobals::TPresenceStatus enums

   925         * @param aEngOnlineStatus: engine /storage side TStorageManagerGlobals::TPresenceStatus enums

   926         * @return TInt: TEnumsPC::TOnlineStatus

   927         */

   928         TEnumsPC::TOnlineStatus GetOnlineStatusConverter(

   929             TStorageManagerGlobals::TPresenceStatus aEngOnlineStatus );

   930 

   931 

   932         /**

   933         * GetTypeConverter: To get TEnumsPC:TItem type of enum from

   934         * the engine side MCAContactListModel::TItemType enums

   935         * @param aItemType: engine side MCAContactListModel::TItemType enums

   936         * @return TInt: EnumsPC::TItem

   937         */

   938         TEnumsPC::TItem GetTypeConverter( MCAContactListModel::TItemType aItemType ) const;

   939 

   940         /**

   941         * ToUpdatePresence: To get the information on whether presence has to be updated

   942         * by anding the two filters

   943         * @parm aFilter1: TEnumsPC::TFilterType

   944         * @parm aFilter2: TEnumsPC::TFilterType

   945         */

   946         virtual TBool ToUpdatePresence( TEnumsPC::TFilterType aFilter1,

   947                                         TEnumsPC::TFilterType aFilter2 );

   948 

   949         /**

   950         * To set the filter type for engine

   951         */

   952         virtual void SetFilter( TEnumsPC::TFilterType aFilter );

   953 

   954         /**

   955         * To get the filter type for engine

   956         */

   957         virtual TEnumsPC::TFilterType Filter();

   958 

   959         /**

   960         * To set the group count down flag, for each logout. For the first time login

   961         * it is set in the constructor to EFalse. This flag ensures that the

   962         * initial deletion of groups from iGroupArray and the subsequent additions

   963         * of user created groups are not reflected on the UI

   964         */

   965         virtual void ResetGroupCountDownOnLogout();

   966 

   967         virtual const TDesC& GetInviteItemID( TInt aIndex );

   968 

   969 

   970 

   971 

   972         // This callback is required when ever the server is added or deleted

   973         // we get a callback and update the singlelist

   974         /**

   975          * From MIMPSSAPObserver

   976          * @see MIMPSSAPObserver for more information

   977          */

   978         void HandleSAPEvent( TSAPEvent aEvent );

   979     public: // From MCAStoredGroupsObserver

   980 

   981         /**

   982          * Called when a group is deleted.

   983          * @param aId The ID of the deleted group

   984          */

   985         void HandleDelete( const TDesC& aId );

   986 

   987         /**

   988          * Called when a group is added.

   989          * @param aId The ID of the added group

   990          */

   991         void HandleAddition( const TDesC& aId );

   992 

   993         /**

   994          * Called when a group is changed.

   995          * @param aId The ID of the changed group

   996          */

   997         void HandleChange( const TDesC& aId );

   998 

   999         /**

  1000          * Called when backup/restore starts/stops.

  1001          * There is no distinction between backup/restore (Symbian limitation).

  1002          * However, the called party should fetch new list(s) as they

  1003          * may have changed if the operation was restore operation.

  1004          * @param aEventType Type of backup/restore event

  1005          */

  1006         void HandleBackupRestoreEvent(

  1007             const TStorageManagerGlobals::TCAObserverEventType aEventType );

  1008 

  1009     public: //Added methods for sorting of openchats

  1010 

  1011         //To Insert a newly arrived Invite on top of openchats list

  1012         void InsertInviteItemL( const MCAInvitation* aInvitation );

  1013         void InsertGroupItemL( MCAStoredGroup* aGroup );

  1014         void InsertConversationItemL( const TDesC& aUserId,

  1015                                       const TDesC& aIdentification );

  1016         void MoveGroupItem( MCAStoredGroup* aGroup, TInt aFoundIndex );

  1017         void RemoveConversationItem( const TDesC& aUserId );

  1018 

  1019         TBool IsOpenChatsMsgPending(

  1020             const TEnumsPC::TItem aType,

  1021             const TDesC& aId );

  1022 

  1023     public:       //from MCAMainViewArrayPC.h

  1024 

  1025         /**

  1026         * See MCAMainViewArrayPC.h

  1027         */

  1028         const TDesC& PendingMessageInfo();

  1029 

  1030         /**

  1031         * See MCAMainViewArrayPC.h

  1032         */

  1033         const TDesC& ChatGroupPendingMessageInfo( TDesC& aGroupName );

  1034 

  1035         /**

  1036         * See MCAMainViewArrayPC.h

  1037         */

  1038         TInt GetIndexOfTopPendingMessage();

  1039 

  1040     public:        // MCAListInitObserver

  1041         /**

  1042          * Callback HandleListInitChange from presence list manager

  1043          * after the list init complete

  1044          */

  1045         void HandleListInitChange( TBool aCompleted );

  1046 

  1047 

  1048     private:

  1049 

  1050         TStorageManagerGlobals::TFilterType GetFilterConverterUITOEngine(

  1051             TEnumsPC::TFilterType aFilter );

  1052 

  1053         void HandleError( TInt );

  1054 

  1055         void HandleItemRemovalL( const TDesC& aContactId );

  1056 

  1057         void HandleItemAdditionL( MCAStoredContact & aContact );

  1058 

  1059 

  1060     private://Added methods for sorting of openchats

  1061 

  1062         TInt ChatGroupMessagesPendingCount() const;

  1063 

  1064         void ResetOpenChatsArrayL( TEnumsPC::TItem aItem );

  1065 

  1066         void InsertIntoInactiveOpenChats( TBool aEnd );

  1067 

  1068         void SetContactListIndex();

  1069         TEnumsPC::TItem GetOpenChatType( TInt aIndex ) const;

  1070 

  1071         TInt RemoveGroupItem( const TDesC& aGroupId );

  1072 

  1073         //method to get bool equivalent for selction mode. Added to make code readable

  1074         //Returns true if single list view selection mode else false.

  1075         TBool SingleListViewSelectMode() const;

  1076 

  1077         void RefreshOpenChatsListItemL();

  1078 

  1079         void RefreshGroupItem( MCAStoredGroup* aGroup, TInt aFoundIndex );

  1080 

  1081 

  1082     private:

  1083 

  1084         //Refenence to engine

  1085         CCAEngine& iEngine;

  1086 

  1087         TBool iSkipStorageEvents;

  1088 

  1089         /**

  1090         * list of items here

  1091         */

  1092         RPointerArray<MCAArrayItemPC> iMainViewListItemArray;

  1093 

  1094         // we need to maintain the list of observers here.whenever any event is

  1095         // happening then we need call back the UI

  1096 

  1097         /*

  1098         * Observers : replace this array with pointer variable and overload = operator.

  1099         */

  1100         RPointerArray< MCAMainViewObserverPC > iMainViewObservers;

  1101 

  1102         /*

  1103         * reference to the contact list model

  1104         */

  1105         MCAContactListModel& iContactListModel;

  1106 

  1107         /*

  1108         * Reference to chat interface

  1109         */

  1110         MCAChatInterface& iChatInterface;

  1111 

  1112         /**

  1113          * Reference to Invite Interface

  1114          */

  1115         MCAInvite& iInviteInterface;

  1116 

  1117         //Owns. Array of active invitations

  1118         RPointerArray<MCAInvitation> iInvitationsArray;

  1119 

  1120         /*

  1121         * reference to the contact list interface

  1122         */

  1123         MCAStoredContacts* iContactInterface;

  1124 

  1125         // is "all" item displayed in beginning of each list

  1126         //used in displaying blockinglist

  1127         TBool iShowAll;

  1128 

  1129         // Owns

  1130         HBufC* iRejectReason;

  1131         /*

  1132         * starting index of Owndata	, it's 0 as per ui spec

  1133         */

  1134         int iOwnDataIndex;

  1135         /*