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 <xqconversions.h>

    19 

    20 #include "afstorageentry.h"

    21 #include "afentry.h"

    22 #include "afserializer.h"

    23 #include "afstorageglobals.h"

    24 // -----------------------------------------------------------------------------

    25 /**

    26  * Constructor. 

    27  * Initialize object with preallocated symbian specyfic data structure. Function doesn't copy content

    28  * @param data - pointer to symbian specyfic data structure

    29  */

    30 AfStorageEntry::AfStorageEntry(QSharedPointer<CAfEntry> data)

    31 :

    32 mData(data)

    33 {}

    34 

    35 // -----------------------------------------------------------------------------

    36 /**

    37 * Constructor

    38 * Initialize object with preallocated data structure. Function doesn't copy content

    39 * @param data - activity data structure

    40 */

    41 AfStorageEntry::AfStorageEntry(const AfStorageEntry &data)

    42 :

    43     mData(data.mData)

    44 {}

    45 

    46 // -----------------------------------------------------------------------------

    47 /**

    48  * Constructor

    49  * Initialize object with data. Function do deep copy of data

    50  * @param appId - unique application identifier

    51  * @param actId - activity identifier

    52  * @param privateData - private part of activity data

    53  * @param publicData - public part of activity data

    54  */

    55 AfStorageEntry::AfStorageEntry(int appId, 

    56                                const QString &actId, 

    57                                const QVariant &privateData, 

    58                                const QVariantHash& publicData)

    59 :

    60     mData(0)

    61 {

    62     int flags(0);

    63     QVariantHash privData;

    64     privData.insert(ActivityDataKeyword, privateData);

    65     RBuf8 privateBuff, publicBuff;

    66     CleanupClosePushL(privateBuff);

    67     CleanupClosePushL(publicBuff);

    68     privateBuff << privData;

    69     publicBuff << publicData;

    70     

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

    72         publicData[ActivityPersistence].toBool()) {

    73         flags |= CAfEntry::Persistent;

    74     }

    75     

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

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

    78         flags |= CAfEntry::Invisible;

    79     }

    80     

    81     HBufC *actBuff = XQConversions::qStringToS60Desc(actId);

    82     CleanupStack::PushL(actBuff);

    83     mData = QSharedPointer<CAfEntry>(CAfEntry::NewL(flags, 

    84                                                     appId, 

    85                                                     *actBuff, 

    86                                                     KNullDesC, 

    87                                                     privateBuff, 

    88                                                     publicBuff));

    89     CleanupStack::PopAndDestroy(actBuff);

    90     CleanupStack::PopAndDestroy(&publicBuff);

    91     CleanupStack::PopAndDestroy(&privateBuff);

    92 }

    93 

    94 // -----------------------------------------------------------------------------

    95 /**

    96  * Retrieve S60 structure representation

    97  */

    98 const CAfEntry* AfStorageEntry::data() const

    99 {

   100     return mData.data();

   101 }

   102  

   103 

   104 // -----------------------------------------------------------------------------

   105 /**

   106  * Retrieve activity flags

   107  * @return activity flags

   108  */

   109 int AfStorageEntry::flags() const

   110 {

   111     return mData->Flags();

   112 }

   113 

   114 // -----------------------------------------------------------------------------

   115 /**

   116  * Retrieve application unique identifier

   117  * @return application identifier

   118  */

   119 int AfStorageEntry::applicationId() const

   120 {

   121     return mData->ApplicationId();

   122 }

   123 

   124 // -----------------------------------------------------------------------------

   125 /**

   126  * Retrieve activity identifier. Identyfier is unique for each application 

   127  * @return activity identifier

   128  */

   129 QString AfStorageEntry::activityId() const

   130 {

   131     return XQConversions::s60DescToQString(mData->ActivityId());

   132 }

   133 

   134 // -----------------------------------------------------------------------------

   135 /**

   136  * Retrieve path to activity thumbanil path 

   137  * @return thumbail loacation path

   138  */

   139 QString AfStorageEntry::imageSrc() const

   140 {

   141     return XQConversions::s60DescToQString(mData->ImageSrc());

   142 }

   143 

   144 // -----------------------------------------------------------------------------

   145 /**

   146  * Retrieve public part of activity data 

   147  * @return public activity data

   148  */

   149 QVariantHash AfStorageEntry::publicData() const

   150 {

   151     QVariantHash deserializedData;

   152     deserializedData << mData->Data(CAfEntry::Public);

   153     deserializedData.insert(ActivityApplicationKeyword, applicationId());

   154     deserializedData.insert(ActivityActivityKeyword, activityId());

   155     deserializedData.insert(ActivityScreenshotKeyword, imageSrc());

   156     deserializedData.insert(ActivityPersistence, (flags() & CAfEntry::Persistent) ? true : false);

   157     deserializedData.insert(ActivityVisibility, (flags() & CAfEntry::Invisible) ? false : true);

   158     return deserializedData;

   159 }

   160 

   161 // -----------------------------------------------------------------------------

   162 /**

   163  * Retrieve private part of activity data 

   164  * @return private activity data

   165  */

   166 QVariant AfStorageEntry::privateData() const

   167 {

   168     QVariantHash deserializedData;

   169     deserializedData << mData->Data(CAfEntry::Private);

   170     return deserializedData[ActivityDataKeyword];

   171 }