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

    20 

    21 #include <QCoreApplication>

    22 #include <QStringList>

    23 #include <QTimer>

    24 #include <QUrl>

    25 #include <QDebug>

    26 #include <QDir>

    27 

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

    29 {

    30     mServerClient = new HsActivityDbClient();

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

    32     if( mIsconnected) {

    33         mServerClient->waitActivity(QVariantHash());

    34     }

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

    36 }

    37 

    38 ActivityClientPrivate::~ActivityClientPrivate()

    39 {

    40     delete mServerClient;

    41 }

    42 

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

    44 {

    45     bool result(false);

    46     if (mIsconnected) {

    47         QVariantHash privateData;

    48         privateData.insert(ActivityDataKeyword, data);

    49         QVariantHash publicData(parameters);

    50         RProcess process;

    51         publicData.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    52         publicData.insert(ActivityActivityKeyword, activityId);

    53         result = (KErrNone == mServerClient->addActivity(privateData, publicData));

    54     }

    55     return result;

    56 }

    57 

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

    59 {

    60     bool result(false);

    61     if (mIsconnected) {

    62         QVariantHash activity;

    63         RProcess process;

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

    65         activity.insert(ActivityActivityKeyword, activityId);

    66         result = (KErrNone == mServerClient->removeActivity(activity));

    67     }

    68     return result;

    69 }

    70 

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

    72 {

    73     bool result(false);

    74     if (mIsconnected) {

    75         QVariantHash privateData;

    76         privateData.insert(ActivityDataKeyword, data);

    77         QVariantHash publicData(parameters);

    78         RProcess process;

    79         publicData.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

    80         publicData.insert(ActivityActivityKeyword, activityId);

    81         result = (KErrNone == mServerClient->updateActivity(privateData, publicData));

    82     }

    83     return result;

    84 }

    85 

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

    87 {

    88     QList<QVariantHash> activities;

    89     if (mIsconnected) {

    90         QVariantHash activity;

    91         RProcess process;

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

    93         mServerClient->applicationActivities(activities, activity);

    94     }

    95     return activities;

    96 }

    97 

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

    99 {

   100     QVariant data;

   101     if (mIsconnected) {

   102         QVariantHash activity;

   103         RProcess process;

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

   105         activity.insert(ActivityActivityKeyword, activityId);

   106         mServerClient->activityData(data, activity);

   107     }

   108     return data;

   109 }

   110 

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

   112 {

   113     QVariantHash activityParams;

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

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

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

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

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

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

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

   121             }

   122 

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

   124                 return activityParams;

   125             }

   126         }

   127     }

   128     return QVariantHash();

   129 }