FCL/sf/app/messaging: comparison messagingapp/msgappfw/server/src/ccssession.cpp

equal deleted inserted replaced

-:84d9eb65b26f
+:518b245aa84c
 // ----------------------------------------------------------------------------
 // CCsSession::CCsSession
 // Construtor
 // ----------------------------------------------------------------------------
 CCsSession::CCsSession(CCsServer* aServer) :
-iServer(aServer)
+iServer(aServer),
+	    iDes(NULL),
+	    iMonitoredConversation(NULL),
+	    iBufferOverflow(EFalse),
+	    iGetConversationBufferOverflow( EFalse),
+	    iNotifyHandling(EFalse),
+	    iConversationListChangeObserver(EFalse),
+	    iConversationChangeObserver(EFalse),
+	    iCachingChangeObserver(EFalse),
+	    iReqCnt(1) //Let's start the event ID from 1
 {
 }
 // ----------------------------------------------------------------------------
 // CCsSession::ConstructL
 // ----------------------------------------------------------------------------
 void CCsSession::ConstructL()
 {
 PRINT ( _L("Enter CCsSession::ConstructL") );
-iBufferOverflow = EFalse;
-iGetConversationBufferOverflow = EFalse;
-des = NULL;
-iNotifyHandling = EFalse;
-iConversationListChangeObserver = EFalse;
-iConversationChangeObserver = EFalse;
-iCachingChangeObserver = EFalse;
-iMonitoredConversation = NULL;
 // initialize the event List
 iEventList = new (ELeave) RPointerArray<CCsConversationEvent> ();
-iReqCnt = 1; //Let's start the event ID from 1
 PRINT ( _L("End CCsSession::ConstructL") );
 }
 // ----------------------------------------------------------------------------
 // CCsSession::CCsSession
 // ----------------------------------------------------------------------------
 CCsSession::~CCsSession()
 {
 PRINT ( _L("Enter CCsSession::~CCsSession") );
-if (des)
+if ( iDes )
 {
-delete des;
+delete iDes;
-des = NULL;
+iDes = NULL;
 }
-if (iEventList)
+if ( iEventList )
 {
 iEventList->ResetAndDestroy();
 iEventList->Close();
 delete iEventList;
 iEventList = NULL;
 }
 TRAP ( errStatus, DoServiceL(aMessage) );
 // Check the error status returned
 if (errStatus != KErrNone)
 {
+// Free memory.
+if(iDes)
+{
+delete iDes;
+iDes=NULL;
+}
 aMessage.Complete(errStatus);
 }
 }
 // ----------------------------------------------------------------------------
 case EGetConversationIdFromAddress:
 PRINT ( _L("Received function EGetConversationIdFromAddress") )
 GetConversationIdfromAddressL(aMessage);
 break;
+case EGetConversationFromConversationId:
+PRINT ( _L("Received function EGetConversationFromConversationId") )
+GetConversationFromConversationIdL(aMessage);
+break;
 		case EGetConversationFromMessageId:
 PRINT ( _L("Received function EGetConversationFromMessageId") )
 GetConversationFromMessageIdL(aMessage);
 break;
 // CCsSession::ServiceError
 //
 // ----------------------------------------------------------------------------
 void CCsSession::ServiceError(const RMessage2& aMessage, TInt aError)
 {
+if(iDes)
+{
+delete iDes;
+iDes=NULL;
+}
 aMessage.Complete(aError);
 }
 // ----------------------------------------------------------------------------
 // CCsSession::GetConversationEntryListL
 if (iBufferOverflow == EFalse)
 {
 RPointerArray<CCsClientConversation>* ClientConversationList =
 new (ELeave) RPointerArray<CCsClientConversation> ();
+CleanupResetAndDestroyPushL(ClientConversationList);
 // get cache pointer
 CCsConversationCache* cache = iServer->ConversationCacheInterface();
 // Call cache function to get recent conversation entry list
 // with dispaly name for all stored conversation entry ID
 cache->GetConversationListL(ClientConversationList);
-CleanupStack::PushL(ClientConversationList);
 //write all list data into stream
 // create a new buffer for writing into stream
 CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
 CleanupStack::PushL(buf);
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-des = HBufC8::NewLC(buf->Size());
+iDes = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
+TPtr8 ptr(iDes->Des());
-TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
-// cleanup
+// Cleanup
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
-CleanupStack::Pop(ClientConversationList);
+// Cleanup ClientConversationList
-// destroy objects inside list
+CleanupStack::PopAndDestroy(ClientConversationList);
-ClientConversationList->ResetAndDestroy();
+}
-ClientConversationList->Close();
-delete ClientConversationList;
-ClientConversationList = NULL;
-}
 TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);
