22 #include <qvariant.h>

    27 #include "afentry.h"

    23 #include <XQConversions>

    28 

    24 

    29 

    25 

    30 

    26 // -----------------------------------------------------------------------------

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

    27 //

    32 /**

    28 // -----------------------------------------------------------------------------

    33  * Constructor

    29 //

    34  */

    33     

    38 

    34 }

    39 }

    35 

    40 

    36 // -----------------------------------------------------------------------------

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

    37 //

    42 /**

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

    43  * Destructor

    39 //

    44  */

    47 //

    52 /**

    48 // -----------------------------------------------------------------------------

    53  * Function establish connection to activity server

    49 //

    54  * @return 0 on succees, error code otherwise

    55  */

    57 //

    63 /**

    58 // -----------------------------------------------------------------------------

    64  * Interface implementation.

    59 //

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

    60 int HsActivityDbClientPrivate::addActivity(const QVariantHash &activity)

    66  */

    61 {

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

    62     int errNo(KErrCorrupt);

    68                                            const QVariantHash &publicData)

    63     if (activity.end() != activity.find(ActivityApplicationKeyword) &&

    69 {

    64         activity.end() != activity.find(ActivityActivityKeyword)) {

    70     return execute(AddActivity, privateData, publicData);

    65         TRAP(errNo, execSimpleRequestL(AddActivity, activity);)

    71     

    66     }

    72 }

    67     return errNo;

    73 

    68 }

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

    69 

    75 /**

    70 // -----------------------------------------------------------------------------

    76  * Interface implementation.

    71 //

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

    72 // -----------------------------------------------------------------------------

    78  */

    73 //

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

    74 int HsActivityDbClientPrivate::updateActivity(const QVariantHash &activity)

    80                                               const QVariantHash &publicData)

    75 {

    81 {

    76     int errNo(KErrCorrupt);

    82     return execute(UpdateActivity, privateData, publicData);

    77     if (activity.end() != activity.find(ActivityApplicationKeyword) &&

    83 }

    78         activity.end() != activity.find(ActivityActivityKeyword)) {

    84 

    79         TRAP(errNo, execSimpleRequestL(UpdateActivity, activity);)

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

    80     }

    86 /**

    81     return errNo;

    87  * Interface implementation.

    82 }

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

    83 

    89  */

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

    85 //

    86 // -----------------------------------------------------------------------------

    87 //

    90     int errNo(KErrCorrupt);

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

    91     if (activity.end() != activity.find(ActivityApplicationKeyword) &&

    93 }

    92         activity.end() != activity.find(ActivityActivityKeyword)) {

    94 

    93         TRAP(errNo, execSimpleRequestL(RemoveActivity, activity);)

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

    94     }

    96 /**

    95     return errNo;

    97  * Interface implementation.

    96 }

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

    97 

    99 */

    98 // -----------------------------------------------------------------------------

   100 

    99 //

   100 // -----------------------------------------------------------------------------

   101 //

   104     int errNo(KErrCorrupt);

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

   105     if (activity.end() != activity.find(ActivityApplicationKeyword)) {

   104 }

   106         TRAP(errNo, execSimpleRequestL(RemoveApplicationActivities, activity);)

   105 

   107     }

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

   108     return errNo;

   107 /**

   109 }

   108  * Interface implementation.

   110 

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

   111 // -----------------------------------------------------------------------------

   110  */

   112 //

   113 // -----------------------------------------------------------------------------

   114 //

   117     TRAPD(errNo, activitiesL(result));

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

   118     return errNo;

   114 }

   119 }

   115 

   120 

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

   121 // -----------------------------------------------------------------------------

   117 /**

   122 //

   118  * Interface implementation.

   123 // -----------------------------------------------------------------------------

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

   124 //

   120  */

   128     TRAPD(errNo, applicationActivitiesL(result, condition));

   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);)

   132 

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

   133 // -----------------------------------------------------------------------------

   141 /**

   134 //

   142  * Interface implementation.

   135 // -----------------------------------------------------------------------------

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

   136 //

   144  */

   139     TRAPD(errNo, waitActivityL(activity);)

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

   140     return errNo;

   159     TRAPD(errNo,HsActivityDbAsyncRequestPrivate::notifyDataChangeLD(mObserver, *this);)

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

   160     return errNo;

   167 }

   161 }

   168 

   162 

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

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

   170 /**

   164 //

   171  * Interface implementation.

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

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

   166 //

   173  */

   169     TRAPD(errNo, execSimpleRequestL(LaunchActivity, activity);)

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

   170     return errNo;

   177 }

   171 }

   178 

   172 

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

   173 // -----------------------------------------------------------------------------

   180 /**

   174 //

   181  * Interface implementation.

   175 // -----------------------------------------------------------------------------

   182  * @see int HsActivityDbClientInterface::cancelWaitActivity()

   176 //

   183  */

   192 //

   199 /**

   193 // -----------------------------------------------------------------------------

   200  * Function start activity server process.

   194 //

   201  * Function can leave on failure.

   202  */

   218 //

   226 /**

   219 // -----------------------------------------------------------------------------

   227  * Function establish connection to activity server.

   220 //

   228  * Function can leave on failure

   229  */

   244 //

   253 /**

   245 // -----------------------------------------------------------------------------

   254  * Function execute remote call request.

   246 //

   255  * @param function - remote function identyfier

   247 void HsActivityDbClientPrivate::execSimpleRequestL(int function, const QVariantHash &activity)

   256  * @param activity - remote function parameters

   248 {

   257  */

   249     TPckgBuf<TInt> appId( activity.find(ActivityApplicationKeyword).value().toInt() );

   258 void HsActivityDbClientPrivate::execSimpleRequestL(int function,

   250     HBufC8 *actId = XQConversions::qStringToS60Desc8(activity.find(ActivityActivityKeyword).value().toString());

   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());

   252     TPckgBuf<TInt> taskId(0);

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

   253     RBuf8 data;

   301                                      publicData[ActivityApplicationKeyword].toInt(),

   254     CleanupClosePushL(data);

   302                                      *actId,

   255     data.CreateL(256);

   303                                      KNullDesC,

   256     data << activity;

   304                                      prvBuffer,

   257     User::LeaveIfError(SendReceive(function, TIpcArgs(&appId, actId, &data, &taskId)));

   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     

   259     CleanupStack::PopAndDestroy(actId);

   320     if (0 != bitmap) {

   260 }

   321         CleanupStack::PopAndDestroy(bitmap);

   261 

   322     }

   262 // -----------------------------------------------------------------------------

   323 

   263 //

   324 }

   264 // -----------------------------------------------------------------------------

   325 

   265 //

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

   327 /**

   328  * Function retrieve all stored activity

   329  * Function can leave on failure

   330  * @param result - list of activity

   331  */

   268     TPckgBuf<TInt> appId(0);

   334     result.clear();

   269     TPtrC8 actId(KNullDesC8);

   335 

   270     TPtrC8 desc(KNullDesC8);

   336     RBuf8 buffer;

   271     TPckgBuf<TInt> taskId(0);

   337     CleanupClosePushL(buffer);

   272     User::LeaveIfError(SendReceive(Activities, 

   338 

   273                        TIpcArgs(&appId, &actId, &desc, &taskId)));

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

   274 

   340     User::LeaveIfError(SendReceive(Activities,

   275     int sizeBuf(appId());

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

   276     RBuf8 data;

   342 

   277     CleanupClosePushL(data);

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

   278     data.Create(sizeBuf);

   344 

   279     User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &data)));

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

   280     

   346 

   281     result << data;

   347     RPointerArray<CAfEntry> entries;

   282     CleanupStack::PopAndDestroy(&data);

   348     CleanupClosePushL(entries);

   283 }

   349 

   284 

   350     entries << buffer;

   285 // -----------------------------------------------------------------------------

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

   286 //

   352 

   287 // -----------------------------------------------------------------------------

   353 

   288 //

   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  */

   292     TPckgBuf<TInt> appId = condition.find(ActivityApplicationKeyword).value().toInt();

   377     result.clear();

   293     TPtrC8 actId(KNullDesC8);

   378 

   294     TPtrC8 desc(KNullDesC8);

   379     RBuf8 buffer;

   295     TPckgBuf<TInt> taskId(0);

   380     CleanupClosePushL(buffer);

   296     User::LeaveIfError(SendReceive(ApplicationActivities, 

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

   297                        TIpcArgs(&appId, &actId, &desc, &taskId)));

   382                                       condition[ActivityApplicationKeyword].toInt(),

   298 

   383                                       KNullDesC,

   299     int sizeBuf(appId());

   384                                       KNullDesC,

   300     RBuf8 data;

   385                                       KNullDesC8,

   301     CleanupClosePushL(data);

   386                                       KNullDesC8);//filtering using application id only

   302     data.Create(sizeBuf);

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

   303     User::LeaveIfError(SendReceive(GetData, TIpcArgs(&taskId, &data)));

   388     RDesWriteStream writer(buffer);

   304     

   389     CleanupClosePushL(writer);

   305     result << data;

   390     writer << (*entry);

   306     CleanupStack::PopAndDestroy(&data);

   391     CleanupStack::PopAndDestroy(&writer);

   307 }

   392     CleanupStack::PopAndDestroy(entry);

   308 

   393 

   309 // -----------------------------------------------------------------------------

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

   310 //

   395     User::LeaveIfError(SendReceive(ApplicationActivities,

   311 // -----------------------------------------------------------------------------

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

   312 //

   397 

   313 void HsActivityDbClientPrivate::waitActivityL(const QVariantHash &activity)

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

   314 {

   399 

   315     HsActivityDbAsyncRequestPrivate::waitActivityLD(mObserver,*this, activity);

   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 

   329 //

   508 /**

   330 // -----------------------------------------------------------------------------

   509  * Function get cached data from server

   331 //

   510  * @param taskId - request task id

   511  * @param dst - destination, preallocated buffer

   512  */

   339 //

   520 /**

   340 // -----------------------------------------------------------------------------

   521  * Function initialize aync request

   341 //

   522  * @param func - requested function

   523  * @param data - request data

   524  * @param status - request status

   525  */

   343                                               const TIpcArgs &data, 

   527                                               const TIpcArgs &data,