1 /*

     2 * Copyright (c) 2009 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:

    15 *

    16 */

    17 #include "activitysession.h"

    18 #include "activitytask.h"

    19 #include "activitycmd.h"

    20 

    21 #include "activitystorageasynctask.h"

    22 #include "activitystoragesynctask.h"

    23 #include "activityobservertask.h"

    24 #include "activitybroadcasttask.h"

    25 #include "activitydataprovidertask.h"

    26 #include "activitythumbnailtask.h"

    27 

    28 _LIT(KTaskAlreadyExists, "Activity task exists");

    29 

    30 // -----------------------------------------------------------------------------

    31 //

    32 // -----------------------------------------------------------------------------

    33 //

    34 CActivitySession::CActivitySession(RFs& fileSession, 

    35                                    MActivityTaskStorage& taskStorage, 

    36                                    CActivityStorage& storage)

    37 :

    38 mFileSession(fileSession),

    39 mTasksStorage(taskStorage),

    40 mStorage(storage)

    41 {

    42     // No implementation required

    43 }

    44 

    45 // -----------------------------------------------------------------------------

    46 //

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

    48 //

    49 CActivitySession::~CActivitySession()

    50 {

    51     mRunningTasks.ResetAndDestroy();

    52 }

    53 

    54 // -----------------------------------------------------------------------------

    55 //

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

    57 //

    58 CActivitySession* CActivitySession::NewL(RFs& fileSession,

    59                                          MActivityTaskStorage& taskStorage,

    60                                          CActivityStorage& storage)

    61 {

    62     CActivitySession* self = new (ELeave) CActivitySession(fileSession, 

    63                                                            taskStorage, 

    64                                                            storage);

    65     CleanupStack::PushL(self);

    66     self->ConstructL();

    67     CleanupStack::Pop(self);

    68     return self;

    69 }

    70 

    71 // -----------------------------------------------------------------------------

    72 //

    73 // -----------------------------------------------------------------------------

    74 //

    75 void CActivitySession::ConstructL()

    76 {

    77 }

    78 

    79 // -----------------------------------------------------------------------------

    80 //

    81 // -----------------------------------------------------------------------------

    82 //

    83 void CActivitySession::ServiceL(const RMessage2& message)

    84 {

    85     switch (message.Function()) {

    86     case AddActivity:

    87     case UpdateActivity:

    88     case RemoveActivity:

    89     case RemoveApplicationActivities:

    90         ActivityStorageSyncTask::ExecuteL(mStorage, message);

    91         break;

    92     

    93     case Activities:

    94     case ApplicationActivities:

    95         CActivityStorageAsyncTask::ExecuteLD(*this, mStorage, message);

    96         break;

    97     

    98     case WaitActivity:

    99         CActivityObserverTask::ExecuteLD(mTasksStorage, *this, message);

   100         break;

   101     case GetThumbnail:

   102         CActivityThumbnailTask::ExecuteLD(mFileSession, *this, message);

   103         break;

   104     

   105     case LaunchActivity:

   106     case CancelWait:

   107         ActivityBroadcastTask::ExecuteL(mTasksStorage, message);

   108         break;

   109     

   110     case GetData:

   111         ActivityDataProviderTask::ExecuteL(*this,message);

   112         break;

   113     

   114     default:

   115         message.Complete(CServer2::EBadMessageNumber);

   116         break;

   117     }

   118 }

   119 

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

   121 //

   122 // -----------------------------------------------------------------------------

   123 //

   124 void CActivitySession::PushL(CActivityTask * task)

   125 {

   126     (KErrNotFound == mRunningTasks.Find(task)) ?

   127      mRunningTasks.AppendL(task) :

   128      User::Panic(KTaskAlreadyExists, KErrAlreadyExists);

   129 }

   130 

   131 // -----------------------------------------------------------------------------

   132 //

   133 // -----------------------------------------------------------------------------

   134 //

   135 void CActivitySession::Pop(CActivityTask *task)

   136 {

   137     const TInt offset(mRunningTasks.Find(task));

   138     if (KErrNotFound != offset) {

   139         mRunningTasks.Remove(offset);

   140     }

   141 }

   142 

   143 // -----------------------------------------------------------------------------

   144 //

   145 // -----------------------------------------------------------------------------

   146 //

   147 const RPointerArray<CActivityTask>& CActivitySession::StorageData() const

   148 {

   149     return mRunningTasks;

   150 }