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 }