-TInt reqdBufferSize = des->Size();
+TInt reqdBufferSize  = iDes->Size();
 PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );
 PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );
 // If the received buffer size from Client API is less than
 else
 {
 PRINT ( _L("Adequate buffer received") );
 PRINT ( _L("Packing the results in response") )
-aMessage.Write(1, *des);
+aMessage.Write(1, *iDes);
 aMessage.Complete(EGetConversationListOperationComplete);
 iBufferOverflow = EFalse;
-delete des;
+delete iDes;
-des = NULL;
+iDes = NULL;
 }
 PRINT_TIMESTAMP ("End CCsSession::GetConversationListL");
 PRINT ( _L("End CCsSession::GetConversationListL") );
 }
 // ----------------------------------------------------------------------------
 if (iBufferOverflow == EFalse)
 {
 RPointerArray<CCsClientConversation>* ClientConversationList =
 new (ELeave) RPointerArray<CCsClientConversation> ();
+CleanupResetAndDestroyPushL(ClientConversationList);
 // get cache pointer
 CCsConversationCache* cache = iServer->ConversationCacheInterface();
 // Call cache function to get recent conversation entry list
 // with dispaly name for all stored conversation entry ID
 cache->GetConversationUnreadListL(ClientConversationList);
-CleanupStack::PushL(ClientConversationList);
 //write all list data into stream
 // create a new buffer for writing into stream
 CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
 CleanupStack::PushL(buf);
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-des = HBufC8::NewLC(buf->Size());
+iDes = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
+TPtr8 ptr(iDes->Des());
-TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 // cleanup
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
-CleanupStack::Pop(ClientConversationList);
+CleanupStack::PopAndDestroy(ClientConversationList);
-// destroy objects inside list
-ClientConversationList->ResetAndDestroy();
-ClientConversationList->Close();
-delete ClientConversationList;
-ClientConversationList = NULL;
 }
 TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);
-TInt reqdBufferSize  = des->Size();
+TInt reqdBufferSize  = iDes->Size();
 PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );
 PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );
 if ( rcevdBufferSize < reqdBufferSize )
 PRINT ( _L("Adequate buffer received") );
 PRINT ( _L("Packing the results in response") )
 TPckgC<TInt> overflowPackage(EFalse);
 aMessage.WriteL(0, overflowPackage);
-aMessage.Write(1, *des);
+aMessage.Write(1, *iDes);
 aMessage.Complete(KErrNone);
 iBufferOverflow = EFalse;
-delete des;
+delete iDes;
-des = NULL;
+iDes = NULL;
 }
 PRINT_TIMESTAMP ("End CCsSession::GetConversationUnreadListL");
 PRINT ( _L("End CCsSession::GetConversationUnreadListL") );
 }
 ClientConversation->InternalizeL(stream);
 CleanupStack::Pop(ClientConversation);
 CleanupStack::PopAndDestroy(2, buffer);//stream, buffer
 CleanupStack::PushL(ClientConversation);
-RPointerArray<CCsConversationEntry>* conversationEntryList =
+RPointerArray<CCsConversationEntry>* conversationEntryList=
-new (ELeave) RPointerArray<CCsConversationEntry> ();
+new (ELeave) RPointerArray<CCsConversationEntry>(10);
-CleanupStack::PushL(conversationEntryList);
+CleanupResetAndDestroyPushL(conversationEntryList);
 // get conversationlist for given ClientConversation
 cache->GetConversationsL(ClientConversation, conversationEntryList);
 // create a new buffer for writing into stream
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-des = HBufC8::NewLC(buf->Size());
+iDes = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
+TPtr8 ptr(iDes->Des());
-TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
-CleanupStack::Pop(conversationEntryList);
 // Cleanup
