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 <fbs.h>

    18 #include <s32mem.h>

    19 

    20 #include <qvariant.h>

    21 #include <XQConversions>

    22 

    23 #include "afstorageclient_p.h"

    24 #include "afasyncrequest_p.h"

    25 #include "afstorageglobals.h"

    26 #include "afserializer.h"

    27 #include "afentry.h"

    28 #include "afstorageentry.h"

    29 

    30 

    31 // -----------------------------------------------------------------------------

    32 template <class T>

    33 void RPointerArrayCleanupMethod(TAny *aPtr)

    34 {

    35     static_cast< RPointerArray<T>* >(aPtr)->ResetAndDestroy();

    36 }

    37 

    38 // -----------------------------------------------------------------------------

    39 template <class T>

    40 void CleanupResetAndDestroyPushL(RPointerArray<T> &array) {

    41     CleanupStack::PushL(TCleanupItem(&RPointerArrayCleanupMethod<T>, &array));

    42 } 

    43 // -----------------------------------------------------------------------------

    44 /**

    45  * Constructor

    46  */

    47 AfStorageClientPrivate::AfStorageClientPrivate(MAfAsyncRequestObserver & observer)

    48 :

    49 mImplementation(observer)

    50 {

    51 }

    52 

    53 // -----------------------------------------------------------------------------

    54 /**

    55  * Destructor

    56  */

    57 AfStorageClientPrivate::~AfStorageClientPrivate()

    58 {

    59     mImplementation.Close();

    60 }

    61 

    62 // -----------------------------------------------------------------------------

    63 /**

    64  * Function implementation

    65  * @see AfStorageClient::connect

    66  */

    67 int AfStorageClientPrivate::connect()

    68 {

    69     TRAPD(errNo, mImplementation.connectL());

    70     return errNo;

    71 }

    72 

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

    74 /**

    75  * Function implementation

    76  * @see AfStorageClient::addActivity(const AfStorageEntry &,const QPixmap&)

    77  */

    78 int AfStorageClientPrivate::addActivity(const AfStorageEntry &entry, 

    79                                         const QPixmap& imageSrc)

    80 {

    81     return execute(AddActivity, entry, imageSrc);

    82 }

    83 

    84 // -----------------------------------------------------------------------------

    85 /**

    86  * Function implementation

    87  * @see AfStorageClient::updateActivity(const AfStorageEntry &,const QPixmap&)

    88  */

    89 int AfStorageClientPrivate::updateActivity(const AfStorageEntry &entry, 

    90                                            const QPixmap& imageSrc)

    91 {

    92     return execute(UpdateActivity, entry, imageSrc);

    93 }

    94 

    95 // -----------------------------------------------------------------------------

    96 /**

    97  * Function implementation

    98  * @see AfStorageClient::removeActivity(const AfStorageEntry &)

    99  */

   100 int AfStorageClientPrivate::removeActivity(const AfStorageEntry &entry)

   101 {

   102     return execute(RemoveActivity, entry, QPixmap());

   103 }

   104 

   105 // -----------------------------------------------------------------------------

   106 /**

   107  * Function implementation

   108  * @see AfStorageClient::removeApplicationActivities(const AfStorageEntry &)

   109  */

   110 int AfStorageClientPrivate::removeApplicationActivities(const AfStorageEntry &entry)

   111 {

   112     return execute(RemoveApplicationActivities, entry, QPixmap());

   113 }

   114 

   115 // -----------------------------------------------------------------------------

   116 /**

   117  * Function implementation

   118  * @see AfStorageClient::activities(QList<AfStorageEntry> &)

   119  */

   120 int AfStorageClientPrivate::activities(QList<AfStorageEntry> &results)

   121 {

   122     return execute(Activities, results, AfStorageEntry());

   123 }

   124 

   125 // -----------------------------------------------------------------------------

   126 /**

   127  * Function implementation

   128  * @see AfStorageClient::applicationActivities(QList<AfStorageEntry> &, const AfStorageEntry &)

   129  */

   130 int AfStorageClientPrivate::applicationActivities(QList<AfStorageEntry> &results,

   131                                                   const AfStorageEntry &templateEntry)

   132 {

   133     return execute(ApplicationActivities, results, templateEntry);

   134 }

   135 

   136 // -----------------------------------------------------------------------------

   137 /**

   138  * Function implementation

   139  * @see AfStorageClient::activityData(AfStorageEntry &, const AfStorageEntry &)

   140  */

   141 int AfStorageClientPrivate::activityData(AfStorageEntry &resultEntry, 

   142                                          const AfStorageEntry &templateEntry)

   143 {

   144     

   145     QList<AfStorageEntry> results;

   146     int errNo(execute(ApplicationActivity, results, templateEntry));

   147     if (0 == errNo) {

   148         resultEntry = results.first();

   149     }

   150     return errNo;

   151 }

   152 

   153 // -----------------------------------------------------------------------------

   154 /**

   155  * Function implementation

   156  * @see AfStorageClient::waitActivity()

   157  */

   158 int AfStorageClientPrivate::waitActivity()

   159 {

   160     return execute(WaitActivity, AfStorageEntry(), QPixmap());

   161 }

   162 

   163 // -----------------------------------------------------------------------------

   164 /**

   165  * Function implementation

   166  * @see AfStorageClient::getThumbnail(QSize, QString, void *)

   167  */

   168 int AfStorageClientPrivate::getThumbnail(QSize size, QString imagePath, void *userData)

   169 {

   170     HBufC *source = XQConversions::qStringToS60Desc(imagePath);

   171     TRAPD(errNo, mImplementation.getThumbnailL(TSize(size.width(), size.height()), *source, userData);)

   172     delete source;

   173     return errNo;

   174     

   175 }

   176 

   177 // -----------------------------------------------------------------------------

   178 /**

   179  * Function implementation

   180  * @see AfStorageClient::notifyDataChange()

   181  */

   182 int AfStorageClientPrivate::notifyDataChange()

   183 {

   184     return execute(NotifyChange, AfStorageEntry(), QPixmap());

   185 }

   186 

   187 // -----------------------------------------------------------------------------

   188 /**

   189  * Function implementation

   190  * @see AfStorageClient::launchActivity(const AfStorageEntry &)

   191  */

   192 int AfStorageClientPrivate::launchActivity(const AfStorageEntry &templateEntry)

   193 {

   194     return execute(LaunchActivity, templateEntry, QPixmap());

   195 }

   196 

   197 // -----------------------------------------------------------------------------

   198 /**

   199  * Function implementation

   200  * @see AfStorageClient::cancelWaitActivity()

   201  */

   202 int AfStorageClientPrivate::cancelWaitActivity()

   203 {

   204     return execute(CancelWait, AfStorageEntry(), QPixmap());

   205 }

   206 

   207 // -----------------------------------------------------------------------------

   208 /**

   209  * Function implementation

   210  * @see AfStorageClient::cancelNotifyDataChange()

   211  */

   212 int AfStorageClientPrivate::cancelNotifyDataChange()

   213 {

   214     return execute(CancelNotify, AfStorageEntry(), QPixmap());

   215 }

   216 

   217 // -----------------------------------------------------------------------------

   218 /**

   219  * Function execute activity framework functinality and return results 

   220  */

   221 int AfStorageClientPrivate::execute(int function, const AfStorageEntry &sourceEntry, const QPixmap& sourceImage)

   222 {

   223     TRAPD(errNo,

   224     const CAfEntry *entry(sourceEntry.data());

   225     int userData(-1);

   226     CFbsBitmap* bitmap(sourceImage.toSymbianCFbsBitmap());

   227     if(0 != bitmap) {

   228         CleanupStack::PushL(bitmap);

   229         userData = bitmap->Handle();

   230     }

   231     switch (function) {

   232     case AddActivity:

   233     case UpdateActivity:

   234     case RemoveActivity:

   235     case RemoveApplicationActivities:

   236     case LaunchActivity:

   237         User::LeaveIfNull(entry);

   238         mImplementation.executeL(function, *entry, userData);

   239         break;

   240     

   241     case CancelNotify:

   242     case CancelWait:

   243     case WaitActivity:

   244     case NotifyChange:

   245         mImplementation.executeL(function);

   246         break;

   247     }

   248     if(0 != bitmap) {

   249         CleanupStack::PopAndDestroy(bitmap);

   250     }

   251     )

   252     return errNo;

   253 }

   254 

   255 // -----------------------------------------------------------------------------

   256 /**

   257  * Function execute activity framework functinality and return results 

   258  */

   259 int AfStorageClientPrivate::execute(int function, QList<AfStorageEntry>& resultsList,const AfStorageEntry& templateEntry)

   260 {

   261     TRAPD(errNo,

   262     RPointerArray<CAfEntry> results;

   263     CleanupResetAndDestroyPushL<CAfEntry>(results);

   264     

   265     CAfEntry *entry(const_cast<CAfEntry *>(templateEntry.data()));

   266     if(0 == entry) {

   267         entry = CAfEntry::NewLC();

   268     }

   269     mImplementation.executeL(function, results, *entry);

   270     if(templateEntry.data() != entry) {

   271         CleanupStack::PopAndDestroy(entry);

   272     }

   273     

   274     //copy data

   275     while (results.Count()) {

   276         resultsList.append(AfStorageEntry(QSharedPointer<CAfEntry>(results[0])));

   277         results.Remove(0);

   278     }

   279     CleanupStack::PopAndDestroy(&results);

   280     )

   281     return errNo;

   282 }