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 "afstorageproxy_p.h"

    19 

    20 #include <fbs.h>

    21 

    22 #include <QSize>

    23 #include <QPixmap>

    24 

    25 #include <XQConversions>

    26 

    27 #include <afstorageglobals.h>

    28 #include <afstorageclient.h>

    29 #include <afentry.h>

    30 

    31 #include "afstorageproxy.h"

    32 #include "afserializer.h"

    33 

    34 AfStorageProxyPrivate::AfStorageProxyPrivate(AfStorageProxy *q) : mClient(0), q_ptr(q)

    35 {    

    36     QT_TRAP_THROWING(mClient = CAfStorageClient::NewL(*this));

    37 }

    38 

    39 AfStorageProxyPrivate::~AfStorageProxyPrivate()

    40 {

    41     delete mClient;

    42 }

    43 

    44 bool AfStorageProxyPrivate::addActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)

    45 {    

    46     int screenshotHandle(-1);

    47     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());

    48     if (bitmap) {

    49         screenshotHandle = bitmap->Handle();

    50     }

    51     

    52     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);

    53     int result = mClient->addActivity(*entry, screenshotHandle);    

    54     delete entry;

    55     delete bitmap;

    56     

    57     return KErrNone == result;

    58 }

    59 

    60 bool AfStorageProxyPrivate::updateActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)

    61 {

    62     int screenshotHandle(-1);

    63     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());

    64     if (bitmap) {

    65         screenshotHandle = bitmap->Handle();

    66     }

    67     

    68     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);

    69     int result = mClient->updateActivity(*entry, screenshotHandle);    

    70     delete entry;

    71     delete bitmap;

    72     

    73     return KErrNone == result;

    74 }

    75 

    76 bool AfStorageProxyPrivate::saveActivity(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata, const QPixmap &screenshot)

    77 {

    78     int screenshotHandle(-1);

    79     CFbsBitmap* bitmap(screenshot.toSymbianCFbsBitmap());

    80     if (bitmap) {

    81         screenshotHandle = bitmap->Handle();

    82     }

    83     

    84     CAfEntry *entry = createSaveEntry(applicationId, activityId, activityData, metadata);

    85     int result = mClient->saveActivity(*entry, screenshotHandle);    

    86     delete entry;

    87     delete bitmap;

    88     

    89     return KErrNone == result;

    90 }

    91 

    92 bool AfStorageProxyPrivate::removeActivity(int applicationId, const QString &activityId)

    93 {

    94     CAfEntry *entry = createFilterEntry(applicationId, activityId);

    95     int result = mClient->removeActivity(*entry);

    96     delete entry;

    97     return KErrNone == result;

    98 }

    99    

   100 bool AfStorageProxyPrivate::removeApplicationActivities(int applicationId)

   101 {

   102     CAfEntry *entry = createFilterEntry(applicationId);

   103     int result = mClient->removeApplicationActivities(*entry);

   104     delete entry;

   105     return KErrNone == result;

   106 }

   107 

   108 bool AfStorageProxyPrivate::activities(QList<QVariantHash> &list)

   109 {

   110     RPointerArray<CAfEntry> results;

   111     

   112     int result = mClient->activities(results);

   113     list.clear();

   114     for (int i=0; i < results.Count(); ++i) {

   115         list.append(extractMetadata(results[i]));

   116     }

   117    

   118     results.ResetAndDestroy();

   119     return KErrNone == result;

   120 }

   121 

   122 bool AfStorageProxyPrivate::applicationActivities(QStringList &list, int applicationId)

   123 {

   124     RPointerArray<CAfEntry> results;

   125     

   126     CAfEntry *entry = createFilterEntry(applicationId);

   127     int result = mClient->applicationActivities(results, *entry);

   128     delete entry;

   129     

   130     list.clear();

   131     for (int i=0; i < results.Count(); ++i) {

   132         list.append(XQConversions::s60DescToQString(results[i]->ActivityId()));

   133     }

   134    

   135     results.ResetAndDestroy();

   136     return KErrNone == result;

   137 }

   138 

   139 bool AfStorageProxyPrivate::activityData(QVariant &data, int applicationId, const QString &activityId)

   140 {

   141     CAfEntry *entry = getEntry(applicationId, activityId);

   142     

   143     if (!entry) {

   144         return false;

   145     }

   146     

   147     QVariantHash deserializedData;

   148     deserializedData << entry->Data(CAfEntry::Private);

   149     data = deserializedData[ActivityDataKeyword];

   150     delete entry;

   151     return true;

   152 }

   153 

   154 bool AfStorageProxyPrivate::activityMetaData(QVariantHash &metadata, int applicationId, const QString &activityId)

   155 {

   156     CAfEntry *entry = getEntry(applicationId, activityId);

   157     

   158     if (entry) {

   159         metadata = extractMetadata(entry);

   160         delete entry;

   161         return true;

   162     }    

   163     

   164     return false;

   165 }

   166 

   167 bool AfStorageProxyPrivate::waitActivity()

   168 {

   169     return KErrNone == mClient->waitActivity();

   170 }

   171     

   172 bool AfStorageProxyPrivate::launchActivity(int applicationId, const QString &activityUri)

   173 {

   174     CAfEntry *entry = createFilterEntry(applicationId, activityUri);

   175     int result = mClient->launchActivity(*entry);

   176     delete entry;

   177     return KErrNone == result;

   178 }

   179 

   180 bool AfStorageProxyPrivate::getThumbnail(const QSize &size, const QString &imagePath, void *userData)

   181 {

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

   183     int result = mClient->getThumbnail(TSize(size.width(), size.height()), *source, userData);

   184     delete source;

   185     return KErrNone == result;

   186 }

   187 

   188 bool AfStorageProxyPrivate::notifyDataChange()

   189 {

   190     return KErrNone == mClient->notifyDataChange();

   191 }

   192 

   193 

   194 void AfStorageProxyPrivate::waitActivityRequestCompleted(int result, const TDesC8 &data)

   195 {

   196     if (KErrCancel != result) {

   197         waitActivity();

   198     }

   199     if (KErrNone == result) {

   200         emit q_ptr->activityRequested(XQConversions::s60Desc8ToQString(data));

   201     }

   202 }

   203 

   204 void AfStorageProxyPrivate::getThumbnailRequestCompleted(int result, int bitmapHandle, void *userData)

   205 {

   206     if (KErrNone == result) {

   207         CFbsBitmap* bitmap = new CFbsBitmap();

   208         if (KErrNone == bitmap->Duplicate(bitmapHandle)) {

   209             emit q_ptr->thumbnailRequested(QPixmap::fromSymbianCFbsBitmap(bitmap), userData);

   210         }

   211         delete bitmap;

   212     }

   213 }

   214 

   215 void AfStorageProxyPrivate::dataChangeNotificationCompleted(int result)

   216 {

   217     if (KErrCancel != result) {

   218         notifyDataChange();

   219     }

   220     if (KErrNone == result) {

   221         emit q_ptr->dataChanged();

   222     }

   223 }

   224  

   225 CAfEntry *AfStorageProxyPrivate::createFilterEntry(int applicationId, const QString &activityId)

   226 {   

   227     CAfEntry *entry(0); 

   228     QT_TRAP_THROWING(entry = CAfEntry::NewL(0, applicationId, TPtrC(static_cast<const TUint16*>(activityId.utf16())), KNullDesC(), KNullDesC8(), KNullDesC8()));

   229     return entry;

   230 }

   231 

   232 CAfEntry *AfStorageProxyPrivate::createSaveEntry(int applicationId, const QString &activityId, const QVariant &activityData, const QVariantHash &metadata)

   233 {   

   234     CAfEntry *entry(0); 

   235     

   236     QT_TRAP_THROWING(

   237         int flags(0);

   238         QVariantHash privData;

   239         privData.insert(ActivityDataKeyword, activityData);

   240         RBuf8 privateBuff;

   241         RBuf8 publicBuff;

   242         CleanupClosePushL(privateBuff);

   243         CleanupClosePushL(publicBuff);

   244         privateBuff << privData;

   245         publicBuff << metadata;

   246         

   247         if (metadata.contains(ActivityPersistence) && metadata[ActivityPersistence].toBool()) {

   248             flags |= CAfEntry::Persistent;

   249         }

   250         

   251         if (metadata.contains(ActivityVisibility) && !metadata[ActivityVisibility].toBool()) {

   252             flags |= CAfEntry::Invisible;

   253         }

   254         

   255         HBufC *actBuff = XQConversions::qStringToS60Desc(activityId);

   256         CleanupStack::PushL(actBuff);

   257         entry = CAfEntry::NewL(flags, 

   258                                applicationId, 

   259                                *actBuff, 

   260                                KNullDesC, 

   261                                privateBuff, 

   262                                publicBuff);

   263         CleanupStack::PopAndDestroy(actBuff);

   264         CleanupStack::PopAndDestroy(&publicBuff);

   265         CleanupStack::PopAndDestroy(&privateBuff);

   266     );

   267     return entry;

   268 }

   269 

   270 CAfEntry *AfStorageProxyPrivate::getEntry(int applicationId, const QString &activityId)

   271 {

   272     CAfEntry *entry = createFilterEntry(applicationId, activityId);

   273     CAfEntry *resultEntry(0);

   274     int result = mClient->activityData(resultEntry, *entry);

   275     delete entry;

   276     

   277     if (KErrNone != result) {

   278         delete resultEntry;

   279         resultEntry = 0;

   280     }

   281     

   282     return resultEntry;

   283 }

   284 

   285 QVariantHash AfStorageProxyPrivate::extractMetadata(CAfEntry *entry)

   286 {

   287     QVariantHash metadata;

   288     metadata << entry->Data(CAfEntry::Public);

   289     metadata.insert(ActivityApplicationKeyword, entry->ApplicationId());

   290     metadata.insert(ActivityActivityKeyword, XQConversions::s60DescToQString(entry->ActivityId()));

   291     metadata.insert(ActivityScreenshotKeyword, XQConversions::s60DescToQString(entry->ImageSrc()));

   292     metadata.insert(ActivityPersistence, (entry->Flags() & CAfEntry::Persistent) ? true : false);

   293     metadata.insert(ActivityVisibility, (entry->Flags() & CAfEntry::Invisible) ? false : true); 

   294     return metadata;

   295 }

   296