activityfw/activityserviceplugin/tsrc/mocks/src/afstorageclient.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     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 
       
    18 #include "afstorageclient.h"
       
    19 
       
    20 #include <afentry.h>
       
    21 #include <afasyncrequestobserver.h>
       
    22 #include <fbs.h>
       
    23 
       
    24 TInt CAfStorageClient::constructorError(KErrNone);
       
    25 TInt CAfStorageClient::expectedReturnCode(KErrNone);
       
    26 
       
    27 CAfEntry *CAfStorageClient::lastCallEntry(0);
       
    28 TInt CAfStorageClient::lastCallImageHandle(0);
       
    29 TSize CAfStorageClient::lastCallThumbnailSize(0, 0);
       
    30 HBufC *CAfStorageClient::lastCallThumbnailPath(0);
       
    31 void *CAfStorageClient::lastCallUserData(0);
       
    32 CAfStorageClient::LastMethodCalled CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;
       
    33     
       
    34 CAfStorageClient *CAfStorageClient::NewL(MAfAsyncRequestObserver &observer)
       
    35 {
       
    36     User::LeaveIfError(CAfStorageClient::constructorError);
       
    37     return new CAfStorageClient(observer);
       
    38 }
       
    39 
       
    40 CAfStorageClient::~CAfStorageClient()
       
    41 {
       
    42     clearLastCallInfo();
       
    43 }
       
    44 
       
    45 CAfStorageClient::CAfStorageClient(MAfAsyncRequestObserver &observer) : mObserver(observer)
       
    46 {
       
    47 }
       
    48 
       
    49 int CAfStorageClient::addActivity(const CAfEntry &entry, TInt imageHandle)
       
    50 {
       
    51     lastMethodCalled = CAfStorageClient::AddActivityMethod;
       
    52     updateLastEntry(entry);
       
    53     lastCallImageHandle = imageHandle;
       
    54     return CAfStorageClient::expectedReturnCode;
       
    55 }
       
    56 
       
    57 int CAfStorageClient::updateActivity(const CAfEntry &entry, TInt imageHandle)
       
    58 {
       
    59     lastMethodCalled = CAfStorageClient::UpdateActivityMethod;
       
    60     updateLastEntry(entry);
       
    61     lastCallImageHandle = imageHandle;
       
    62     return CAfStorageClient::expectedReturnCode;
       
    63 }
       
    64 
       
    65 int CAfStorageClient::saveActivity(const CAfEntry &entry, TInt imageHandle)
       
    66 {
       
    67     lastMethodCalled = CAfStorageClient::SaveActivityMethod;
       
    68     updateLastEntry(entry);
       
    69     lastCallImageHandle = imageHandle;
       
    70     return CAfStorageClient::expectedReturnCode;
       
    71 }
       
    72 
       
    73 int CAfStorageClient::removeActivity(const CAfEntry &entry)
       
    74 {
       
    75     lastMethodCalled = CAfStorageClient::RemoveActivityMethod;
       
    76     updateLastEntry(entry);
       
    77     return CAfStorageClient::expectedReturnCode;
       
    78 }
       
    79 
       
    80 int CAfStorageClient::removeApplicationActivities(const CAfEntry &entry)
       
    81 {
       
    82     lastMethodCalled = CAfStorageClient::RemoveApplicationActivitiesMethod;
       
    83     updateLastEntry(entry);
       
    84     return CAfStorageClient::expectedReturnCode;
       
    85 }
       
    86 
       
    87 int CAfStorageClient::activities(RPointerArray<CAfEntry> &dst)
       
    88 {
       
    89     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {
       
    90         dst.Append(CAfStorageClient::lastCallEntry);
       
    91         CAfStorageClient::lastCallEntry =0;
       
    92     }
       
    93     lastMethodCalled = CAfStorageClient::ActivitiesMethod;
       
    94     return CAfStorageClient::expectedReturnCode;
       
    95 }
       
    96 
       
    97 int CAfStorageClient::applicationActivities(RPointerArray<CAfEntry> &dst, const CAfEntry &entry)
       
    98 {
       
    99     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {
       
   100         dst.Append(CAfStorageClient::lastCallEntry);
       
   101         CAfStorageClient::lastCallEntry =0;
       
   102     }
       
   103     lastMethodCalled = CAfStorageClient::ApplicationActivitiesMethod;
       
   104     updateLastEntry(entry);
       
   105     return CAfStorageClient::expectedReturnCode;
       
   106 }
       
   107 
       
   108 int CAfStorageClient::activityData(CAfEntry *&dst, const CAfEntry &entry)
       
   109 {
       
   110     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {
       
   111         dst =CAfStorageClient::lastCallEntry;
       
   112         CAfStorageClient::lastCallEntry =0;
       
   113     }
       
   114     lastMethodCalled = CAfStorageClient::ActivityDataMethod;
       
   115     // @todo return something in dst
       
   116     updateLastEntry(entry);
       
   117     return CAfStorageClient::expectedReturnCode;
       
   118 }
       
   119 
       
   120 int CAfStorageClient::waitActivity()
       
   121 {
       
   122     if(lastMethodCalled == CAfStorageClient::NoCall) {
       
   123         lastMethodCalled = CAfStorageClient::WaitActivityMethod;
       
   124         mObserver.waitActivityRequestCompleted(CAfStorageClient::expectedReturnCode, KNullDesC8);
       
   125     }
       
   126     
       
   127     lastMethodCalled = CAfStorageClient::WaitActivityMethod;
       
   128     return CAfStorageClient::expectedReturnCode;
       
   129 }
       
   130 
       
   131 int CAfStorageClient::launchActivity(const CAfEntry &entry)
       
   132 {
       
   133     lastMethodCalled = CAfStorageClient::LaunchActivityMethod;
       
   134     updateLastEntry(entry);
       
   135     return CAfStorageClient::expectedReturnCode;
       
   136 }
       
   137 
       
   138 int CAfStorageClient::getThumbnail(const TSize &size, const TDesC &imagePath, void *userData)
       
   139 {
       
   140     lastMethodCalled = CAfStorageClient::GetThumbnailMethod;
       
   141     lastCallThumbnailSize = size;
       
   142     delete lastCallThumbnailPath;
       
   143     lastCallThumbnailPath = imagePath.Alloc();
       
   144     lastCallUserData = userData;
       
   145     int result = KErrNone;
       
   146     if(size.iHeight <=0 || size.iWidth <= 0 ){
       
   147         mObserver.getThumbnailRequestCompleted(KErrArgument, -1, userData);
       
   148     } else {
       
   149         CFbsBitmap *bitmap = new (ELeave)CFbsBitmap();
       
   150         CleanupStack::PushL(bitmap);
       
   151         User::LeaveIfError(bitmap->Create(size, EColor4K));
       
   152         mObserver.getThumbnailRequestCompleted(CAfStorageClient::expectedReturnCode, bitmap->Handle(), userData);
       
   153         CleanupStack::PopAndDestroy(bitmap);
       
   154     }
       
   155     
       
   156     return CAfStorageClient::expectedReturnCode;
       
   157 }
       
   158 
       
   159 int CAfStorageClient::notifyDataChange()
       
   160 {
       
   161     if(lastMethodCalled == CAfStorageClient::NoCall) {
       
   162         lastMethodCalled = CAfStorageClient::NotifyDataChangeMethod;
       
   163         mObserver.dataChangeNotificationCompleted(CAfStorageClient::expectedReturnCode);
       
   164     }
       
   165     lastMethodCalled = CAfStorageClient::NotifyDataChangeMethod;
       
   166     return CAfStorageClient::expectedReturnCode;
       
   167 }
       
   168 
       
   169 // ---------------------------------------------------------------------------
       
   170 //  Invoking callbacks
       
   171 // ---------------------------------------------------------------------------
       
   172 // 
       
   173 void CAfStorageClient::invokeWaitActivityCallback(int result, const TDesC8 &data)
       
   174 {
       
   175     mObserver.waitActivityRequestCompleted(result, data);
       
   176 }
       
   177 
       
   178 void CAfStorageClient::invokeGetThumbnailCallback(int result, int bitmapHandle, void *userData)
       
   179 {
       
   180     mObserver.getThumbnailRequestCompleted(result, bitmapHandle, userData);
       
   181 }
       
   182 
       
   183 void CAfStorageClient::invokeDataChangeCallback(int result)
       
   184 {
       
   185     mObserver.dataChangeNotificationCompleted(result);
       
   186 }
       
   187 
       
   188 // ---------------------------------------------------------------------------
       
   189 //  Helper methods
       
   190 // ---------------------------------------------------------------------------
       
   191 // 
       
   192 void CAfStorageClient::clearLastCallInfo()
       
   193 {
       
   194     CAfStorageClient::constructorError = EFalse;
       
   195     CAfStorageClient::expectedReturnCode = KErrNone;
       
   196 
       
   197     delete CAfStorageClient::lastCallEntry;
       
   198     CAfStorageClient::lastCallEntry = 0;
       
   199     
       
   200     CAfStorageClient::lastCallImageHandle = 0;
       
   201     CAfStorageClient::lastCallThumbnailSize = TSize(0,0);
       
   202     
       
   203     delete CAfStorageClient::lastCallThumbnailPath;
       
   204     CAfStorageClient::lastCallThumbnailPath = 0;
       
   205     
       
   206     CAfStorageClient::lastCallUserData = 0;
       
   207     
       
   208     lastMethodCalled = CAfStorageClient::NoCall;
       
   209 }
       
   210 
       
   211 void CAfStorageClient::updateLastEntry(const CAfEntry &entry)
       
   212 {
       
   213     delete CAfStorageClient::lastCallEntry;
       
   214     
       
   215     CAfStorageClient::lastCallEntry = CAfEntry::NewL(
       
   216         entry.Flags(),
       
   217         entry.ApplicationId(),
       
   218         entry.ActivityId(),
       
   219         entry.ImageSrc(),
       
   220         entry.Data(CAfEntry::Private),
       
   221         entry.Data(CAfEntry::Public)
       
   222     );
       
   223 }