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:  Manager for presence operations (fetcher/notifier/publisher).

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "CCAPEngPresenceManager.h"

    22 #include "CAPresenceDefinitions.h"

    23 #include "CAPresenceUtils.h"

    24 #include "CCAPEngListManager.h"

    25 

    26 // Contact handling

    27 #include "CCAStorageManagerFactory.h"

    28 #include "MCAStoredContacts.h"

    29 

    30 #include "impsbuilddefinitions.h"

    31 

    32 #include "MCAContactList.h"

    33 

    34 #include "MCAStoredContact.h"

    35 

    36 #include "ChatDebugPrint.h"

    37 

    38 #include "MCAPresenceObserver.h"

    39 #include "MCAWatcherObserver.h"

    40 #include "MCASettings.h"

    41 

    42 #include "CCAPresenceErrors.h"

    43 #include "CAPresenceConst.h"

    44 #include "MCAPresence.h"

    45 #include "MCAContactLists.h"

    46 #include "TCAWrappers.h"

    47 

    48 #include "MCAReactiveAuthObserver.h"

    49 #include "SServerPrefers.h"

    50 #include "TDecodeAttrParams.h"

    51 

    52 #include "ImpsCSPAllErrors.h"

    53 

    54 #include <WVUIPresenceVariationNG.rsg>

    55 

    56 #include <PEngWVPresenceAttributes2.h>

    57 #include <PEngWVPresenceErrors2.h>

    58 #include <CPEngPresenceNotifier2.h>

    59 #include <CPEngAttributeTransaction2.h>

    60 #include <CPEngAttributeStore2.h>

    61 #include <CPEngTrackedPresenceIDs2.h>

    62 #include <CPEngTrackedPresenceID2.h>

    63 #include <CIMPSSAPSettingsStore.h>

    64 #include <PEngPresenceEngineConsts2.h>

    65 #include <CPEngNWSessionSlotID2.h>

    66 

    67 #include <MPEngPresenceAttrModel2.h>

    68 #include <MPEngTransactionStatus2.h>

    69 

    70 #include <CPEngReactAuthStore.h>

    71 #include <CPEngReactAuthTransaction.h>

    72 #include <CPEngReactAuthNotifier.h>

    73 #include <CPEngReactAuthTransaction.h>

    74 #include <MPEngReactAuthObserver.h>

    75 #include <MPEngReactAuthTransactionObserver.h>

    76 #include <MPEngAuthorizationRequest.h>

    77 #include <MPEngAuthorizationRespond.h>

    78 #include <MPEngAuthorizationStatus.h>

    79 

    80 // ============================ MEMBER FUNCTIONS ===============================

    81 

    82 // -----------------------------------------------------------------------------

    83 // CCAPEngPresenceManager::CCAPEngPresenceManager

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

    85 // might leave.

    86 // -----------------------------------------------------------------------------

    87 //

    88 CCAPEngPresenceManager::CCAPEngPresenceManager()

    89         : iAuthMode( KUndefined ),

    90         iNetworkState( KUndefined ),

    91         iPEngAPIInitialized( EFalse ),

    92         iObserverQueued( EFalse ),

    93         iCachedStatus( EFalse ),

    94         iAttributeProcessing( ETrue )

    95     {

    96     }

    97 

    98 // -----------------------------------------------------------------------------

    99 // CCAPEngPresenceManager::ConstructL

   100 // Symbian 2nd phase constructor can leave.

   101 // -----------------------------------------------------------------------------

   102 //

   103 void CCAPEngPresenceManager::ConstructL( MCASettings* aApplicationSettings )

   104     {

   105     // Set settings API

   106     SetSettingsAPIL( aApplicationSettings );

   107 

   108     // Assign attributes that we are handling

   109     ResetAttributesL( EFalse );

   110 

   111     // Create detailed error container

   112     iErrors = CCAPresenceErrors::NewL();

   113 

   114     iIdle = CIdle::NewL( CActive::EPriorityIdle );

   115     }

   116 

   117 // -----------------------------------------------------------------------------

   118 // CCAPEngPresenceManager::NewL

   119 // Two-phased constructor.

   120 // -----------------------------------------------------------------------------

   121 //

   122 CCAPEngPresenceManager* CCAPEngPresenceManager::NewL(

   123     MCASettings* aApplicationSettings )

   124     {

   125     CCAPEngPresenceManager* self = new( ELeave ) CCAPEngPresenceManager;

   126 

   127     CleanupStack::PushL( self );

   128     self->ConstructL( aApplicationSettings );

   129     CleanupStack::Pop( self );

   130 

   131     return self;

   132     }

   133 

   134 

   135 // Destructor

   136 CCAPEngPresenceManager::~CCAPEngPresenceManager()

   137     {

   138     delete iPEngAttributeTransaction;

   139     delete iListManager;

   140     delete iPEngAttributeStore;

   141     delete iErrors;

   142     if ( iOwnPresenceNotifier )

   143         {

   144         iOwnPresenceNotifier->RemoveObserver( *this );

   145         }

   146     delete iOwnPresenceNotifier;

   147     delete iCachedStatusText;

   148 

   149     iAttributes.Close();

   150 

   151     if ( iRANotifier )

   152         {

   153         iRANotifier->RemoveObserver( *this );

   154         iRANotifier->Stop();

   155         }

   156 

   157     delete iRAStore;

   158     delete iRANotifier;

   159     delete iRATransaction;

   160 

   161     delete iSessionSlotID;

   162 

   163     iOwnStates.ResetAndDestroy();

   164     iPresenceStates.ResetAndDestroy();

   165     iFetchObjects.ResetAndDestroy();

   166 

   167     TInt count( iAttrArrays.Count() );

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

   169         {

   170         iAttrArrays[ a ].iArray.ResetAndDestroy();

   171         }

   172     iAttrArrays.Close();

   173 

   174     delete iIdle;

   175     }

   176 

   177 

   178 // -----------------------------------------------------------------------------

   179 // CCAPEngPresenceManager::AddWatcherL

   180 // Sets watcher flag for given contact

   181 // (other items were commented in a header).

   182 // -----------------------------------------------------------------------------

   183 //

   184 void CCAPEngPresenceManager::AddWatcherL( const TDesC& aWVId )

   185     {

   186     CHAT_DP_TXT( "CCAPEngPresenceManager::AddWatcherL" );

   187     CCAStorageManagerFactory::ContactListInterfaceL()->SetWatched( aWVId, ETrue );

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // CCAPEngPresenceManager::GetOnlineFriendsL

   192 // Fetches list of online-friends

   193 // (other items were commented in a header).

   194 // -----------------------------------------------------------------------------

   195 //

   196 void CCAPEngPresenceManager::GetOnlineFriendsL( CDesCArray &aOnlineList,

   197                                                 TBool aFetchFromNetwork )

   198     {

   199     CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL()...starts" );

   200 

   201     CPtrCArray* friends = CAPresenceUtils::GenerateFriendsArrayLC(

   202                               CCAStorageManagerFactory::ContactListInterfaceL() );

   203 

   204     // Reset given array

   205     aOnlineList.Reset();

   206 

   207     // update our lists

   208     if ( aFetchFromNetwork )

   209         {

   210         CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL starting \

   211                       network fetch" );

   212         FetchAttributesL( *friends, &aOnlineList, NULL, NULL, EFalse );

   213         }

   214 

   215     // Populate aOnlineList with online friends

   216     TInt friendCount( friends->Count() );

   217     MCAStoredContact* contact = NULL;

   218 

   219     for ( TInt i( 0 ); i < friendCount; ++i )

   220         {

   221         contact = CCAStorageManagerFactory::ContactListInterfaceL()->

   222                   FindAnyContact( ( *friends )[i] );

   223         if ( contact )

   224             {

   225             TStorageManagerGlobals::TPresenceStatus status =

   226                 contact->OnlineStatus();

   227             if ( status == TStorageManagerGlobals::EOnline ||

   228                  status == TStorageManagerGlobals::EAway ||

   229                  status == TStorageManagerGlobals::EBusy )

   230                 {

   231                 aOnlineList.AppendL( contact->UserId() );

   232                 }

   233             }

   234         }

   235 

   236     CleanupStack::PopAndDestroy( friends );

   237 

   238     CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL...over" );

   239     }

   240 

   241 // -----------------------------------------------------------------------------

   242 // CCAPEngPresenceManager::GetOnlineUsersL

   243 // Fetches list of online users from given user-list

   244 // (other items were commented in a header).

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

   246 //

   247 void CCAPEngPresenceManager::GetOnlineUsersL( const CDesCArray &aUserList,

   248                                               CDesCArray *aOnlineList,

   249                                               CDesCArray *aOffLineList,

   250                                               TBool aUpdateStorage /*= EFalse*/ )

   251     {

   252     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::GetOnlineUsersL, \

   253                           aUserList.Count() = %d, &aOnlineList = %d, \

   254                           &aOffLineList = %d" ),

   255              aUserList.Count(), aOnlineList, aOffLineList );

   256 

   257     FetchAttributesL( aUserList, aOnlineList, aOffLineList, NULL,

   258                       aUpdateStorage );

   259 

   260     CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineUsersL done" );

   261     }

   262 

   263 // -----------------------------------------------------------------------------

   264 // CCAPEngPresenceManager::PresenceObserver

   265 // Returns presence-observer pointer

   266 // (other items were commented in a header).

   267 // -----------------------------------------------------------------------------

   268 //

   269 MCAPresenceObserver* CCAPEngPresenceManager::PresenceObserver() const

   270     {

   271     return iPresenceObserver;

   272     }

   273 

   274 // -----------------------------------------------------------------------------

   275 // CCAPEngPresenceManager::RefreshFriendsL

   276 // Refreshes the presence status of friends according to refresh-flags

   277 // (other items were commented in a header).

   278 // -----------------------------------------------------------------------------

   279 //

   280 void CCAPEngPresenceManager::RefreshFriendsL()

   281     {

   282     // Create needed MDesCArray-based array for presence operations

   283     CPtrCArray* contactsArray = CAPresenceUtils::GenerateFriendsArrayLC(

   284                                     CCAStorageManagerFactory::ContactListInterfaceL()/*, EFalse*/ );

   285     FetchAttributesL( *contactsArray, NULL, NULL, NULL, ETrue );

   286     CleanupStack::PopAndDestroy( contactsArray );

   287     }

   288 

   289 // -----------------------------------------------------------------------------

   290 // CCAPEngPresenceManager::SubscribeFriendsL

   291 // Subscribes friends based on update-flag

   292 // (other items were commented in a header).

   293 // -----------------------------------------------------------------------------

   294 //

   295 void CCAPEngPresenceManager::SubscribeFriendsL( const TSubscribeMode aMode )

   296     {

   297     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::SubscribeFriendsL, mode = %d" ),

   298              aMode );

   299 

   300     if ( !iPEngAPIInitialized )

   301         {

   302         return;

   303         }

   304     iListManager->SubscribeListsL( aMode == MCAPresence::ESubscribe );

   305     }

   306 

   307 // -----------------------------------------------------------------------------

   308 // CCAPEngPresenceManager::ContactLists

   309 // Returns contact-list-handling interface

   310 // (other items were commented in a header).

   311 // -----------------------------------------------------------------------------

   312 //

   313 MCAContactLists* CCAPEngPresenceManager::ContactLists()

   314     {

   315     return iListManager;

   316     }

   317 

   318 // -----------------------------------------------------------------------------

   319 // CCAPEngPresenceManager::LastOperationResult

   320 // Returns last operation's error results

   321 // (other items were commented in a header).

   322 // -----------------------------------------------------------------------------

   323 //

   324 const CCAPresenceErrors& CCAPEngPresenceManager::LastOperationResult() const

   325     {

   326     return *iErrors;

   327     }

   328 

   329 // -----------------------------------------------------------------------------

   330 // CCAPEngPresenceManager::SettingsAPI

   331 // Return settings-API

   332 // (other items were commented in a header).

   333 // -----------------------------------------------------------------------------

   334 //

   335 MCASettings* CCAPEngPresenceManager::SettingsAPI() const

   336     {

   337     return iApplicationSettings;

   338     }

   339 

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

   341 // CCAPEngPresenceManager::SetSettingsAPIL

   342 // Sets settings API

   343 // (other items were commented in a header).

   344 // -----------------------------------------------------------------------------

   345 //

   346 void CCAPEngPresenceManager::SetSettingsAPIL(

   347     MCASettings* aApplicationSettings )

   348     {

   349     // CCAPEngPresenceManager need settings API to function correctly

   350     if ( !iApplicationSettings && !aApplicationSettings )

   351         {

   352         User::Leave( ECANoSettingsAPI );

   353         }

   354 

   355     // If settings API handle provided, then update current handle

   356     if ( aApplicationSettings )

   357         {

   358         iApplicationSettings = aApplicationSettings;

   359         }

   360     }

   361 

   362 // -----------------------------------------------------------------------------

   363 // CCAPEngPresenceManager::RemoveWatcherL

   364 // Removes watcher from given user

   365 // (other items were commented in a header).

   366 // -----------------------------------------------------------------------------

   367 //

   368 void CCAPEngPresenceManager::RemoveWatcherL( const TDesC &aWVId )

   369     {

   370     CHAT_DP_TXT( "CCAPEngPresenceManager::RemoveWatcherL" );

   371     CCAStorageManagerFactory::ContactListInterfaceL()->

   372     SetWatched( aWVId, EFalse );

   373     }

   374 

   375 // -----------------------------------------------------------------------------

   376 // CCAPEngPresenceManager::SetPresenceObserver

   377 // Sets presence observer

   378 // (other items were commented in a header).

   379 // -----------------------------------------------------------------------------

   380 //

   381 void CCAPEngPresenceManager::SetPresenceObserver(

   382     MCAPresenceObserver* aObserver )

   383     {

   384     iPresenceObserver = aObserver;

   385     }

   386 

   387 // -----------------------------------------------------------------------------

   388 // CCAPEngPresenceManager::SetWatcherObserver

   389 // Sets watcher observer

   390 // (other items were commented in a header).

   391 // -----------------------------------------------------------------------------

   392 //

   393 void CCAPEngPresenceManager::SetWatcherObserver( MCAWatcherObserver* aObserver )

   394     {

   395     iWatcherObserver = aObserver;

   396     }

   397 

   398 // -----------------------------------------------------------------------------

   399 // CCAPEngPresenceManager::HandleNetworkStateL

   400 // To be called when network state changes

   401 // (other items were commented in a header).

   402 // -----------------------------------------------------------------------------

   403 //

   404 void CCAPEngPresenceManager::HandleNetworkStateL( TNetworkStatus aState,

   405                                                   const SServerPrefers& aServerPreferences,

   406                                                   CPEngNWSessionSlotID2* aSessionSlotID )

   407     {

   408     CHAT_DP_FUNC_ENTER( "CCAPEngPresenceManager::HandleNetworkState" );

   409 

   410     // read own states from resource

   411     CAPresenceUtils::ReadStatesFromResourceL(

   412         RSC_CHAT_VARIATION_OWN_PRESENCE_STATES, iOwnStates );

   413 

   414     // read incoming presence states from resource

   415     CAPresenceUtils::ReadStatesFromResourceL(

   416         RSC_CHAT_VARIATION_PRESENCE_STATES, iPresenceStates );

   417 

   418     iServerPrefers = aServerPreferences;

   419     iAliasUsed = aServerPreferences.iAliasUsed;

   420 

   421     if ( aState != EUpdateBrand )

   422         {

   423         // notification of branding must not keep the state

   424         // changed, but should be returned to the existing state

   425         iNetworkState = aState;

   426         }

   427 

   428     if ( aState == ELoggedIn )

   429         {

   430         // initialize own presence observer, if one is queued

   431         InitializeOwnPresenceObserverL();

   432         // check if we have cached values

   433         if ( iCachedAppSettingsAuthValue )

   434             {

   435             SetPresenceAuthorizationL( iCachedAppSettingsAuthValue );

   436             iCachedAppSettingsAuthValue = 0;

   437             }

   438         if ( iCachedStatus )

   439             {

   440             ChangeStatusL( iCachedPresenceStatus, *iCachedStatusText );

   441             iCachedStatus = EFalse;

   442             delete iCachedStatusText;

   443             iCachedStatusText = NULL;

   444             }

   445         else if ( iCachedStatusText )

   446             {

   447             ChangeStatusMessageL( *iCachedStatusText );

   448             delete iCachedStatusText;

   449             iCachedStatusText = NULL;

   450             }

   451         }

   452 

   453     // update own state and notify observers

   454     NotifyOwnPresenceObserverL();

   455 

   456     if ( aState == EUpdateBrand )

   457         {

   458         iRAUsed = aServerPreferences.iReactiveAuthorization;

   459         iAliasUsed = aServerPreferences.iAliasUsed;

   460         return;

   461         }

   462 

   463     if ( iListManager )

   464         {

   465         iListManager->SetLoggedIn( iNetworkState == ELoggedIn, aSessionSlotID );

   466         }

   467 

   468     if ( !IsLoggedIn() )

   469         {

   470         // logging out

   471         CancelPendingRequests();

   472 

   473         // stop the RA notifier

   474         if ( iRANotifier )

   475             {

   476             iRANotifier->Stop();

   477             }

   478         }

   479 

   480     CHAT_DP_FUNC_DONE( "CCAPEngPresenceManager::HandleNetworkState" );

   481     }

   482 

   483 // -----------------------------------------------------------------------------

   484 // CCAPEngPresenceManager::InitializePEngAPIL

   485 // Handles changes in setting values

   486 // (other items were commented in a header).

   487 // -----------------------------------------------------------------------------

   488 //

   489 void CCAPEngPresenceManager::InitializePEngAPIL()

   490     {

   491     // we can straight delete the old one, since

   492     // if creating does not work, then we cannot do anything anyway

   493     delete iListManager;

   494     iListManager = NULL;

   495     // Create list manager

   496     iListManager = CCAPEngListManager::NewL(

   497                        *iApplicationSettings,

   498                        iAttributes,

   499                        *this,             // presence observer

   500                        iSessionSlotID,

   501                        *this );           // presence updater

   502 

   503     delete iPEngAttributeTransaction;

   504     iPEngAttributeTransaction = NULL;

   505     // Create publisher

   506     iPEngAttributeTransaction =

   507         CPEngAttributeTransaction2::NewL( *iSessionSlotID );

   508 

   509     delete iPEngAttributeStore;

   510     iPEngAttributeStore = NULL;

   511     // Create attribute store

   512     iPEngAttributeStore = CPEngAttributeStore2::NewL( *iSessionSlotID );

   513 

   514     // reactive authorization stuffs

   515     delete iRAStore;

   516     iRAStore = NULL;

   517     iRAStore = CPEngReactAuthStore::NewL( *iSessionSlotID );

   518 

   519     delete iRANotifier;

   520     iRANotifier = NULL;

   521     iRANotifier = CPEngReactAuthNotifier::NewL( *iSessionSlotID );

   522     iRANotifier->AddObserver( *this );

   523 

   524     delete iRATransaction;

   525     iRATransaction = NULL;

   526     iRATransaction = CPEngReactAuthTransaction::NewL( *iSessionSlotID );

   527 

   528     iPEngAPIInitialized = ETrue;

   529 

   530     MCAStoredContacts* contacts =

   531         CCAStorageManagerFactory::ContactListInterfaceL();

   532     contacts->OwnStatus().SetUserIdL( iSessionSlotID->UserId() );

   533     contacts->OwnStatus().SetAliasL( KNullDesC );

   534     iListManager->SetLoggedIn( ETrue, iSessionSlotID );

   535     }

   536 

   537 // -----------------------------------------------------------------------------

   538 // CCAPEngPresenceManager::HandleSettingsChangeL

   539 // Handles changes in setting values

   540 // (other items were commented in a header).

   541 // -----------------------------------------------------------------------------

   542 //

   543 void CCAPEngPresenceManager::HandleSettingsChangeL( TInt aChangedSettingEnum )

   544     {

   545     if ( ! IsLoggedIn() )

   546         {

   547         // we might not have a server, unless we're logged in, so we can't do

   548         // any presence stuff

   549         return;

   550         }

   551 

   552     // Presence update mode change

   553     if ( aChangedSettingEnum == MCASettings::EAutomaticPresenceUpdate )

   554         {

   555         if ( iApplicationSettings->Value(

   556                  MCASettings::EAutomaticPresenceUpdate ) )

   557             {

   558             SubscribeFriendsL( MCAPresence::ESubscribe );

   559             }

   560         else

   561             {

   562             SubscribeFriendsL( MCAPresence::EUnSubscribe );

   563             }

   564         }

   565 

   566     if ( aChangedSettingEnum == MCASettings::EOwnAlias )

   567         {

   568         // this branch will not get done unless alias usage has been enabled

   569         // through resource variation.

   570         UpdateAliasAttributeL();

   571         }

   572 

   573     // Presence authorization mode change

   574     if ( aChangedSettingEnum == MCASettings::EAuthorizeIMPresence )

   575         {

   576         SetPresenceAuthorizationL( iApplicationSettings->Value(

   577                                        MCASettings::EAuthorizeIMPresence ) );

   578         }

   579     }

   580 

   581 // -----------------------------------------------------------------------------

   582 // CCAPEngPresenceManager::HandleAttributeTransactionError

   583 // Handler for fetcher errors

   584 // (other items were commented in a header).

   585 // -----------------------------------------------------------------------------

   586 //

   587 void CCAPEngPresenceManager::HandleAttributeTransactionError(

   588     TInt aError,

   589     CPEngAttributeTransaction2& /*aTransaction*/,

   590     TInt aTransactionOperation )

   591     {

   592     if ( aTransactionOperation == EPEngTransOpOwnAttributePublish )

   593         {

   594         CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::\

   595                               HandlePresencePublishError, error %d" ), aError );

   596         iRequestQueue.ResponseReceived( TCARequestQueue::EPublisherWait );

   597         }

   598     else if ( ( aTransactionOperation == EPEngTransOpAttributeFetchToCache ) ||

   599               ( aTransactionOperation == EPEngTransOpAttributeFetchToObjects ) )

   600         {

   601         CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::HandleAttributeFetchError, \

   602                               error = %d" ), aError );

   603         iRequestQueue.ResponseReceived( TCARequestQueue::EFetcherWait );

   604 

   605         // delete previous results, so that we don't accidentally use them

   606         if ( aTransactionOperation == EPEngTransOpAttributeFetchToObjects )

   607             {

   608             iFetchObjects.ResetAndDestroy();

   609             }

   610         }

   611 

   612     iOperationError = CAPresenceUtils::MapErrorPECtoCSP( aError );

   613     }

   614 

   615 // -----------------------------------------------------------------------------

   616 // CCAPEngPresenceManager::HandleAttributeTransactionCompleteL

   617 // Handler for fetcher complete

   618 // (other items were commented in a header).

   619 // -----------------------------------------------------------------------------

   620 //

   621 void CCAPEngPresenceManager::HandleAttributeTransactionCompleteL(

   622     MPEngTransactionStatus2& aStatus,

   623     CPEngAttributeTransaction2& aTransaction,

   624     TInt aTransactionOperation )

   625     {

   626     if ( aTransactionOperation == EPEngTransOpOwnAttributePublish )

   627         {

   628         CHAT_DP_TXT( "CCAPEngPresenceManager::HandlePresencePublishCompletedL" );

   629         NotifyOwnPresenceObserverL();

   630         iRequestQueue.ResponseReceived( TCARequestQueue::EPublisherWait );

   631         }

   632     else if ( aTransactionOperation == EPEngTransOpAttributeFetchToCache )

   633         {

   634         CHAT_DP_TXT( "CCAPEngPresenceManager::HandleAttributeFetchCompletedL" );

   635         iRequestQueue.ResponseReceived( TCARequestQueue::EFetcherWait );

   636         }

   637     else if ( aTransactionOperation == EPEngTransOpAttributeFetchToObjects )

   638         {

   639         CHAT_DP_TXT( "CCAPEngPresenceManager::HandleAttributeFetchCompletedL" );

   640         iFetchObjects.ResetAndDestroy();

   641         aTransaction.GetFetchedAttributes( iFetchObjects );

   642         iRequestQueue.ResponseReceived( TCARequestQueue::EFetcherWait );

   643         }

   644     iOperationError = CAPresenceUtils::MapErrorPECtoCSP( aStatus.Status() );

   645     CAPresenceUtils::HandleTransactionStatusL( aStatus, *iErrors );

   646     }

   647 

   648 // -----------------------------------------------------------------------------

   649 // CCAPEngPresenceManager::HandlePresenceChangeL

   650 // Handler for attribute change event

   651 // (other items were commented in a header).

   652 // -----------------------------------------------------------------------------

   653 //

   654 void CCAPEngPresenceManager::HandlePresenceChangeL(

   655     CPEngPresenceNotifier2& /*aNotifier*/,

   656     CPEngTrackedPresenceIDs2& aChangedPresenceIDs )

   657     {

   658     CHAT_DP_TXT( "CCAPEngPresenceManager::HandlePresenceChangeL" );

   659 

   660     DecodeNotifierDataL( &aChangedPresenceIDs, NULL );

   661     }

   662 

   663 // -----------------------------------------------------------------------------

   664 // CCAPEngPresenceManager::HandlePresenceError

   665 // Handler for attribute notifier errors

   666 // (other items were commented in a header).

   667 // -----------------------------------------------------------------------------

   668 //

   669 void CCAPEngPresenceManager::HandlePresenceError( TInt aError,

   670                                                   CPEngPresenceNotifier2& /* aNotifier */ )

   671     {

   672     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::HandlePresenceNotifyError: %d" ),

   673              aError );

   674 

   675     iOperationError = CAPresenceUtils::MapErrorPECtoCSP( aError );

   676     }

   677 

   678 

   679 // -----------------------------------------------------------------------------

   680 // CCAPEngPresenceManager::DecodeFetcherDataL

   681 // Decodes fetcher data

   682 // (other items were commented in a header).

   683 // -----------------------------------------------------------------------------

   684 //

   685 void CCAPEngPresenceManager::DecodeFetcherDataL(

   686     const MDesCArray& aUserList,

   687     CDesCArray *aStateOnline,

   688     CDesCArray *aStateOffline,

   689     CDesCArray *aStateUnknown,

   690     TBool aUpdateStorage )

   691     {

   692     MCAStoredContacts* contacts = aUpdateStorage ?

   693                                   CCAStorageManagerFactory::ContactListInterfaceL() : NULL;

   694 

   695     User::LeaveIfError( iAttrArrays.Append( TDecodeAttrParams() ) );

   696     // newly created array entry must be filled completely, so no leaving allowed!

   697     TInt pos( iAttrArrays.Count() - 1 );

   698     TDecodeAttrParams& decodeParams = iAttrArrays[ pos ];

   699     decodeParams.iPresenceStates = &iPresenceStates;

   700     decodeParams.iContactStorage = contacts;

   701     decodeParams.iStateOnline = aStateOnline;

   702     decodeParams.iStateOffline = aStateOffline;

   703     decodeParams.iStateUnknown = aStateUnknown;

   704     decodeParams.iEntryIndex = 0;

   705     decodeParams.iServerPrefers = iServerPrefers;

   706     decodeParams.iWait = TCARequestQueue::EDecodeAttrWait;

   707     decodeParams.iWatcherObserver = NULL;

   708     TRAPD( err, PopulateAttrModelsL( decodeParams.iArray, &aUserList ) );

   709     if ( err != KErrNone )

   710         {

   711         // array entry could not be filled properly => remove it

   712         decodeParams.iArray.ResetAndDestroy();

   713         iAttrArrays.Remove( pos );

   714         // now it's safe to leave

   715         User::Leave( err );

   716         }

   717 

   718     iOperationError = KErrNone;

   719 

   720     if ( !iIdle->IsActive() )

   721         {

   722         iIdle->Start( TCallBack( DecodeAttrModels, this ) );

   723         }

   724 

   725     iRequestQueue.WaitForResponseL( TCARequestQueue::EDecodeAttrWait );

   726 

   727     User::LeaveIfError( iOperationError );

   728     }

   729 

   730 

   731 TInt CCAPEngPresenceManager::DecodeAttrModels( TAny *aInstance )

   732     {

   733     return static_cast<CCAPEngPresenceManager*>( aInstance )->

   734            DoDecodeAttrModels();

   735     }

   736 

   737 TInt CCAPEngPresenceManager::DoDecodeAttrModels()

   738     {

   739     CHAT_DP_TXT( "CCAPEngPresenceManager::DoDecodeAttrModels" );

   740     TBool retval( EFalse );

   741 

   742     if ( !iAttrArrays.Count() ) // No modelarray to decode.

   743         {

   744         return EFalse;

   745         }

   746 

   747     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::DoDecodeAttrModels, \

   748                           Count of attr packets %d" ), iAttrArrays.Count() );

   749 

   750     TDecodeAttrParams& decodeParams = iAttrArrays[ 0 ];

   751 

   752     TRAP( iOperationError, retval = CAPresenceUtils::DecodeAttrModelsL(

   753                                         decodeParams ) );

   754 

   755     if ( iOperationError != KErrNone || !retval )

   756         {

   757         // Ready.

   758         TCARequestQueue::TWaitCategory wait = decodeParams.iWait;

   759         decodeParams.iArray.ResetAndDestroy();

   760         iAttrArrays.Remove( 0 );

   761         if ( wait != TCARequestQueue::ENoWaitNeeded )

   762             {

   763             iRequestQueue.ResponseReceived( wait );

   764             }

   765 

   766         if ( iOperationError != KErrNone )

   767             {

   768             CActiveScheduler::Current()->Error( iOperationError );

   769             }

   770         }

   771 

   772     return TBool( iAttrArrays.Count() );

   773     }

   774 

   775 // -----------------------------------------------------------------------------

   776 // CCAPEngPresenceManager::DecodeNotifierDataL

   777 // Decodes notifier data

   778 // (other items were commented in a header).

   779 // -----------------------------------------------------------------------------

   780 //

   781 void CCAPEngPresenceManager::DecodeNotifierDataL(

   782     CPEngTrackedPresenceIDs2* aChangedPresenceIDs,

   783     const MDesCArray* aUserList )

   784     {

   785     CHAT_DP_TXT( "CCAPEngPresenceManager::DecodeNotifierDataL - Enter" );

   786 

   787     if ( !aChangedPresenceIDs && aUserList )

   788         {

   789         return;

   790         }

   791 

   792     MCAStoredContacts* contacts = CCAStorageManagerFactory::ContactListInterfaceL();

   793 

   794     User::LeaveIfError( iAttrArrays.Append( TDecodeAttrParams() ) );

   795     // newly created array entry must be filled completely, so no leaving allowed!

   796     TInt pos( iAttrArrays.Count() - 1 );

   797     TDecodeAttrParams& decodeParams = iAttrArrays[ pos ];

   798     decodeParams.iPresenceStates = &iPresenceStates;

   799     decodeParams.iContactStorage = contacts;

   800     decodeParams.iStateOnline = NULL;

   801     decodeParams.iStateOffline = NULL;

   802     decodeParams.iStateUnknown = NULL;

   803     decodeParams.iEntryIndex = 0;

   804     decodeParams.iServerPrefers = iServerPrefers;

   805     decodeParams.iWait = TCARequestQueue::ENoWaitNeeded;

   806     decodeParams.iWatcherObserver = iWatcherObserver;

   807     TRAPD( err, PopulateAttrModelsL( decodeParams.iArray, aUserList, aChangedPresenceIDs ) );

   808     if ( err != KErrNone )

   809         {

   810         // array entry could not be filled properly => remove it

   811         decodeParams.iArray.ResetAndDestroy();

   812         iAttrArrays.Remove( pos );

   813         // now it's safe to leave

   814         User::Leave( err );

   815         }

   816 

   817     if ( iAttributeProcessing && !iIdle->IsActive() )

   818         {

   819         iIdle->Start( TCallBack( DecodeAttrModels, this ) );

   820         }

   821 

   822     CHAT_DP_TXT( "CCAPEngPresenceManager::DecodeNotifierDataL - Done" );

   823     }

   824 

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

   826 // CCAPEngPresenceManager::IsLoggedIn

   827 // Returns the network state of module

   828 // (other items were commented in a header).

   829 // -----------------------------------------------------------------------------

   830 //

   831 TBool CCAPEngPresenceManager::IsLoggedIn() const

   832     {

   833     return iNetworkState == ELoggedIn ;

   834     }

   835 

   836 // -----------------------------------------------------------------------------

   837 // CCAPEngPresenceManager::PopulateAttrModelsL

   838 // Populates attribute-model-array with given data. If aNotifierData is given,

   839 // then uses notifier data, otherwise uses fetcher data

   840 // (other items were commented in a header).

   841 // -----------------------------------------------------------------------------

   842 //

   843 void CCAPEngPresenceManager::PopulateAttrModelsL(

   844     RPointerArray<MPEngPresenceAttrModel2>& aArray,

   845     const MDesCArray* aUserList,

   846     CPEngTrackedPresenceIDs2* aChangedPresenceIDs /*=NULL*/ )

   847     {

   848     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::PopulateAttrModelsL, \

   849                           &aChangedPresenceIDs=%d" ), aChangedPresenceIDs );

   850 

   851     if ( !iPEngAPIInitialized )

   852         {

   853         CHAT_DP_TXT( "iPEngAPIInitialized not initialized" );

   854         return;

   855         }

   856 

   857     TLinearOrder<MPEngPresenceAttrModel2> rule(

   858         CAPresenceUtils::CompareAttrModelArray );

   859 

   860     if ( aChangedPresenceIDs ) // Notifier

   861         {

   862         // wrap changed ids and update models for those users

   863         TTrackedPresenceIds updatedIds;

   864         updatedIds.InitializeLC( *aChangedPresenceIDs );

   865         ExtractAttributeModelsForUsersL( updatedIds, aArray );

   866         CleanupStack::PopAndDestroy(); // updatedIds

   867         }

   868     else // Fetcher

   869         {

   870         // we are using fetcher which has fetched the attributes to cache.

   871         // so we must use the cache to decode the stuff

   872         ExtractAttributeModelsForUsersL( *aUserList, aArray );

   873         }

   874     }

   875 

   876 // -----------------------------------------------------------------------------

   877 // CCAPEngPresenceManager::ExtractAttributeModelL

   878 // (other items were commented in a header).

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

   880 //

   881 void CCAPEngPresenceManager::ExtractAttributeModelL( const TDesC& aId,

   882                                                      RPointerArray<MPEngPresenceAttrModel2>& aArray, TUint32 aAttribute )

   883     {

   884     MPEngPresenceAttrModel2* attributeModel = NULL;

   885     TInt error( KErrNone );

   886     if ( aId.Length() == 0 )

   887         {

   888         // no id

   889         error = iPEngAttributeStore->GetOwnAttribute( aAttribute,

   890                                                       attributeModel );

   891         }

   892     else

   893         {

   894         // have id

   895         error = iPEngAttributeStore->GetCachedAttribute( aId, aAttribute,

   896                                                          attributeModel );

   897         }

   898 

   899     if ( error == KErrNone )

   900         {

   901         CleanupClosePushL( *attributeModel );

   902         aArray.AppendL( attributeModel );   // ownership transfers

   903         CleanupStack::Pop(); // attributeModel

   904         }

   905     else if ( ( error != KErrNotSupported ) && ( error != KErrNotFound ) )

   906         {

   907         User::Leave( error );

   908         }

   909     }

   910 

   911 // -----------------------------------------------------------------------------

   912 // CCAPEngPresenceManager::SetPresenceAuthorizationL

   913 // Sets presence authorization mode

   914 // (other items were commented in a header).

   915 // -----------------------------------------------------------------------------

   916 //

   917 void CCAPEngPresenceManager::SetPresenceAuthorizationL(

   918     TInt aAppSettingsAuthValue )

   919     {

   920     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::SetPresenceAuthorizationL, \

   921                          aAppSettingsAuthValue = %d" ), aAppSettingsAuthValue );

   922 

   923     if ( !iPEngAPIInitialized )

   924         {

   925         iCachedAppSettingsAuthValue = aAppSettingsAuthValue;

   926         return;

   927         }

   928 

   929     if ( iRAUsed )

   930         {

   931         CHAT_DP_TXT( "CCAPEngPresenceManager::SetPresenceAuthorizationL - \

   932                       Reactive authorization in use, ignoring call" );

   933         return;

   934         }

   935 

   936     CHAT_DP_TXT( "CCAPEngPresenceManager::SetPresenceAuthorizationL - \

   937                   Reactive authorization not in use" );

   938 

   939     switch ( aAppSettingsAuthValue )

   940         {

   941         case MCASettings::EAll:

   942             {

   943             CHAT_DP_TXT( "Own presence publish: to all" );

   944             iListManager->SetAuthorizationToAllL();

   945             break;

   946             }

   947         case MCASettings::EFriends:

   948             {

   949             CHAT_DP_TXT( "Own presence publish: to friends" );

   950             iListManager->SetAuthorizationToFriendsL();

   951             break;

   952             }

   953         case MCASettings::ENobody:

   954             {

   955             CHAT_DP_TXT( "Own presence publish: to nobody" );

   956             iListManager->SetAuthorizationToNoneL();

   957             break;

   958             }

   959         default:

   960             {

   961             User::Leave( KErrNotSupported );

   962             break;

   963             }

   964         }

   965     }

   966 

   967 

   968 // -----------------------------------------------------------------------------

   969 // CCAPEngPresenceManager::FetchAttributesL

   970 // Fetches attributes for given users

   971 // (other items were commented in a header).

   972 // -----------------------------------------------------------------------------

   973 //

   974 void CCAPEngPresenceManager::FetchAttributesL(  const MDesCArray& aUsers,

   975                                                 CDesCArray *aStateOnline,

   976                                                 CDesCArray *aStateOffline,

   977                                                 CDesCArray *aStateUnknown,

   978                                                 TBool aUpdateStorage  )

   979     {

   980     CHAT_DP_TXT( "CCAPEngPresenceManager::FetchAttributesL" );

   981 

   982     if ( IsLoggedIn() && aUsers.MdcaCount() > 0 )

   983         {

   984         CHAT_DP_TXT( "CCAPEngPresenceManager::FetchAttributesL, \

   985                       fetching attributes" );

   986 #ifdef _DEBUG

   987         TInt count( aUsers.MdcaCount() );

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

   989             {

   990             TPtrC data( aUsers.MdcaPoint( i ) );

   991             CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::FetchAttributesL, \

   992                                   user %d: %S" ), i, &data );

   993             }

   994 #endif

   995         iOperationError = KErrNone;

   996 

   997         // Fetching of attributes may return error

   998         // Leave to avoid hanging in WaitResponseL

   999         User::LeaveIfError( iPEngAttributeTransaction->

  1000                             FetchAttributesToCache( aUsers,

  1001                                                     iAttributes.Array(),

  1002                                                     *this ) );

  1003 

  1004         iRequestQueue.WaitForResponseL( TCARequestQueue::EFetcherWait );

  1005         CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::FetchAttributesL, \

  1006                               attribute fetch done (%d)" ), iOperationError );

  1007 

  1008         // Decode retrieved data if we still have memory left

  1009         if ( iOperationError != KErrNoMemory && iOperationError != KErrDiskFull )

  1010             {

  1011             DecodeFetcherDataL( aUsers, aStateOnline, aStateOffline,

  1012                                 aStateUnknown, aUpdateStorage );

  1013             }

  1014 

  1015         User::LeaveIfError( iOperationError );

  1016         }

  1017     }

  1018 

  1019 // -----------------------------------------------------------------------------

  1020 // CCAPEngPresenceManager::UpdateAliasAttributeL

  1021 // Update alias attribute to the network.

  1022 // (other items were commented in a header).

  1023 // -----------------------------------------------------------------------------

  1024 //

  1025 void CCAPEngPresenceManager::UpdateAliasAttributeL()

  1026     {

  1027     CHAT_DP_TXT( "CCAPEngPresenceManager::UpdateAliasAttributeL" );

  1028 

  1029     if ( iNetworkState != ELoggedIn && iNetworkState != ELoggingOut )

  1030         {

  1031         CHAT_DP_TXT( "CCAPEngPresenceManager::UpdateAliasAttributeL: No active \

  1032                       network state -> ignore!" );

  1033         return;

  1034         }

  1035 

  1036     // check if alias is enabled at all

  1037     if ( ! iAliasUsed )

  1038         {

  1039         CHAT_DP_TXT( "CCAPEngPresenceManager::UpdateAliasAttributeL: Alias \

  1040                       support disabled" );

  1041         return;

  1042         }

  1043 

  1044     HBufC* alias = iApplicationSettings->OwnAliasL();

  1045     if ( !alias )

  1046         {

  1047         CHAT_DP_TXT( "CCAPEngPresenceManager::UpdateAliasAttributeL: Alias \

  1048                       is not defined" );

  1049         return;

  1050         }

  1051 

  1052     CleanupStack::PushL( alias );

  1053     MPEngPresenceAttrModel2* aliasAttr = NULL;

  1054     User::LeaveIfError( iPEngAttributeStore->GetAndLockOwnAttribute(

  1055                             KUidPrAttrAlias, aliasAttr ) );

  1056     CleanupClosePushL( *aliasAttr );

  1057     aliasAttr->SetDataDesC16L( *alias, EPEngAlias );

  1058 

  1059     CHAT_DP_TXT( "CCAPEngPresenceManager::UpdateAliasAttributeL, publishing \

  1060                   attribute" );

  1061     iOperationError = KErrNone;

  1062     TInt err = iPEngAttributeTransaction->PublishAndUnLockOwnAttribute(

  1063                    aliasAttr, *this );

  1064     if ( err )

  1065         {

  1066         CleanupStack::PopAndDestroy(); // aliasAttr

  1067         }

  1068     else

  1069         {

  1070         CleanupStack::Pop( ); // aliasAttr

  1071         }

  1072     CleanupStack::PopAndDestroy( alias );

  1073 

  1074     iRequestQueue.WaitForResponseL( TCARequestQueue::EPublisherWait );

  1075 

  1076     CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::UpdateAliasAttributeL, \

  1077                           attribute publishing done (%d)" ), iOperationError );

  1078 

  1079     if ( iOperationError == ECSPInvalidPresenceValue )

  1080         {

  1081         User::Leave( iOperationError );

  1082         }

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // CCAPEngPresenceManager::SetReactiveAuthObserver

  1087 // Reactive authorization observer for internal events

  1088 // (other items were commented in a header).

  1089 // -----------------------------------------------------------------------------

  1090 //

  1091 void CCAPEngPresenceManager::SetReactiveAuthObserver(

  1092     MCAReactiveAuthObserver* aRAObserver )

  1093     {

  1094     iRAObserver = aRAObserver;

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // CCAPEngPresenceManager::CancelPendingRequests

  1099 // Fetches attributes for given users

  1100 // (other items were commented in a header).

  1101 // -----------------------------------------------------------------------------

  1102 //

  1103 void CCAPEngPresenceManager::CancelPendingRequests()

  1104     {

  1105     CHAT_DP_FUNC_ENTER( "CancelPendingRequests" );

  1106 

  1107     if ( iPEngAttributeTransaction )

  1108         {

  1109         iPEngAttributeTransaction->CancelFetchAttributes();

  1110         iPEngAttributeTransaction->CancelPublishOwnAttributes();

  1111         }

  1112 

  1113     if ( iListManager )

  1114         {

  1115         iListManager->CancelPendingRequests();

  1116         }

  1117 

  1118     CHAT_DP_FUNC_DONE( "CancelPendingRequests" );

  1119     }

  1120 

  1121 // -----------------------------------------------------------------------------

  1122 // CCAPEngPresenceManager::SynchronizePresenceSettingsL

  1123 // Make sure server state is in sync with our presence settings

  1124 // (other items were commented in a header).

  1125 // -----------------------------------------------------------------------------

  1126 //

  1127 void CCAPEngPresenceManager::SynchronizePresenceSettingsL(

  1128     const SServerPrefers& /* aServerPreferences */ )

  1129     {

  1130     // authorization

  1131     SetPresenceAuthorizationL( iApplicationSettings->Value(

  1132                                    MCASettings::EAuthorizeIMPresence ) );

  1133     }

  1134 

  1135 // -----------------------------------------------------------------------------