Mercurial Mercurial > oss > FCL > sf > mw > homescreensrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
activityfw/activityserviceplugin/activityclient_p.cpp
changeset 73 4bc7b118b3df
parent 66 32469d7d46ff
equal deleted inserted replaced
66:32469d7d46ff 73:4bc7b118b3df 
    24 #include <QTimer>
 
    24 #include <QTimer>
 
    25 #include <QUrl>
 
    25 #include <QUrl>
 
    26 #include <QDebug>
 
    26 #include <QDebug>
 
    27 #include <QDir>
 
    27 #include <QDir>
 
    28 
    28 
    29 ActivityClientPrivate::ActivityClientPrivate(ActivityClient *q) : QObject(q), isconnected(false)
 
    29 ActivityClientPrivate::ActivityClientPrivate(ActivityClient *q) : QObject(q), mIsconnected(false)
 
    30 {
 
    30 {
 
    31     mDataStorage = new ActivityDataStorage();
 
    31     mDataStorage = new ActivityDataStorage();
 
    32     mServerClient = new HsActivityDbClient();
 
    32     mServerClient = new HsActivityDbClient();
 
    33     isconnected = ( KErrNone == mServerClient->connect());
 
    33     mIsconnected = ( KErrNone == mServerClient->connect());
 
    34     connect(mServerClient, SIGNAL(activityRequested(QString)), q, SIGNAL(activityRequested(QString)));
 
    34     connect(mServerClient, SIGNAL(activityRequested(QString)), q, SIGNAL(activityRequested(QString)));
 
    35 }
 
    35 }
 
    36 
    36 
    37 ActivityClientPrivate::~ActivityClientPrivate()
 
    37 ActivityClientPrivate::~ActivityClientPrivate()
 
    38 {
 
    38 {
 
    40     delete mDataStorage;
 
    40     delete mDataStorage;
 
    41 }
 
    41 }
 
    42 
    42 
    43 bool ActivityClientPrivate::addActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)
 
    43 bool ActivityClientPrivate::addActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)
 
    44 {
 
    44 {
 
    45     if (isconnected) {
 
    45     bool result(false);
 
    46         mDataStorage->addActivity(activityId, data);
 
    46     if (mIsconnected) {
 
    47         QVariantHash activity(parameters);
 
    47         result = mDataStorage->addActivity(activityId, data);
 
    48         RProcess process;
 
    48         if ( result ) {
 
    49         registerThumbnail(activityId, activity);
 
    49             QVariantHash activity(parameters);
 
    50         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
    50             RProcess process;
 
    51         activity.insert(ActivityActivityKeyword, activityId);
 
    51             registerThumbnail(activityId, activity);
 
    52         mServerClient->addActivity(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         }
 
    53     }
 
    57     }
 
    54     // @todo make those operations atomic
 
    58     // @todo make those operations atomic
 
    55     // @todo return real result
 
    59     return result;
 
    56     return isconnected;
 
       
    57 }
 
    60 }
 
    58 
    61 
    59 bool ActivityClientPrivate::removeActivity(const QString &activityId)
 
    62 bool ActivityClientPrivate::removeActivity(const QString &activityId)
 
    60 {
 
    63 {
 
    61     if (isconnected) {
 
    64     bool result(false);
 
    62         mDataStorage->removeActivity(activityId);
 
    65     if (mIsconnected) {
 
    63         QVariantHash activity;
 
    66         result = mDataStorage->removeActivity(activityId);
 
    64         RProcess process;
 
    67         if ( result ) {            
    65         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
    68             QVariantHash activity;
 
    66         activity.insert(ActivityActivityKeyword, activityId);
 
    69             RProcess process;
 
    67         mServerClient->removeActivity(activity);
 
    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         }
 
    68     }
 
    78     }
 
    69     // @todo make those operations atomic
 
    79     // @todo make those operations atomic
 
    70     // @todo return real result
 
    80     return result;
 
    71     return isconnected;
 
       
    72 }
 
    81 }
 
    73 
    82 
    74 bool ActivityClientPrivate::updateActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)
 
    83 bool ActivityClientPrivate::updateActivity(const QString &activityId, const QVariant &data, const QVariantHash &parameters)
 
    75 {
 
    84 {
 
    76     if (isconnected) {
 
    85     bool result(false);
 
    77         mDataStorage->updateActivity(activityId, data);
 
    86     if (mIsconnected) {
 
    78         QVariantHash activity(parameters);
 
    87         result = mDataStorage->updateActivity(activityId, data);
 
    79         RProcess process;
 
    88         if ( result ) {
 
    80         registerThumbnail(activityId, activity);
 
    89             QVariantHash activity(parameters);
 
    81         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
    90             RProcess process;
 
    82         activity.insert(ActivityActivityKeyword, activityId);
 
    91             registerThumbnail(activityId, activity);
 
    83         mServerClient->updateActivity(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         }
 
    84     }
 
    97     }
 
    85     // @todo make those operations atomic
 
    98     // @todo make those operations atomic
 
    86     // @todo return real result
 
    99     return result;
 
    87     return isconnected;
 
       
    88 }
 
   100 }
 
    89 
   101 
    90 QList<QVariantHash> ActivityClientPrivate::activities() const
 
   102 QList<QVariantHash> ActivityClientPrivate::activities() const
 
    91 {
 
   103 {
 
    92     QList<QVariantHash> activities;
 
   104     QList<QVariantHash> activities;
 
    93     if (isconnected) {
 
   105     if (mIsconnected) {
 
    94         QVariantHash activity;
 
   106         QVariantHash activity;
 
    95         RProcess process;
 
   107         RProcess process;
 
    96         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
   108         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
    97         mServerClient->applicationActivities(activities, activity);
 
   109         mServerClient->applicationActivities(activities, activity);
 
    98     }
 
   110     }
 
    99     return activities;
 
   111     return activities;
 
   100 }
 
   112 }
 
   101 
   113 
   102 QVariant ActivityClientPrivate::activityData(const QString &activityId) const
 
   114 QVariant ActivityClientPrivate::activityData(const QString &activityId) const
 
   103 {
 
   115 {
 
   104     return isconnected ? mDataStorage->activityData(activityId) : QVariant();
 
   116     return mIsconnected ? mDataStorage->activityData(activityId) : QVariant();
 
   105 }
 
   117 }
 
   106 
   118 
   107 bool ActivityClientPrivate::waitActivity()
 
   119 bool ActivityClientPrivate::waitActivity()
 
   108 {
 
   120 {
 
   109     bool retVal(isconnected);
 
   121     bool retVal(mIsconnected);
 
   110     if (isconnected) {
 
   122     if (mIsconnected) {
 
   111         RProcess process;
 
   123         RProcess process;
 
   112         QVariantHash activity;
 
   124         QVariantHash activity;
 
   113         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
   125         activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));
 
   114         retVal = !mServerClient->waitActivity(activity);
 
   126         retVal = !mServerClient->waitActivity(activity);
 
   115     }
 
   127     }
 
   136     return QVariantHash();
 
   148     return QVariantHash();
 
   137 }
 
   149 }
 
   138 
   150 
   139 void ActivityClientPrivate::registerThumbnail(const QString &name, QVariantHash &activity)
 
   151 void ActivityClientPrivate::registerThumbnail(const QString &name, QVariantHash &activity)
 
   140 {
 
   152 {
 
   141     QVariantHash::const_iterator    findIterator(activity.constFind(ActivityScreenshotKeyword));
 
   153     QVariantHash::const_iterator findIterator(activity.constFind(ActivityScreenshotKeyword));
 
   142     if (activity.constEnd() != findIterator   &&
 
   154     if (activity.constEnd() != findIterator   &&
 
   143         findIterator.value().canConvert<QPixmap>()) {
 
   155         findIterator.value().canConvert<QPixmap>()) {
 
   144         const QString thumbnailManagerName = thumbnailName(name);
 
   156         const QString thumbnailManagerName = thumbnailName(name);
 
   145         if (findIterator.value().value<QPixmap>().save(thumbnailManagerName)) {
 
   157         if (findIterator.value().value<QPixmap>().save(thumbnailManagerName)) {
 
   146             activity.insert(ActivityScreenshotKeyword, thumbnailManagerName);
 
   158             activity.insert(ActivityScreenshotKeyword, thumbnailManagerName);
 
   155     return QDir::toNativeSeparators(qApp->applicationDirPath() + 
   167     return QDir::toNativeSeparators(qApp->applicationDirPath() + 
   156                                     "/" + 
   168                                     "/" + 
   157                                     QString::number(qHash(activityId), 16) + 
   169                                     QString::number(qHash(activityId), 16) + 
   158                                     ".png");
 
   170                                     ".png");
 
   159 }
 
   171 }
 
       
   172
FCL/sf/mw/homescreensrv