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     if( mIsconnected) {

    35         mServerClient->waitActivity(QVariantHash());

    36     }

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

    38 }

    39 

    40 ActivityClientPrivate::~ActivityClientPrivate()

    41 {

    42     delete mServerClient;

    43     delete mDataStorage;

    44 }

    45 

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

    47 {

    48     bool result(false);

    49     if (mIsconnected) {

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

    51         if ( result ) {

    52             QVariantHash activity(parameters);

    53             RProcess process;

    54             registerThumbnail(activityId, activity);

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

    56             activity.insert(ActivityActivityKeyword, activityId);

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

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

    59         }

    60     }

    61     // @todo make those operations atomic

    62     return result;

    63 }

    64 

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

    66 {

    67     bool result(false);

    68     if (mIsconnected) {

    69         result = mDataStorage->removeActivity(activityId);

    70         if ( result ) {            

    71             QVariantHash activity;

    72             RProcess process;

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

    74             activity.insert(ActivityActivityKeyword, activityId);

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

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

    77             if (result) {

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

    79             }

    80         }

    81     }

    82     // @todo make those operations atomic

    83     return result;

    84 }

    85 

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

    87 {

    88     bool result(false);

    89     if (mIsconnected) {

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

    91         if ( result ) {

    92             QVariantHash activity(parameters);

    93             RProcess process;

    94             registerThumbnail(activityId, activity);

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

    96             activity.insert(ActivityActivityKeyword, activityId);

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

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

    99         }

   100     }

   101     // @todo make those operations atomic

   102     return result;

   103 }

   104 

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

   106 {

   107     QList<QVariantHash> activities;

   108     if (mIsconnected) {

   109         QVariantHash activity;

   110         RProcess process;

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

   112         mServerClient->applicationActivities(activities, activity);

   113     }

   114     return activities;

   115 }

   116 

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

   118 {

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

   120 }

   121 

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

   123 {

   124     QVariantHash activityParams;

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

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

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

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

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

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

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

   132             }

   133 

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

   135                 return activityParams;

   136             }

   137         }

   138     }

   139     return QVariantHash();

   140 }

   141 

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

   143 {

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

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

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

   147         const QString thumbnailManagerName = thumbnailName(name);

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

   149             activity.insert(ActivityScreenshotKeyword, thumbnailManagerName);

   150         } else {

   151             activity.remove(ActivityScreenshotKeyword);

   152         }

   153     }

   154 }

   155 

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

   157 {

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

   159                                     "/" + 

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

   161                                     ".png");

   162 }

   163