-conversationEntryList->ResetAndDestroy();
+CleanupStack::PopAndDestroy(conversationEntryList);
-conversationEntryList->Close();
-delete conversationEntryList;
-conversationEntryList = NULL;
 CleanupStack::PopAndDestroy(ClientConversation);
 }
 TInt rcevdBufferSize = aMessage.GetDesMaxLength(1);
-TInt reqdBufferSize = des->Size();
+TInt reqdBufferSize  = iDes->Size();
 PRINT1 ( _L("Received buffer size = %d"), rcevdBufferSize );
 PRINT1 ( _L("Required buffer size = %d"), reqdBufferSize );
 // If the received buffer size from Client API is less than
 else
 {
 PRINT ( _L("Adequate buffer received") );
 PRINT ( _L("Packing the results in response") )
-aMessage.Write(1, *des);
+aMessage.Write(1, *iDes);
 aMessage.Complete(EGetConversationOperationComplete);
 iGetConversationBufferOverflow = EFalse;
-delete des;
+delete iDes;
-des = NULL;
+iDes = NULL;
 }
 PRINT ( _L("End CCsSession::GetConversationsL") );
 }
 // ----------------------------------------------------------------------------
 CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf
 iNotifyHandling = EFalse;
 }
 PRINT ( _L("End CCsSession::HandleDeleteConversationListEventL") );
+}
+// ----------------------------------------------------------------------------
+// CCsSession::HandlePartialDeleteConversationListEventL
+// Notify client about partial delete conversation event
+// ----------------------------------------------------------------------------
+void CCsSession::HandlePartialDeleteConversationListEvent(
+CCsClientConversation* aClientConversation)
+{
+PRINT ( _L("Enter CCsSession::HandlePartialDeleteConversationListEvent") );
+if (!iConversationListChangeObserver)
+return;
+if (! (iNotifyHandling))
+{
+//append in notify list
+CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();
+conversationEvent->SetClientConversationL(*aClientConversation);
+CleanupStack::PushL(conversationEvent);
+conversationEvent->SetEvent(KConversationListEventPartialDelete);
+iEventList->AppendL(conversationEvent);
+CleanupStack::Pop(conversationEvent);
+}
+else
+{
+// create a new buffer for writing into stream
+CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
+CleanupStack::PushL(buf);
+RBufWriteStream writeStream(*buf);
+writeStream.PushL();
+//externalize ClientConversation
+aClientConversation->ExternalizeL(writeStream);
+// Results are already packed in the stream
+writeStream.CommitL();
+// --------------------------------------------------------------
+// Create a heap descriptor from the buffer
+HBufC8* notifyDes = HBufC8::NewLC(buf->Size());
+TPtr8 ptr(notifyDes->Des());
+buf->Read(0, ptr, buf->Size());
+iAsyncReqRMessage.Write(1, *notifyDes);
+iAsyncReqRMessage.Complete(EPartialDeleteConversationListEvent);
+CleanupStack::PopAndDestroy(3, buf); // notifyDes, writestream, buf
+iNotifyHandling = EFalse;
+}
 }
 // ----------------------------------------------------------------------------
 // CCsSession::HandleModifyConversationListEventL
 // Notify client about update conversation event
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
 PRINT ( _L("Enter CCsSession::HandleNewConversationEventL") );
 if (!iConversationChangeObserver)
 return;
