1 /*

     2 * Copyright (c) 2008 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:  Impementation for Presence Cache Server session

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include <mpresencebuddyinfo2.h>

    22 

    23 #include "presenceobjecthelpers.h"

    24 #include "presencecachesession.h"

    25 #include "presencecacheserver.h"

    26 #include "presencetrace.h"

    27 #include "cacheobjecthelpers.h"

    28 #include "presencecacheservicestore.h"

    29 #include "presencecachebuddystore.h"

    30 #include "presencecacheevent.h"

    31 

    32 //Include Cache server namespace

    33 using namespace NCacheSrv2;

    34 

    35 

    36 // ---------------------------------------------------------------------------

    37 // CPresenceCacheSession::NewL()

    38 // ---------------------------------------------------------------------------

    39 //

    40 CPresenceCacheSession* CPresenceCacheSession::NewL( CPresenceCacheServer& aServer )

    41     {

    42     CPresenceCacheSession* self = CPresenceCacheSession::NewLC( aServer );

    43     CleanupStack::Pop(self);

    44     return self;    

    45     }

    46     

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

    48 // CPresenceCacheSession::NewLC()

    49 // ---------------------------------------------------------------------------

    50 //

    51 CPresenceCacheSession* CPresenceCacheSession::NewLC( CPresenceCacheServer& aServer )

    52     {

    53     CPresenceCacheSession* self = new ( ELeave ) CPresenceCacheSession( aServer );

    54     CleanupStack::PushL(self);

    55     self->ConstructL();

    56     return self;    

    57     }

    58 

    59 // ---------------------------------------------------------------------------

    60 // CPresenceCacheSession::~CPresenceCacheSession()

    61 // ---------------------------------------------------------------------------

    62 //

    63 CPresenceCacheSession::~CPresenceCacheSession()

    64     {

    65     if(iDataPack)

    66         delete iDataPack;

    67     if(iDataPackAsync)

    68         delete iDataPackAsync;

    69     iBuddypresInfoList.ResetAndDestroy();

    70     iBuddypresInfoList.Close();

    71         

    72     if(iActiveHelper)

    73         delete iActiveHelper;

    74     iServer.DecrementSessions();

    75     RemoveMySubscriptions(); // remove all subscriptions subscribed by this session

    76     iSubscribedStores.Close();

    77     

    78     EmptyNotificationQueue();

    79     

    80     iNotifyEvents.Close();

    81     

    82     TRACE_1( _L("CPresenceCacheSession[%d]::~CPresenceCacheSession()"), this );

    83     }

    84 

    85 

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

    87 // CPresenceCacheSession::ServiceL()

    88 // ---------------------------------------------------------------------------

    89 //

    90 void CPresenceCacheSession::ServiceL( const RMessage2& aMessage )

    91     {

    92     switch ( aMessage.Function() )

    93         {

    94         case NRequest::EPrepReadPresenceInfoSync:

    95             HandlePrepReadPresenceInfoSyncL(aMessage);

    96             break;

    97             

    98         case NRequest::EGetLastPreparedPacket:

    99             HandleGetLastPreparedPacketL(aMessage);

   100             break;

   101             

   102         case NRequest::EGetLastAsyncPreparedPacket:

   103             HandleGetLastPreparedAsyncPacketL(aMessage);

   104             break;

   105             

   106         case NRequest::EBuddyCountInAllServices:

   107             HandleBuddyCountInAllServicesL(aMessage);

   108             break;

   109             

   110         case NRequest::EBuddyCountInService:

   111             HandleBuddyCountInServiceL(aMessage);

   112             break;

   113             

   114         case NRequest::EGetServiceCount:

   115             HandleGetServiceCountL(aMessage);

   116             break;

   117             

   118         case NRequest::EDeleteService:

   119             HandleDeleteServiceL(aMessage);

   120             break;

   121             

   122         case NRequest::EDeletePresence:

   123             HandleDeletePresenceL(aMessage);

   124             break;

   125             

   126         case NRequest::ECancelAsyncOperation:

   127             HandleCancel(aMessage);

   128             break;

   129 

   130         case NRequest::EWritePresenceInfoSync:

   131             HandleWritePresenceInfoSyncL(aMessage);

   132             break;

   133 

   134         case NRequest::EWritePresenceInfoAsync:

   135             HandleWritePresenceInfoAsyncL(aMessage);

   136             break;

   137             

   138         case NRequest::EPrepReadAllBuddiesPresenceInService:

   139             HandlePrepReadAllBuddiesPresenceInService(aMessage);

   140             break;

   141             

   142         case NRequest::ESubscribeBuddyPresenceChange:// 0:aService.iUid, 1:myIdPack

   143             HandleSubscribeBuddyPresenceChangeL(aMessage);

   144             break;

   145         

   146         case NRequest::EUnSubscribeBuddyPresenceChange: // 0:aService.iUid, 1:myIdPack

   147             HandleUnSubscribeBuddyPresenceChangeL(aMessage);

   148             break;

   149         

   150         case NRequest::EGetLastNotifiedtPacket: // 0:&ptrBuf

   151             HandleGetLastNotifiedtPacketL(aMessage);

   152             break;

   153         

   154         case NRequest::EWaitingForNotification: // 0:&sizePckg

   155             HandleWaitingForNotificationL(aMessage);

   156             break;

   157         

   158         case NRequest::ECancelWaitingForNotification:

   159             HandleCancelWaitingForNotification(aMessage);

   160             break;

   161 

   162         default:

   163         	TRACE( _L("CPresenceCacheSession::ServiceL - default"));

   164             aMessage.Complete(KErrArgument);

   165             break;

   166         }

   167     iServer.StartExpiryCheck();

   168     }

   169 

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

   171 // CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL()

   172 // ---------------------------------------------------------------------------

   173 //

   174 void CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL( const RMessage2& aMessage )

   175     {

   176     TRACE( _L("CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL - begin"));

   177 

   178     TInt sizeOfReturnPacket(NULL);

   179  

   180     // unpacking identity

   181     const TInt pckSize = aMessage.GetDesLengthL(1);

   182     HBufC* idPack = HBufC::NewLC( pckSize );

   183     TPtr paramPckPtr = idPack->Des();    

   184     aMessage.ReadL( 1, paramPckPtr );

   185     

   186     TPtrC serviceName = GetServiceName( paramPckPtr );  

   187     TPtrC identity( paramPckPtr ); 

   188     

   189     // now processing

   190     TInt serviceCount = iServer.iPresenceCache.Count();

   191     MPresenceBuddyInfo2* buddyPresenceInfo(NULL);

   192     CPresenceCacheBuddyStore* buddyStore(NULL);

   193     

   194     TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

   195     

   196     for(TInt i=0; i<serviceCount; i++)

   197         {

   198         if (!(serviceName.CompareF( (iServer.iPresenceCache[i])->ServiceName())))

   199             {

   200             buddyStore = (iServer.iPresenceCache[i])->FindAndGet(identity);

   201             if(buddyStore)

   202                 buddyPresenceInfo = buddyStore->PresenceBuddyInfo();

   203             break;

   204             }

   205         }

   206     

   207     CleanupStack::PopAndDestroy(idPack);

   208     

   209     TInt err = KErrNotFound;

   210     

   211     TRACE_1( _L("_______buddyPresenceInfo[%d]"), buddyPresenceInfo);

   212     if (buddyPresenceInfo) // if found

   213         {

   214         if(iDataPack)

   215             delete iDataPack; iDataPack=NULL;

   216         iDataPack = PackPresenceInfoLC(*buddyPresenceInfo);

   217         CleanupStack::Pop(iDataPack);

   218         sizeOfReturnPacket = (iDataPack->Des()).Size();

   219         err = KErrNone;

   220         }

   221     

   222     TPckgBuf<TInt> p(sizeOfReturnPacket);

   223     aMessage.WriteL(2,p);            

   224     aMessage.Complete(err);

   225     TRACE( _L("CPresenceCacheSession::HandlePrepReadPresenceInfoSyncL - end"));

   226     }

   227 

   228 // ---------------------------------------------------------------------------

   229 // CPresenceCacheSession::HandleGetLastPreparedPacketL()

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

   231 //

   232 void CPresenceCacheSession::HandleGetLastPreparedPacketL( const RMessage2& aMessage )

   233     {

   234     TRACE( _L("CPresenceCacheSession::HandleGetLastPreparedPacketL() - begin"));

   235     if(iDataPack)

   236         aMessage.WriteL(0, *(iDataPack));

   237     aMessage.Complete(KErrNone);   

   238     }

   239 

   240 // ---------------------------------------------------------------------------

   241 // CPresenceCacheSession::HandleGetLastPreparedAsyncPacketL()

   242 // ---------------------------------------------------------------------------

   243 //

   244 void CPresenceCacheSession::HandleGetLastPreparedAsyncPacketL( const RMessage2& aMessage )

   245     {

   246     if(iDataPackAsync)

   247         aMessage.WriteL(0, *(iDataPackAsync));

   248     aMessage.Complete(KErrNone);   

   249     }

   250 

   251 // ---------------------------------------------------------------------------

   252 // CPresenceCacheSession::HandleWritePresenceInfoSyncL()

   253 // ---------------------------------------------------------------------------

   254 //

   255 void CPresenceCacheSession::HandleWritePresenceInfoSyncL(const RMessage2& aMessage )

   256     {

   257     TRACE( _L("CPresenceCacheSession::HandleWritePresenceInfoSyncL - begin"));

   258     TInt err(KErrNone);

   259     const TInt pckSize = aMessage.GetDesLengthL(0);

   260     if(iDataPack)

   261         delete iDataPack; iDataPack=NULL;

   262     iDataPack = HBufC8::NewL( pckSize );

   263     TPtr8 paramPckPtr = iDataPack->Des();

   264     aMessage.ReadL( 0, paramPckPtr );

   265     

   266     MPresenceBuddyInfo2* buddypresenceInfo = MPresenceBuddyInfo2::NewLC();          

   267     TCacheObjectPacker< MPresenceBuddyInfo2 >::UnPackL(*buddypresenceInfo, *iDataPack);        

   268     err = TryWriteBuddyToCacheL(buddypresenceInfo);

   269     

   270     if(err==KErrNone || err == KErrNoMemory)  //ownership  transferred

   271         {

   272         CleanupStack::Pop();       //buddypresenceInfo

   273         }

   274     else       //KErrGeneral, ownership not transferred

   275         {

   276         CleanupStack::PopAndDestroy();

   277         }

   278     aMessage.Complete(err);

   279     TRACE( _L("CPresenceCacheSession::HandleWritePresenceInfoSyncL - end"));

   280     }

   281 

   282 // ---------------------------------------------------------------------------

   283 // CPresenceCacheSession::HandlePrepReadAllBuddiesPresenceInService()

   284 // ---------------------------------------------------------------------------

   285 //

   286 void CPresenceCacheSession::HandlePrepReadAllBuddiesPresenceInService

   287                                                         (const RMessage2& aMessage )

   288     {

   289     if(iActiveHelper->IsActive())

   290         aMessage.Complete(KErrServerBusy);

   291     else

   292         {

   293         iMessage = aMessage;

   294         

   295         iAsyncReq = NRequest::EPrepReadAllBuddiesPresenceInService;

   296         iActiveHelper->Start();

   297         }

   298     }

   299 

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

   301 // CPresenceCacheSession::ReadAllBuddiesPresenceInServiceL()

   302 // ---------------------------------------------------------------------------

   303 //

   304 void CPresenceCacheSession::ReadAllBuddiesPresenceInServiceL()

   305     {

   306     const TInt pckSize = iMessage.GetDesLengthL(0);

   307     HBufC* serviceName = HBufC16::NewLC( pckSize );

   308     TPtr16 paramPckPtr = serviceName->Des();

   309     iMessage.ReadL( 0, paramPckPtr );

   310     

   311     TInt serviceCount = iServer.iPresenceCache.Count();

   312     CPresenceCacheServiceStore* serviceStore(NULL);

   313     CPresenceCacheBuddyStore* buddyStore(NULL);

   314     MPresenceBuddyInfo2* presBuddyInfo(NULL);

   315     TInt presCount(0);

   316     TInt count(0);

   317     

   318     RPointerArray<MPresenceBuddyInfo2> tempArray;

   319     CleanupClosePushL( tempArray );

   320         

   321     for (TInt i=0; i<serviceCount; i++)

   322         {

   323         serviceStore = iServer.iPresenceCache[i];

   324         if (!(serviceName->Des().CompareF( serviceStore->ServiceName())))

   325             {

   326             presCount = serviceStore->PresenceCount();

   327             // if it has presences

   328             if (presCount)

   329                 {

   330                 count = serviceStore->Count();

   331                 for (TInt j=0; j<count; j++)

   332                     {

   333                     buddyStore = serviceStore->GetObjectCollection()[j];

   334                     presBuddyInfo = buddyStore->PresenceBuddyInfo();

   335                     if (presBuddyInfo)

   336                         {

   337                         tempArray.AppendL( presBuddyInfo );

   338                         }

   339                     }                  

   340                 }

   341             break;

   342             }

   343         }

   344         

   345     TInt size(KErrNotFound); // this may also indicate error to client if negative

   346     if ( tempArray.Count() ) // if found

   347         {

   348         if(iDataPackAsync)

   349             delete iDataPackAsync; iDataPackAsync = NULL;

   350         iDataPackAsync = TPresenceArrayPacker::PackArrayL( tempArray );    

   351         size = (iDataPackAsync->Des()).Size();

   352         }

   353     

   354     CleanupStack::PopAndDestroy( ); // tempArray    

   355     CleanupStack::PopAndDestroy(serviceName);

   356     iAsyncReq = NRequest::ENoRequestMade;

   357     iMessage.Complete(size);    

   358     }

   359     

   360 // ---------------------------------------------------------------------------

   361 // CPresenceCacheSession::TryWriteBuddyToCache()

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

   363 //

   364 TInt CPresenceCacheSession::TryWriteBuddyToCacheL(MPresenceBuddyInfo2* aBuddyPresInfo)

   365     {

   366     if (!aBuddyPresInfo)

   367         return KErrArgument;

   368     

   369     TPtrC serviceName = GetServiceName( aBuddyPresInfo->BuddyId() );

   370     TInt serviceCount = iServer.iPresenceCache.Count();

   371     CPresenceCacheBuddyStore* buddyStore(NULL);

   372     

   373     for (TInt i=0; i<serviceCount; i++)

   374         {

   375         CPresenceCacheServiceStore* serviceStore = iServer.iPresenceCache[i];

   376         if ( serviceName.CompareF( serviceStore->ServiceName() ) == 0)

   377             {

   378             buddyStore = serviceStore->AddOrReplacePresenceL(aBuddyPresInfo);

   379             break;

   380             }

   381         }

   382     if (!buddyStore) // if not written

   383         {

   384         CPresenceCacheServiceStore* newServiceStore = CPresenceCacheServiceStore::NewLC();

   385         newServiceStore->SetServiceNameL(serviceName);

   386         buddyStore = newServiceStore->AddOrReplacePresenceL(aBuddyPresInfo);

   387         (iServer.iPresenceCache).Append(newServiceStore); //ownership transferred

   388         CleanupStack::Pop(newServiceStore);

   389         }

   390         

   391     TInt err = KErrGeneral;

   392     if (buddyStore)

   393         {

   394         TRAP( err, NotifyAllSubscribersL(buddyStore) );

   395         if (err != KErrNone && err != KErrNoMemory)

   396             {

   397             User::LeaveIfError(err);

   398             }

   399         

   400         // reset expiry time stamp

   401         PresenceCacheBuddyUtils::ResetBuddyInfoTimeStamp( *aBuddyPresInfo );

   402         }

   403     return err;

   404     }

   405     

   406 

   407 // ---------------------------------------------------------------------------

   408 // CPresenceCacheSession::HandleCancel()

   409 // ---------------------------------------------------------------------------

   410 //

   411 void CPresenceCacheSession::HandleCancel(const RMessage2& aMessage )

   412     {

   413     if (iActiveHelper->IsActive())

   414         iActiveHelper->Cancel(); //see also iActiveHelper->DoCancel()

   415     aMessage.Complete(KErrNotFound);

   416     }

   417     

   418 // ---------------------------------------------------------------------------

   419 // CPresenceCacheSession::HandleBuddyCountInAllServicesL()

   420 // ---------------------------------------------------------------------------

   421 //

   422 void CPresenceCacheSession::HandleBuddyCountInAllServicesL(const RMessage2& aMessage )

   423     {

   424     TRACE( _L("CPresenceCacheSession::HandleBuddyCountInAllServices - begin"));

   425     TInt count(NULL);

   426     TInt serviceCount = iServer.iPresenceCache.Count();

   427     

   428     for(TInt i=0; i<serviceCount; i++)

   429         {

   430         count = (count) + ((iServer.iPresenceCache[i])->PresenceCount());

   431         }

   432     

   433     TPckgBuf<TInt> p(count);

   434     aMessage.WriteL(0,p);               

   435     aMessage.Complete(KErrNone);

   436     TRACE( _L("CPresenceCacheSession::HandleBuddyCountInAllServices - end"));

   437     }

   438 

   439 // ---------------------------------------------------------------------------

   440 // CPresenceCacheSession::HandleBuddyCountInServiceL()

   441 // ---------------------------------------------------------------------------

   442 //

   443 void CPresenceCacheSession::HandleBuddyCountInServiceL(const RMessage2& aMessage )

   444     {

   445     TInt count(NULL);

   446     

   447     const TInt pckSize = aMessage.GetDesLengthL(1);

   448     HBufC* serviceName = HBufC16::NewLC( pckSize );

   449     TPtr16 paramPckPtr = serviceName->Des();

   450     aMessage.ReadL( 1, paramPckPtr );

   451     

   452     TInt serviceCount = iServer.iPresenceCache.Count();

   453     TInt err(KErrNotFound);

   454     

   455     for(TInt i=0; i<serviceCount; i++)

   456         {

   457         if (!(serviceName->Des().CompareF((iServer.iPresenceCache[i])->ServiceName())))

   458             {

   459             count = ((iServer.iPresenceCache[i])->PresenceCount());

   460             err = KErrNone;

   461             break;

   462             }

   463         }

   464     

   465     CleanupStack::PopAndDestroy(serviceName);

   466     TPckgBuf<TInt> p(count);

   467     aMessage.WriteL(0,p);

   468     aMessage.Complete(err);    

   469     }

   470 

   471 // ---------------------------------------------------------------------------

   472 // CPresenceCacheSession::HandleDeleteServiceL()

   473 // ---------------------------------------------------------------------------

   474 //

   475 void CPresenceCacheSession::HandleDeleteServiceL(const RMessage2& aMessage )

   476     {

   477     TRACE( _L("CPresenceCacheSession::HandleDeleteServiceL - begin"));

   478     TInt err(KErrNotFound);

   479         

   480     const TInt pckSize = aMessage.GetDesLengthL(0);

   481     HBufC* serviceName = HBufC16::NewLC( pckSize );

   482     TPtr16 paramPckPtr = serviceName->Des();

   483     aMessage.ReadL( 0, paramPckPtr );

   484     

   485     TInt serviceCount = iServer.iPresenceCache.Count();

   486     TInt buddyCount(NULL);

   487     

   488     TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

   489     for(TInt i=serviceCount-1; i >= 0; i--)

   490         {

   491         if (!(serviceName->Des().CompareF((iServer.iPresenceCache[i])->ServiceName())))

   492             {

   493             (iServer.iPresenceCache[i])->RemoveAllPresences();

   494             buddyCount = (iServer.iPresenceCache[i])->GetObjectCollection().Count();

   495             TRACE_1( _L("_______buddyCountAfter[%d]"), buddyCount);

   496             

   497             //if there are no buddies left in this service delete this whole service

   498             if (buddyCount == 0)

   499                 {

   500                 delete iServer.iPresenceCache[i];

   501                 iServer.iPresenceCache.Remove(i);

   502                 }

   503                 

   504             //inform all subscribers

   505             for(TInt j=0; j < buddyCount; j++)

   506                 {

   507                 NotifyAllSubscribersL((iServer.iPresenceCache[i])->GetObjectCollection()[j]);

   508                 }

   509             err = KErrNone;

   510             // break;

   511             }

   512         }

   513     CleanupStack::PopAndDestroy(serviceName);

   514     aMessage.Complete(err);

   515     TRACE( _L("CPresenceCacheSession::HandleDeleteServiceL - end"));

   516     }

   517     

   518 // ---------------------------------------------------------------------------

   519 // CPresenceCacheSession::HandleDeletePresenceL()

   520 // ---------------------------------------------------------------------------

   521 //

   522 void CPresenceCacheSession::HandleDeletePresenceL(const RMessage2& aMessage )

   523     {

   524     const TInt pckSize = aMessage.GetDesLengthL(0);

   525     HBufC* idPack = HBufC::NewLC( pckSize );

   526     TPtr paramPckPtr = idPack->Des();

   527     aMessage.ReadL( 0, paramPckPtr );

   528     TInt err(KErrNotFound);

   529     TInt buddyCount(NULL);

   530         

   531     TPtrC serviceName = GetServiceName( paramPckPtr );  

   532     TPtrC identity( paramPckPtr );     

   533             

   534     TInt serviceCount = iServer.iPresenceCache.Count();

   535     

   536     CPresenceCacheBuddyStore* buddyStore(NULL);

   537     for(TInt i=0; i<serviceCount; i++)

   538         {

   539         if( !((iServer.iPresenceCache[i])->ServiceName()).CompareF(serviceName) )

   540             {

   541             buddyStore = (iServer.iPresenceCache[i])->FindAndRemove( identity,err);

   542             

   543             buddyCount = (iServer.iPresenceCache[i])->GetObjectCollection().Count();

   544             TRACE_1( _L("_______buddyCountAfter[%d]"), buddyCount);

   545             

   546             //if there are no buddies left in this service delete this whole service

   547             if(buddyCount==0)

   548                 {

   549                 delete iServer.iPresenceCache[i];

   550                 iServer.iPresenceCache.Remove(i);

   551                 }

   552             break;

   553             }

   554         }

   555 

   556     CleanupStack::PopAndDestroy(idPack);

   557     aMessage.Complete(err);

   558     

   559     if(buddyStore) // if subscribers

   560         NotifyAllSubscribersL(buddyStore);

   561     }

   562     

   563 

   564 // ---------------------------------------------------------------------------

   565 // CPresenceCacheSession::HandleGetServiceCountL()

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

   567 //

   568 void CPresenceCacheSession::HandleGetServiceCountL(const RMessage2& aMessage )

   569     {

   570     // iLastServiceCount is also used for mem aloc by client before calling

   571     // GetAllServices

   572     TInt serviceCount = iServer.iPresenceCache.Count();

   573     iLastServiceCount = 0;

   574     TRACE_1( _L("CPresenceCacheSession::HandleGetServiceCount realcount[%d]- end"),serviceCount);

   575     for(TInt i=0;i<serviceCount;i++)

   576         {

   577         if((iServer.iPresenceCache[i])->PresenceCount())

   578             iLastServiceCount++;

   579         }

   580 

   581     TPckgBuf<TInt> p(iLastServiceCount);

   582     aMessage.WriteL(0,p);

   583     aMessage.Complete(KErrNone);

   584     }

   585 

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

   587 // CPresenceCacheSession::HandleGetAllServicesL()

   588 // ---------------------------------------------------------------------------

   589 //

   590 /*

   591 void CPresenceCacheSession::HandleGetAllServicesL(const RMessage2& aMessage )   

   592     {

   593     TInt serviceCount = iServer.iPresenceCache.Count();

   594     TInt size(NULL);

   595     

   596     if(serviceCount)

   597     	{

   598         CArrayFixFlat<TUid>* services = new (ELeave) CArrayFixFlat<TUid>(1);

   599         CleanupStack::PushL(services);

   600     	

   601     	for(TInt i=0; i<serviceCount; i++)

   602 	        {

   603 	        if((iServer.iPresenceCache[i])->PresenceCount())

   604 	            services->AppendL((iServer.iPresenceCache[i])->Service());

   605 	        }

   606 	    

   607 	    if (iDataPack)

   608 	        {

   609 	        delete iDataPack; iDataPack = NULL;

   610 	        }

   611 	    iDataPack = PackServicesL(services);

   612 	    CleanupStack::PopAndDestroy(services);

   613 	    size = (iDataPack->Des()).Size();

   614     	}

   615     aMessage.Complete(size);

   616     }*/

   617     

   618 // ---------------------------------------------------------------------------

   619 // CPresenceCacheSession::HandleWritePresenceInfoAsyncL()

   620 // ---------------------------------------------------------------------------

   621 //

   622 void CPresenceCacheSession::HandleWritePresenceInfoAsyncL(const RMessage2& aMessage )

   623     {

   624     if(iActiveHelper->IsActive())

   625         {

   626         aMessage.Complete(KErrServerBusy);

   627         return;        

   628         }

   629     iMessage = aMessage;

   630            

   631     const TInt pckSize = aMessage.GetDesLengthL(0);

   632     if(iDataPackAsync)

   633         delete iDataPackAsync; iDataPackAsync = NULL;

   634     iDataPackAsync = HBufC8::NewL( pckSize );

   635     TPtr8 paramPckPtr = iDataPackAsync->Des();

   636     aMessage.ReadL( 0, paramPckPtr );  

   637     

   638     TPresenceArrayPacker::UnPackArrayL( iBuddypresInfoList,*iDataPackAsync  );

   639         

   640     iAsyncReq = NRequest::EWritePresenceInfoAsync;

   641     iActiveHelper->Start();

   642     return;          

   643     }

   644 

   645 // ---------------------------------------------------------------------------

   646 // CPresenceCacheSession::WritePresenceInfoAsyncL()

   647 // ---------------------------------------------------------------------------

   648 //

   649 void CPresenceCacheSession::WritePresenceInfoAsyncL()

   650     {

   651     TInt err(KErrNone);

   652     TInt thisTimeWrites(0);

   653     

   654     // This routine reads data from iBuddypresInfoList and tries to write 

   655     // data to cache on each runl cycle. It writes either KMaxWriteEachCycle 

   656     // times, or upto data is finnished. After data is written KMaxWriteEachCycle

   657     // times and still more data is left, it makes this class active so that this

   658     // function is again called on next RunL.

   659     

   660     while (iBuddypresInfoList.Count())

   661         {

   662         err = TryWriteBuddyToCacheL( iBuddypresInfoList[0]);        

   663         if (err == KErrNone || err == KErrNoMemory)       // ownership transferred

   664             {

   665             iBuddypresInfoList.Remove( 0 );            

   666             }

   667         else        

   668             {

   669             iBuddypresInfoList.ResetAndDestroy();            

   670             break; 

   671             }

   672         thisTimeWrites++;    

   673         if(thisTimeWrites == NConstants::KMaxWriteEachCycle) // this times writes are over

   674             {

   675             if(iActiveHelper->IsActive())// unusual condition

   676                 {

   677                 err = KErrGeneral;

   678                 break;

   679                 }

   680             iActiveHelper->Start();

   681             return; // set for next time writing.

   682             }

   683        }

   684               

   685     // if we able to come out of while loop either writing is complete or

   686     // there was some error while writing, in both cases finnish writing

   687     iAsyncReq = NRequest::ENoRequestMade;

   688     iMessage.Complete(err);

   689     return;

   690     }

   691 

   692 // ---------------------------------------------------------------------------

   693 // CPresenceCacheSession::HandleSubscribeBuddyPresenceChangeL()

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

   695 //

   696 void CPresenceCacheSession::HandleSubscribeBuddyPresenceChangeL

   697                                                 (const RMessage2& aMessage )

   698     {

   699     TRACE( _L("CPresenceCacheSession::HandleSubscribeBuddyPresenceChange - begin"));

   700 

   701     // Extract info from message

   702     const TInt pckSize = aMessage.GetDesLengthL(1);

   703     HBufC* idPack = HBufC::NewLC( pckSize );

   704     TPtr paramPckPtr = idPack->Des();

   705     aMessage.ReadL( 1, paramPckPtr );

   706     

   707     TPtrC identity = paramPckPtr;

   708     TPtrC serviceName = GetServiceName( identity );

   709     

   710     CPresenceCacheBuddyStore* buddyStore(NULL);

   711     CPresenceCacheServiceStore* serviceStore(NULL);

   712     

   713     TInt err(KErrNone);

   714     

   715     // now processing

   716     TInt serviceCount = iServer.iPresenceCache.Count();

   717     

   718     TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

   719     

   720     for (TInt i=0; i<serviceCount; i++)

   721         {

   722         if (!(serviceName.CompareF((iServer.iPresenceCache[i])->ServiceName())))

   723             {

   724             serviceStore = iServer.iPresenceCache[i];

   725             buddyStore = (iServer.iPresenceCache[i])->FindAndGet(identity);

   726             break;

   727             }

   728         }

   729         

   730     if (!buddyStore) // if buddy was not found, create and add it

   731         {

   732         if (!serviceStore) //if service was also not found, create it

   733             {

   734             serviceStore = CPresenceCacheServiceStore::NewLC();

   735             serviceStore->SetServiceNameL(serviceName);

   736             (iServer.iPresenceCache).Append(serviceStore); //ownership transferred

   737             CleanupStack::Pop(serviceStore);  

   738             }

   739         else

   740             {            

   741             }

   742         buddyStore = CPresenceCacheBuddyStore::NewLC(serviceStore,identity);

   743         err = serviceStore->AddBlind(buddyStore); //ownership transferred

   744         CleanupStack::Pop(buddyStore);

   745         } 

   746     else

   747         {

   748         }

   749     

   750     CleanupStack::PopAndDestroy(idPack);

   751     

   752     TRACE_1( _L("buddyStore[%d]"), buddyStore);

   753 

   754     buddyStore->AddSubscribedSession(this);

   755     if (iSubscribedStores.Find(buddyStore) < 0) //if session not already there

   756         iSubscribedStores.Append(buddyStore);

   757     

   758     aMessage.Complete(err); // there shouldnt be any errors

   759     TRACE( _L("CPresenceCacheSession::HandleSubscribeBuddyPresenceChange - end"));

   760     }

   761 

   762 // ---------------------------------------------------------------------------

   763 // CPresenceCacheSession::HandleUnSubscribeBuddyPresenceChangeL()

   764 // ---------------------------------------------------------------------------

   765 //

   766 void CPresenceCacheSession::HandleUnSubscribeBuddyPresenceChangeL

   767                                                 (const RMessage2& aMessage )

   768     {

   769     TRACE( _L("CPresenceCacheSession::HandleUnSubscribeBuddyPresenceChange - begin"));

   770 

   771     // Extract info from message

   772     const TInt pckSize = aMessage.GetDesLengthL(1);

   773     HBufC* idPack = HBufC::NewLC( pckSize );

   774     TPtr paramPckPtr = idPack->Des();

   775     aMessage.ReadL( 1, paramPckPtr );

   776     TInt err(KErrNotFound);

   777     TPtrC identity = paramPckPtr;        

   778     TPtrC serviceName = GetServiceName(identity);

   779         

   780     // now processing

   781     TInt serviceCount = iServer.iPresenceCache.Count();

   782     CPresenceCacheBuddyStore* buddyStore(NULL);

   783     

   784     TRACE_1( _L("_______serviceCount[%d]"), serviceCount);

   785     

   786     for(TInt i=0; i<serviceCount; i++)

   787         {

   788         if (!(serviceName.CompareF((iServer.iPresenceCache[i])->ServiceName())))

   789             {

   790             buddyStore = (iServer.iPresenceCache[i])->FindAndGet(identity);

   791             break;

   792             }

   793         }

   794     

   795     CleanupStack::PopAndDestroy(idPack);

   796     

   797     TRACE_1( _L("buddyStore[%d]"), buddyStore);

   798     if(buddyStore) // if found

   799         {

   800         buddyStore->RemoveSubscribedSession(this);

   801 		

   802         const TInt buddyStoreIndex = iSubscribedStores.Find(buddyStore);

   803         if ( KErrNotFound != buddyStoreIndex )

   804             {

   805             iSubscribedStores.Remove(buddyStoreIndex);

   806             }

   807         err = KErrNone;

   808         }

   809     

   810     aMessage.Complete(err);

   811     TRACE_1( _L("CPresenceCacheSession::HandleUnSubscribeBuddyPresenceChange (%d) - end"),err);

   812     }

   813 

   814 // ---------------------------------------------------------------------------

   815 // CPresenceCacheSession::HandleGetLastNotifiedtPacketL()

   816 // ---------------------------------------------------------------------------

   817 //

   818 void CPresenceCacheSession::HandleGetLastNotifiedtPacketL(const RMessage2& aMessage )

   819     {

   820     TRACE( _L("CPresenceCacheSession::HandleGetLastNotifiedtPacketL() - begin"));

   821     

   822     SendNextEventL( aMessage );

   823     

   824     aMessage.Complete(KErrNone); 

   825     

   826     SendNextEventNotificationL();

   827         

   828     TRACE( _L("CPresenceCacheSession::HandleGetLastNotifiedtPacketL() - end"));    

   829     }

   830 

   831 // ---------------------------------------------------------------------------

   832 // CPresenceCacheSession::HandleWaitingForNotificationL()

   833 // ---------------------------------------------------------------------------

   834 //

   835 void CPresenceCacheSession::HandleWaitingForNotificationL(const RMessage2& aMessage )

   836     {

   837     iMessageForNoti = aMessage;

   838     SendNextEventNotificationL( );

   839     }

   840 

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

   842 // CPresenceCacheSession::HandleCancelWaitingForNotification()

   843 // ---------------------------------------------------------------------------

   844 //

   845 void CPresenceCacheSession::HandleCancelWaitingForNotification

   846                                                     (const RMessage2& aMessage )

   847     {

   848     aMessage.Complete(KErrNone);

   849     if(!iMessageForNoti.IsNull())

   850         iMessageForNoti.Complete(KErrCancel);

   851     EmptyNotificationQueue();    

   852     }

   853 

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

   855 // CPresenceCacheSession::NotifyPresenceChangeL()

   856 // ---------------------------------------------------------------------------

   857 //

   858 void CPresenceCacheSession::NotifyPresenceChangeL(

   859     const MPresenceBuddyInfo2* aPresenceBuddyInfo )  

   860     {

   861     TRACE( _L("CPresenceCacheSession::NotifyPresenceChangeL() - begin"));

   862     TInt sizeOfReturnPacket(NULL);

   863     

   864     if ( !aPresenceBuddyInfo)

   865         {        

   866         return;

   867         }

   868 

   869     HBufC8* msg = PackBuddyPresenceInfoLC(aPresenceBuddyInfo);        

   870     AddIntoQueueL( msg );

   871     // ownership is taken

   872     CleanupStack::Pop( msg );

   873         

   874     SendNextEventNotificationL( );

   875     

   876     TRACE( _L("CPresenceCacheSession::NotifyPresenceChangeL - end"));

   877     }

   878     

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

   880 // CPresenceCacheSession::NotifyAllSubscribersL()

   881 // ---------------------------------------------------------------------------

   882 //

   883 void CPresenceCacheSession::NotifyAllSubscribersL

   884                                         (CPresenceCacheBuddyStore* aBuddyStore)

   885     {

   886     TRACE( _L("CPresenceCacheSession::NotifyAllSubscribers() - begin"));

   887     if (!aBuddyStore)

   888         return;

   889     TInt subsCount = aBuddyStore->GetSubscribedSessions().Count();

   890     TRACE_1( _L("_______total subscribed sessions[%d]"), subsCount);

   891     TBool ownBuddyInfo(EFalse);

   892     const MPresenceBuddyInfo2* buddyInfo;

   893     

   894     if (subsCount) // start processing if there are subscribers

   895         {

   896         //if presence has been deleted we need to identity and service id in the packed

   897         //which will be sent to clients

   898         if (!(aBuddyStore->PresenceBuddyInfo()))

   899             {           

   900             MPresenceBuddyInfo2* buddyInfoTemp =  MPresenceBuddyInfo2::NewLC();

   901             buddyInfoTemp->SetIdentityL( aBuddyStore->BuddyId() );

   902             ownBuddyInfo = ETrue;

   903             buddyInfo = buddyInfoTemp;

   904             }

   905         else

   906             {

   907             buddyInfo = aBuddyStore->PresenceBuddyInfo();  

   908             }

   909             

   910         CPresenceCacheSession* session(NULL);

   911         for (TInt i=0;i<subsCount;i++)

   912             {

   913             session = aBuddyStore->GetSubscribedSessions()[i];

   914             if (iServer.SessionExists(session))

   915                 {

   916                 TRACE_1( _L("_______valid session notified[%d]"), session);

   917                 session->NotifyPresenceChangeL(buddyInfo);

   918                 }

   919             else

   920                 {

   921                 aBuddyStore->RemoveSubscribedSession(session);

   922                 subsCount--;//substract this removed session from total count

   923                 i--;

   924                 TRACE_1( _L("_______invalid session removed[%d]"), session);

   925                 }    

   926             }

   927         }

   928         

   929     if (ownBuddyInfo)

   930         CleanupStack::PopAndDestroy(1); //buddyInfoTemp

   931     TRACE( _L("CPresenceCacheSession::NotifyAllSubscribers() - end"));

   932     }

   933 

   934 // ---------------------------------------------------------------------------

   935 // CPresenceCacheSession::GetServiceName()

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

   937 //

   938 TPtrC CPresenceCacheSession::GetServiceName(const TDesC& aXspId)

   939     {

   940     _LIT(KColon, ":");

   941     TInt pos = aXspId.Find(KColon);

   942     TPtrC serviceName;

   943     if(pos>0) // if colon found and there is something before colon, i.e. xsp id

   944         {

   945         serviceName.Set(aXspId.Left(pos));

   946         }

   947     else

   948         serviceName.Set(TPtrC());

   949     return serviceName;

   950     }

   951         

   952 // ---------------------------------------------------------------------------

   953 // CPresenceCacheSession::Cancel()

   954 // ---------------------------------------------------------------------------

   955 //

   956 void CPresenceCacheSession::Cancel()

   957     {

   958     if (iAsyncReq != NRequest::ENoRequestMade)

   959         {

   960         iMessage.Complete(KErrCancel);

   961         iAsyncReq = NRequest::ENoRequestMade;

   962         }

   963     return;   

   964     }

   965     

   966 // ---------------------------------------------------------------------------

   967 // CPresenceCacheSession::PackPresenceDocLC()

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

   969 //

   970 HBufC8* CPresenceCacheSession::PackPresenceInfoLC(const MPresenceBuddyInfo2& aPresInfo)

   971     {

   972     HBufC8* pack = TCacheObjectPacker< MPresenceBuddyInfo2 >::PackL( aPresInfo );    

   973     CleanupStack::PushL( pack );

   974     return pack;

   975     }

   976     

   977 // ---------------------------------------------------------------------------

   978 // CPresenceCacheSession::PackBuddyPresenceInfoLC()

   979 // ---------------------------------------------------------------------------

   980 //

   981 HBufC8* CPresenceCacheSession::PackBuddyPresenceInfoLC(

   982     const MPresenceBuddyInfo2* aBuddyPresInfo )

   983     {

   984     HBufC8* pack(NULL);

   985     if ( aBuddyPresInfo )

   986         {

   987         pack = TCacheObjectPacker< const MPresenceBuddyInfo2>::PackL( *aBuddyPresInfo );

   988         CleanupStack::PushL( pack );

   989         }

   990 

   991     return pack;

   992     }

   993     

   994 // ---------------------------------------------------------------------------

   995 // CPresenceCacheSession::CPresenceCacheSession()

   996 // ---------------------------------------------------------------------------

   997 //

   998 CPresenceCacheSession::CPresenceCacheSession( CPresenceCacheServer& aServer )

   999                                                         : iServer( aServer ),

  1000                                                         iLastServiceCount(0)

  1001     {

  1002     TRACE( _L("CPresenceCacheSession::CPresenceCacheSession()"));

  1003     }

  1004 

  1005 // ---------------------------------------------------------------------------

  1006 // CPresenceCacheSession::ConstructL()

  1007 // ---------------------------------------------------------------------------

  1008 //

  1009 void CPresenceCacheSession::ConstructL()

  1010     {

  1011     iActiveHelper = CCacheSessionActiveHelper::NewL(this);    

  1012     iServer.IncrementSessions();

  1013     return;

  1014     }

  1015     

  1016 // ---------------------------------------------------------------------------

  1017 // CPresenceCacheSession::RemoveMySubscriptions()

  1018 // ---------------------------------------------------------------------------

  1019 //

  1020 void CPresenceCacheSession::RemoveMySubscriptions()

  1021     {

  1022     TInt count = iSubscribedStores.Count();

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

  1024         {

  1025         // it can be assumed that store is alive, since it won't be deleted

  1026         // until there is any session subscribed to it

  1027         (iSubscribedStores[i])->RemoveSubscribedSession(this);

  1028         }

  1029     }

  1030 

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

  1032 // 

  1033 void CPresenceCacheSession::EmptyNotificationQueue()

  1034     {

  1035     const TInt count = iNotifyEvents.Count();

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

  1037         {

  1038         CPresenceCacheEvent* event( iNotifyEvents[0] );

  1039         iNotifyEvents.Remove( 0 );

  1040         delete event;

  1041         event = NULL;

  1042         }

  1043     }

  1044 

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

  1046 // 

  1047 void CPresenceCacheSession::AddIntoQueueL( HBufC8* aMsg )

  1048     {

  1049     TRACE( _L("CPresenceCacheSession::AddIntoQueueL() - begin"));    

  1050     CPresenceCacheEvent* event = CPresenceCacheEvent::NewL( aMsg );

  1051     CleanupStack::PushL( event );

  1052     User::LeaveIfError( iNotifyEvents.Append( event ) );

  1053     CleanupStack::Pop();  //event

  1054     TRACE( _L("CPresenceCacheSession::AddIntoQueueL() - end"));    

  1055     }

  1056 

  1057 // ----------------------------------------------------

  1058 // 

  1059 void CPresenceCacheSession::SendNextEventL( const RMessage2& aMessage )

  1060     {

  1061     TRACE( _L("CPresenceCacheSession::SendNextEventL() - begin"));    

  1062     

  1063     if ( iNotifyEvents.Count() > 0 )

  1064         {

  1065         CPresenceCacheEvent* event( iNotifyEvents[0] );

  1066         aMessage.WriteL(0, event->Message());            

  1067         // aMessage.Complete(KErrNone);       

  1068         iNotifyEvents.Remove( 0 );

  1069         delete event;

  1070         event = NULL;

  1071         }

  1072     else

  1073         {        

  1074         }

  1075     

  1076     TRACE( _L("CPresenceCacheSession::SendNextEventL() - end"));

  1077     

  1078     return;

  1079     }

  1080 

  1081 // ----------------------------------------------------

  1082 // 

  1083 void CPresenceCacheSession::SendNextEventNotificationL( )

  1084     {

  1085     TRACE( _L("CPresenceCacheSession::SendNextEventNotificationL() - begin"));

  1086     

  1087     TInt sizeOfReturnPacket(NULL);    

  1088     

  1089     if ( iNotifyEvents.Count() > 0 && (!iMessageForNoti.IsNull()))

  1090         {

  1091         CPresenceCacheEvent* event( iNotifyEvents[0] );

  1092         if ( !event->NotifySent() )

  1093             {

  1094             event->SetNotifySent();              

  1095             sizeOfReturnPacket = event->Message().Size();

  1096             TPckgBuf<TInt> p(sizeOfReturnPacket);          

  1097             iMessageForNoti.WriteL(0,p);            

  1098             iMessageForNoti.Complete(KErrNone); 

  1099             }

  1100         else

  1101             {

  1102             // Do not sent twice the same, 

  1103             // client first refresh notification request and after that gets the last notification packet.

  1104             }

  1105         }

  1106     else

  1107         {        

  1108         }

  1109     

  1110     TRACE( _L("CPresenceCacheSession::SendNextEventNotificationL() - end"));

  1111     

  1112     return;

  1113     }

  1114     

  1115 // ---------------------------------------------------------------------------

  1116 // CCacheSessionActiveHelper::NewL()

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

  1118 //

  1119 CCacheSessionActiveHelper* CCacheSessionActiveHelper::NewL

  1120                                             (CPresenceCacheSession* aSession )

  1121     {

  1122     CCacheSessionActiveHelper* self = new(ELeave) CCacheSessionActiveHelper(aSession);

  1123     CleanupStack::PushL( self );

  1124     self->ConstructL( );

  1125     CleanupStack::Pop( self );

  1126     return self;

  1127     }

  1128 

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

  1130 // CCacheSessionActiveHelper::~CCacheSessionActiveHelper()

  1131 // ---------------------------------------------------------------------------

  1132 //

  1133 CCacheSessionActiveHelper::~CCacheSessionActiveHelper( )

  1134     {

  1135     Cancel();