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 Server Mark read Handler

    15 *

    16 */

    17 // INCLUDES

    18 #include <ccsclientconversation.h>

    19 #include <ccsconversationentry.h>

    20 #include "ccsconversationcache.h"

    21 #include "ccsconversationmarkreadhandler.h"

    22 #include "mcsconversationmarkreadobserver.h"

    23 #include <mmsconst.h>

    24 

    25 // ----------------------------------------------------------------------------

    26 // CCsConversationMarkReadHandler::NewL

    27 // Two Phase Construction

    28 // ----------------------------------------------------------------------------

    29 CCsConversationMarkReadHandler* CCsConversationMarkReadHandler::

    30 NewL(CCsConversationCache* aCache, MCsConversationMarkReadObserver* aObserver)

    31     {

    32     CCsConversationMarkReadHandler* self = 

    33             new (ELeave) CCsConversationMarkReadHandler();

    34     CleanupStack::PushL(self);

    35     self->ConstructL(aCache, aObserver);

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

    37     return self;

    38     }

    39 

    40 // ----------------------------------------------------------------------------

    41 // Constructor

    42 // ----------------------------------------------------------------------------

    43 CCsConversationMarkReadHandler::CCsConversationMarkReadHandler():

    44         CActive(CActive::EPriorityLow)

    45     {

    46     CActiveScheduler::Add( this );

    47     }

    48 

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

    50 // Constructor

    51 // ----------------------------------------------------------------------------

    52 void CCsConversationMarkReadHandler::ConstructL(CCsConversationCache* aCache,

    53         MCsConversationMarkReadObserver* aObserver)

    54     {

    55     iCache = aCache;

    56     iState = EMarkReadIdle;

    57     iObserver = aObserver;

    58     

    59     iConversationEntryList = new (ELeave)RPointerArray<CCsConversationEntry> ();  

    60     iSession = CMsvSession::OpenSyncL(*this);

    61     }

    62 

    63 // ----------------------------------------------------------------------------

    64 // Destructor

    65 // ----------------------------------------------------------------------------

    66 CCsConversationMarkReadHandler::~CCsConversationMarkReadHandler()

    67     {

    68     if(iSession)

    69         {

    70         delete iSession;

    71         iSession = NULL;

    72         }

    73     }

    74 

    75 // ----------------------------------------------------------------------------

    76 // Mark set of messages as read

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

    78 void CCsConversationMarkReadHandler::MarkReadL(TInt aConversationId)

    79     {

    80     // Temp client conversation object

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

    82     clientConversation->SetConversationEntryId(aConversationId);

    83     CleanupStack::PushL(clientConversation);

    84     

    85     // Create entry list

    86     iConversationEntryList = new (ELeave)RPointerArray<CCsConversationEntry> ();  

    87     

    88     // Get conversationlist for given client conversation

    89     iCache->GetConversationsL (clientConversation, iConversationEntryList);

    90     

    91     iMarkReadCount = 0;

    92     

    93     // Cleanup  

    94     CleanupStack::PopAndDestroy(clientConversation);

    95         

    96     iState = EMarkReadStart;

    97     IssueRequest();

    98     }

    99 

   100 // ----------------------------------------------------------------------------

   101 // Mark read a message

   102 // ----------------------------------------------------------------------------

   103 void CCsConversationMarkReadHandler::MarkReadOneMessageL()

   104     {

   105     CCsConversationEntry* entry = 

   106             static_cast<CCsConversationEntry*>((*iConversationEntryList)[iMarkReadCount]);    

   107   

   108     if ( entry->IsAttributeSet(ECsAttributeNew) ||

   109          entry->IsAttributeSet(ECsAttributeUnread) )

   110         {    

   111         TInt id = entry->EntryId();          

   112         

   113         CMsvEntry* cEntry = NULL;

   114         TRAPD(err, cEntry = iSession->GetEntryL(id));

   115         if ( err == KErrNotFound )

   116            return;

   117         

   118         TMsvEntry entry = cEntry->Entry();

   119         if ( entry.Unread() ) 

   120            {

   121            // Mark the entry as read

   122             if(entry.iMtm != KUidMsgTypeMultimedia)

   123             {

   124                 entry.SetUnread( EFalse );

   125             }

   126            cEntry->ChangeL( entry );

   127            }

   128         delete cEntry;

   129         }

   130     }

   131 

   132 // ----------------------------------------------------------------------------

   133 // RunL

   134 // ----------------------------------------------------------------------------

   135 void CCsConversationMarkReadHandler::RunL()

   136     {

   137     switch ( iState )

   138         {

   139         case EMarkReadStart:

   140             if ( iConversationEntryList->Count() > 0 )

   141                 {

   142                 iMarkReadCount = iConversationEntryList->Count();

   143                 iState = EMarkReadNext;

   144                 IssueRequest();

   145                 }

   146             else

   147                 {

   148                 iState = EMarkReadComplete;

   149                 IssueRequest();

   150                 }

   151             break;

   152         

   153         case EMarkReadNext:

   154             iMarkReadCount--;

   155             MarkReadOneMessageL();

   156             if ( iMarkReadCount > 0 )

   157                 {

   158                 iState = EMarkReadNext;

   159                 IssueRequest();

   160                 }

   161             else

   162                 {

   163                 iState = EMarkReadComplete;

   164                 IssueRequest();

   165                 }

   166             break;

   167             

   168         case EMarkReadComplete:

   169             // Cleanup

   170             iMarkReadCount = 0;

   171             iConversationEntryList->ResetAndDestroy();

   172             iConversationEntryList->Close();

   173             delete iConversationEntryList;

   174             iConversationEntryList = NULL;  

   175             

   176             // Notify observers

   177             iObserver->MarkReadComplete(this);

   178             break;

   179         }

   180     }

   181 

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

   183 // DoCancel

   184 // ----------------------------------------------------------------------------

   185 void CCsConversationMarkReadHandler::DoCancel()

   186     {

   187     // Not supported

   188     }

   189 

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

   191 // Move to next state

   192 // ---------------------------------------------------------------------------

   193 //

   194 void CCsConversationMarkReadHandler::IssueRequest()

   195     {

   196     if( !IsActive() )

   197         {

   198         iStatus = KRequestPending;

   199         TRequestStatus* status = &iStatus;

   200         SetActive();

   201         User::RequestComplete(status, KErrNone);

   202         }

   203     }

   204 

   205 // EOF