-if (aClientConversation->GetConversationEntryId()
+//this is check to send notif to clients for a new message
-!= iMonitoredConversation->GetConversationEntryId())
+//1. if the client is subscribed with contact id ==> then send
-return;
+//2. if the client is subscribed with conv id ---> then send
+// else dont send
-if (! (iNotifyHandling))
-{
+if ((aClientConversation->GetContactId() ==
-//append in notify list
+iMonitoredConversation->GetContactId() &&
-CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();
+aClientConversation->GetContactId() != -1)
-CleanupStack::PushL(conversationEvent);
+||(aClientConversation->GetConversationEntryId() ==
-conversationEvent->SetClientConversationL(*aClientConversation);
+iMonitoredConversation->GetConversationEntryId()))
-conversationEvent->SetEvent(KConversationEventNew);
+{
-iEventList->AppendL(conversationEvent);
-CleanupStack::Pop(conversationEvent);
+if (! (iNotifyHandling))
-}
+{
-else
+//append in notify list
-{
+CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();
-// create a new buffer for writing into stream
+CleanupStack::PushL(conversationEvent);
-CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
+conversationEvent->SetClientConversationL(*aClientConversation);
-CleanupStack::PushL(buf);
+conversationEvent->SetEvent(KConversationEventNew);
+iEventList->AppendL(conversationEvent);
-RBufWriteStream writeStream(*buf);
+CleanupStack::Pop(conversationEvent);
-writeStream.PushL();
+}
+else
-//externalize ClientConversation
+{
-aClientConversation->ExternalizeL(writeStream);
+// create a new buffer for writing into stream
+CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
-// Results are already packed in the stream
+CleanupStack::PushL(buf);
-writeStream.CommitL();
-// --------------------------------------------------------------
+RBufWriteStream writeStream(*buf);
+writeStream.PushL();
-// Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+//externalize ClientConversation
-CleanupStack::Pop(des);
+aClientConversation->ExternalizeL(writeStream);
-TPtr8 ptr(des->Des());
-buf->Read(0, ptr, buf->Size());
+// Results are already packed in the stream
+writeStream.CommitL();
-CleanupStack::PopAndDestroy(2, buf); // writestream, buf
+// --------------------------------------------------------------
-iAsyncReqRMessage.Write(1, *des);
+// Create a heap descriptor from the buffer
-iAsyncReqRMessage.Complete(EAddConversationEvent);
+HBufC8* des = HBufC8::NewLC(buf->Size());
-delete des;
+CleanupStack::Pop(des);
-iNotifyHandling = EFalse;
+TPtr8 ptr(des->Des());
-}
+buf->Read(0, ptr, buf->Size());
+CleanupStack::PopAndDestroy(2, buf); // writestream, buf
+iAsyncReqRMessage.Write(1, *des);
+iAsyncReqRMessage.Complete(EAddConversationEvent);
+delete des;
+iNotifyHandling = EFalse;
+}
+}
 PRINT ( _L("End CCsSession::HandleNewConversationEventL") );
 }
 // ----------------------------------------------------------------------------
 // CCsSession::HandleDeleteConversationEventL
 PRINT ( _L("Enter CCsSession::HandleDeleteConversationEventL") );
 if (!iConversationChangeObserver)
 return;
