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

    18 

    19 #include <QSqlDatabase>

    20 #include <QSqlQuery>

    21 #include <QSqlError>

    22 #include <QStringList>

    23 #include <QSettings>

    24 

    25 #include <hsactivitydbclient.h>

    26 

    27 const char KConnectionName[] = "ActivityDatabase";

    28 

    29 ActivityDatabasePrivate::ActivityDatabasePrivate()

    30 {

    31     // determine database localization

    32     QSettings settings("nokia", "activities");

    33     if (!settings.contains("activitydatabase")) {

    34         settings.setValue("activitydatabase", "C:\\activitydatabase.db");

    35     }

    36     QString databaseFile = settings.value("activitydatabase").toString();

    37 

    38     QSqlDatabase database;

    39     if (QSqlDatabase::contains(KConnectionName)) {

    40         database = QSqlDatabase::database(KConnectionName);

    41     } else {

    42         database = QSqlDatabase::addDatabase("QSQLITE", KConnectionName);

    43         database.setDatabaseName(databaseFile);

    44         if (!database.open()) {

    45             qFatal(qPrintable(database.lastError().text()));

    46         }

    47     }

    48 

    49     if (!checkTables()) {

    50         recreateTables();

    51     }

    52 }

    53 

    54 ActivityDatabasePrivate::~ActivityDatabasePrivate()

    55 {

    56     QSqlDatabase::database(KConnectionName).close();

    57 }

    58 

    59 void ActivityDatabasePrivate::saveActivity(const QString &applicationName, const QString &activityName, const QVariantHash &activityMetadata)

    60 {

    61     if (applicationName.isEmpty() || activityName.isEmpty() || activityMetadata.value("screenshot").isNull()) {

    62         qWarning("Activity entry is invalid, aborting save");

    63         return;

    64     }

    65 

    66     QVariantHash activityData(activityMetadata);

    67     activityData.insert(ActivityApplicationKeyword, applicationName);

    68     activityData.insert(ActivityActivityKeyword, activityName);

    69 

    70     // stream whole entry to bytearray

    71     QByteArray streamedData;

    72     {

    73         QDataStream stream(&streamedData, QIODevice::WriteOnly);

    74         stream << activityData;

    75     }

    76 

    77     QSqlDatabase database = QSqlDatabase::database(KConnectionName);

    78 

    79     if (!database.transaction()) {

    80         qFatal(qPrintable(database.lastError().text()));

    81     }

    82 

    83     // update or insert data

    84     {

    85         QSqlQuery query(database);

    86         if (!query.exec(QString("SELECT ApplicationName FROM Activities WHERE ApplicationName = '%1' AND ActivityName = '%2'").arg(applicationName).arg(activityName))) {

    87             qFatal(qPrintable(query.lastError().text()));

    88         }

    89 

    90         if (query.next()) {

    91             if (!query.prepare("UPDATE Activities SET Data = :Data WHERE ApplicationName = :ApplicationName AND ActivityName = :ActivityName")) {

    92                 qFatal(qPrintable(query.lastError().text()));

    93             }

    94             query.bindValue(":Data", streamedData);

    95             query.bindValue(":ApplicationName", applicationName);

    96             query.bindValue(":ActivityName", activityName);

    97             if (!query.exec()) {

    98                 qFatal(qPrintable(query.lastError().text()));

    99             }

   100         } else {

   101             if (!query.prepare("INSERT INTO Activities(ApplicationName, ActivityName, Data) VALUES(:ApplicationName, :ActivityName, :Data)")) {

   102                 qFatal(qPrintable(query.lastError().text()));

   103             }

   104             query.bindValue(":ApplicationName", applicationName);

   105             query.bindValue(":ActivityName", activityName);

   106             query.bindValue(":Data", streamedData);

   107             if (!query.exec()) {

   108                 qFatal(qPrintable(query.lastError().text()));

   109             }

   110         }

   111     }

   112 

   113     if (!database.commit()) {

   114         qFatal(qPrintable(database.lastError().text()));

   115     }

   116 }

   117 

   118 void ActivityDatabasePrivate::deleteActivity(const QString &applicationName, const QString &activityName)

   119 {

   120     QString sqlCommand = QString("DELETE FROM Activities WHERE ApplicationName = '%1' AND ActivityName = '%2'").arg(applicationName).arg(activityName);

   121     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   122     if (!query.exec(sqlCommand)) {

   123         qFatal(qPrintable(query.lastError().text()));

   124     }

   125 }

   126 

   127 void ActivityDatabasePrivate::deleteApplicationActivities(const QString &applicationName)

   128 {

   129     QString sqlCommand = QString("DELETE FROM Activities WHERE ApplicationName = '%1'").arg(applicationName);

   130     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   131     if (!query.exec(sqlCommand)) {

   132         qFatal(qPrintable(query.lastError().text()));

   133     }

   134 }

   135 

   136 QList<QVariantHash> ActivityDatabasePrivate::allActivitiesList()

   137 {

   138     return activitiesList("SELECT Data FROM Activities");

   139 }

   140 

   141 QList<QVariantHash> ActivityDatabasePrivate::applicationActivitiesList(const QString &applicationName)

   142 {

   143     return activitiesList(QString("SELECT Data FROM Activities WHERE ApplicationName = '%1'").arg(applicationName));

   144 }

   145 

   146 QList<QVariantHash> ActivityDatabasePrivate::activitiesList(const QString &sqlCommand)

   147 {

   148     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   149     if (!query.exec(sqlCommand)) {

   150         qFatal(qPrintable(query.lastError().text()));

   151     }

   152 

   153     QList<QVariantHash> result;

   154     while (query.next()) {

   155         QVariantHash activityEntry;

   156         {

   157             QByteArray data(query.value(0).toByteArray());

   158             QDataStream stream(&data, QIODevice::ReadOnly);

   159             stream >> activityEntry;

   160         }

   161         result.append(activityEntry);

   162     }

   163     return result;

   164 }

   165 

   166 QString ActivityDatabasePrivate::requestedActivityName(const QString &applicationName)

   167 {

   168     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   169     if (!query.exec(QString("SELECT ActivityName FROM Activities WHERE ApplicationName = '%1' AND RequestFlag").arg(applicationName))) {

   170         qFatal(qPrintable(query.lastError().text()));

   171     }

   172 

   173     QString result;

   174     if (query.next()) {

   175         result = query.value(0).toString();

   176     }

   177     return result;

   178 }

   179 

   180 void ActivityDatabasePrivate::setActivityRequestFlag(const QString &applicationName, const QString &activityName)

   181 {

   182     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   183 

   184     // clear old requests for given application

   185     if (!query.exec(QString("UPDATE Activities SET RequestFlag=0 WHERE ApplicationName = '%1'").arg(applicationName))) {

   186         qFatal(qPrintable(query.lastError().text()));

   187     }

   188 

   189     // set new request

   190     if (!query.exec(QString("UPDATE Activities SET RequestFlag=1 WHERE ApplicationName = '%1' AND ActivityName = '%2'").arg(applicationName).arg(activityName))) {

   191         qFatal(qPrintable(query.lastError().text()));

   192     }

   193 }

   194 

   195 void ActivityDatabasePrivate::clearActivityRequestFlag(const QString &applicationName, const QString &activityName)

   196 {

   197     QSqlQuery query(QSqlDatabase::database(KConnectionName));

   198 

   199     // just clear the given request

   200     if (!query.exec(QString("UPDATE Activities SET RequestFlag=0 WHERE ApplicationName = '%1' AND ActivityName = '%2'").arg(applicationName).arg(activityName))) {

   201         qFatal(qPrintable(query.lastError().text()));

   202     }

   203 }

   204 

   205 bool ActivityDatabasePrivate::checkTables()

   206 {

   207     QStringList expectedTables("Activities");

   208     QStringList actualTables = QSqlDatabase::database(KConnectionName).tables();

   209     return (expectedTables == actualTables);

   210 }

   211 

   212 void ActivityDatabasePrivate::recreateTables()

   213 {

   214     QSqlDatabase database = QSqlDatabase::database(KConnectionName);

   215 

   216     if (!database.transaction()) {

   217         qFatal(qPrintable(database.lastError().text()));

   218     }

   219 

   220     // drop any existing tables

   221     {

   222         QSqlQuery dropQuery(database);

   223         foreach(const QString &tableName, database.tables()) {

   224             if (!dropQuery.exec(QString("DROP TABLE %1").arg(tableName))) {

   225                 qFatal(qPrintable(dropQuery.lastError().text()));

   226             }

   227         }

   228     }

   229 

   230     // create new table

   231     {

   232         QSqlQuery createQuery(database);

   233         QString statement(

   234             "CREATE TABLE Activities("

   235             "ApplicationName TEXT NOT NULL,"

   236             "ActivityName TEXT NOT NULL,"

   237             "RequestFlag BOOL NOT NULL DEFAULT FALSE,"

   238             "Data BLOB NOT NULL,"

   239             "PRIMARY KEY(ActivityName, ApplicationName))");

   240 

   241         if (!createQuery.exec(statement)) {

   242             qFatal(qPrintable(createQuery.lastError().text()));

   243         }

   244     }

   245 

   246     if (!database.commit()) {

   247         qFatal(qPrintable(database.lastError().text()));

   248     }

   249 }