1 /*

     2 * Copyright (c) 2007 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:  Handles the use of Precense Framework

    15  *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 /*#include <ximpclient.h>*/

    21 #include <ximpcontext.h>

    22 #include <ximpobjectfactory.h>

    23 #include <presenceobjectfactory.h>

    24 #include <ximpidentity.h> //for MXIMPIdentity

    25 #include <presentitygroups.h>

    26 #include <presencewatching.h> //for MximpPresenceWatching

    27 #include <ximpstatus.h> //Presence info test

    28 #include <presentitygroupcontentevent.h>

    29 #include <presentitygroupmemberinfo.h>

    30 #include <presenceauthorization.h>

    31 #include <presentitypresenceevent.h>

    32 #include <presencegrantrequestlistevent.h> // Grant request list

    33 #include <presencegrantrequestinfo.h>

    34 #include <ximpcontextstateevent.h>

    35 #include <ximprequestcompleteevent.h>

    36 #include <presenceblocklistevent.h>

    37 #include <presenceblockinfo.h>

    38 

    39 

    40 #include <presencefeatures.h>

    41 #include <presenceinfofilter.h> //info filtter

    42 #include <presenceinfofield.h> //MximpPresenceInfoField

    43 #include <presenceinfofieldcollection.h> //MximpPresenceInfoFieldCollection

    44 #include <presenceinfofieldvaluetext.h> //MximpPresenceInfoFieldValueText

    45 #include <presenceinfofieldvalueenum.h>

    46 #include <personpresenceinfo.h> // MximpPersonPresenceInfo

    47 #include <presencepublishing.h>//MximpPresencePublishing

    48 #include <ximperrors.hrh> //ximp errors

    49 #include <presenceinfofieldvaluebinary.h>

    50 //presence cache headers 

    51 #include <presencecachereader2.h> // cache reader

    52 

    53 

    54 #include "cvimpstenginepresencesubservice.h"

    55 #include "cvimpststoragemanagerfactory.h"

    56 #include "mvimpststoragecontact.h"

    57 #include "mvimpststoragecontactlist.h"

    58 #include "cvimpstenginerequestmapper.h"

    59 #include "cvimpstenginecchhandler.h"

    60 #include "mvimpststorageserviceview.h"

    61 #include "tvimpstconsts.h"

    62 #include "cvimpstengineservicetablefetcher.h"

    63 #include "cvimpstenginecchhandler.h"

    64 #include "cvimpstenginesessioncntxtobserver.h"

    65 #include "vimpstutilsnotemapper.h"

    66 #include "vimpstallerrors.h"

    67 #include "cvimpstenginerequest.h"

    68 #include "cvimpstblockedlistmanager.h"

    69 #include "mvimpstengineblockedlistfetcheventobserver.h"

    70 

    71 #include   <ximpfeatureinfo.h>

    72 #include <avabilitytext.h>

    73 

    74 //Presence Observer

    75 #include "mvimpstenginepresencesubserviceeventobserver.h"

    76 #include "uiservicetabtracer.h"

    77 #include "vimpstcustomcleanupapi.h" //For customized cleanup function

    78 #include "mvimpstengineserviceconnectioneventobserver.h"

    79 

    80 // CONTANTS

    81 const TInt KUriMaxLength = 255; 

    82 _LIT( KListNameAllBuddy ,"buddylist" );

    83 const TInt KCollationLevel = 1;

    84 

    85 // Compares alphabetically using MVIMPSTStorageContact::Identification and 

    86 // TDesC::CompareC

    87 TInt CompareAlphabetically( const TPtrC& aFirst, 

    88                             const TPtrC& aSecond )

    89     {

    90     return aFirst.CompareC( aSecond, KCollationLevel, NULL );

    91     }

    92 

    93 

    94 // ================= MEMBER FUNCTIONS =======================

    95 

    96 // ---------------------------------------------------------------------------

    97 // CVIMPSTEnginePresenceSubService::

    98 //      CVIMPSTEnginePresenceSubService()

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

   100 //

   101 CVIMPSTEnginePresenceSubService::CVIMPSTEnginePresenceSubService( TUint32 aServiceId, 

   102         CVIMPSTEngineCchHandler& aCchHandler,

   103         CVIMPSTEngineServiceTableFetcher& aTableFetcher,

   104         CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,

   105         MVIMPSTEngineServiceConnectionEventObserver& aObserver ) 

   106 :iServiceId( aServiceId ),

   107 iCchHandler(aCchHandler),

   108 iSettingsTableFetcher(aTableFetcher),

   109 iXimpEventObserver(aXimpEventObserver),

   110     iObserver(aObserver),

   111     iChangeStatusSupported ( ETrue ),

   112     iChangeStatusMsgSupported( ETrue ),

   113     iAvatarSupported( EFalse ),

   114     iIsClearingAvatar(EFalse)

   115         {

   116 	TRACER_AUTO;

   117         }

   118 

   119 // ---------------------------------------------------------------------------

   120 // CVIMPSTEnginePresenceSubService::ConstructL()

   121 // ---------------------------------------------------------------------------

   122 //

   123 void CVIMPSTEnginePresenceSubService::ConstructL()

   124     {

   125 	TRACER_AUTO;

   126 

   127     iCchHandler.RegisterCchObserverL(this,ECCHPresenceSub);

   128 

   129     TCCHSubserviceState serviceState = ECCHUninitialized;    

   130     TInt error = iCchHandler.GetServiceState( 

   131             iServiceId, ECCHPresenceSub, serviceState );

   132 

   133     iServiceState = ResolveServiceStateL(serviceState, error);   

   134     //initialize the presence cache.

   135     iPresenceCacheReader = MPresenceCacheReader2::CreateReaderL();                                                        

   136 

   137     iPresenceCacheReader->SetObserverForSubscribedNotifications(this);

   138     iServiceName = HBufC::NewL( KVIMPSTUISPSMaxPropertyLength );

   139     TPtr serviceNamePtr( iServiceName->Des() );    

   140     iSettingsTableFetcher.GetServiceNameL(iServiceId, serviceNamePtr);      

   141     iBlockedListMgr = CVIMPSTBlockedListManager::NewL();

   142     iBlockListFetchReqPending = EFalse; //req of fetching blocked list has been completed.

   143     

   144 	iLogoutRequest = EFalse;

   145 	iSubscribeToAuthList = EFalse;

   146 	iAutoAccept = EFalse;

   147 

   148     }

   149 

   150 // ---------------------------------------------------------------------------

   151 // CVIMPSTEnginePresenceSubService::NewL()

   152 // ---------------------------------------------------------------------------

   153 //

   154 CVIMPSTEnginePresenceSubService* 

   155 CVIMPSTEnginePresenceSubService::NewL( TUint32 aServiceId, 

   156         CVIMPSTEngineCchHandler& aCchHandler,

   157         CVIMPSTEngineServiceTableFetcher& aTableFetcher,

   158         CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,

   159         MVIMPSTEngineServiceConnectionEventObserver& aObserver )

   160     {

   161 	TRACER_AUTO;

   162     CVIMPSTEnginePresenceSubService* self = NewLC( aServiceId,aCchHandler, aTableFetcher, 

   163             aXimpEventObserver,aObserver );

   164     CleanupStack::Pop(self);

   165     return self;

   166     }

   167 

   168 // ---------------------------------------------------------------------------

   169 // CVIMPSTEnginePresenceSubService::NewLC()

   170 // ---------------------------------------------------------------------------

   171 //

   172 CVIMPSTEnginePresenceSubService* 

   173 CVIMPSTEnginePresenceSubService::NewLC( TUint32 aServiceId, 

   174         CVIMPSTEngineCchHandler& aCchHandler,

   175         CVIMPSTEngineServiceTableFetcher& aTableFetcher,

   176         CVIMPSTEngineSessionCntxtObserver& aXimpEventObserver,

   177         MVIMPSTEngineServiceConnectionEventObserver& aObserver )

   178     {

   179 	TRACER_AUTO;

   180     CVIMPSTEnginePresenceSubService* self =

   181     new (ELeave) CVIMPSTEnginePresenceSubService( aServiceId,aCchHandler, aTableFetcher,  aXimpEventObserver,aObserver);

   182     CleanupStack::PushL(self);

   183     self->ConstructL();

   184     return self;

   185     }

   186 

   187 // ---------------------------------------------------------------------------

   188 // CVIMPSTEnginePresenceSubService::

   189 //      ~CVIMPSTEnginePresenceSubService()

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

   191 //

   192 CVIMPSTEnginePresenceSubService::~CVIMPSTEnginePresenceSubService()

   193     {

   194 	TRACER_AUTO;

   195 	

   196 	iCchHandler.UnRegisterCchObserver(ECCHPresenceSub);

   197     

   198     delete iServiceName;

   199     delete iPresenceCacheReader ; 

   200     

   201     delete iBlockedListMgr;

   202     iBlockedListMgr = NULL;

   203        

   204     }

   205 

   206 // ---------------------------------------------------------------------------

   207 // CVIMPSTEnginePresenceSubService::

   208 //      ServiceState()

   209 // ---------------------------------------------------------------------------

   210 //

   211 

   212 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::SubServiceState() const

   213 	{

   214 	TRACER_AUTO;

   215 	return iServiceState;

   216 	}

   217 

   218 // ---------------------------------------------------------------------------

   219 // CVIMPSTEnginePresenceSubService::

   220 //      Type()

   221 // ---------------------------------------------------------------------------

   222 //

   223 TVIMPSTEnums::SubServiceType CVIMPSTEnginePresenceSubService::Type() const

   224 	{

   225 	TRACER_AUTO;

   226 	TRACE( "CVIMPSTEnginePresenceSubService: [0x%x]", this );

   227 	return TVIMPSTEnums::EPresence;

   228 	}

   229 

   230 // ---------------------------------------------------------------------------

   231 // CVIMPSTEnginePresenceSubService::

   232 //      Enabled()

   233 // ---------------------------------------------------------------------------

   234 //

   235 

   236 TBool CVIMPSTEnginePresenceSubService::Enabled()

   237     {

   238 	TRACER_AUTO;

   239     TBool ret = EFalse;

   240     if( TVIMPSTEnums::ESVCERegistered == iServiceState)

   241         {

   242         ret = ETrue;

   243         }

   244     return ret;    

   245     }

   246 

   247 // ---------------------------------------------------------------------------

   248 // CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL

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

   250 //

   251 void CVIMPSTEnginePresenceSubService::RetrieveSubscribedListL()

   252     {

   253 	TRACER_AUTO;

   254 

   255     //Create group id

   256     TBuf<KUriMaxLength> buffer( KListNameAllBuddy );

   257     MXIMPIdentity* groupList = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();

   258      __ASSERT_ALWAYS( groupList , User::Leave( KErrNoMemory ) );		

   259     groupList->SetIdentityL( buffer );

   260     iIsFetchingContact = ETrue;

   261     //Subscribe buddy list

   262     // do get subscribe list"));

   263     TXIMPRequestId operationId = TXIMPRequestId::Null();

   264     operationId = iXimpEventObserver.XimpPresentityGroupsL().SubscribePresentityGroupContentL( 

   265             *groupList );

   266     CVIMPSTEngineRequestMapper* requestMapper =iXimpEventObserver.GetRequestMapper();

   267     requestMapper->CreateRequestL(operationId,EFalse,EVIMPSTXimpOperationGetSubscribedList);

   268     CleanupStack::PopAndDestroy(); // groupList

   269     // list retrieving ok. Waiting for list.;

   270     }

   271 

   272 // ---------------------------------------------------------------------------

   273 // CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL

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

   275 //

   276 void CVIMPSTEnginePresenceSubService::SubscribePresenceOfSingleContactL( const TDesC& aUriOfTheContact)

   277     {

   278 	TRACER_AUTO;

   279      __ASSERT_ALWAYS( aUriOfTheContact.Length(), User::Leave( KErrArgument ) );		

   280      //if anything is there with colon eg sip:user@presence1. strip the part before :

   281     TInt len = aUriOfTheContact.Find(_L(":"));

   282     TPtrC buddyId = aUriOfTheContact.Right( aUriOfTheContact.Length() - len - KColon().Length());

   283     HBufC* name = HBufC::NewLC( KPropertyMaxLength );

   284     TPtr namePtr( name->Des() );

   285     namePtr.Zero();

   286 

   287     // append the service name followed by user id ,seperated by colon

   288     namePtr.Append(*iServiceName);

   289     namePtr.Append(KColon);

   290     namePtr.Append(buddyId);

   291     

   292     TRACE("SubscribeToPresenceCacheL: %S", &namePtr );

   293     iPresenceCacheReader->SubscribePresenceBuddyChangeL(*name);

   294     CleanupStack::PopAndDestroy(name); //  name    

   295     }

   296 

   297 // ---------------------------------------------------------------------------

   298 // CVIMPSTEnginePresenceSubService::

   299 //      UnsubscribePrecenseOfSingleContactL

   300 // ---------------------------------------------------------------------------

   301 //

   302 void CVIMPSTEnginePresenceSubService::UnSubscribePresenceOfSingleContactL(

   303         const TDesC& aUriOfTheContact )

   304     {

   305 	TRACER_AUTO;

   306     HBufC* name = HBufC::NewLC( KPropertyMaxLength );

   307     TPtr namePtr( name->Des() );

   308     namePtr.Zero();

   309     // append the service name followed by user id ,seperated by colon

   310     namePtr.Append(*iServiceName);

   311     namePtr.Append(KColon);

   312     namePtr.Append(aUriOfTheContact);

   313     

   314     TRACE( "UnSubscribeToPresenceCacheL: %S", &namePtr);

   315     iPresenceCacheReader->UnSubscribePresenceBuddyChangeL(*name);

   316     CleanupStack::PopAndDestroy(name); //  name                  

   317     }

   318 

   319 // ---------------------------------------------------------------------------

   320 // CVIMPSTEnginePresenceSubService::

   321 //      DoHandlePresentityGroupContentEventL

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

   323 //

   324 void CVIMPSTEnginePresenceSubService::

   325 DoHandlePresentityGroupContentEventL(

   326         const MXIMPContext& /*aContext*/,

   327         const MXIMPBase& aEvent )

   328     {

   329 	TRACER_AUTO;

   330 	  	      

   331     const MPresentityGroupContentEvent& event =

   332     	*TXIMPGetInterface< const MPresentityGroupContentEvent >::From( 

   333             aEvent,

   334             MXIMPBase::EPanicIfUnknown );

   335     //this needs to be checked if server contacts is supported only then update to 

   336     //store else don't.

   337 	TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();

   338   	if(EVIMPSTFeatureFetch & supportedFeatures)

   339 		{   

   340   	TRACE(" -> storing into respective service store" );

   341 	    StoreToVirtualStoreL( event );

   342 		}

   343 	//this is to ensure the presence for the local sotre contacts is not lost.

   344   	TRACE( "new member count: %d" , event.NewMembersCount() ); 

   345     TRACE( " current member count: %d" , event.CurrentMembersCount() );  

   346     TRACE( "disappeared member count: %d" , event.DisappearedMembersCount() );   

   347     }

   348 

   349 // ---------------------------------------------------------------------------

   350 // CVIMPSTEnginePresenceSubService::

   351 //      DoHandlePresenceGrantRequestListEventL

   352 // ---------------------------------------------------------------------------

   353 //

   354 void CVIMPSTEnginePresenceSubService::

   355 DoHandlePresenceGrantRequestListEventL(

   356         const MXIMPContext& /*aContext*/,

   357         const MXIMPBase& aEvent )

   358     {

   359 	TRACER_AUTO;

   360     TVIMPSTEnums::TVIMPSTPresenceRequestStatus autoAccept = iSettingsTableFetcher.PresenceRequestStatusL(iServiceId);

   361     if(autoAccept == TVIMPSTEnums::ESVCEPresenceRequestStatusAutoAccept)

   362         {

   363         iAutoAccept = ETrue;

   364         }

   365     else

   366         {

   367         iAutoAccept = EFalse;

   368         }

   369     

   370      const MPresenceGrantRequestListEvent& event = 

   371      							*TXIMPGetInterface<const MPresenceGrantRequestListEvent >::From( 

   372 								aEvent, MXIMPBase::EPanicIfUnknown );

   373 

   374      TRACE("new watcher count: %d" , event.NewRequestsCount() );   

   375      TRACE("current watcher count: %d" , event.CurrentRequestsCount() ); 

   376     HBufC* identbuf(NULL);

   377     HBufC* displayName(NULL);

   378     TInt newcount     = event.NewRequestsCount();

   379     TInt currentcount = event.CurrentRequestsCount();

   380     if(newcount)

   381         {

   382     TRACE( " newcount =%d" , newcount );    

   383     TRACE( "iServiceState =%d" , iServiceState );    

   384 

   385         for(TInt i=0; i<newcount; i++)

   386             {

   387             const MPresenceGrantRequestInfo& reqInfo = event.NewRequest ( i );// its always a new request

   388             identbuf = reqInfo.RequestorId().Identity().AllocLC();

   389             displayName = reqInfo.RequestorDisplayName().AllocLC();

   390             TPtr identbufPtr = identbuf->Des();

   391             TRACE( "identity: %S" , &identbufPtr );   

   392             if(identbuf->Length())

   393                 {

   394             TRACE( " pass to command process" );   

   395                 if( iAutoAccept &&

   396                         TVIMPSTEnums::ESVCERegistered == iServiceState)

   397                     {

   398                     TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );                    

   399                     }

   400                  else if( iSubServiceObserver )

   401                     {

   402                  TRACE( " informed observer." ); 

   403                     iSubServiceObserver->HandleAddRequestEventL( TVIMPSTEnums::EAddItem , *identbuf, *displayName);

   404                     }                    

   405                 TRACE( " pass to command process" );

   406                 }

   407             CleanupStack::PopAndDestroy( displayName );

   408             CleanupStack::PopAndDestroy( identbuf );

   409             }

   410         }

   411     else if(currentcount)

   412         {

   413         const MPresenceGrantRequestInfo& reqInfo = event.CurrentRequest(0 );// its always a new request

   414         identbuf = reqInfo.RequestorId().Identity().AllocLC();

   415         displayName  = reqInfo.RequestorDisplayName().AllocLC();

   416         TPtr identbufPtr = identbuf->Des();

   417         TRACE( "identity: %S" , &identbufPtr );  

   418         if(identbuf->Length())

   419             {

   420         TRACE( " pass to command process" );

   421             if( iAutoAccept)

   422                 {

   423                 TInt error = SendPresenceGrantPresentityL( identbufPtr, ETrue );                    

   424                 }

   425              else if( iSubServiceObserver )

   426                 {

   427              TRACE( " informed observer."); 

   428                 iSubServiceObserver->HandleAddRequestEventL(TVIMPSTEnums::EAddItem ,*identbuf, *displayName);

   429                 }      

   430             TRACE( "pass to command process" ); 

   431             }

   432         CleanupStack::PopAndDestroy( displayName );

   433         CleanupStack::PopAndDestroy ( identbuf );

   434         }    

   435 

   436     }

   437 

   438 // ---------------------------------------------------------------------------

   439 // CVIMPSTEnginePresenceSubService::ResolveServiceStateL

   440 // ---------------------------------------------------------------------------

   441 // 

   442 TVIMPSTEnums::TVIMPSTRegistrationState CVIMPSTEnginePresenceSubService::ResolveServiceStateL(

   443         TCCHSubserviceState aState, 

   444         TInt aServiceError )

   445     {

   446 

   447 	TRACER_AUTO;

   448 

   449     TVIMPSTEnums::TVIMPSTRegistrationState state = TVIMPSTEnums::ESVCENotRegistered;       

   450 

   451     

   452     TRACE( " iServiceId: %d, ServiceState: %d",  iServiceId, aState ); 

   453 

   454     TBool handleServiceStates = ETrue;

   455     if ( aServiceError && ECCHDisabled != aState )

   456         {    

   457         //Only if the Service supports ALR, the state can goto WaitingForNetwork

   458         //Still API from CCH is required to know whether ALR is supported or not

   459         //Not sure whether the below is right - have mailed to Markus for MoreInfo on this state

   460         if ( (KCCHErrorInvalidSettings != aServiceError) && (ECCHConnecting == aState) )        

   461             {   

   462             TRACE( " ESVCEWaitingForNetwork");

   463             handleServiceStates = EFalse;  

   464             //state = TVIMPSTEnums::ESVCEWaitingForNetwork;

   465             state = TVIMPSTEnums::ESVCENotRegistered; 

   466             }

   467         }

   468 

   469     if ( handleServiceStates )

   470         {        

   471         switch ( aState )

   472             {

   473             case ECCHEnabled:

   474                 {

   475                 TRACE( "ESVCERegistered" );

   476                 state = TVIMPSTEnums::ESVCEUpdatingContacts;   

   477                 break;

   478                 }

   479             case ECCHDisconnecting:      

   480                 {

   481                 TRACE( " ESVCERegistered" );   

   482                 state = TVIMPSTEnums::ESVCENetworkDisConnecting;

   483                 }

   484                 break;

   485 

   486             case ECCHUninitialized:

   487             case ECCHDisabled:  

   488                 {

   489                 TRACE( "ESVCENotRegistered");

   490                 state = TVIMPSTEnums::ESVCENotRegistered;                

   491                 }

   492                 break;

   493 

   494             case ECCHConnecting:               

   495                 {

   496                 TRACE( " ESVCENoNetworkConnecting");  

   497                 state = TVIMPSTEnums::ESVCENetworkConnecting;

   498                 }

   499                 break;

   500 

   501             default:

   502                 break;

   503             }

   504         }        

   505 

   506 

   507     return state;  

   508 

   509     }

   510 

   511 

   512 // ---------------------------------------------------------------------------

   513 // CVIMPSTEnginePresenceSubService::CchEventOccuredL

   514 // ---------------------------------------------------------------------------

   515 //

   516 void CVIMPSTEnginePresenceSubService::CchEventOccuredL( 

   517         TUint /*aServiceId*/, 

   518         TCCHSubserviceState aState, 

   519         TInt aServiceError )

   520     {

   521 

   522 	TRACER_AUTO;

   523 	

   524     TRACE("TCCHSubserviceState : %d, ServiceErr: %d", aState, aServiceError );

   525 

   526     if ( aServiceError && ECCHDisabled != aState )

   527         {

   528         //we might even end up in waiting for connection state for all

   529         //those service which are ALR enabled

   530         //So better check here if you get any CCH errors=        

   531         iServiceState = ResolveServiceStateL( aState, aServiceError );

   532         iObserver.HandleServceConnectionEventL();

   533         DoHandleCchErrorL( aServiceError );

   534         }

   535     else

   536         {

   537         TVIMPSTEnums::TVIMPSTRegistrationState currentState = 

   538         							ResolveServiceStateL( aState, aServiceError );

   539         							

   540 		if ( TVIMPSTEnums::ESVCERegistered == iServiceState 

   541 				&& TVIMPSTEnums::ESVCEUpdatingContacts == currentState )

   542 			{

   543 			//dont do anything

   544 			//updating contacts is a special case

   545 			//Once updating contacts, we fetch the groups and once this is done

   546 			//we end up changing the state to registered

   547 			//but CCH might send the same callback twice	

   548 			//to handle this situation we add a check here

   549 			//because we might have already moved from Updatin to Registered state

   550 			}

   551 		else

   552 			{

   553 			iServiceState = ResolveServiceStateL( aState, aServiceError );    

   554 		    iObserver.HandleServceConnectionEventL();			}

   555         }   

   556 

   557 

   558     }

   559 

   560 

   561 // ---------------------------------------------------------------------------

   562 // CVIMPSTEnginePresenceSubService::DoHandleCchErrorL()

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

   564 // 

   565 void CVIMPSTEnginePresenceSubService::DoHandleCchErrorL( 

   566         TInt aServiceError )

   567     {

   568 

   569 	TRACER_AUTO;

   570 	   TRACE( "ServiceErr: %d",  aServiceError );

   571 

   572     if ( aServiceError )

   573         {

   574         //unsubscribe can only be done, when bind is already done

   575         if(TVIMPSTEnums::EVIMPSTBindDone ==iXimpEventObserver.ContextBindStatus())

   576             {

   577             TRACE( "unscribe and unbind");

   578             TRAP_IGNORE( UnsubscribeListsL() ); 

   579             iXimpEventObserver.ServerUnBindL( ETrue );

   580             }

   581         }

   582 

   583 

   584     }

   585 

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

   587 // CVIMPSTEnginePresenceSubService::PublishOwnPresenceL

   588 // 

   589 // ---------------------------------------------------------    

   590 TInt CVIMPSTEnginePresenceSubService::PublishOwnPresenceL(TVIMPSTEnums::TOnlineStatus aStatus, 

   591 														  const TDesC& aValue,

   592 						         						  const TDesC& aFilename /*= KNullDesC*/, 

   593 						         						  const TDesC8& aMimetype /*= KNullDesC8*/,

   594 						         						  TBool aIsAvatar /*= EFalse*/ )

   595     {

   596 	TRACER_AUTO;

   597     // Take handles to object factory and publish interface

   598     MPresencePublishing& publisher = iXimpEventObserver.XimpPresencePublishingL();

   599 

   600     //Fill presence doc with presence components and attributes

   601     MPresenceInfo* myPresence = iXimpEventObserver.PresenceObjectFactoryL().NewPresenceInfoLC();//1

   602     MPersonPresenceInfo *personPresence = iXimpEventObserver.PresenceObjectFactoryL().NewPersonPresenceInfoLC();//2

   603     MPresenceInfoFieldCollection& attributeFields = personPresence->Fields();

   604 	

   605  	MPresenceInfoField* infoField = NULL;

   606  	TRACE( "aIsAvatar: %d",  aIsAvatar );

   607 	// avatar field set || clear

   608 	if ( aIsAvatar )

   609         {

   610 	TRACE( " PublishOwnPresenceL adding avatar field");

   611         

   612      	infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();

   613         MPresenceInfoFieldValueBinary* avatarField = iXimpEventObserver.PresenceObjectFactoryL().NewBinaryInfoFieldLC(); 

   614         TRACE( " PublishOwnPresenceL processing image data");

   615         CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();

   616         CleanupStack::PushL(imageHandler);

   617         // get the avatar content from the image processor

   618         // returns image content if the  processing succesful 

   619         

   620         HBufC8* avatarContent = imageHandler->ProcessImageFromFileL( aFilename , aMimetype);

   621         TRACE( " PublishOwnPresenceL processing image data completed ");

   622         if ( avatarContent )

   623 			{

   624         TRACE( "PublishOwnPresenceL valid image data found ");

   625 			CleanupStack::PushL(avatarContent);

   626 			// set a new avatar

   627 			avatarField->SetBinaryValueL(*avatarContent);

   628  			avatarField->SetMimeTypeL(aMimetype);

   629 			CleanupStack::PopAndDestroy(); // avatarContent

   630 			}

   631 		else

   632 			{

   633 		TRACE("PublishOwnPresenceL NULL image data found ");

   634 			//  clear the avatar 

   635 			avatarField->SetBinaryValueL(KNullDesC8);

   636 			iIsClearingAvatar = ETrue;  //set iIsClearingAvatar to ETrue

   637 			}

   638         CleanupStack::PopAndDestroy(imageHandler); // imageHandler

   639         

   640  	    //Fill presence doc with presence components and attributes

   641         infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvatar ); 

   642         // for clear avatar mimetye is KNUllDesc so set for all the cases

   643        	infoField->SetFieldValue( avatarField );  // avatarField ownership transfered

   644         CleanupStack::Pop(); // avatarField

   645 		attributeFields.AddOrReplaceFieldL(infoField ); // infofield ownership transfered

   646         CleanupStack::Pop(); // infoField

   647 		infoField = NULL;

   648 		TRACE( "adding avatar field completed ");

   649         }

   650 

   651     // availabilty field

   652     infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();//3

   653     //based on the state conver it to  ximpfw status.

   654     NPresenceInfo::TAvailabilityValues availablity = ConvertPresenceStatus( aStatus );

   655     // "availability" attribute

   656     MPresenceInfoFieldValueEnum* availabilityField = iXimpEventObserver.PresenceObjectFactoryL().NewEnumInfoFieldLC();//4

   657     availabilityField->SetValueL( availablity );

   658     infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KAvailabilityEnum ); 

   659     infoField->SetFieldValue( availabilityField );

   660     CleanupStack::Pop(); // availabilityField

   661     attributeFields.AddOrReplaceFieldL(infoField );

   662     CleanupStack::Pop(); // infoField

   663 

   664     //status text field

   665     infoField = iXimpEventObserver.PresenceObjectFactoryL().NewInfoFieldLC();//7

   666     MPresenceInfoFieldValueText* statustextField = iXimpEventObserver.PresenceObjectFactoryL().NewTextInfoFieldLC();//8

   667     //ownership is transfered to statustextField

   668     HBufC* statusText = aValue.AllocLC();

   669     //ownership is not transferred

   670     statustextField->SetTextValueL( *statusText); // some status text

   671     CleanupStack::PopAndDestroy();//statusText

   672     infoField->SetFieldTypeL( NPresenceInfo::NFieldType::KStatusMessage );

   673     infoField->SetFieldValue( statustextField );

   674     CleanupStack::Pop(); // statustextField

   675     attributeFields.AddOrReplaceFieldL( infoField );

   676     CleanupStack::Pop(); // infoField

   677 	

   678 

   679 	myPresence->SetPersonPresenceL(personPresence);

   680     CleanupStack::Pop(); // personPresence

   681   

   682     TXIMPRequestId reqId;

   683     reqId = publisher.PublishOwnPresenceL( *myPresence );

   684     // wait completion

   685     // not own

   686     CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();

   687     mapper->CreateRequestL(reqId, ETrue,EVIMPSTXimpOperationPublisOwnPresence);// waite here

   688     TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error

   689     CleanupStack::PopAndDestroy(1); // myPresence

   690     

   691     return error;

   692     }

   693 

   694 // ---------------------------------------------------------

   695 // CVIMPSTEnginePresenceSubService::UpdateStatusToServerL

   696 // 

   697 // ---------------------------------------------------------    

   698 NPresenceInfo::TAvailabilityValues CVIMPSTEnginePresenceSubService::ConvertPresenceStatus(TVIMPSTEnums::TOnlineStatus aStatus)

   699     {

   700 	TRACER_AUTO;

   701     NPresenceInfo::TAvailabilityValues availablity;

   702     switch(aStatus)

   703         {

   704         case TVIMPSTEnums::EOffline:

   705             {

   706             availablity = NPresenceInfo::ENotAvailable;

   707             break;

   708             }

   709         case TVIMPSTEnums::EOnline:

   710             {

   711             availablity = NPresenceInfo::EAvailable;

   712             break;

   713             }

   714         case TVIMPSTEnums::EInvisible:

   715             {

   716             availablity = NPresenceInfo::EHidden;

   717             break;

   718             }

   719         case TVIMPSTEnums::EAway:

   720             {

   721             availablity = NPresenceInfo::EAway;

   722             break;

   723             }

   724         case TVIMPSTEnums::EBusy:

   725             {

   726             availablity = NPresenceInfo::EBusy;

   727             break;

   728             }

   729         case TVIMPSTEnums::EOnPhone:

   730             {

   731             availablity = NPresenceInfo::EOnPhone;

   732             break;

   733             }

   734         case TVIMPSTEnums::EDoNotDisturb:

   735             {

   736             availablity = NPresenceInfo::EDoNotDisturb;

   737             break;

   738             }

   739         default: 

   740             {

   741             availablity = NPresenceInfo::ENotAvailable;

   742             break;

   743             }

   744         }

   745     return availablity;

   746     }

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

   748 // CVIMPSTEnginePresenceSubService::FetchPresenceFromCache

   749 // 

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

   751 TInt  CVIMPSTEnginePresenceSubService::FetchPresenceFromCache()

   752     {

   753     //TODO::Figure out how to get the service name.

   754     // passed the service id to see the member count

   755     TInt error( KErrArgument );

   756     TRACER_AUTO;

   757 	if( iServiceName )

   758 		{

   759 		TPtr serviceNamePtr = iServiceName->Des();

   760 		TRACE( "CVIMPSTEnginePresenceSubService::FetchPresenceFormCache() - %S", &serviceNamePtr );

   761 		// passed the service to register for notification

   762 		error = iPresenceCacheReader->AllBuddiesPresenceInService(*iServiceName, this );		

   763 		}

   764 	return error;

   765     }

   766 

   767 // ---------------------------------------------------------------------------

   768 // CVIMPSTEnginePresenceSubService::HandlePresenceReadL

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

   770 //  

   771 void CVIMPSTEnginePresenceSubService::HandlePresenceReadL(TInt /*aErrorCode*/,

   772         RPointerArray<MPresenceBuddyInfo2>& aPresenceBuddyInfoList)

   773     {

   774 	TRACER_AUTO;

   775     // we have the ownership of  aPresenceBuddyInfoList : Push it to customize cleanupstack

   776     // aPresenceBuddyInfoList is collection of owned object and each object need to be deleted

   777     CustomCleanupResetAndDestroyPushL(aPresenceBuddyInfoList);

   778     MVIMPSTStorageServiceView* storage = 

   779     				CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId);

   780     TInt buddyCount = aPresenceBuddyInfoList.Count();

   781     TRACE( "count: %d" , buddyCount );

   782     for ( TInt i =0 ; i < buddyCount ; ++i)

   783 		{

   784     TRACE( " buddy index: %d" , i );

   785 		MPresenceBuddyInfo2* buddyinfo = aPresenceBuddyInfoList[i];

   786 		// read the buddyID : returns in XSP format

   787 		TPtrC buddyXSPId = buddyinfo->BuddyId();

   788 		TRACE( "Status Message: %s" , &buddyXSPId );

   789 		TPtrC buddyId = buddyXSPId.Right( buddyXSPId.Length() - iServiceName->Length() - KColon().Length());

   790 		// read the availability /presence state enum value 

   791 		MPresenceBuddyInfo2::TAvailabilityValues availabilityEnum = buddyinfo->Availability();

   792 		TRACE( "Availability ENUM value: %d" , availabilityEnum );

   793 		TPtrC avablityText = buddyinfo->AvailabilityText();

   794 		// convert the presence cache enum value to service tab enum 

   795 		TVIMPSTEnums::TOnlineStatus status = ConvertPresenceCacheEnums( availabilityEnum , avablityText);

   796 		//  get the GetAnyFiled(which has only pending and blocked states.)

   797 		if(TVIMPSTEnums::EUnKnown == status)

   798 			{

   799 			GetKeyFieldsAndValuesL(*buddyinfo,status);

   800 			}

   801 		// read the  status message 

   802 		TPtrC statusMsg = buddyinfo->StatusMessage();

   803 		TRACE("Status Message: %s" , &statusMsg );

   804 		TPtrC8 avatarContent = buddyinfo->Avatar();

   805 		HBufC8* avatarScaledData = NULL;

   806 		if ( avatarContent.Length() )

   807 			{

   808 			TRACE( "avatarContent Content available"  );

   809 			CVIMPSTEngineImageHandler* imageHandler = CVIMPSTEngineImageHandler::NewL();

   810 			CleanupStack::PushL(imageHandler);

   811 			TRACE( "imageHandler created "  );

   812 		    avatarScaledData = imageHandler->ProcessImageFromDataL( avatarContent , KNullDesC8() );

   813 		    TRACE( "ProcessImageFromDataL returned " );

   814 			CleanupStack::PopAndDestroy();//imageHandler

   815 			}

   816 		if( avatarScaledData && avatarScaledData->Length() )

   817 			{

   818 			CleanupStack::PushL(avatarScaledData);

   819 			storage->UpdatePresenceL(buddyId,status,statusMsg, *avatarScaledData );	

   820 			CleanupStack::PopAndDestroy();//avatarScaledData

   821 			}

   822 		else  

   823 			{

   824 			storage->UpdatePresenceL(buddyId, status, statusMsg, KNullDesC8 );		

   825 			}

   826 		}

   827     aPresenceBuddyInfoList.ResetAndDestroy();

   828  

   829     CleanupStack::PopAndDestroy();  //  aPresenceBuddyInfoList

   830     }

   831 

   832 // ---------------------------------------------------------------------------

   833 // CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL

   834 // ---------------------------------------------------------------------------

   835 //  

   836 void CVIMPSTEnginePresenceSubService::HandlePresenceNotificationL(TInt /*aErrorCode*/,

   837         MPresenceBuddyInfo2* aPresenceBuddyInfo)

   838     {

   839 	TRACER_AUTO;

   840        

   841     if ( aPresenceBuddyInfo )

   842         {

   843         CleanupDeletePushL( aPresenceBuddyInfo );

   844         DoHandlePresenceNotificationL(*aPresenceBuddyInfo);

   845         CleanupStack::PopAndDestroy(1); // aPresenceBuddyInfo

   846         

   847         }

   848     }

   849 

   850 

   851 // ---------------------------------------------------------

   852 // CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL

   853 //  

   854 // ---------------------------------------------------------    

   855 void  CVIMPSTEnginePresenceSubService::SubscribeForAuthorizationL()

   856     {

   857 	TRACER_AUTO;

   858     TXIMPRequestId req;

   859     MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();

   860     req = authorization.SubscribePresenceGrantRequestListL();  

   861     // mapper is not own

   862     CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper(); 

   863     mapper->CreateRequestL(req, EFalse,EVIMPSTXimpOperationSubcribeGrantRequestList);

   864     

   865     iSubscribeToAuthList = ETrue;

   866     }

   867 // ---------------------------------------------------------

   868 // CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityResponseL

   869 //  

   870 // ---------------------------------------------------------    

   871 TInt CVIMPSTEnginePresenceSubService::SendPresenceGrantPresentityL( const TDesC& aContactId , TBool aResponse )

   872     {

   873 	TRACER_AUTO;

   874     __ASSERT_ALWAYS( aContactId.Length(), User::Leave( KErrArgument ) );

   875       

   876     // return the response to the server.    

   877     MPresenceAuthorization& authorization = iXimpEventObserver.XimpAuthorizationL();

   878     // mapper is not own

   879     CVIMPSTEngineRequestMapper* mapper = iXimpEventObserver.GetRequestMapper();

   880 

   881     MXIMPIdentity* contactIdentity = iXimpEventObserver.XimpPresenceContextL().ObjectFactory().NewIdentityLC();

   882      __ASSERT_ALWAYS( contactIdentity , User::Leave( KErrNoMemory ) );		

   883     contactIdentity->SetIdentityL( aContactId ) ;    

   884     TXIMPRequestId req;

   885     //accepted the request.

   886     if(aResponse)

   887         {

   888         MPresenceInfoFilter* infoFilt = iXimpEventObserver.PresenceObjectFactoryL().NewPresenceInfoFilterLC();

   889         if( infoFilt )

   890             {

   891             infoFilt->AcceptPersonFilterL( NPresenceInfo::NFieldType::KAcceptAll );

   892             req = authorization.GrantPresenceForPresentityL(*contactIdentity ,*infoFilt );

   893             CleanupStack::PopAndDestroy(); //infoFilt   	

   894             }

   895         }

   896     else// rejected the request.

   897         {        

   898         req = authorization.WithdrawPresenceGrantFromPresentityL(*contactIdentity);         

   899         }

   900     if( iSubServiceObserver && !iAutoAccept )

   901         {

   902         iSubServiceObserver->HandleAddRequestEventL(TVIMPSTEnums::ERemoveItem ,aContactId, KNullDesC() );

   903         }

   904     mapper->CreateRequestL(req, !iAutoAccept, EVIMPSTXimpOperationGrantPresenceForPresentity );

   905 

   906     TInt error = iXimpEventObserver.GetCompletedReqResult(); // get the result error    

   907     if( ( ( error == KPREQUESTERRSUCCESSFUL) || ( error == KErrNone )  || iAutoAccept)  )

   908         {        

   909         MVIMPSTStorageServiceView* storage = CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;

   910         if(storage && ( !storage->IsLocalStore() || iAutoAccept  ) && aResponse )

   911             {   

   912         TRACE( " server store" );

   913             storage->CreateNewContactL( aContactId,KNullDesC, ETrue, iAutoAccept ); // ETrue is for invitation item 

   914             } 

   915         }

   916     CleanupStack::PopAndDestroy(); //contactIdentity

   917     return error;

   918     }  

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

   920 // CVIMPSTEnginePresenceSubService::HandleSessionContextEventL

   921 // ---------------------------------------------------------

   922 void CVIMPSTEnginePresenceSubService::HandleSessionContextEventL(const MXIMPContext& aContext,

   923         const MXIMPBase& aEvent,

   924         TXimpOperation aXimpOperation /*= EVIMPSTXimpOperationNoOperation*/ )

   925     {

   926 	TRACER_AUTO;

   927     TInt32 eventId = aEvent.GetInterfaceId();

   928 

   929     switch( aEvent.GetInterfaceId() )

   930         {

   931         case MXIMPRequestCompleteEvent::KInterfaceId:

   932             {

   933             TRACE( "MXIMPRequestCompleteEvent");

   934             //temp fix TBD

   935             //Only use the operations that u r intertest in

   936             if ( aXimpOperation <= EVIMPSTXimpOperationUnsubscribe )  

   937                 {

   938 

   939                 const MXIMPRequestCompleteEvent* event =

   940                 TXIMPGetInterface< const MXIMPRequestCompleteEvent >::From( 

   941                         aEvent, MXIMPBase::EPanicIfUnknown );

   942                 TRAP_IGNORE( HandleXimpRequestCompleteL( 

   943                         aXimpOperation,

   944                         event->CompletionResult().ResultCode(),

   945                         aEvent ) );

   946                 }

   947             TRACE( "HandlePresenceContextEvent");  

   948 

   949             break;

   950             }

   951         case MXIMPContextStateEvent::KInterfaceId:

   952             {

   953             TRACE( "InsideCallbackswitch::MXIMPContextStateEvent");

   954             TRACE("InsideCallback::MXIMPContextStateEvent");

   955             break;

   956             }

   957         case MPresentityGroupContentEvent::KInterfaceId:

   958             {

   959             TRACE( "MPresentityGroupContentEvent");

   960             DoHandlePresentityGroupContentEventL( aContext, aEvent );

   961             TRACE( "MPresentityGroupContentEvent");

   962             break;  

   963             }

   964         case MPresenceGrantRequestListEvent::KInterfaceId:

   965             {

   966             TRACE( "MPresenceGrantRequestListEvent");

   967             DoHandlePresenceGrantRequestListEventL( aContext, aEvent );

   968             TRACE( "MPresenceGrantRequestListEvent");

   969             break;

   970             }

   971         case MPresenceBlockListEvent::KInterfaceId:

   972            {

   973            TRACE( "MPresenceBlockListEvent");

   974            DoHandlePresenceBlockListEventL( aContext, aEvent );

   975            TRACE( "MPresenceBlockListEvent");

   976 

   977            break;

   978            }

   979            

   980         default:

   981             {

   982             break;

   983             }

   984         }

   985     }    

   986 

   987 // ---------------------------------------------------------------------------

   988 // CVIMPSTEnginePresenceSubService::HandleListEventCompleteL

   989 // ---------------------------------------------------------------------------

   990 //

   991 void CVIMPSTEnginePresenceSubService::HandleListEventCompleteL(TXimpOperation aType,

   992         TInt aCompleteCode,

   993         const MXIMPBase& /*aEvent*/)

   994     { 

   995 	TRACER_AUTO;

   996 

   997     switch ( aType )

   998         {

   999         case EVIMPSTXimpOperationBind:

  1000             {

  1001             if(iLogoutRequest)

  1002                 {

  1003                 //since logout is requested, no need to Subscribe and Retrieve list

  1004                 break;

  1005                 }

  1006             if ( KErrNone == aCompleteCode )

  1007                 {         

  1008 			    SubscribeForAuthorizationL();

  1009                 // get the list.

  1010                 RetrieveSubscribedListL();

  1011                 

  1012                 }

  1013             break;

  1014 

  1015             }

  1016         case EVIMPSTXimpOperationGetSubscribedList:

  1017             {

  1018             if(iLogoutRequest)

  1019                 {

  1020                 //Since logout is requested need not to retrive block list

  1021                 break;

  1022                 }

  1023             // check if blocking is supported then get the blocked list and 

  1024             // subscribe those to persence cache.

  1025             TInt supportedFeatures = iXimpEventObserver.GetSupportedFeatures();

  1026             if ( (EVIMPSTFeatureBlock & supportedFeatures) && (EVIMPSTFeatureUnBlock & supportedFeatures) )

  1027                {

  1028                RetrieveBlockListL();

  1029                }

  1030             break;

  1031             }

  1032         case EVIMPSTXimpOperationUnBind:

  1033             {

  1034             //Logout request completed

  1035             iLogoutRequest = EFalse;

  1036             break;

  1037             }            

  1038         default:

  1039             break;   

  1040         }

  1041     }

  1042 

  1043 // ---------------------------------------------------------------------------

  1044 // CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL

  1045 // ---------------------------------------------------------------------------

  1046 //

  1047 void CVIMPSTEnginePresenceSubService::HandleXimpRequestCompleteL(TXimpOperation aType,

  1048         TInt aCompleteCode,const MXIMPBase& aEvent )

  1049     {

  1050 	TRACER_AUTO;

  1051     switch ( aType )

  1052         {

  1053         case EVIMPSTXimpOperationBind:

  1054         case EVIMPSTXimpOperationGetSubscribedList:

  1055         case EVIMPSTXimpOperationGetBlockList:

  1056             //case TVIMPSTEnums::ESVCEXimpOperationGetWatcherList:

  1057         case EVIMPSTXimpOperationUnBind:        

  1058             {

  1059             HandleListEventCompleteL( aType, aCompleteCode,aEvent );

  1060             break;

  1061             }

  1062         case EVIMPSTXimpOperationWithdrawPresenceGrant:

  1063             {

  1064             break;

  1065             }

  1066         case EVIMPSTXimpOperationBlockPresenceForPresentity:

  1067         case EVIMPSTXimpOperationCancelPresenceBlockFromPresentity:

  1068         default:

  1069             {

  1070             break;

  1071             }

  1072         }

  1073 

  1074 

  1075     }

  1076 // -----------------------------------------------------------------------------

  1077 // CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL

  1078 // -----------------------------------------------------------------------------

  1079 //  

  1080 void CVIMPSTEnginePresenceSubService::StoreToVirtualStoreL(

  1081                             const MPresentityGroupContentEvent& aListEvent )

  1082     {

  1083 	TRACER_AUTO;

  1084 	TRACE( " count = %d",aListEvent.CurrentMembersCount() );

  1085     TRACE("NewMembersCount count = %d",aListEvent.NewMembersCount() );

  1086     TRACE( "UpdatedMembersCount count = %d",aListEvent.UpdatedMembersCount() );

  1087     MVIMPSTStorageServiceView* storage = 

  1088     CVIMPSTStorageManagerFactory::ContactListInterfaceL(iServiceId) ;	

  1089     TLinearOrder< TPtrC > linearOrder (*CompareAlphabetically );

  1090     if (storage)

  1091         {		

  1092         //currMembrCount will be 0 when you login to the service

  1093         if( iIsFetchingContact)  

  1094             {

  1095             // there are contacts process each

  1096             TPtrC listName = aListEvent.GroupId().Identity() ;

  1097             RArray <TPtrC> firstNameList;

  1098             CleanupClosePushL( firstNameList );

  1099             RArray <TPtrC> serviceField;

  1100             CleanupClosePushL( serviceField );

  1101             

  1102             firstNameList.Reset();

  1103             serviceField.Reset();

  1104             // number of contact in this list

  1105            TInt currentMembrcount = aListEvent.CurrentMembersCount();

  1106            TRACE( "currentMembrcount count = %d",currentMembrcount );

  1107             // Handle first current items

  1108             for(TInt j = 0; j < currentMembrcount ;j++ )

  1109                 {

  1110                 const MPresentityGroupMemberInfo& memberInfo = 

  1111                     aListEvent.CurrentMember( j ) ;

  1112                 const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;

  1113                 TPtrC userId = memberIdentity.Identity();

  1114                 TPtrC displayeName = memberInfo.GroupMemberDisplayName();

  1115                 serviceField.AppendL(userId );    

  1116                 firstNameList.AppendL(displayeName );

  1117                 }

  1118 

  1119             // number of contact in this list

  1120             TInt newMembrcount = aListEvent.NewMembersCount() ;

  1121             TRACE("newMembrcount count = %d",newMembrcount );

  1122             for(TInt i = 0; i < newMembrcount ;i++ )

  1123                 {

  1124                 const MPresentityGroupMemberInfo& memberInfo = 

  1125                 aListEvent.NewMember( i ) ;

  1126                 const MXIMPIdentity& memberIdentity = memberInfo.GroupMemberId() ;

  1127                 TPtrC userId = memberIdentity.Identity();

  1128                 TPtrC displayeName = memberInfo.GroupMemberDisplayName();

  1129                 TInt error = serviceField.InsertInOrder(userId,linearOrder);

  1130                 if(KErrAlreadyExists != error)

  1131                     {

  1132                     firstNameList.Append(displayeName);

  1133                     }

  1134                 }