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

    19 #include "hsactivitydbclient_p.h"

    20 #include "hsactivitydbclient.h"

    21 #include <fbs.h>

    22 #include <XQConversions>

    23 

    24 

    25 // -----------------------------------------------------------------------------

    26 //

    27 // -----------------------------------------------------------------------------

    28 //

    29 HsActivityDbAsyncRequestPrivate*

    30 HsActivityDbAsyncRequestPrivate::NewLC(HsActivityDbAsyncRequestObserver &observer,

    31                                       HsActivityDbClientPrivate &session, 

    32                                       TAsyncRequest requestType,

    33                                       void* userData)

    34 {

    35     HsActivityDbAsyncRequestPrivate *self = 

    36     new(ELeave)HsActivityDbAsyncRequestPrivate(observer, session, requestType, userData);

    37     CleanupStack::PushL(self);

    38     self->mDataBuf.CreateL(64);

    39     return self;

    40 }

    41 

    42 // -----------------------------------------------------------------------------

    43 //

    44 // -----------------------------------------------------------------------------

    45 //

    46 void HsActivityDbAsyncRequestPrivate::waitActivityLD(

    47                                 HsActivityDbAsyncRequestObserver & observer, 

    48                                 HsActivityDbClientPrivate & session, 

    49                                 const QVariantHash &activity)

    50 {

    51     HsActivityDbAsyncRequestPrivate *self =

    52         HsActivityDbAsyncRequestPrivate::NewLC(observer, 

    53                                                session, 

    54                                                EWaitActivity);

    55     self->mSession.PushL(self);

    56     CleanupStack::Pop(self);

    57     self->waitActivity(activity);

    58 }

    59 

    60 // -----------------------------------------------------------------------------

    61 //

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

    63 //

    64 void HsActivityDbAsyncRequestPrivate::notifyDataChangeLD(

    65                                    HsActivityDbAsyncRequestObserver &observer, 

    66                                    HsActivityDbClientPrivate &session)

    67 {

    68     HsActivityDbAsyncRequestPrivate *self = 

    69         HsActivityDbAsyncRequestPrivate::NewLC(observer, 

    70                                               session,

    71                                               ENotifyDataChange);

    72     self->mSession.PushL(self);

    73     CleanupStack::Pop(self);

    74     self->notifyDataChange();

    75 }

    76 

    77 // -----------------------------------------------------------------------------

    78 //

    79 // -----------------------------------------------------------------------------

    80 //

    81 void HsActivityDbAsyncRequestPrivate::getThumbnailLD(HsActivityDbAsyncRequestObserver &observer,

    82                                       HsActivityDbClientPrivate &session, 

    83                                       QSize size, 

    84                                       const QString &imagePath, 

    85                                       const QString &mimeType, 

    86                                       void *userDdata)

    87 {

    88     HsActivityDbAsyncRequestPrivate *instance = 

    89         HsActivityDbAsyncRequestPrivate::NewLC(observer, session, EWaitGetThumbnail, userDdata);

    90     session.PushL(instance);

    91     CleanupStack::Pop(instance);

    92     instance->getThumbnail( size, imagePath, mimeType);

    93 }

    94 

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

    96 //

    97 // -----------------------------------------------------------------------------

    98 //

    99 HsActivityDbAsyncRequestPrivate::HsActivityDbAsyncRequestPrivate(HsActivityDbAsyncRequestObserver &observer,

   100                                                                  HsActivityDbClientPrivate &session,

   101                                                                  TAsyncRequest requestType, 

   102                                                                  void* userData)

   103     :

   104     CActive(EPriorityStandard),

   105     mObserver(observer),

   106     mSession(session),

   107     mRequestType(requestType),

   108     mUserData(userData)

   109 {

   110     CActiveScheduler::Add(this);

   111 }

   112 

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

   114 //

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

   116 //

   117 HsActivityDbAsyncRequestPrivate::~HsActivityDbAsyncRequestPrivate()

   118 {

   119     mDataBuf.Close();

   120     Cancel();

   121     delete mBitmapPath;

   122     delete mBitmapMimeType;

   123 }

   124 

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

   126 //

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

   128 //

   129 void HsActivityDbAsyncRequestPrivate::DoCancel()

   130 {

   131     if (IsActive()) {

   132         switch (mRequestType) {

   133         case EWaitActivity: mSession.cancelWaitActivity(); break;

   134         case ENotifyDataChange: mSession.cancelNotifyDataChange(); break;

   135         };

   136     }

   137 }

   138 

   139 // -----------------------------------------------------------------------------

   140 //

   141 // -----------------------------------------------------------------------------

   142 //

   143 void HsActivityDbAsyncRequestPrivate::RunL()

   144 {

   145     switch (mRequestType) {

   146     case WaitActivity: {

   147         QString data;

   148         if (KErrNone == iStatus.Int()) {

   149             RBuf8 buff;

   150             CleanupClosePushL(buff);

   151             if (0 < mDataSize()) {

   152                 buff.CreateL(mDataSize());

   153             }

   154             mSession.getData(mTaskId(), buff);

   155             data = QString::fromAscii(reinterpret_cast<const char *>(buff.Ptr()),

   156                                       buff.Length());

   157             CleanupStack::PopAndDestroy(&buff);

   158         }

   159         mObserver.asyncRequestCompleated(iStatus.Int(), mRequestType, data);

   160         mSession.Pop(this);

   161         delete this;

   162         break;

   163         }

   164     case EWaitGetThumbnail: {

   165         QPixmap pixmap;

   166         if (KErrNone == iStatus.Int()) {

   167             CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

   168             CleanupStack::PushL(bitmap);

   169             User::LeaveIfError(bitmap->Duplicate(mBitmapId()));

   170             mSession.getData(mTaskId(), mDataBuf);//ACK Bitmap copy

   171             pixmap = QPixmap::fromSymbianCFbsBitmap(bitmap);

   172             CleanupStack::PopAndDestroy(bitmap);

   173         }

   174         mObserver.asyncRequestCompleated(iStatus.Int(), mRequestType, pixmap, mUserData);

   175         mSession.Pop(this);

   176         delete this;

   177         break;

   178         }

   179     case ENotifyDataChange: {

   180         mObserver.asyncRequestCompleated(iStatus.Int(),mRequestType);

   181         mSession.Pop(this);

   182         delete this;

   183         }

   184     }

   185 }

   186 

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

   188 //

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

   190 //

   191 void HsActivityDbAsyncRequestPrivate::waitActivity(const QVariantHash &condition)

   192 {

   193     iStatus = KRequestPending;

   194     SetActive();

   195     mDataSize = condition.find(ActivityApplicationKeyword).value().toInt();

   196     TPtrC8 actId(KNullDesC8);

   197     TPtrC8 desc(KNullDesC8);

   198     mSession.sendDataAsync(mRequestType, TIpcArgs(&mDataSize, &actId, &desc, &mTaskId), iStatus);

   199 }

   200 

   201 // -----------------------------------------------------------------------------

   202 //

   203 // -----------------------------------------------------------------------------

   204 //

   205 void HsActivityDbAsyncRequestPrivate::getThumbnail(QSize size, QString imagePath, QString  mimeType)

   206 {

   207     iStatus = KRequestPending;

   208     SetActive();

   209     mBitmapId = size.width();

   210     mTaskId = size.height();

   211     mBitmapPath = XQConversions::qStringToS60Desc(imagePath);

   212     mBitmapMimeType = XQConversions::qStringToS60Desc8(mimeType);

   213     mSession.sendDataAsync(mRequestType, TIpcArgs(&mBitmapId, &mTaskId, mBitmapPath, mBitmapMimeType), iStatus);

   214 }

   215 

   216 // -----------------------------------------------------------------------------

   217 //

   218 // -----------------------------------------------------------------------------

   219 //

   220 void HsActivityDbAsyncRequestPrivate::notifyDataChange()

   221 {

   222     iStatus = KRequestPending;

   223     SetActive();

   224     mSession.sendDataAsync(ENotifyDataChange, TIpcArgs(), iStatus);

   225 }