-if (aClientConversation->GetConversationEntryId()
+if ((aClientConversation->GetContactId()
-!= iMonitoredConversation->GetConversationEntryId())
+!= iMonitoredConversation->GetContactId()) &&
+(aClientConversation->GetConversationEntryId()
+!= iMonitoredConversation->GetConversationEntryId())
+)
 return;
 if (! (iNotifyHandling))
 {
 //append in notify list
 // Results are already packed in the stream
 writeStream.CommitL();
 // --------------------------------------------------------------
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
 PRINT ( _L("Enter CCsSession::HandleModifyConversationEventL") );
 if (!iConversationChangeObserver)
 return;
-if (aClientConversation->GetConversationEntryId()
+//this is check to send notif to clients for a new message
-!= iMonitoredConversation->GetConversationEntryId())
+//1. if the client is subscribed with contact id ==> then send
-return;
+//2. if the client is subscribed with conv id ---> then send
+// else dont send
-if (! (iNotifyHandling))
-{
+if ((aClientConversation->GetContactId() ==
-//append in notify list
+iMonitoredConversation->GetContactId() &&
-CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();
+aClientConversation->GetContactId() != -1)
-CleanupStack::PushL(conversationEvent);
+||(aClientConversation->GetConversationEntryId() ==
-conversationEvent->SetClientConversationL(*aClientConversation);
+iMonitoredConversation->GetConversationEntryId()))
-conversationEvent->SetEvent(KConversationEventUpdate);
+{
-iEventList->AppendL(conversationEvent);
-CleanupStack::Pop(conversationEvent);
+if (! (iNotifyHandling))
-}
+{
-else
+//append in notify list
-{
+CCsConversationEvent* conversationEvent = CCsConversationEvent::NewL();
-// create a new buffer for writing into stream
+CleanupStack::PushL(conversationEvent);
-CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
+conversationEvent->SetClientConversationL(*aClientConversation);
-CleanupStack::PushL(buf);
+conversationEvent->SetEvent(KConversationEventUpdate);
+iEventList->AppendL(conversationEvent);
-RBufWriteStream writeStream(*buf);
+CleanupStack::Pop(conversationEvent);
-writeStream.PushL();
+}
+else
-//externalize ClientConversation
+{
-aClientConversation->ExternalizeL(writeStream);
+// create a new buffer for writing into stream
+CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
-// Results are already packed in the stream
+CleanupStack::PushL(buf);
-writeStream.CommitL();
-// --------------------------------------------------------------
+RBufWriteStream writeStream(*buf);
+writeStream.PushL();
-// Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+//externalize ClientConversation
-CleanupStack::Pop(des);
+aClientConversation->ExternalizeL(writeStream);
-TPtr8 ptr(des->Des());
-buf->Read(0, ptr, buf->Size());
+// Results are already packed in the stream
+writeStream.CommitL();
-CleanupStack::PopAndDestroy(2, buf); // writestream, buf
+// --------------------------------------------------------------
-iAsyncReqRMessage.Write(1, *des);
+// Create a heap descriptor from the buffer
-iAsyncReqRMessage.Complete(EModifyConversationEvent);
+HBufC8* des = HBufC8::NewL(buf->Size());
-delete des;
+TPtr8 ptr(des->Des());
-iNotifyHandling = EFalse;
+buf->Read(0, ptr, buf->Size());
-}
+CleanupStack::PopAndDestroy(2, buf); // writestream, buf
+iAsyncReqRMessage.Write(1, *des);
+iAsyncReqRMessage.Complete(EModifyConversationEvent);
+delete des;
+iNotifyHandling = EFalse;
+}
+}
 PRINT ( _L("End CCsSession::HandleModifyConversationEventL") );
 }
 // ----------------------------------------------------------------------------
 // CCsSession::NotifyClient
 }
 else if (aConversationEvent->IsUpdateConversationListEventSet())
 {
 iAsyncReqRMessage.Complete(EModifyConversationListEvent);
 }
+else if(aConversationEvent->IsPartialDeleteConversationListEventSet())
+{
+iAsyncReqRMessage.Complete(EPartialDeleteConversationListEvent);
+}
 else if (aConversationEvent->IsNewConversationEventSet())
 {
 iAsyncReqRMessage.Complete(EAddConversationEvent);
 }
 else if (aConversationEvent->IsDeleteConversationEventSet())
 HandleModifyConversationListEventL(aConversation);
 }
 else if (aEvent & KConversationListEventDelete)
 {
 HandleDeleteConversationListEventL(aConversation);
+}
+else if(aEvent & KConversationListEventPartialDelete)
+{
+HandlePartialDeleteConversationListEvent(aConversation);
 }
 else if (aEvent & KConversationEventNew)
 {
 HandleNewConversationEventL(aConversation);
 }
 TInt conversationId = aMessage.Int0();
 // Delete handler
 CCsConversationCache* cache = iServer->ConversationCacheInterface();
 CCsConversationDeleteHandler* deleteHandler =
-CCsConversationDeleteHandler::NewL(cache, this);
+CCsConversationDeleteHandler::NewL(cache);
 deleteHandler->DeleteL(conversationId);
 aMessage.Complete(EUserDeleteConversationComplete);
 PRINT ( _L("End CCsSession::DeleteConversationL") );
