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:  CS Session class

    15  *

    16  */

    17 

    18 // INCLUDE FILES

    19 #include <ccsconversationentry.h>

    20 #include <ccsclientconversation.h>

    21 

    22 #include "ccsconversationevent.h"

    23 #include "ccsdebug.h"

    24 #include "ccsserver.h"

    25 #include "ccssession.h"

    26 #include "ccsplugininterface.h"

    27 #include "ccsconversationcache.h"

    28 #include "ccscontactsresolver.h"

    29 #include "ccsconversationdeletehandler.h"

    30 #include "ccsconversationmarkreadhandler.h"

    31 

    32 // CONSTANTS

    33 const TInt KTinyBuffer = 256; // 256 bytes

    34 const TInt KBigBuffer = 2048; // 2K

    35 

    36 // ============================== MEMBER FUNCTIONS ============================

    37 

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

    39 // CCsSession::NewL

    40 // Two Phase Construction

    41 // ----------------------------------------------------------------------------

    42 CCsSession* CCsSession::NewL(CCsServer* aServer)

    43 {

    44     PRINT ( _L("Enter CCsSession::NewL") );

    45 

    46     CCsSession* self = new (ELeave) CCsSession(aServer);

    47     CleanupStack::PushL(self);

    48     self->ConstructL();

    49     CleanupStack::Pop(self); // self

    50 

    51     PRINT ( _L("End CCsSession::NewL") );

    52 

    53     return self;

    54 }

    55 

    56 // ----------------------------------------------------------------------------

    57 // CCsSession::CCsSession

    58 // Construtor

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

    60 CCsSession::CCsSession(CCsServer* aServer) :

    61     iServer(aServer),

    62 	    iDes(NULL),

    63 	    iMonitoredConversation(NULL),

    64 	    iBufferOverflow(EFalse),

    65 	    iGetConversationBufferOverflow( EFalse),

    66 	    iNotifyHandling(EFalse),

    67 	    iConversationListChangeObserver(EFalse),

    68 	    iConversationChangeObserver(EFalse),

    69 	    iCachingChangeObserver(EFalse),

    70 	    iReqCnt(1) //Let's start the event ID from 1    

    71 {

    72 }

    73 

    74 // ----------------------------------------------------------------------------

    75 // CCsSession::ConstructL

    76 // Second phase constructor

    77 // ----------------------------------------------------------------------------

    78 void CCsSession::ConstructL()

    79 {

    80     PRINT ( _L("Enter CCsSession::ConstructL") );

    81 

    82 

    83     // initialize the event List

    84     iEventList = new (ELeave) RPointerArray<CCsConversationEvent> ();

    85 

    86     PRINT ( _L("End CCsSession::ConstructL") );

    87 }

    88 

    89 // ----------------------------------------------------------------------------

    90 // CCsSession::CCsSession

    91 // Destructor

    92 // ----------------------------------------------------------------------------

    93 CCsSession::~CCsSession()

    94 {

    95     PRINT ( _L("Enter CCsSession::~CCsSession") );

    96 

    97     if ( iDes )

    98         {

    99         delete iDes;

   100         iDes = NULL;

   101         }

   102 		

   103     if ( iEventList )

   104         {

   105         iEventList->ResetAndDestroy();

   106         iEventList->Close();

   107         delete iEventList;

   108         iEventList = NULL;

   109     }

   110 

   111     if (iMonitoredConversation)

   112     {

   113         delete iMonitoredConversation;

   114         iMonitoredConversation = NULL;

   115     }

   116 

   117     PRINT ( _L("End CCsSession::~CCsSession") );

   118 }

   119 

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

   121 // CCsSession::ServiceL

   122 //

   123 // ----------------------------------------------------------------------------

   124 void CCsSession::ServiceL(const RMessage2& aMessage)

   125 {

   126     TInt errStatus = KErrNone;

   127 

   128     // Do the service

   129     TRAP ( errStatus, DoServiceL(aMessage) );

   130 

   131     // Check the error status returned

   132     if (errStatus != KErrNone)

   133     {

   134         // Free memory.

   135         if(iDes)

   136             {

   137             delete iDes;

   138             iDes=NULL;

   139             }

   140         aMessage.Complete(errStatus);

   141     }

   142 }

   143 

   144 // ----------------------------------------------------------------------------

   145 // CCsSession::DoServiceL

   146 //

   147 // ----------------------------------------------------------------------------

   148 void CCsSession::DoServiceL(const RMessage2& aMessage)

   149 {

   150     switch (aMessage.Function())

   151     {

   152         case EGetConversationList:

   153             PRINT ( _L("Received function EGetConversationList") )

   154             GetConversationListL(aMessage);

   155             break;

   156             

   157         case EGetConversationUnreadList:

   158             PRINT ( _L("Received function EGetConversationUnreadList") )

   159             GetConversationUnreadListL(aMessage);

   160             break;

   161 

   162         case EGetConversations:

   163             PRINT ( _L("Received function EGetConversations") )

   164             GetConversationsL(aMessage);

   165             break;

   166             

   167         case EGetTotalUnreadCount:

   168             PRINT ( _L("Received function EGetTotalUnreadCount") )

   169             GetTotalUnreadCountL(aMessage);

   170             break;

   171 

   172         case ERequestChangeEvent:

   173             PRINT ( _L("Received function ERequestChangeEvent") )

   174             RequestChangeEventL(aMessage);

   175             break;

   176 

   177         case ERemoveChangeEvent:

   178             PRINT ( _L("Received function ERemoveChangeEvent") )

   179             RemoveChangeEventL(aMessage);

   180             break;

   181 

   182         case ESetConversationListChangeObserver:

   183             PRINT ( _L("Received function ESetConversationListChangeObserver") )

   184             SetConversationListChangeObserverL(aMessage);

   185             break;

   186 

   187         case EResetConversationListChangeObserver:

   188             PRINT ( _L("Received function EResetConversationListChangeObserver") )

   189             ResetConversationListChangeObserverL(aMessage);

   190             break;

   191 

   192         case ESetConversationChangeObserver:

   193             PRINT ( _L("Received function ESetConversationChangeObserver") )

   194             SetConversationChangeObserverL(aMessage);

   195             break;

   196 

   197         case EResetConversationChangeObserver:

   198             PRINT ( _L("Received function EResetConversationChangeObserver") )

   199             ResetConversationChangeObserverL(aMessage);

   200             break;

   201 

   202         case ESetCachingStatusObserver:

   203             PRINT ( _L("Received function ESetCachingStatusObserver") )

   204             SetCachingStatusObserverL(aMessage);

   205             break;

   206 

   207         case EResetCachingStatusObserver:

   208             PRINT ( _L("Received function EResetCachingStatusObserver") )

   209             ResetCachingStatusObserverL(aMessage);

   210             break;

   211 

   212         case EGetCachingStatus:

   213             GetCachingStatusL(aMessage);

   214             break;

   215 

   216         case EShutdown:

   217             PRINT ( _L("Received function EShutdown") )

   218             ShutdownServerL(aMessage);

   219             break;

   220 

   221         case EUserDeleteConversation:

   222             PRINT ( _L("Received function EDeleteConversation") )

   223             DeleteConversationL(aMessage);

   224             break;

   225 

   226         case EGetConversationId:

   227             PRINT ( _L("Received function EGetConversationId") )

   228             GetConversationIdL(aMessage);

   229             break;

   230             

   231         case EGetConversationIdFromAddress:

   232             PRINT ( _L("Received function EGetConversationIdFromAddress") )

   233             GetConversationIdfromAddressL(aMessage);

   234             break;

   235 

   236         case EGetConversationFromConversationId:

   237             PRINT ( _L("Received function EGetConversationFromConversationId") )

   238             GetConversationFromConversationIdL(aMessage);

   239             break;

   240 			

   241 		case EGetConversationFromMessageId:

   242             PRINT ( _L("Received function EGetConversationFromMessageId") )

   243             GetConversationFromMessageIdL(aMessage);

   244             break;

   245 

   246         case EUserMarkReadConversation:

   247             PRINT ( _L("Received function EUserMarkReadConversation") )

   248             MarkConversationReadL(aMessage);

   249             break;

   250     }

   251 

   252     return;

   253 }

   254 

   255 // ----------------------------------------------------------------------------

   256 // CCsSession::ServiceError

   257 //

   258 // ----------------------------------------------------------------------------

   259 void CCsSession::ServiceError(const RMessage2& aMessage, TInt aError)

   260 {

   261     if(iDes)

   262         {

   263         delete iDes;

   264         iDes=NULL;

   265         }

   266     aMessage.Complete(aError);

   267 }

   268 

   269 // ----------------------------------------------------------------------------

   270 // CCsSession::GetConversationEntryListL

   271 // the function to handle the request of Listing

   272 // of recent(latest) conversation entry and

   273 // list of dispalyname for all stored conversation entry ID

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

   275 void CCsSession::GetConversationListL(const RMessage2& aMessage)

   276 {

   277     PRINT ( _L("Enter CCsSession::GetConversationListL") );

   278     PRINT_TIMESTAMP ("Enter CCsSession::GetConversationListL");

   279 

   280     if (iBufferOverflow == EFalse)

   281     {

   282         RPointerArray<CCsClientConversation>* ClientConversationList =

   283                 new (ELeave) RPointerArray<CCsClientConversation> ();

   284         CleanupResetAndDestroyPushL(ClientConversationList);

   285         // get cache pointer

   286         CCsConversationCache* cache = iServer->ConversationCacheInterface();

   287 

   288         // Call cache function to get recent conversation entry list

   289         // with dispaly name for all stored conversation entry ID

   290         cache->GetConversationListL(ClientConversationList);

   291 

   292         //write all list data into stream

   293         // create a new buffer for writing into stream

   294         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   295         CleanupStack::PushL(buf);

   296 

   297         RBufWriteStream writeStream(*buf);

   298         writeStream.PushL();

   299 

   300         TInt listCount = ClientConversationList->Count();

   301 

   302         if (listCount == 0)

   303         {

   304             iConversationListChangeObserver = ETrue;

   305         }

   306 

   307         // write the count first

   308         writeStream.WriteUint16L(listCount);

   309 

   310         // now go through the list and do externalize

   311         for (int iloop = 0; iloop < listCount; iloop++)

   312         {

   313             CCsClientConversation

   314                     * ClientConversation =

   315                             static_cast<CCsClientConversation*> ( (*ClientConversationList)[iloop]);

   316             //write list of ClientConversation

   317             ClientConversation->ExternalizeL(writeStream);

   318         }

   319 

   320         // Results are already packed in the stream

   321         writeStream.CommitL();

   322 

   323         // --------------------------------------------------------------

   324         // Create a heap descriptor from the buffer

   325         iDes = HBufC8::NewL(buf->Size());

   326         TPtr8 ptr(iDes->Des());

   327         buf->Read(0, ptr, buf->Size());

   328 

   329         // Cleanup

   330         CleanupStack::PopAndDestroy(2, buf); // writestream, buf

   331         

   332         // Cleanup ClientConversationList

   333         CleanupStack::PopAndDestroy(ClientConversationList);

   334         }

   335 

   336     TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);

   337     TInt reqdBufferSize  = iDes->Size();

   338 

   339     PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );

   340     PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );

   341 

   342     // If the received buffer size from Client API is less than

   343     // the required buffer size write the required buffer size

   344     // and return.

   345     if (rcevdBufferSize < reqdBufferSize)

   346     {

   347         PRINT ( _L("In-adequate buffer received") );

   348         PRINT ( _L("Packing the required buffer size in response") );

   349 

   350         TPckgC<TInt> bufferSizePackage(reqdBufferSize);

   351         aMessage.WriteL(1, bufferSizePackage);

   352         aMessage.Complete(EGetConversationListBufferOverflow);

   353         iBufferOverflow = ETrue;

   354     }

   355     else

   356     {

   357         PRINT ( _L("Adequate buffer received") );

   358         PRINT ( _L("Packing the results in response") )

   359 

   360         aMessage.Write(1, *iDes);

   361         aMessage.Complete(EGetConversationListOperationComplete);

   362         iBufferOverflow = EFalse;

   363         delete iDes;

   364         iDes = NULL;

   365         }

   366     

   367     PRINT_TIMESTAMP ("End CCsSession::GetConversationListL");

   368     PRINT ( _L("End CCsSession::GetConversationListL") );

   369 }

   370 

   371 // ----------------------------------------------------------------------------

   372 // CCsSession::GetConversationUnreadListL

   373 // the function to handle the request of Listing

   374 // of recent(latest) unread conversation entry and

   375 // list of dispalyname for all stored conversation entry ID

   376 // ----------------------------------------------------------------------------

   377 void CCsSession::GetConversationUnreadListL(const RMessage2& aMessage)

   378     {

   379     PRINT ( _L("Enter CCsSession::GetConversationUnreadListL") );

   380     PRINT_TIMESTAMP ("Enter CCsSession::GetConversationUnreadListL");

   381 

   382     if (iBufferOverflow == EFalse)

   383         {

   384         RPointerArray<CCsClientConversation>* ClientConversationList =

   385                 new (ELeave) RPointerArray<CCsClientConversation> ();

   386         CleanupResetAndDestroyPushL(ClientConversationList);

   387         // get cache pointer

   388         CCsConversationCache* cache = iServer->ConversationCacheInterface();

   389 

   390         // Call cache function to get recent conversation entry list

   391         // with dispaly name for all stored conversation entry ID

   392         cache->GetConversationUnreadListL(ClientConversationList);

   393 

   394         //write all list data into stream

   395         // create a new buffer for writing into stream

   396         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   397         CleanupStack::PushL(buf);

   398 

   399         RBufWriteStream writeStream(*buf);

   400         writeStream.PushL();

   401 

   402         TInt listCount  = ClientConversationList->Count();

   403 

   404         if (listCount == 0)

   405             {

   406             iConversationListChangeObserver = ETrue;

   407             }

   408 

   409         // write the count first

   410         writeStream.WriteUint16L(listCount);

   411 

   412         // now go through the list and do externalize

   413         for (int iloop=0 ; iloop < listCount ; iloop++)

   414             {

   415             CCsClientConversation* ClientConversation =

   416             static_cast<CCsClientConversation*>((*ClientConversationList)[iloop]);

   417             //write list of ClientConversation

   418             ClientConversation->ExternalizeL(writeStream);

   419             }

   420 

   421         // Results are already packed in the stream

   422         writeStream.CommitL();

   423 

   424         // --------------------------------------------------------------

   425         // Create a heap descriptor from the buffer

   426         iDes = HBufC8::NewL(buf->Size());

   427         TPtr8 ptr(iDes->Des());

   428         buf->Read(0, ptr, buf->Size());

   429 

   430         // cleanup

   431         CleanupStack::PopAndDestroy(2, buf); // writestream, buf

   432         CleanupStack::PopAndDestroy(ClientConversationList);

   433 

   434         }

   435 

   436     TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);

   437     TInt reqdBufferSize  = iDes->Size();

   438 

   439     PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );

   440     PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );

   441 

   442     if ( rcevdBufferSize < reqdBufferSize )

   443         {

   444         PRINT ( _L("In-adequate buffer received") );

   445         PRINT ( _L("Packing the required buffer size in response") );

   446 

   447         TPckgC<TInt> overflowPackage(ETrue);

   448         aMessage.WriteL(0, overflowPackage);

   449         TPckgC<TInt> bufferSizePackage(reqdBufferSize);

   450         aMessage.WriteL(1, bufferSizePackage);

   451         aMessage.Complete(KErrNone);

   452         iBufferOverflow = ETrue;

   453         }

   454     else

   455         {

   456         PRINT ( _L("Adequate buffer received") );

   457         PRINT ( _L("Packing the results in response") )

   458 

   459         TPckgC<TInt> overflowPackage(EFalse);

   460         aMessage.WriteL(0, overflowPackage);

   461         aMessage.Write(1, *iDes);

   462         aMessage.Complete(KErrNone);

   463         iBufferOverflow = EFalse;

   464         delete iDes;

   465         iDes = NULL;

   466         }

   467 

   468     PRINT_TIMESTAMP ("End CCsSession::GetConversationUnreadListL");

   469     PRINT ( _L("End CCsSession::GetConversationUnreadListL") );

   470     }

   471 

   472 // ----------------------------------------------------------------------------

   473 // CCsSession::GetConversationsL

   474 // the function to handle the request

   475 // of conversation entry list for one conversation entry ID

   476 // ----------------------------------------------------------------------------

   477 void CCsSession::GetConversationsL(const RMessage2& aMessage)

   478 {

   479     PRINT ( _L("Enter CCsSession::GetConversationsL") );

   480 

   481     if (iGetConversationBufferOverflow == EFalse)

   482     {

   483         // Read Contact from the message

   484         HBufC8* buffer = HBufC8::NewLC(KBigBuffer);

   485 

   486         TPtr8 bufferPtr(buffer->Des());

   487         aMessage.ReadL(0, bufferPtr);

   488 

   489         // Stream over the buffer

   490         RDesReadStream stream(bufferPtr);

   491         stream.PushL();

   492         

   493         //Read known index and page size

   494         TInt knownIndex = stream.ReadInt32L();

   495         TInt pageSize  = stream.ReadInt32L();

   496         

   497         // get cache pointer

   498         CCsConversationCache* cache = iServer->ConversationCacheInterface();

   499 

   500         // read the Client Conversation consist of Entry Id

   501         CCsClientConversation* ClientConversation =

   502                 CCsClientConversation::NewL();

   503         CleanupStack::PushL(ClientConversation);

   504         ClientConversation->InternalizeL(stream);

   505         CleanupStack::Pop(ClientConversation);

   506         CleanupStack::PopAndDestroy(2, buffer);//stream, buffer

   507 

   508         CleanupStack::PushL(ClientConversation);

   509         RPointerArray<CCsConversationEntry>* conversationEntryList=

   510                 new (ELeave) RPointerArray<CCsConversationEntry>(10);

   511         CleanupResetAndDestroyPushL(conversationEntryList);

   512 

   513         // get conversation entry  list for given ClientConversation 

   514         TInt totalCount(0);

   515         cache->GetConversationsL (ClientConversation,

   516                 conversationEntryList,

   517                 knownIndex,

   518                 pageSize,

   519                 totalCount);

   520 

   521         // create a new buffer for writing into stream

   522         // write all list data into stream

   523         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   524         CleanupStack::PushL(buf);

   525 

   526         RBufWriteStream writeStream(*buf);

   527         writeStream.PushL();

   528 

   529         TInt ItemCount = conversationEntryList->Count();

   530         //write  recent conversation entry list

   531         writeStream.WriteInt32L(ItemCount);

   532         

   533         //Write total count in the stream to update UI

   534         writeStream.WriteInt32L(totalCount);

   535         

   536         // Write the conversation entry

   537         for (TInt iloop = 0; iloop < ItemCount; iloop++)

   538         {

   539             CCsConversationEntry

   540                     * entry =

   541                             static_cast<CCsConversationEntry*> ( (*conversationEntryList)[iloop]);

   542             entry->ExternalizeL(writeStream);

   543         }

   544 

   545         // Results are already packed in the stream

   546         writeStream.CommitL();

   547 

   548         // --------------------------------------------------------------

   549         // Create a heap descriptor from the buffer

   550         iDes = HBufC8::NewL(buf->Size());

   551         TPtr8 ptr(iDes->Des());

   552         buf->Read(0, ptr, buf->Size());

   553 

   554         CleanupStack::PopAndDestroy(2, buf); // writestream, buf

   555      

   556         // Cleanup

   557         CleanupStack::PopAndDestroy(conversationEntryList);

   558         CleanupStack::PopAndDestroy(ClientConversation);

   559     }

   560 

   561     TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);

   562     TInt reqdBufferSize  = iDes->Size();

   563 

   564     PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );

   565     PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );

   566 

   567     // If the received buffer size from Client API is less than

   568     // the required buffer size write the required buffer size

   569     if (rcevdBufferSize < reqdBufferSize)

   570     {

   571         PRINT ( _L("In-adequate buffer received") );

   572         PRINT ( _L("Packing the required buffer size in response") );

   573 

   574         TPckgC<TInt> bufferSizePackage(reqdBufferSize);

   575         aMessage.WriteL(1, bufferSizePackage);

   576         aMessage.Complete(EGetConversationBufferOverflow);

   577         iGetConversationBufferOverflow = ETrue;

   578     }

   579     else

   580     {

   581         PRINT ( _L("Adequate buffer received") );

   582         PRINT ( _L("Packing the results in response") )

   583 

   584         aMessage.Write(1, *iDes);

   585         aMessage.Complete(EGetConversationOperationComplete);

   586         iGetConversationBufferOverflow = EFalse;

   587         delete iDes;

   588         iDes = NULL;

   589         }

   590 

   591     PRINT ( _L("End CCsSession::GetConversationsL") );

   592 }

   593 

   594 // ----------------------------------------------------------------------------

   595 // CCsSession::ShutdownServerL

   596 // Stops the scheduler

   597 // ----------------------------------------------------------------------------

   598 void CCsSession::ShutdownServerL(const RMessage2& aMessage)

   599 {

   600     aMessage.Complete(KErrNone);

   601     CActiveScheduler::Stop();

   602 

   603     PRINT ( _L("CCsSession::ShutdownServerL - Server ShutDown") );

   604 }

   605 

   606 // ----------------------------------------------------------------------------

   607 // CCsSession::HandleNewConversationListEventL

   608 // Notify client about new conversation event

   609 // ----------------------------------------------------------------------------

   610 void CCsSession::HandleNewConversationListEventL(

   611                                                  CCsClientConversation* aClientConversation)

   612 {

   613     PRINT ( _L("Enter CCsSession::HandleNewConversationListEventL") );

   614 

   615     if (!iConversationListChangeObserver)

   616         return;

   617 

   618     if (! (iNotifyHandling))

   619     {

   620         //append in notify list

   621         CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();

   622         CleanupStack::PushL(conversationEvent);

   623         conversationEvent->SetClientConversationL(*aClientConversation);

   624         conversationEvent->SetEvent(KConversationListEventNew);

   625         iEventList->AppendL(conversationEvent);

   626         CleanupStack::Pop(conversationEvent);

   627     }

   628     else

   629     {

   630         // create a new buffer for writing into stream

   631         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   632         CleanupStack::PushL(buf);

   633 

   634         RBufWriteStream writeStream(*buf);

   635         writeStream.PushL();

   636 

   637         //externalize ClientConversation

   638         aClientConversation->ExternalizeL(writeStream);

   639 

   640         // Results are already packed in the stream

   641         writeStream.CommitL();

   642 

   643         // --------------------------------------------------------------

   644         // Create a heap descriptor from the buffer

   645         HBufC8* notifyDes = HBufC8::NewLC(buf->Size());

   646         TPtr8 ptr(notifyDes->Des());

   647         buf->Read(0, ptr, buf->Size());

   648 

   649         iAsyncReqRMessage.Write(1, *notifyDes);

   650         iAsyncReqRMessage.Complete(EAddConversationListEvent);

   651         CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf 

   652         iNotifyHandling = EFalse;

   653     }

   654 

   655     PRINT ( _L("End CCsSession::HandleNewConversationListEventL") );

   656 }

   657 

   658 // ----------------------------------------------------------------------------

   659 // CCsSession::HandleDeleteConversationListEventL

   660 // Notify client about delete conversation event

   661 // ----------------------------------------------------------------------------

   662 void CCsSession::HandleDeleteConversationListEventL(

   663                                                     CCsClientConversation* aClientConversation)

   664 {

   665     PRINT ( _L("Enter CCsSession::HandleDeleteConversationListEventL") );

   666 

   667     if (!iConversationListChangeObserver)

   668         return;

   669 

   670     if (! (iNotifyHandling))

   671     {

   672         //append in notify list

   673         CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();

   674         conversationEvent->SetClientConversationL(*aClientConversation);

   675         CleanupStack::PushL(conversationEvent);

   676         conversationEvent->SetEvent(KConversationListEventDelete);

   677         iEventList->AppendL(conversationEvent);

   678         CleanupStack::Pop(conversationEvent);

   679     }

   680     else

   681     {

   682         // create a new buffer for writing into stream

   683         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   684         CleanupStack::PushL(buf);

   685 

   686         RBufWriteStream writeStream(*buf);

   687         writeStream.PushL();

   688 

   689         //externalize ClientConversation

   690         aClientConversation->ExternalizeL(writeStream);

   691 

   692         // Results are already packed in the stream

   693         writeStream.CommitL();

   694 

   695         // --------------------------------------------------------------

   696         // Create a heap descriptor from the buffer

   697         HBufC8* notifyDes = HBufC8::NewLC(buf->Size());

   698         TPtr8 ptr(notifyDes->Des());

   699         buf->Read(0, ptr, buf->Size());

   700 

   701         iAsyncReqRMessage.Write(1, *notifyDes);

   702         iAsyncReqRMessage.Complete(EDeleteConversationListEvent);

   703         CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf

   704         iNotifyHandling = EFalse;

   705     }

   706 

   707     PRINT ( _L("End CCsSession::HandleDeleteConversationListEventL") );

   708 }

   709 

   710 // ----------------------------------------------------------------------------

   711 // CCsSession::HandlePartialDeleteConversationListEventL

   712 // Notify client about partial delete conversation event

   713 // ----------------------------------------------------------------------------

   714 

   715 void CCsSession::HandlePartialDeleteConversationListEvent(

   716                                                     CCsClientConversation* aClientConversation)

   717 {

   718     PRINT ( _L("Enter CCsSession::HandlePartialDeleteConversationListEvent") );

   719 

   720     if (!iConversationListChangeObserver)

   721         return;

   722     

   723     if (! (iNotifyHandling))

   724     {

   725         //append in notify list

   726         CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();

   727         conversationEvent->SetClientConversationL(*aClientConversation);

   728         CleanupStack::PushL(conversationEvent);

   729         conversationEvent->SetEvent(KConversationListEventPartialDelete);

   730         iEventList->AppendL(conversationEvent);

   731         CleanupStack::Pop(conversationEvent);

   732     }

   733     else

   734     {

   735         // create a new buffer for writing into stream

   736         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   737         CleanupStack::PushL(buf);

   738 

   739         RBufWriteStream writeStream(*buf);

   740         writeStream.PushL();

   741 

   742         //externalize ClientConversation

   743         aClientConversation->ExternalizeL(writeStream);

   744 

   745         // Results are already packed in the stream

   746         writeStream.CommitL();

   747 

   748         // --------------------------------------------------------------

   749         // Create a heap descriptor from the buffer

   750         HBufC8* notifyDes = HBufC8::NewLC(buf->Size());

   751         TPtr8 ptr(notifyDes->Des());

   752         buf->Read(0, ptr, buf->Size());

   753 

   754         iAsyncReqRMessage.Write(1, *notifyDes);

   755         iAsyncReqRMessage.Complete(EPartialDeleteConversationListEvent);

   756         CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf

   757         iNotifyHandling = EFalse;

   758     }

   759 }

   760 

   761 // ----------------------------------------------------------------------------

   762 // CCsSession::HandleModifyConversationListEventL

   763 // Notify client about update conversation event

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

   765 void CCsSession::HandleModifyConversationListEventL(

   766                                                     CCsClientConversation* aClientConversation)

   767 {

   768     PRINT ( _L("Enter CCsSession::HandleModifyConversationListEventL") );

   769 

   770     if (!iConversationListChangeObserver)

   771         return;

   772 

   773     if (! (iNotifyHandling))

   774     {

   775         //append in notify list

   776         CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();

   777         conversationEvent->SetClientConversationL(*aClientConversation);

   778         CleanupStack::PushL(conversationEvent);

   779         conversationEvent->SetEvent(KConversationListEventUpdate);

   780         iEventList->AppendL(conversationEvent);

   781         CleanupStack::Pop(conversationEvent);

   782     }

   783     else

   784     {

   785         // create a new buffer for writing into stream

   786         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   787         CleanupStack::PushL(buf);

   788 

   789         RBufWriteStream writeStream(*buf);

   790         writeStream.PushL();

   791 

   792         //externalize ClientConversation

   793         aClientConversation->ExternalizeL(writeStream);

   794 

   795         // Results are already packed in the stream

   796         writeStream.CommitL();

   797         // --------------------------------------------------------------

   798 

   799         // Create a heap descriptor from the buffer

   800         HBufC8* notifyDes = HBufC8::NewLC(buf->Size());

   801         TPtr8 ptr(notifyDes->Des());

   802         buf->Read(0, ptr, buf->Size());

   803 

   804         iAsyncReqRMessage.Write(1, *notifyDes);

   805         iAsyncReqRMessage.Complete(EModifyConversationListEvent);

   806         CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf

   807         iNotifyHandling = EFalse;

   808     }

   809 

   810     PRINT ( _L("End CCsSession::HandleModifyConversationListEventL") );

   811 }

   812 

   813 // ----------------------------------------------------------------------------

   814 // CCsSession::RequestChangeEventL

   815 // the function to register for cache change event notification

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

   817 void CCsSession::RequestChangeEventL(const RMessage2& aMessage)

   818 {

   819     iAsyncReqRMessage = aMessage;

   820     iNotifyHandling = ETrue;

   821 

   822     if (iEventList->Count() > 0)

   823     {

   824         CCsConversationEvent* conversationEvent = (*iEventList)[0];

   825 

   826         // check if the reqCnt matches with the latest arrived count

   827         // then its not a duplicate, delete the top event

   828         if (iReqCnt == aMessage.Int2())

   829         {

   830             iEventList->Remove(0);

   831             delete conversationEvent;

   832 

   833             if (iEventList->Count() > 0)

   834             {

   835                 // increment the count

   836                 iReqCnt++;

   837                 conversationEvent = (*iEventList)[0];

   838             }

   839             else

   840             {

   841                 // no more pending events, simply return

   842                 return;

   843             }

   844         }

   845 

   846         HBufC8* buffer = HBufC8::NewLC(4);

   847         TPtr8 cntPtr(buffer->Des());

   848         _LIT8(KFormat,"%d");

   849         cntPtr.Format(KFormat, iReqCnt);

   850         iAsyncReqRMessage.Write(0, *buffer);

   851 

   852         // create a new buffer for writing into stream

   853         CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

   854         CleanupStack::PushL(buf);

   855 

   856         RBufWriteStream writeStream(*buf);

   857         writeStream.PushL();

   858 

   859         // Externalize ClientConversation

   860         if (conversationEvent->ClientConversation())

   861             conversationEvent->ClientConversation()->ExternalizeL(writeStream);

   862 

   863         // Results are already packed in the stream

   864         writeStream.CommitL();

   865 

   866         // --------------------------------------------------------------

   867         // Create a heap descriptor from the buffer

   868         HBufC8* notifyDes = HBufC8::NewLC(buf->Size());

   869         TPtr8 ptr(notifyDes->Des());

   870         buf->Read(0, ptr, buf->Size());

   871 

   872         iAsyncReqRMessage.Write(1, *notifyDes);

   873 

   874         NotifyClient(conversationEvent);

   875 

   876         CleanupStack::PopAndDestroy(4, buffer);

   877         // notifyDes, writestream, buf, buffer

   878         iNotifyHandling = EFalse;

   879     }

   880 }

   881 

   882 // ----------------------------------------------------------------------------

   883 // CCsSession::RemoveChangeEventL

   884 // Deregister the cache change event notification

   885 // ----------------------------------------------------------------------------

   886 void CCsSession::RemoveChangeEventL(const RMessage2& aMessage)

   887 {

   888     if (! (iNotifyHandling))

   889     {

   890         // complete message with aMessage

   891         aMessage.Complete(KErrNone);

   892     }

   893     else

   894     {

   895         iAsyncReqRMessage.Complete(KErrCancel);

   896         iNotifyHandling = EFalse;

   897         // complete message with aMessage

   898         aMessage.Complete(KErrNone);

   899     }

   900 }

   901 

   902 // ----------------------------------------------------------------------------

   903 // CCsSession::GetCachingStatusL

   904 // the function to request conversation server

   905 // to get caching status.

   906 // ----------------------------------------------------------------------------

   907 void CCsSession::GetCachingStatusL(const RMessage2& aMessage)

   908 {

   909     PRINT ( _L("Enter CCsSession::GetCachingStatusL") );

   910 

   911     // create a new buffer for writing into stream

   912     CBufFlat* buf = CBufFlat::NewL(KTinyBuffer);

   913 

   914     CleanupStack::PushL(buf);

   915     RBufWriteStream writeStream(*buf);

   916     writeStream.PushL();

   917 

   918     // Externalize caching status

   919     writeStream.WriteUint8L(iServer->GetCachingStatus());

   920 

   921     // Results are already packed in the stream

   922     writeStream.CommitL();

   923     // --------------------------------------------------------------

   924 

   925     // Create a heap descriptor from the buffer

   926     HBufC8* des = HBufC8::NewL(buf->Size());

   927     TPtr8 ptr(des->Des());

   928     buf->Read(0, ptr, buf->Size());

   929 

   930     CleanupStack::PopAndDestroy(2, buf); // writestream, buf

   931 

   932     aMessage.Write(1, *des);

   933     aMessage.Complete(KErrNone);

   934     delete des;

   935 

   936     PRINT ( _L("End CCsSession::GetCachingStatusL") );

   937 }

   938 

   939 // ----------------------------------------------------------------------------

   940 // CCsSession::GetTotalUnreadCountL

   941 // Gets total unread conversation entries.

   942 // ----------------------------------------------------------------------------

   943 void CCsSession::GetTotalUnreadCountL(const RMessage2& aMessage)

   944     {

   945     PRINT ( _L("Enter CCsSession::GetTotalUnreadCountL") );

   946 

   947     // create a new buffer for writing into stream

   948     CBufFlat* buf = CBufFlat::NewL(KTinyBuffer);

   949 

   950     CleanupStack::PushL(buf);

   951     RBufWriteStream writeStream(*buf);

   952     writeStream.PushL();

   953 

   954     CCsConversationCache* cache = iServer->ConversationCacheInterface();

   955 

   956     // Externalize caching status

   957     writeStream.WriteUint32L(cache->GetTotalUnreadCount());

   958 

   959     // Results are already packed in the stream

   960     writeStream.CommitL();

   961     // --------------------------------------------------------------

   962 

   963     // Create a heap descriptor from the buffer

   964     HBufC8* des = HBufC8::NewL(buf->Size());

   965     TPtr8 ptr(des->Des());

   966     buf->Read(0, ptr, buf->Size());

   967 

   968     CleanupStack::PopAndDestroy(2, buf); // writestream, buf

   969 

   970     aMessage.Write(1, *des);

   971     aMessage.Complete(KErrNone);

   972     delete des;

   973 

   974     PRINT ( _L("End CCsSession::GetTotalUnreadCountL") );

   975     }

   976 

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

   978 // CCsSession::SetConversationListChangeObserverL

   979 // the function to request conversation server

   980 // to set ConversationListChangeObserver.

   981 // ----------------------------------------------------------------------------

   982 void CCsSession::SetConversationListChangeObserverL(const RMessage2& aMessage)

   983 {

   984     iConversationListChangeObserver = ETrue;

   985     aMessage.Complete(KErrNone);

   986 }

   987 

   988 // ----------------------------------------------------------------------------

   989 // CCsSession::ResetConversationListChangeObserverL

   990 // the function to request conversation server

   991 // to reset ConversationListChangeObserver.

   992 // ----------------------------------------------------------------------------

   993 void CCsSession::ResetConversationListChangeObserverL(const RMessage2& aMessage)

   994 {

   995     iConversationListChangeObserver = EFalse;

   996     aMessage.Complete(KErrNone);

   997 }

   998 

   999 // ----------------------------------------------------------------------------

  1000 // CCsSession::SetConversationChangeObserverL

  1001 // the function to request conversation server

  1002 // to set ConversationChangeObserver.

  1003 // ----------------------------------------------------------------------------

  1004 void CCsSession::SetConversationChangeObserverL(const RMessage2& aMessage)

  1005 {

  1006     // Read Contact from the message

  1007     HBufC8* buffer = HBufC8::NewLC(KBigBuffer);

  1008 

  1009     TPtr8 bufferPtr(buffer->Des());

  1010     aMessage.ReadL(0, bufferPtr);

  1011 

  1012     // Stream over the buffer

  1013     RDesReadStream stream(bufferPtr);

  1014     stream.PushL();

  1015 

  1016     // Get the client conversation

  1017     CCsClientConversation* clientConversation = CCsClientConversation::NewL();

  1018     CleanupStack::PushL(clientConversation);

  1019     clientConversation->InternalizeL(stream);

  1020     CleanupStack::Pop(clientConversation);

  1021 

  1022     CleanupStack::PopAndDestroy(2, buffer);//stream, buffer

  1023 

  1024     iMonitoredConversation = clientConversation;

  1025     iConversationChangeObserver = ETrue;

  1026 

  1027     aMessage.Complete(KErrNone);

  1028 }

  1029 

  1030 // ----------------------------------------------------------------------------

  1031 // CCsSession::ResetConversationChangeObserverL

  1032 // the function to request conversation server

  1033 // to reset ConversationChangeObserver.

  1034 // ----------------------------------------------------------------------------

  1035 void CCsSession::ResetConversationChangeObserverL(const RMessage2& aMessage)

  1036 {

  1037     // Read Contact from the message

  1038     HBufC8* buffer = HBufC8::NewLC(KBigBuffer);

  1039 

  1040     TPtr8 bufferPtr(buffer->Des());

  1041     aMessage.ReadL(0, bufferPtr);

  1042 

  1043     // Stream over the buffer

  1044     RDesReadStream stream(bufferPtr);

  1045     stream.PushL();

  1046 

  1047     // Read the client conversation

  1048     CCsClientConversation* clientConversation = CCsClientConversation::NewL();

  1049     CleanupStack::PushL(clientConversation);

  1050     clientConversation->InternalizeL(stream);

  1051     CleanupStack::Pop(clientConversation);

  1052 

  1053     CleanupStack::PopAndDestroy(2, buffer); //stream, buffer

  1054 

  1055     if (iMonitoredConversation)

  1056     {

  1057         delete iMonitoredConversation;

  1058         iMonitoredConversation = NULL;

  1059         iConversationChangeObserver = EFalse;

  1060     }

  1061 

  1062     delete clientConversation;

  1063 

  1064     aMessage.Complete(KErrNone);

  1065 }

  1066 

  1067 // ----------------------------------------------------------------------------

  1068 // CCsSession::SetCachingStatusObserverL

  1069 // the function to request conversation server

  1070 // to set caching status observer flag.

  1071 // ----------------------------------------------------------------------------

  1072 void CCsSession::SetCachingStatusObserverL(const RMessage2& aMessage)

  1073 {

  1074     iCachingChangeObserver = ETrue;

  1075     aMessage.Complete(KErrNone);

  1076 }

  1077 

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

  1079 // CCsSession::ResetCachingStatusObserverL

  1080 // the function to request conversation server

  1081 // to reset caching status observer flag.

  1082 // ----------------------------------------------------------------------------

  1083 void CCsSession::ResetCachingStatusObserverL(const RMessage2& aMessage)

  1084 {

  1085     iCachingChangeObserver = EFalse;

  1086     aMessage.Complete(KErrNone);

  1087 }

  1088 

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

  1090 // CCsSession::HandleNewConversationEventL

  1091 // the function to handles the new conversation event received from cache

  1092 // asynchronously

  1093 // ----------------------------------------------------------------------------

  1094 void CCsSession::HandleNewConversationEventL(

  1095                                              CCsClientConversation* aClientConversation)

  1096 {

  1097     PRINT ( _L("Enter CCsSession::HandleNewConversationEventL") );

  1098 

  1099     if (!iConversationChangeObserver)

  1100         return;

  1101 

  1102     //this is check to send notif to clients for a new message

  1103     //1. if the client is subscribed with contact id ==> then send

  1104     //2. if the client is subscribed with conv id ---> then send

  1105     // else dont send

  1106     

  1107     if ((aClientConversation->GetContactId() == 

  1108             iMonitoredConversation->GetContactId() && 

  1109             aClientConversation->GetContactId() != -1)

  1110             ||(aClientConversation->GetConversationEntryId() == 

  1111                     iMonitoredConversation->GetConversationEntryId()))

  1112     {

  1113 

  1114         if (! (iNotifyHandling))

  1115         {

  1116             //append in notify list

  1117             CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();

  1118             CleanupStack::PushL(conversationEvent);

  1119             conversationEvent->SetClientConversationL(*aClientConversation);

  1120             conversationEvent->SetEvent(KConversationEventNew);

  1121             iEventList->AppendL(conversationEvent);

  1122             CleanupStack::Pop(conversationEvent);

  1123         }

  1124         else

  1125         {

  1126             // create a new buffer for writing into stream

  1127             CBufFlat* buf = CBufFlat::NewL(KBigBuffer);

  1128             CleanupStack::PushL(buf);

  1129     

  1130             RBufWriteStream writeStream(*buf);

  1131             writeStream.PushL();

  1132     

  1133             //externalize ClientConversation

  1134             aClientConversation->ExternalizeL(writeStream);

  1135