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

    24 #include "hsactivitydbasyncrequest_p.h"

    25 #include "hsactivityglobals.h"

    26 #include "hsserializer.h"

    27 #include "afentry.h"

    28 

    29 

    30 

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

    32 /**

    33  * Constructor

    34  */

    35 HsActivityDbClientPrivate::HsActivityDbClientPrivate(HsActivityDbAsyncRequestObserver &observer):

    36     mObserver(observer)

    37 {

    38 

    39 }

    40 

    41 // -----------------------------------------------------------------------------

    42 /**

    43  * Destructor

    44  */

    45 HsActivityDbClientPrivate::~HsActivityDbClientPrivate()

    46 {

    47     mAsyncTasks.ResetAndDestroy();

    48     Close();

    49 }

    50 

    51 // -----------------------------------------------------------------------------

    52 /**

    53  * Function establish connection to activity server

    54  * @return 0 on succees, error code otherwise

    55  */

    56 int HsActivityDbClientPrivate::connect()

    57 {

    58     TRAPD(errNo, connectL());

    59     return errNo;

    60 }

    61 

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

    63 /**

    64  * Interface implementation.

    65  * @see int HsActivityDbClientInterface::addActivity(const QVariantHash &)

    66  */

    67 int HsActivityDbClientPrivate::addActivity(const QVariantHash &privateData,

    68                                            const QVariantHash &publicData)

    69 {

    70     return execute(AddActivity, privateData, publicData);

    71     

    72 }

    73 

    74 // -----------------------------------------------------------------------------

    75 /**

    76  * Interface implementation.

    77  * @see int HsActivityDbClientInterface::updateActivity(const QVariantHash &)

    78  */

    79 int HsActivityDbClientPrivate::updateActivity(const QVariantHash &privateData,

    80                                               const QVariantHash &publicData)

    81 {

    82     return execute(UpdateActivity, privateData, publicData);

    83 }

    84 

    85 // -----------------------------------------------------------------------------

    86 /**

    87  * Interface implementation.

    88  * @see int HsActivityDbClientInterface::removeActivity(const QVariantHash &)

    89  */

    90 int HsActivityDbClientPrivate::removeActivity(const QVariantHash &activity)

    91 {

    92     return execute(RemoveActivity, QVariantHash(), activity);

    93 }

    94 

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

    96 /**

    97  * Interface implementation.

    98  * @see int HsActivityDbClientInterface::removeApplicationActivities(const QVariantHash &)

    99 */

   100 

   101 int HsActivityDbClientPrivate::removeApplicationActivities(const QVariantHash &activity)

   102 {

   103     return execute(RemoveApplicationActivities, QVariantHash(), activity);

   104 }

   105 

   106 // -----------------------------------------------------------------------------

   107 /**

   108  * Interface implementation.

   109  * @see int HsActivityDbClientInterface::activities(QList<QVariantHash> &);

   110  */

   111 int HsActivityDbClientPrivate::activities(QList<QVariantHash>& result)

   112 {

   113     return execute(Activities, result, QVariantHash());

   114 }

   115 

   116 // -----------------------------------------------------------------------------

   117 /**

   118  * Interface implementation.

   119  * @see int HsActivityDbClientInterface::applicationActivities(QList<QVariantHash> &, const QVariantHash &)

   120  */

   121 int HsActivityDbClientPrivate::applicationActivities(QList<QVariantHash>& result,

   122         const QVariantHash &condition)

   123 {

   124     return execute(ApplicationActivities, result, condition);

   125 }

   126 

   127 // -----------------------------------------------------------------------------

   128 /**

   129  * Interface implementation.

   130  * @see int HsActivityDbClientInterface::activityData(QVariant &, const QVariantHash &)

   131  */

   132 int HsActivityDbClientPrivate::activityData(QVariant &result, const QVariantHash &activity)

   133 {

   134     TRAPD(errNo,

   135     User::LeaveIfError(checkDataConstraint(ApplicationActivity, activity));

   136     activityDataL(result, activity);)

   137     return errNo;

   138 }

   139 

   140 // -----------------------------------------------------------------------------

   141 /**

   142  * Interface implementation.

   143  * @see int HsActivityDbClientInterface::waitActivity(const QVariantHash &)

   144  */

   145 int HsActivityDbClientPrivate::waitActivity(const QVariantHash &activity)

   146 {

   147     return execute(WaitActivity, QVariantHash(), activity);

   148 }

   149 

   150 // -----------------------------------------------------------------------------

   151 //

   152 // -----------------------------------------------------------------------------

   153 //

   154 int HsActivityDbClientPrivate::getThumbnail(QSize size, QString imagePath, QString  mimeType, void *userDdata)

   155 {

   156     TRAPD(errNo, getThumbnailL(size, imagePath, mimeType, userDdata);)

   157     return errNo;

   158 }

   159 

   160 // -----------------------------------------------------------------------------

   161 //

   162 // -----------------------------------------------------------------------------

   163 //

   164 int HsActivityDbClientPrivate::notifyDataChange()

   165 {

   166     return execute(NotifyChange, QVariantHash(), QVariantHash());

   167 }

   168 

   169 // -----------------------------------------------------------------------------

   170 /**

   171  * Interface implementation.

   172  * @see int HsActivityDbClientInterface::launchActivity(const QVariantHash &)

   173  */

   174 int HsActivityDbClientPrivate::launchActivity(const QVariantHash &activity)

   175 {

   176     return execute(LaunchActivity, QVariantHash(), activity);

   177 }

   178 

   179 // -----------------------------------------------------------------------------

   180 /**

   181  * Interface implementation.

   182  * @see int HsActivityDbClientInterface::cancelWaitActivity()

   183  */

   184 int HsActivityDbClientPrivate::cancelWaitActivity()

   185 {

   186     return SendReceive(CancelWait, TIpcArgs());

   187 }

   188 

   189 // -----------------------------------------------------------------------------

   190 //

   191 // -----------------------------------------------------------------------------

   192 //

   193 int HsActivityDbClientPrivate::cancelNotifyDataChange()

   194 {

   195     return SendReceive(CancelNotify, TIpcArgs());

   196 }

   197 

   198 // -----------------------------------------------------------------------------

   199 /**

   200  * Function start activity server process.

   201  * Function can leave on failure.

   202  */

   203 void HsActivityDbClientPrivate::startServerL()

   204 {

   205     RProcess server;

   206     const TUidType uid(KNullUid, KNullUid, KActivityServerUid);

   207     User::LeaveIfError(server.Create(KActivityServerName, KNullDesC, uid));

   208     TRequestStatus stat;

   209     server.Rendezvous(stat);

   210     if (stat != KRequestPending) {

   211         server.Kill(0);

   212     } else {

   213         server.Resume();

   214     }

   215     User::WaitForRequest(stat);

   216     int errNo = (EExitPanic == server.ExitType()) ?

   217                 KErrGeneral : stat.Int();

   218     if (KErrCancel == errNo) {

   219         errNo = KErrNone;

   220     }

   221     server.Close();

   222     User::LeaveIfError(errNo);

   223 }

   224 

   225 // -----------------------------------------------------------------------------

   226 /**

   227  * Function establish connection to activity server.

   228  * Function can leave on failure

   229  */

   230 void HsActivityDbClientPrivate::connectL()

   231 {

   232     const int asyncMessageSlots(12);

   233     const int maxRetry(4);

   234 

   235     TInt retry = maxRetry;

   236     TInt errNo(KErrNone);

   237     do {

   238         errNo = CreateSession(KActivityServerName, TVersion(0, 0, 0), asyncMessageSlots);

   239         if (KErrNotFound != errNo && KErrServerTerminated != errNo) {

   240             retry =0;

   241         } else {

   242             TRAP(errNo, startServerL());

   243             if (KErrNone != errNo && KErrAlreadyExists != errNo) {

   244                 retry =0;

   245                 errNo = CreateSession(KActivityServerName, TVersion(0, 0, 0), asyncMessageSlots);

   246             }

   247         }

   248     } while (--retry > 0);

   249     User::LeaveIfError(errNo);

   250 }

   251 

   252 // -----------------------------------------------------------------------------

   253 /**

   254  * Function execute remote call request.

   255  * @param function - remote function identyfier

   256  * @param activity - remote function parameters

   257  */

   258 void HsActivityDbClientPrivate::execSimpleRequestL(int function,

   259                                                    const QVariantHash &privateData,

   260                                                    const QVariantHash &publicData)

   261 {

   262 

   263     TPckgBuf<TInt> bitmapHdl(0);

   264     int flags(0);

   265     if(publicData.end() != publicData.find(ActivityPersistence) &&

   266        publicData[ActivityPersistence].toBool()) {

   267         flags |= CAfEntry::Persistent;

   268     }

   269     if(publicData.end() != publicData.find(ActivityVisibility) &&

   270        !publicData[ActivityVisibility].toBool()) {

   271         flags |= CAfEntry::Invisible;

   272     }

   273     CFbsBitmap* bitmap(0);

   274     if (publicData.end() != publicData.find(ActivityScreenshotKeyword)) {

   275         bitmap = publicData[ActivityScreenshotKeyword].value<QPixmap>().toSymbianCFbsBitmap();

   276         if (bitmap) {

   277             CleanupStack::PushL(bitmap);

   278             bitmapHdl = bitmap->Handle();

   279         }

   280         

   281         

   282     }

   283 

   284     RBuf8 prvBuffer, pubBuffer, data;

   285     CleanupClosePushL(data);

   286     CleanupClosePushL(prvBuffer);

   287     CleanupClosePushL(pubBuffer);

   288 

   289     prvBuffer << privateData;

   290     if (publicData.end() != publicData.find(ActivityScreenshotKeyword)) {

   291         QVariantHash localData(publicData);

   292         localData.remove(ActivityScreenshotKeyword);

   293         pubBuffer << localData;

   294     } else {

   295         pubBuffer << publicData;

   296     }

   297     

   298     HBufC *actId = XQConversions::qStringToS60Desc(publicData[ActivityActivityKeyword].toString());

   299     CleanupStack::PushL(actId);

   300     CAfEntry *entry = CAfEntry::NewL(flags,

   301                                      publicData[ActivityApplicationKeyword].toInt(),

   302                                      *actId,

   303                                      KNullDesC,

   304                                      prvBuffer,

   305                                      pubBuffer);

   306     CleanupStack::PopAndDestroy(actId);

   307     CleanupStack::PopAndDestroy(&pubBuffer);

   308     CleanupStack::PopAndDestroy(&prvBuffer);

   309 

   310     CleanupStack::PushL(entry);

   311     data.CreateL(entry->Size());

   312     RDesWriteStream stream(data);

   313     CleanupClosePushL(stream);

   314     stream << (*entry);

   315     CleanupStack::PopAndDestroy(&stream);

   316     CleanupStack::PopAndDestroy(entry);

   317     User::LeaveIfError(SendReceive(function, TIpcArgs(&data, &bitmapHdl)));

   318     

   319     CleanupStack::PopAndDestroy(&data);

   320     if (0 != bitmap) {

   321         CleanupStack::PopAndDestroy(bitmap);

   322     }

   323 

   324 }

   325 

   326 // -----------------------------------------------------------------------------

   327 /**

   328  * Function retrieve all stored activity

   329  * Function can leave on failure

   330  * @param result - list of activity

   331  */

   332 void HsActivityDbClientPrivate::activitiesL(QList<QVariantHash>& result)

   333 {

   334     result.clear();

   335 

   336     RBuf8 buffer;

   337     CleanupClosePushL(buffer);

   338 

   339     TPckgBuf<int> emptyFilter(0), length(0), taskId(0);

   340     User::LeaveIfError(SendReceive(Activities,

   341                                    TIpcArgs(&emptyFilter, &length, &taskId)));

   342 

   343     CAfEntry::ReallocL(buffer, length());

   344 

   345     User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

   346 

   347     RPointerArray<CAfEntry> entries;

   348     CleanupClosePushL(entries);

   349 

   350     entries << buffer;

   351     buffer.Close();//release unneeded resources

   352 

   353 

   354     while(entries.Count()) {

   355         QVariantHash publicData;

   356         publicData << entries[0]->Data(CAfEntry::Public);

   357         publicData.insert(ActivityScreenshotKeyword,

   358                           QString::fromUtf16(entries[0]->ImageSrc().Ptr(),

   359                                              entries[0]->ImageSrc().Length()));

   360         result.append(publicData);

   361         entries.Remove(0);

   362     }

   363     CleanupStack::PopAndDestroy(&entries);

   364     CleanupStack::PopAndDestroy(&buffer);

   365 }

   366 

   367 // -----------------------------------------------------------------------------

   368 /**

   369  * Function retrieve all stored activity

   370  * Function can leave on failure

   371  * @param result - list of activity

   372  * @param cond - request conditions

   373  */

   374 void HsActivityDbClientPrivate::applicationActivitiesL(QList<QVariantHash>& result,

   375                                                      const QVariantHash & condition)

   376 {

   377     result.clear();

   378 

   379     RBuf8 buffer;

   380     CleanupClosePushL(buffer);

   381     CAfEntry *entry = CAfEntry::NewLC(0,

   382                                       condition[ActivityApplicationKeyword].toInt(),

   383                                       KNullDesC,

   384                                       KNullDesC,

   385                                       KNullDesC8,

   386                                       KNullDesC8);//filtering using application id only

   387     CAfEntry::ReallocL(buffer, entry->Size());

   388     RDesWriteStream writer(buffer);

   389     CleanupClosePushL(writer);

   390     writer << (*entry);

   391     CleanupStack::PopAndDestroy(&writer);

   392     CleanupStack::PopAndDestroy(entry);

   393 

   394     TPckgBuf<int> length(0), taskId(0);

   395     User::LeaveIfError(SendReceive(ApplicationActivities,

   396                                    TIpcArgs(&buffer, &length, &taskId)));

   397 

   398     CAfEntry::ReallocL(buffer, length());

   399 

   400     User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

   401 

   402     RPointerArray<CAfEntry> entries;

   403     CleanupClosePushL(entries);

   404 

   405     entries << buffer;

   406     buffer.Close();//release unneeded resources

   407 

   408 

   409     while(entries.Count()) {

   410         QVariantHash publicData;

   411         publicData << entries[0]->Data(CAfEntry::Public);

   412         publicData.insert(ActivityScreenshotKeyword,

   413                           QString::fromUtf16(entries[0]->ImageSrc().Ptr(),

   414                                              entries[0]->ImageSrc().Length()));

   415         result.append(publicData);

   416         entries.Remove(0);

   417     }

   418     CleanupStack::PopAndDestroy(&entries);

   419     CleanupStack::PopAndDestroy(&buffer);

   420 }

   421 

   422 // -----------------------------------------------------------------------------

   423 /**

   424  * Function retrieve private data of stored activity

   425  * Function can leave on failure

   426  * @param result - list of activity

   427  * @param activity - request conditions

   428  */

   429 void HsActivityDbClientPrivate::activityDataL(QVariant &result, const QVariantHash &activity)

   430 {

   431     result.clear();

   432 

   433     RBuf8 buffer;

   434     CleanupClosePushL(buffer);

   435 

   436     {   // prepare entry to send

   437         HBufC *activityId = XQConversions::qStringToS60Desc(activity[ActivityActivityKeyword].toString());

   438         CleanupStack::PushL(activityId);

   439 

   440         CAfEntry *entry = CAfEntry::NewLC(0,

   441                                           activity[ActivityApplicationKeyword].toInt(),

   442                                           *activityId,

   443                                           KNullDesC,

   444                                           KNullDesC8,

   445                                           KNullDesC8);//filtering using application id only

   446         CAfEntry::ReallocL(buffer, entry->Size());

   447         RDesWriteStream writer(buffer);

   448         CleanupClosePushL(writer);

   449         writer << (*entry);

   450         CleanupStack::PopAndDestroy(&writer);

   451         CleanupStack::PopAndDestroy(entry);

   452         CleanupStack::PopAndDestroy(activityId);

   453     }

   454 

   455     {   // get data

   456         TPckgBuf<int> length(0), taskId(0);

   457         User::LeaveIfError(SendReceive(ApplicationActivity, TIpcArgs(&buffer, &length, &taskId)));

   458 

   459         CAfEntry::ReallocL(buffer, length());

   460         User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &buffer)));

   461     }

   462 

   463     {   // read data to Qt structure

   464         CAfEntry *entry = CAfEntry::NewLC();

   465         RDesReadStream reader(buffer);

   466         CleanupClosePushL(reader);

   467         entry->InternalizeL(reader);

   468         CleanupStack::PopAndDestroy(&reader);

   469 

   470         buffer.Close(); //release unneeded resources

   471 

   472         QVariantHash privateData;

   473         privateData << entry->Data(CAfEntry::Private);

   474         result = privateData.value(ActivityDataKeyword);

   475 

   476         CleanupStack::PopAndDestroy(entry);

   477     }

   478     CleanupStack::PopAndDestroy(&buffer);

   479 }

   480 

   481 // -----------------------------------------------------------------------------

   482 //

   483 // -----------------------------------------------------------------------------

   484 //

   485 void HsActivityDbClientPrivate::launchActivityL(const QVariantHash &activity)

   486 {

   487     TPckgC<TInt> applicationId(activity[ActivityApplicationKeyword].toInt());

   488     HBufC8 *activityId = XQConversions::qStringToS60Desc8(activity[ActivityActivityKeyword].toString());

   489     CleanupStack::PushL(activityId);

   490     TPtrC8 empty(KNullDesC8);

   491     User::LeaveIfError(SendReceive(LaunchActivity,

   492                                    TIpcArgs(&applicationId, activityId, &empty, &empty)));

   493     CleanupStack::PopAndDestroy(activityId);

   494 

   495 }

   496 

   497 // -----------------------------------------------------------------------------

   498 //

   499 // -----------------------------------------------------------------------------

   500 //

   501 void HsActivityDbClientPrivate::getThumbnailL(QSize size, QString imagePath, QString  mimeType, void *userDdata)

   502 {

   503     HsActivityDbAsyncRequestPrivate::getThumbnailLD(mObserver,

   504                               *this, size, imagePath, mimeType, userDdata);

   505 }

   506 

   507 // -----------------------------------------------------------------------------

   508 /**

   509  * Function get cached data from server

   510  * @param taskId - request task id

   511  * @param dst - destination, preallocated buffer

   512  */

   513 void HsActivityDbClientPrivate::getData(int taskId, RBuf8 &data)

   514 {

   515     TPckgBuf<int> requestId(taskId);

   516     SendReceive(GetData, TIpcArgs(&requestId, &data));

   517 }

   518 

   519 // -----------------------------------------------------------------------------

   520 /**

   521  * Function initialize aync request

   522  * @param func - requested function

   523  * @param data - request data

   524  * @param status - request status

   525  */

   526 void HsActivityDbClientPrivate::sendDataAsync(int func,

   527                                               const TIpcArgs &data,

   528                                               TRequestStatus& status)

   529 {

   530     SendReceive(func, data, status);

   531 }

   532 

   533 // -----------------------------------------------------------------------------

   534 //

   535 // -----------------------------------------------------------------------------

   536 //

   537 void HsActivityDbClientPrivate::PushL(HsActivityDbAsyncRequestPrivate * task)

   538 {

   539     (KErrNotFound == mAsyncTasks.Find(task)) ?

   540         mAsyncTasks.AppendL(task):

   541         User::Leave(KErrAlreadyExists);

   542 }

   543 

   544 // -----------------------------------------------------------------------------

   545 //

   546 // -----------------------------------------------------------------------------

   547 //

   548 void HsActivityDbClientPrivate::Pop(HsActivityDbAsyncRequestPrivate *task)

   549 {

   550     const TInt offset(mAsyncTasks.Find(task));

   551     if (KErrNotFound != offset) {

   552         mAsyncTasks.Remove(offset);

   553     }

   554 }

   555 

   556 // -----------------------------------------------------------------------------

   557 //

   558 // -----------------------------------------------------------------------------

   559 //

   560 int HsActivityDbClientPrivate::execute(int func, const QVariantHash &privateData, const QVariantHash &publicData)

   561 {

   562     TRAPD(errNo,

   563     User::LeaveIfError(checkDataConstraint(func, publicData));

   564     switch (func) {

   565     case AddActivity:

   566     case UpdateActivity:

   567     case RemoveActivity:

   568     case RemoveApplicationActivities:

   569         execSimpleRequestL(func, privateData, publicData);

   570         break;

   571     

   572     case LaunchActivity:

   573         launchActivityL(publicData);

   574         break;

   575     

   576     case NotifyChange:

   577         HsActivityDbAsyncRequestPrivate::notifyDataChangeLD(mObserver, *this);

   578         break;

   579     

   580     case WaitActivity:

   581         HsActivityDbAsyncRequestPrivate::waitActivityLD(mObserver,*this, publicData);

   582         break;

   583     

   584     }

   585     

   586     )

   587     return errNo;

   588 }

   589 

   590 // -----------------------------------------------------------------------------

   591 //

   592 // -----------------------------------------------------------------------------

   593 //

   594 int HsActivityDbClientPrivate::execute(int func, 

   595                                        QList<QVariantHash>&dst, 

   596                                        const QVariantHash &src)

   597 {

   598     TRAPD(errNo,

   599     User::LeaveIfError(checkDataConstraint(func, src));

   600     switch (func) {

   601     case Activities: activitiesL(dst);break;

   602     case ApplicationActivities: applicationActivitiesL(dst, src); break;

   603     }

   604     )

   605     return errNo;

   606 }

   607 

   608 // -----------------------------------------------------------------------------

   609 //

   610 // -----------------------------------------------------------------------------

   611 //

   612 int HsActivityDbClientPrivate::checkDataConstraint(int func, const QVariantHash &data)

   613 {

   614     int retVal(KErrNone);

   615     QStringList constraints;

   616     switch(func) {

   617     case AddActivity:

   618     case UpdateActivity:

   619         constraints << ActivityApplicationKeyword 

   620                     << ActivityActivityKeyword 

   621                     << ActivityScreenshotKeyword;

   622         break;

   623     

   624     case ApplicationActivity:

   625     case LaunchActivity:

   626     case RemoveActivity:

   627         constraints << ActivityApplicationKeyword

   628                     << ActivityActivityKeyword;

   629                     break;

   630     

   631     case WaitActivity:

   632     case RemoveApplicationActivities:

   633         constraints << ActivityApplicationKeyword;

   634         break;

   635     }

   636     foreach (QString constraint, constraints) {

   637         if (data.end() == data.find(constraint)) {

   638             retVal = KErrCorrupt;

   639             break;

   640         }

   641     }

   642     return retVal;

   643 }