-}
-// ----------------------------------------------------------------------------
-// CCsSession::DeleteComplete
-// ----------------------------------------------------------------------------
-void CCsSession::DeleteComplete(CCsConversationDeleteHandler* aHandler)
-{
-delete aHandler;
-}
-// ----------------------------------------------------------------------------
-// CCsSession::DeleteInProgress
-// ----------------------------------------------------------------------------
-void CCsSession::DeleteInProgress(CCsConversationDeleteHandler* aHandler)
-{
-delete aHandler;
 }
 // ----------------------------------------------------------------------------
 // CCsSession::HandleRefreshConversationListL
 // ----------------------------------------------------------------------------
 // Results are already packed in the stream
 writeStream.CommitL();
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
 aMessage.Write(1, *des);
 aMessage.Complete(EGetConversationIdComplete);
+delete des;
+}
+void CCsSession::GetConversationFromConversationIdL(const RMessage2& aMessage)
+{
+// create a new buffer for writing into stream
+CBufFlat* buf = CBufFlat::NewL(KBigBuffer);
+CleanupStack::PushL(buf);
+RBufWriteStream writeStream(*buf);
+writeStream.PushL();
+// Get the conversation id
+TInt conversationId = aMessage.Int0();
+CCsConversationCache* cache = iServer->ConversationCacheInterface();
+CCsClientConversation* clientConv = cache->GetConversationFromConversationIdL(conversationId);
+// if no conversation exists for given message-id,
+// create a dummy conversation and complete response
+if(clientConv == NULL)
+{
+//create dummy conversation
+clientConv = CCsClientConversation::NewL();
+CleanupStack::PushL(clientConv);
+clientConv->SetConversationEntryId(-1);
+CCsConversationEntry* entry = CCsConversationEntry::NewL();
+CleanupStack::PushL(entry);
+entry->SetEntryId(-1);
+clientConv->SetConversationEntryL(entry); // clone
+CleanupStack::PopAndDestroy(entry);
+}
+else
+{
+CleanupStack::PushL(clientConv);
+}
+// Externalize
+clientConv->ExternalizeL(writeStream);
+// Results are already packed in the stream
+writeStream.CommitL();
+// Create a heap descriptor from the buffer
+HBufC8* des = HBufC8::NewL(buf->Size());
+TPtr8 ptr(des->Des());
+buf->Read(0, ptr, buf->Size());
+CleanupStack::PopAndDestroy(3, buf); // clientConv, writestream, buf
+aMessage.Write(1, *des);
+aMessage.Complete(EGetConversationFromConversationIdComplete);
 delete des;
 }
 // ----------------------------------------------------------------------------
 // GetConversationFromMessageIdL
 // Results are already packed in the stream
 writeStream.CommitL();
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(3, buf); // conversation, writestream, buf
 // Results are already packed in the stream
 writeStream.CommitL();
 // Create a heap descriptor from the buffer
-HBufC8* des = HBufC8::NewLC(buf->Size());
+HBufC8* des = HBufC8::NewL(buf->Size());
-CleanupStack::Pop(des);
 TPtr8 ptr(des->Des());
 buf->Read(0, ptr, buf->Size());
 CleanupStack::PopAndDestroy(2, buf); // writestream, buf
 CleanupStack::PopAndDestroy(&buffer);
 TInt conversationId = aMessage.Int0();
 // Mark read handler
 CCsConversationCache* cache = iServer->ConversationCacheInterface();
-CCsConversationMarkReadHandler* markHandler =
+CCsConversationMarkReadHandler* markHandler = CCsConversationMarkReadHandler::NewL(cache);
-CCsConversationMarkReadHandler::NewL(cache, this);
 markHandler->MarkReadL(conversationId);
 aMessage.Complete(EUserMarkReadConversationComplete);
 PRINT ( _L("End CCsSession::MarkConversationReadL") );
 }
-// ----------------------------------------------------------------------------
-// CCsSession::MarkReadComplete
-// ----------------------------------------------------------------------------
-void CCsSession::MarkReadComplete(CCsConversationMarkReadHandler* aHandler)
-{
-delete aHandler;
-}
 //EOF

changeset 37	518b245aa84c
parent 25	84d9eb65b26f
child 48	4f501b74aeb1