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::saveActivity(const CAfEntry &entry, TInt imageHandle)

    50 {

    51     lastMethodCalled = CAfStorageClient::SaveActivityMethod;

    52     updateLastEntry(entry);

    53     lastCallImageHandle = imageHandle;

    54     return CAfStorageClient::expectedReturnCode;

    55 }

    56 

    57 int CAfStorageClient::removeActivity(const CAfEntry &entry)

    58 {

    59     lastMethodCalled = CAfStorageClient::RemoveActivityMethod;

    60     updateLastEntry(entry);

    61     return CAfStorageClient::expectedReturnCode;

    62 }

    63 

    64 int CAfStorageClient::removeApplicationActivities(const CAfEntry &entry)

    65 {

    66     lastMethodCalled = CAfStorageClient::RemoveApplicationActivitiesMethod;

    67     updateLastEntry(entry);

    68     return CAfStorageClient::expectedReturnCode;

    69 }

    70 

    71 int CAfStorageClient::activities(RPointerArray<CAfEntry> &dst, int /*limit*/)

    72 {

    73     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {

    74         dst.Append(CAfStorageClient::lastCallEntry);

    75         CAfStorageClient::lastCallEntry =0;

    76     }

    77     lastMethodCalled = CAfStorageClient::ActivitiesMethod;

    78     return CAfStorageClient::expectedReturnCode;

    79 }

    80 

    81 int CAfStorageClient::applicationActivities(RPointerArray<CAfEntry> &dst, const CAfEntry &entry)

    82 {

    83     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {

    84         dst.Append(CAfStorageClient::lastCallEntry);

    85         CAfStorageClient::lastCallEntry =0;

    86     }

    87     lastMethodCalled = CAfStorageClient::ApplicationActivitiesMethod;

    88     updateLastEntry(entry);

    89     return CAfStorageClient::expectedReturnCode;

    90 }

    91 

    92 int CAfStorageClient::activityData(CAfEntry *&dst, const CAfEntry &entry)

    93 {

    94     if (lastMethodCalled == CAfStorageClient::SaveActivityMethod && CAfStorageClient::lastCallEntry) {

    95         dst =CAfStorageClient::lastCallEntry;

    96         CAfStorageClient::lastCallEntry =0;

    97     }

    98     lastMethodCalled = CAfStorageClient::ActivityDataMethod;

    99     // @todo return something in dst

   100     updateLastEntry(entry);

   101     return CAfStorageClient::expectedReturnCode;

   102 }

   103 

   104 int CAfStorageClient::waitActivity()

   105 {

   106     if(lastMethodCalled == CAfStorageClient::NoCall) {

   107         lastMethodCalled = CAfStorageClient::WaitActivityMethod;

   108         mObserver.waitActivityRequestCompleted(CAfStorageClient::expectedReturnCode, KNullDesC8);

   109     }

   110     

   111     lastMethodCalled = CAfStorageClient::WaitActivityMethod;

   112     return CAfStorageClient::expectedReturnCode;

   113 }

   114 

   115 int CAfStorageClient::launchActivity(const CAfEntry &entry)

   116 {

   117     lastMethodCalled = CAfStorageClient::LaunchActivityMethod;

   118     updateLastEntry(entry);

   119     return CAfStorageClient::expectedReturnCode;

   120 }

   121 

   122 int CAfStorageClient::getThumbnail(const TDesC &imagePath, void *userData)

   123 {

   124     lastMethodCalled = CAfStorageClient::GetThumbnailMethod;

   125     delete lastCallThumbnailPath;

   126     lastCallThumbnailPath = imagePath.Alloc();

   127     lastCallUserData = userData;

   128     CFbsBitmap *bitmap = new (ELeave)CFbsBitmap();

   129     CleanupStack::PushL(bitmap);

   130     User::LeaveIfError(bitmap->Create(TSize(128, 128), EColor4K));

   131     mObserver.getThumbnailRequestCompleted(CAfStorageClient::expectedReturnCode, bitmap->Handle(), userData);

   132     CleanupStack::PopAndDestroy(bitmap);

   133     return CAfStorageClient::expectedReturnCode;

   134 }

   135 

   136 int CAfStorageClient::notifyDataChange()

   137 {

   138     if(lastMethodCalled == CAfStorageClient::NoCall) {

   139         lastMethodCalled = CAfStorageClient::NotifyDataChangeMethod;

   140         mObserver.dataChangeNotificationCompleted(CAfStorageClient::expectedReturnCode);

   141     }

   142     lastMethodCalled = CAfStorageClient::NotifyDataChangeMethod;

   143     return CAfStorageClient::expectedReturnCode;

   144 }

   145 

   146 // ---------------------------------------------------------------------------

   147 //  Invoking callbacks

   148 // ---------------------------------------------------------------------------

   149 // 

   150 void CAfStorageClient::invokeWaitActivityCallback(int result, const TDesC8 &data)

   151 {

   152     mObserver.waitActivityRequestCompleted(result, data);

   153 }

   154 

   155 void CAfStorageClient::invokeGetThumbnailCallback(int result, int bitmapHandle, void *userData)

   156 {

   157     mObserver.getThumbnailRequestCompleted(result, bitmapHandle, userData);

   158 }

   159 

   160 void CAfStorageClient::invokeDataChangeCallback(int result)

   161 {

   162     mObserver.dataChangeNotificationCompleted(result);

   163 }

   164 

   165 // ---------------------------------------------------------------------------

   166 //  Helper methods

   167 // ---------------------------------------------------------------------------

   168 // 

   169 void CAfStorageClient::clearLastCallInfo()

   170 {

   171     CAfStorageClient::constructorError = EFalse;

   172     CAfStorageClient::expectedReturnCode = KErrNone;

   173 

   174     delete CAfStorageClient::lastCallEntry;

   175     CAfStorageClient::lastCallEntry = 0;

   176     

   177     CAfStorageClient::lastCallImageHandle = 0;

   178     CAfStorageClient::lastCallThumbnailSize = TSize(0,0);

   179     

   180     delete CAfStorageClient::lastCallThumbnailPath;

   181     CAfStorageClient::lastCallThumbnailPath = 0;

   182     

   183     CAfStorageClient::lastCallUserData = 0;

   184     

   185     lastMethodCalled = CAfStorageClient::NoCall;

   186 }

   187 

   188 void CAfStorageClient::updateLastEntry(const CAfEntry &entry)

   189 {

   190     delete CAfStorageClient::lastCallEntry;

   191     

   192     CAfStorageClient::lastCallEntry = CAfEntry::NewL(

   193         entry.Flags(),

   194         entry.ApplicationId(),

   195         entry.ActivityId(),

   196         entry.CustomActivityName(),

   197         entry.ImageSrc(),

   198         entry.Data(CAfEntry::Private),

   199         entry.Data(CAfEntry::Public),

   200         entry.Timestamp()

   201     );

   202 }