1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 #include "qmessagestore.h"

    42 #include "qmessagestore_p.h"

    43 #include "modestengine_maemo_p.h"

    44 #include "telepathyengine_maemo_p.h"

    45 #include "maemohelpers_p.h"

    46 #include "eventloggerengine_maemo_p.h"

    47 

    48 

    49 QTM_BEGIN_NAMESPACE

    50 

    51 class QMessageStorePrivatePlatform

    52 {

    53 public:

    54     QMessageStorePrivatePlatform(QMessageStorePrivate *d, QMessageStore *q)

    55         :d_ptr(d), q_ptr(q) {}

    56     QMessageStorePrivate *d_ptr;

    57     QMessageStore *q_ptr;

    58     EventLoggerEngine *el;

    59 };

    60 

    61 QMessageStorePrivate::QMessageStorePrivate()

    62     :q_ptr(0),

    63      p_ptr(0)

    64 {

    65 

    66 }

    67 

    68 QMessageStorePrivate::~QMessageStorePrivate()

    69 {

    70 }

    71 

    72 void QMessageStorePrivate::initialize(QMessageStore *store)

    73 { 

    74     q_ptr = store;

    75     p_ptr = new QMessageStorePrivatePlatform(this, store);

    76     p_ptr->el= EventLoggerEngine::instance();

    77 }

    78 

    79 void QMessageStorePrivate::messageNotification(QMessageStorePrivate::NotificationType type, const QMessageId& id,

    80                                                const QMessageManager::NotificationFilterIdSet &matchingFilters)

    81 {

    82     switch (type) {

    83     case Added:

    84         emit q_ptr->messageAdded(id, matchingFilters);

    85         break;

    86     case Updated:

    87         emit q_ptr->messageUpdated(id, matchingFilters);

    88         break;

    89     case Removed:

    90         emit q_ptr->messageRemoved(id, matchingFilters);

    91         break;

    92     }

    93 }

    94 

    95 

    96 Q_GLOBAL_STATIC(QMessageStorePrivate,data);

    97 

    98 QMessageStore::QMessageStore(QObject *parent)

    99     : QObject(parent),

   100       d_ptr(data())

   101 {

   102     Q_ASSERT(d_ptr != 0);

   103     Q_ASSERT(d_ptr->q_ptr == 0); // QMessageStore should be singleton

   104  //   d_ptr->initialize(this);

   105     // be sure that singletons are initialized

   106     EventLoggerEngine::instance();

   107     TelepathyEngine::instance();

   108 }

   109 

   110 QMessageStore::~QMessageStore()

   111 {

   112     d_ptr = 0; // should be cleaned up by automatically

   113 }

   114 

   115 QMessageStore* QMessageStore::instance()

   116 {

   117     QMessageStorePrivate *d = data();

   118     Q_ASSERT(d != 0);

   119     if (!d->q_ptr)

   120         d->initialize(new QMessageStore());

   121     return d->q_ptr;

   122 }

   123 

   124 QMessageManager::Error QMessageStore::error() const

   125 {

   126     return QMessageManager::NoError;

   127 }

   128 

   129 QMessageIdList QMessageStore::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const

   130 {

   131     QMessageIdList messageIds;

   132 

   133     QMessageFilter handledFilter = filter;

   134     MessagingHelper::handleNestedFiltersFromMessageFilter(handledFilter);

   135 

   136     bool isFiltered = false;

   137     bool isSorted = false;

   138     

   139     messageIds = ModestEngine::instance()->queryMessagesSync(handledFilter, sortOrder, limit, offset,

   140                                                              isFiltered, isSorted);

   141     

   142     messageIds += EventLoggerEngine::instance()->filterAndOrderMessages(handledFilter,sortOrder,QString(),QMessageDataComparator::MatchFlags());

   143 

   144     if (!isFiltered) {

   145         MessagingHelper::filterMessages(messageIds, handledFilter);

   146     }

   147     if (!isSorted) {

   148         MessagingHelper::orderMessages(messageIds, sortOrder);

   149     }

   150     MessagingHelper::applyOffsetAndLimitToMessageIdList(messageIds, limit, offset);

   151 

   152     ModestEngine::instance()->clearHeaderCache();

   153 

   154     return messageIds;

   155 }

   156 

   157 QMessageIdList QMessageStore::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) const

   158 {

   159     QMessageIdList messageIds;

   160 

   161     QMessageFilter handledFilter = filter;

   162     MessagingHelper::handleNestedFiltersFromMessageFilter(handledFilter);

   163 

   164     bool isFiltered = false;

   165     bool isSorted = false;

   166     messageIds = ModestEngine::instance()->queryMessagesSync(handledFilter, body, matchFlags, sortOrder,

   167                                                              limit, offset, isFiltered, isSorted);

   168 

   169     messageIds +=EventLoggerEngine::instance()->filterAndOrderMessages(handledFilter,sortOrder,body,matchFlags);

   170 

   171     if (!isFiltered) {

   172         MessagingHelper::filterMessages(messageIds, handledFilter);

   173     }

   174     if (!isSorted) {

   175         MessagingHelper::orderMessages(messageIds, sortOrder);

   176     }

   177     MessagingHelper::applyOffsetAndLimitToMessageIdList(messageIds, limit, offset);

   178 

   179     ModestEngine::instance()->clearHeaderCache();

   180 

   181     return messageIds;

   182 }

   183 

   184 QMessageFolderIdList QMessageStore::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset) const

   185 {

   186     QMessageFolderIdList folderIds;

   187 

   188     QMessageFolderFilter handledFilter = filter;

   189     MessagingHelper::handleNestedFiltersFromFolderFilter(handledFilter);

   190 

   191     bool isFiltered = false;

   192     bool isSorted = false;

   193     folderIds = ModestEngine::instance()->queryFolders(handledFilter, sortOrder, limit, offset, isFiltered, isSorted);

   194     if (!isFiltered) {

   195         MessagingHelper::filterFolders(folderIds, filter);

   196     }

   197     if (!isSorted) {

   198         MessagingHelper::orderFolders(folderIds, sortOrder);

   199     }

   200     MessagingHelper::applyOffsetAndLimitToFolderIdList(folderIds, limit, offset);

   201 

   202     return folderIds;

   203 }

   204 

   205 QMessageAccountIdList QMessageStore::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const

   206 {

   207     QMessageAccountIdList accountIds;

   208 

   209     bool isFiltered = false;

   210     bool isSorted = false;

   211     accountIds = ModestEngine::instance()->queryAccounts(filter, sortOrder, limit, offset, isFiltered, isSorted);

   212     if (!isFiltered) {

   213         MessagingHelper::filterAccounts(accountIds, filter);

   214     }

   215     accountIds += TelepathyEngine::instance()->queryAccounts(filter, sortOrder, limit, offset, isFiltered, isSorted);

   216     if (!isFiltered) {

   217         MessagingHelper::filterAccounts(accountIds, filter);

   218     }

   219     if (!isSorted) {

   220         MessagingHelper::orderAccounts(accountIds, sortOrder);

   221     }

   222     MessagingHelper::applyOffsetAndLimitToAccountIdList(accountIds, limit, offset);

   223 

   224     return accountIds;

   225 }

   226 

   227 int QMessageStore::countMessages(const QMessageFilter& filter) const

   228 {

   229     int count = 0;

   230 

   231     QMessageFilter handledFilter = filter;

   232     MessagingHelper::handleNestedFiltersFromMessageFilter(handledFilter);

   233 

   234     count += ModestEngine::instance()->countMessagesSync(handledFilter);

   235 

   236     ModestEngine::instance()->clearHeaderCache();

   237 

   238     return count;

   239 }

   240 

   241 int QMessageStore::countFolders(const QMessageFolderFilter& filter) const

   242 {

   243     int count = 0;

   244 

   245     count += ModestEngine::instance()->countFolders(filter);

   246 

   247     return count;

   248 }

   249 

   250 int QMessageStore::countAccounts(const QMessageAccountFilter& filter) const

   251 {

   252     int count = 0;

   253 

   254     count += ModestEngine::instance()->countAccounts(filter);

   255     count += TelepathyEngine::instance()->countAccounts(filter);

   256     return count;

   257 }

   258 

   259 bool QMessageStore::removeMessage(const QMessageId& id, QMessageManager::RemovalOption option)

   260 {

   261     if (id.toString().startsWith("MO_")) {

   262         return ModestEngine::instance()->removeMessage(id, option);

   263     }

   264     return EventLoggerEngine::instance()->deleteMessage(id);

   265 }

   266 

   267 bool QMessageStore::removeMessages(const QMessageFilter& filter, QMessageManager::RemovalOption option)

   268 {

   269     QMessageIdList ids = queryMessages(filter, QMessageSortOrder(), 0, 0);

   270 

   271     for (int i=0; i < ids.count(); i++) {

   272         if (ids[i].toString().startsWith("MO_")) {

   273             if (!ModestEngine::instance()->removeMessage(ids[i], option)) {

   274                 return false;

   275             } 

   276 	} else 

   277 	  if(!EventLoggerEngine::instance()->deleteMessage(ids[i]))

   278 	    return false;

   279     }

   280     return true;

   281 }

   282 

   283 bool QMessageStore::addMessage(QMessage *m)

   284 {

   285     bool retVal = true;

   286 

   287     QMessageAccountId accountId = m->parentAccountId();

   288     QMessage::Type msgType = QMessage::NoType;

   289 

   290     // Check message type

   291     if (m->type() == QMessage::AnyType || m->type() == QMessage::NoType) {

   292         if (accountId.isValid()) {

   293             // ParentAccountId was defined => Message type can be read

   294             // from parent account

   295             QMessageAccount account = QMessageAccount(accountId);

   296             QMessage::TypeFlags types = account.messageTypes();

   297             if (types & QMessage::Sms) {

   298                 msgType = QMessage::Sms;

   299             } else if (account.messageTypes() & QMessage::InstantMessage) {

   300                 msgType = QMessage::InstantMessage;

   301             } else if (types & QMessage::Mms) {

   302                 msgType = QMessage::Mms;

   303             } else if (types & QMessage::Email) {

   304                 msgType = QMessage::Email;

   305             }

   306         }

   307         if (msgType == QMessage::NoType) {

   308             retVal = false;

   309         }

   310     }

   311 

   312     if (retVal) {

   313         // Check account

   314         if (!accountId.isValid()) {

   315             accountId = QMessageAccount::defaultAccount(m->type());

   316             if (!accountId.isValid()) {

   317                 retVal = false;

   318             }

   319         }

   320     }

   321 

   322     QMessageAccount account(accountId);

   323     if (retVal) {

   324         // Check account/message type compatibility

   325         if (!(account.messageTypes() & m->type()) && (msgType == QMessage::NoType)) {

   326             retVal = false;

   327         }

   328     }

   329 

   330     if (retVal) {

   331         // Set default account if unset

   332         if (!m->parentAccountId().isValid()) {

   333             m->setParentAccountId(accountId);

   334         }

   335 

   336         if (account.messageTypes() & QMessage::Sms) {

   337             retVal = false; //TODO:

   338             qWarning() << "QMessageManager::add not yet implemented for SMS";

   339         } else if (account.messageTypes() & QMessage::InstantMessage) {

   340             retVal = false; //TODO:

   341             qWarning() << "QMessageManager::add not yet implemented for Instant Message";

   342         } else if (account.messageTypes() & QMessage::Mms) {

   343             retVal = false; //TODO:

   344             qWarning() << "QMessageManager::add not yet implemented for MMS";

   345         } else if (account.messageTypes() & QMessage::Email) {

   346             retVal = ModestEngine::instance()->addMessage(*m);

   347         }

   348     }

   349 

   350     return retVal;

   351 }

   352 

   353 bool QMessageStore::updateMessage(QMessage *m)

   354 {

   355     bool retVal = false;

   356 

   357     if (m->type() == QMessage::Sms) {

   358         retVal = false; //TODO:

   359         qWarning() << "QMessageManager::update not yet implemented for SMS";

   360     } else if (m->type() == QMessage::InstantMessage) {

   361         retVal = false; //TODO:

   362         qWarning() << "QMessageManager::update not yet implemented for Instant Message";

   363     } else if (m->type() == QMessage::Mms) {

   364         retVal = false; //TODO:

   365         qWarning() << "QMessageManager::update not yet implemented for Instant MMS";

   366     } else if (m->type() == QMessage::Email) {

   367         retVal = ModestEngine::instance()->updateMessage(*m);

   368     }

   369 

   370     return retVal;

   371 }

   372 

   373 QMessage QMessageStore::message(const QMessageId& id) const

   374 {

   375     if (id.toString().startsWith("MO_")) {

   376         return ModestEngine::instance()->message(id);

   377     } else {

   378         return d_ptr->p_ptr->el->message(id);

   379     }

   380 }

   381 

   382 QMessageFolder QMessageStore::folder(const QMessageFolderId& id) const

   383 {

   384     if (id.toString().startsWith("MO_")) {

   385         return ModestEngine::instance()->folder(id);

   386     }

   387 

   388     return QMessageFolder();

   389 }

   390 

   391 QMessageAccount QMessageStore::account(const QMessageAccountId& id) const

   392 {

   393     if (id.toString().startsWith("MO_")) {

   394         return ModestEngine::instance()->account(id);

   395     } else {

   396         return  TelepathyEngine::instance()->account(id);

   397     }

   398 }

   399 

   400 QMessageManager::NotificationFilterId QMessageStore::registerNotificationFilter(const QMessageFilter &filter)

   401 {

   402     QMessageManager::NotificationFilterId id = d_ptr->p_ptr->el->registerNotificationFilter(*d_ptr,filter);

   403     return ModestEngine::instance()->registerNotificationFilter(*data(), filter, id);

   404 }

   405 

   406 void QMessageStore::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId)

   407 {

   408     ModestEngine::instance()->unregisterNotificationFilter(notificationFilterId);

   409     d_ptr->p_ptr->el->unregisterNotificationFilter( notificationFilterId);

   410 }

   411 

   412 

   413 QTM_END_NAMESPACE