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

    18 #include "activityclient.h"

    19 #include "activitydatastorage.h"

    20 #include <hsactivitydbclient.h>

    21 

    22 #include <QCoreApplication>

    23 #include <QStringList>

    24 #include <QTimer>

    25 #include <QUrl>

    26 #include <QDebug>

    27 #include <QDir>

    28 

    29 ActivityClientPrivate::ActivityClientPrivate(ActivityClient *q) : QObject(q), mIsconnected(false)

    30 {

    31     mDataStorage = new ActivityDataStorage();

    32     mServerClient = new HsActivityDbClient();

    33     mIsconnected = ( KErrNone == mServerClient->connect());

    34     connect(mServerClient, SIGNAL(activityRequested(QString)), q, SIGNAL(activityRequested(QString)));

    35 }

    36 

    37 ActivityClientPrivate::~ActivityClientPrivate()

    38 {

    39     delete mServerClient;

    40     delete mDataStorage;

    41 }

    42 

    43 bool ActivityClientPrivate::addActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)

    44 {

    45     bool result(false);

    46     if (mIsconnected) {

    47         result = mDataStorage->addActivity(activityId, data);

    48         if ( result ) {

    49             QVariantHash activity(parameters);

    50             RProcess process;

    51             registerThumbnail(activityId, activity);

    52             activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    53             activity.insert(ActivityActivityKeyword, activityId);

    54             int error = mServerClient->addActivity(activity);

    55             result = error == KErrNone ? true : false;

    56         }

    57     }

    58     // @todo make those operations atomic

    59     return result;

    60 }

    61 

    62 bool ActivityClientPrivate::removeActivity(const QString &activityId)

    63 {

    64     bool result(false);

    65     if (mIsconnected) {

    66         result = mDataStorage->removeActivity(activityId);

    67         if ( result ) {            

    68             QVariantHash activity;

    69             RProcess process;

    70             activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    71             activity.insert(ActivityActivityKeyword, activityId);

    72             int error = mServerClient->removeActivity(activity);

    73             result = error == KErrNone ? true : false;

    74             if (result) {

    75                 result = QFile::remove(thumbnailName(activityId));

    76             }

    77         }

    78     }

    79     // @todo make those operations atomic

    80     return result;

    81 }

    82 

    83 bool ActivityClientPrivate::updateActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)

    84 {

    85     bool result(false);

    86     if (mIsconnected) {

    87         result = mDataStorage->updateActivity(activityId, data);

    88         if ( result ) {

    89             QVariantHash activity(parameters);

    90             RProcess process;

    91             registerThumbnail(activityId, activity);

    92             activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    93             activity.insert(ActivityActivityKeyword, activityId);

    94             int error = mServerClient->updateActivity(activity);

    95             result = error == KErrNone ? true : false;

    96         }

    97     }

    98     // @todo make those operations atomic

    99     return result;

   100 }

   101 

   102 QList<QVariantHash> ActivityClientPrivate::activities() const

   103 {

   104     QList<QVariantHash> activities;

   105     if (mIsconnected) {

   106         QVariantHash activity;

   107         RProcess process;

   108         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

   109         mServerClient->applicationActivities(activities, activity);

   110     }

   111     return activities;

   112 }

   113 

   114 QVariant ActivityClientPrivate::activityData(const QString &activityId) const

   115 {

   116     return mIsconnected ? mDataStorage->activityData(activityId) : QVariant();

   117 }

   118 

   119 bool ActivityClientPrivate::waitActivity()

   120 {

   121     bool retVal(mIsconnected);

   122     if (mIsconnected) {

   123         RProcess process;

   124         QVariantHash activity;

   125         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

   126         retVal = !mServerClient->waitActivity(activity);

   127     }

   128     return retVal;

   129 }

   130 

   131 QVariantHash ActivityClientPrivate::parseCommandLine(const QStringList &commandLineParams) const

   132 {

   133     QVariantHash activityParams;

   134     int activityMarkerIndex = commandLineParams.indexOf("-activity");

   135     if (activityMarkerIndex != -1 && commandLineParams.count() - 1 > activityMarkerIndex) {

   136         QUrl activityUri(commandLineParams.at(activityMarkerIndex+1));

   137         if (activityUri.scheme() == "appto") {

   138             QList<QPair<QString, QString> > parameters = activityUri.queryItems();

   139             for (QList<QPair<QString, QString> >::const_iterator i = parameters.constBegin(); i != parameters.constEnd(); ++i) {

   140                 activityParams.insert(i->first, i->second);

   141             }

   142 

   143             if (activityParams.contains("activityname") && !activityParams.value("activityname").toString().isEmpty()) {

   144                 return activityParams;

   145             }

   146         }

   147     }

   148     return QVariantHash();

   149 }

   150 

   151 void ActivityClientPrivate::registerThumbnail(const QString &name, QVariantHash &activity)

   152 {

   153     QVariantHash::const_iterator findIterator(activity.constFind(ActivityScreenshotKeyword));

   154     if (activity.constEnd() != findIterator   &&

   155         findIterator.value().canConvert<QPixmap>()) {

   156         const QString thumbnailManagerName = thumbnailName(name);

   157         if (findIterator.value().value<QPixmap>().save(thumbnailManagerName)) {

   158             activity.insert(ActivityScreenshotKeyword, thumbnailManagerName);

   159         } else {

   160             activity.remove(ActivityScreenshotKeyword);

   161         }

   162     }

   163 }

   164 

   165 QString ActivityClientPrivate::thumbnailName(const QString &activityId) const

   166 {

   167     return QDir::toNativeSeparators(qApp->applicationDirPath() + 

   168                                     "/" + 

   169                                     QString::number(qHash(activityId), 16) + 

   170                                     ".png");

   171 }

   172