activityfw/activitydatabase/hsactivitydbclient/s60/src/hsactivitydbasyncrequest_p.cpp
changeset 73 4bc7b118b3df
parent 66 32469d7d46ff
child 80 397d00875918
equal deleted inserted replaced
66:32469d7d46ff 73:4bc7b118b3df
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include "hsactivitydbasyncrequest_p.h"
    18 #include "hsactivitydbasyncrequest_p.h"
    19 #include "hsactivitydbclient_p.h"
    19 #include "hsactivitydbclient_p.h"
    20 #include "hsserializer.h"
    20 #include "hsactivitydbclient.h"
       
    21 #include <fbs.h>
       
    22 #include <xqconversions>
       
    23 
       
    24 
    21 // -----------------------------------------------------------------------------
    25 // -----------------------------------------------------------------------------
    22 //
    26 //
    23 // -----------------------------------------------------------------------------
    27 // -----------------------------------------------------------------------------
    24 //
    28 //
    25 HsActivityDbAsyncRequestPrivate*
    29 HsActivityDbAsyncRequestPrivate*
    26 HsActivityDbAsyncRequestPrivate::NewL(HsActivityDbAsyncRequestObserver &observer,
    30 HsActivityDbAsyncRequestPrivate::NewL(HsActivityDbAsyncRequestObserver &observer,
    27                                       HsActivityDbClientPrivate &session)
    31                                       HsActivityDbClientPrivate &session, 
       
    32                                       TAsyncRequest requestType,
       
    33                                       void* userData)
    28 {
    34 {
    29     HsActivityDbAsyncRequestPrivate *self =
    35     HsActivityDbAsyncRequestPrivate *self = 
    30         HsActivityDbAsyncRequestPrivate::NewLC(observer, session);
    36     new(ELeave)HsActivityDbAsyncRequestPrivate(observer, session, requestType, userData);
       
    37     CleanupStack::PushL(self);
       
    38     self->mDataBuf.CreateL(64);
    31     CleanupStack::Pop(self);
    39     CleanupStack::Pop(self);
    32     return self;
    40     return self;
    33 }
    41 }
       
    42 
    34 // -----------------------------------------------------------------------------
    43 // -----------------------------------------------------------------------------
    35 //
    44 //
    36 // -----------------------------------------------------------------------------
    45 // -----------------------------------------------------------------------------
    37 //
    46 //
    38 HsActivityDbAsyncRequestPrivate*
    47 HsActivityDbAsyncRequestPrivate*
    39 HsActivityDbAsyncRequestPrivate::NewLC(HsActivityDbAsyncRequestObserver &observer,
    48 HsActivityDbAsyncRequestPrivate::newWaitActivityL(HsActivityDbAsyncRequestObserver & observer, 
    40                                        HsActivityDbClientPrivate &session)
    49             HsActivityDbClientPrivate & session)
       
    50     {
       
    51     return HsActivityDbAsyncRequestPrivate::NewL(observer, session, EWaitActivity);
       
    52     }
       
    53 
       
    54 // -----------------------------------------------------------------------------
       
    55 //
       
    56 // -----------------------------------------------------------------------------
       
    57 //
       
    58 void HsActivityDbAsyncRequestPrivate::getThumbnailLD(HsActivityDbAsyncRequestObserver &observer,
       
    59                                       HsActivityDbClientPrivate &session, 
       
    60                                       QSize size, 
       
    61                                       QString imagePath, 
       
    62                                       QString  mimeType, 
       
    63                                       void *userDdata)
    41 {
    64 {
    42     HsActivityDbAsyncRequestPrivate *self =
    65     HsActivityDbAsyncRequestPrivate *instance = 
    43         new(ELeave)HsActivityDbAsyncRequestPrivate(observer, session);
    66         HsActivityDbAsyncRequestPrivate::NewL(observer, session, EWaitGetThumbnail, userDdata);
    44     CleanupStack::PushL(self);
    67     instance->getThumbnail( size, imagePath, mimeType);
    45     self->mDataBuf.CreateL(64);
       
    46     return self;
       
    47 }
    68 }
       
    69 
    48 // -----------------------------------------------------------------------------
    70 // -----------------------------------------------------------------------------
    49 //
    71 //
    50 // -----------------------------------------------------------------------------
    72 // -----------------------------------------------------------------------------
    51 //
    73 //
    52 HsActivityDbAsyncRequestPrivate::HsActivityDbAsyncRequestPrivate(HsActivityDbAsyncRequestObserver &observer,
    74 HsActivityDbAsyncRequestPrivate::HsActivityDbAsyncRequestPrivate(HsActivityDbAsyncRequestObserver &observer,
    53                                                                  HsActivityDbClientPrivate &session)
    75                                                                  HsActivityDbClientPrivate &session,
       
    76                                                                  TAsyncRequest requestType, 
       
    77                                                                  void* userData)
    54     :
    78     :
    55     CActive(EPriorityStandard),
    79     CActive(EPriorityStandard),
    56     mObserver(observer),
    80     mObserver(observer),
    57     mSession(session),
    81     mSession(session),
    58     mRequestType(-1),
    82     mRequestType(requestType),
    59     mDataSize()
    83     mUserData(userData)
    60 {
    84 {
    61     CActiveScheduler::Add(this);
    85     CActiveScheduler::Add(this);
    62 }
    86 }
    63 
    87 
    64 // -----------------------------------------------------------------------------
    88 // -----------------------------------------------------------------------------
    67 //
    91 //
    68 HsActivityDbAsyncRequestPrivate::~HsActivityDbAsyncRequestPrivate()
    92 HsActivityDbAsyncRequestPrivate::~HsActivityDbAsyncRequestPrivate()
    69 {
    93 {
    70     mDataBuf.Close();
    94     mDataBuf.Close();
    71     Cancel();
    95     Cancel();
       
    96     delete mBitmapPath;
       
    97     delete mBitmapMimeType;
    72 }
    98 }
    73 
    99 
    74 // -----------------------------------------------------------------------------
   100 // -----------------------------------------------------------------------------
    75 //
   101 //
    76 // -----------------------------------------------------------------------------
   102 // -----------------------------------------------------------------------------
    86 //
   112 //
    87 // -----------------------------------------------------------------------------
   113 // -----------------------------------------------------------------------------
    88 //
   114 //
    89 void HsActivityDbAsyncRequestPrivate::RunL()
   115 void HsActivityDbAsyncRequestPrivate::RunL()
    90 {
   116 {
    91     RBuf8 buff;
       
    92     CleanupClosePushL(buff);
       
    93     QString data;
       
    94     int requestResult(iStatus.Int());
   117     int requestResult(iStatus.Int());
    95     if (KErrNone == requestResult) {
   118     if (KErrNone == requestResult) {
    96         if (0 < mDataSize()) {
   119         switch (mRequestType){
    97             buff.CreateL(mDataSize());
   120         case WaitActivity: {
       
   121             RBuf8 buff;
       
   122             CleanupClosePushL(buff);
       
   123             QString data;
       
   124             if (0 < mDataSize()) {
       
   125                 buff.CreateL(mDataSize());
       
   126             }
       
   127             mSession.getData(mTaskId(), buff);
       
   128             data = QString::fromAscii(reinterpret_cast<const char *>(buff.Ptr()),
       
   129                                       buff.Length());
       
   130             buff.Close();
       
   131             mObserver.asyncRequestCompleated(requestResult, mRequestType, data);
       
   132             CleanupStack::PopAndDestroy(&buff);
       
   133             break;
       
   134             }
       
   135         case EWaitGetThumbnail: {
       
   136             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
       
   137             CleanupStack::PushL(bitmap);
       
   138             User::LeaveIfError(bitmap->Duplicate(mBitmapId()));
       
   139             mSession.getData(mTaskId(), mDataBuf);//ACK Bitmap copy
       
   140             mObserver.asyncRequestCompleated(requestResult, mRequestType, QPixmap::fromSymbianCFbsBitmap(bitmap), mUserData);
       
   141             CleanupStack::PopAndDestroy(bitmap);
       
   142             break;
       
   143             }
    98         }
   144         }
    99         mSession.getData(buff);
   145         mSession.Pop(this);
   100         data = QString::fromAscii(reinterpret_cast<const char *>(buff.Ptr()),
       
   101                                   buff.Length());
       
   102         buff.Close();
       
   103     }
   146     }
   104     mObserver.asyncRequestCompleated(requestResult, mRequestType, data);
       
   105     CleanupStack::PopAndDestroy(&buff);
       
   106 }
   147 }
   107 
   148 
   108 // -----------------------------------------------------------------------------
   149 // -----------------------------------------------------------------------------
   109 //
   150 //
   110 // -----------------------------------------------------------------------------
   151 // -----------------------------------------------------------------------------
   111 //
   152 //
   112 void HsActivityDbAsyncRequestPrivate::waitActivity(const QVariantHash &condition)
   153 void HsActivityDbAsyncRequestPrivate::waitActivity(const QVariantHash &condition)
   113 {
   154 {
   114     mRequestType = WaitActivity;
       
   115     iStatus = KRequestPending;
   155     iStatus = KRequestPending;
   116     SetActive();
   156     SetActive();
   117     mDataBuf << condition;
   157     mDataSize = condition.find(ActivityApplicationKeyword).value().toInt();
   118     mSession.sendDataAsync(mRequestType, TIpcArgs(&mDataBuf, &mDataSize), iStatus);
   158     TPtrC8 actId(KNullDesC8);
       
   159     TPtrC8 desc(KNullDesC8);
       
   160     mSession.sendDataAsync(mRequestType, TIpcArgs(&mDataSize, &actId, &desc, &mTaskId), iStatus);
   119 }
   161 }
       
   162 
       
   163 // -----------------------------------------------------------------------------
       
   164 //
       
   165 // -----------------------------------------------------------------------------
       
   166 //
       
   167 void HsActivityDbAsyncRequestPrivate::getThumbnail(QSize size, QString imagePath, QString  mimeType)
       
   168 {
       
   169     iStatus = KRequestPending;
       
   170     SetActive();
       
   171     mBitmapId = size.width();
       
   172     mTaskId = size.height();
       
   173     mBitmapPath = XQConversions::qStringToS60Desc(imagePath);
       
   174     mBitmapMimeType = XQConversions::qStringToS60Desc8(mimeType);
       
   175     mSession.sendDataAsync(mRequestType, TIpcArgs(&mBitmapId, &mTaskId, mBitmapPath, mBitmapMimeType), iStatus);
       
   176 }