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

    42 #include "qmtmengine_symbian_p.h"

    43 #ifdef FREESTYLEMAILUSED

    44 #include "qfsengine_symbian_p.h"

    45 #endif

    46 #include "messagingutil_p.h"

    47 #include "maemohelpers_p.h" // contains non-meamo specific helpers for messaging

    48 

    49 #include <QString>

    50 

    51 QTM_BEGIN_NAMESPACE

    52 

    53 using namespace SymbianHelpers;

    54 

    55 

    56 Q_GLOBAL_STATIC(QMessageStorePrivate,messageStorePrivate);

    57 

    58 QMessageStorePrivate::QMessageStorePrivate()

    59   : q_ptr(0),

    60     _mtmEngine(0),

    61     _error(QMessageManager::NoError)

    62 {

    63 }

    64 

    65 QMessageStorePrivate::~QMessageStorePrivate()

    66 {

    67 }

    68 

    69 void QMessageStorePrivate::initialize(QMessageStore *store)

    70 {

    71     q_ptr = store;

    72     _mtmEngine = CMTMEngine::instance();

    73 #ifdef FREESTYLEMAILUSED

    74     _fsEngine = CFSEngine::instance();

    75 #endif

    76 }

    77 

    78 QMessageIdList QMessageStorePrivate::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const

    79 {

    80     QMessageIdList ids;

    81     QMessageService service;

    82     connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), this, SLOT(messagesFound(const QMessageIdList&)));

    83     if (service.queryMessages(filter, sortOrder, limit, offset)) {

    84         QObject::connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), &loop, SLOT(quit()));

    85         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));

    86         loop.exec();

    87         ids = _ids;

    88         _ids.clear();

    89     }

    90     return ids;

    91 }

    92 

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

    94 {

    95     QMessageIdList ids;

    96     QMessageService service;

    97     connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), this, SLOT(messagesFound(const QMessageIdList&)));

    98     if (service.queryMessages(filter, body, matchFlags, sortOrder, limit, offset)) {

    99         QObject::connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), &loop, SLOT(quit()));

   100         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));

   101         loop.exec();

   102         ids = _ids;

   103         _ids.clear();

   104     }

   105     return ids;

   106 }

   107 

   108 int QMessageStorePrivate::countMessages(const QMessageFilter& filter) const

   109 {

   110     int count = 0;

   111     QMessageService service;

   112     connect(&service, SIGNAL(messagesCounted(int)), this, SLOT(messagesCounted(int)));

   113     if (service.countMessages(filter)) {

   114         QObject::connect(&service, SIGNAL(messagesCounted(int)), &loop, SLOT(quit()));

   115         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));

   116         loop.exec();

   117         count = _count;

   118         _count = 0;

   119     }

   120     return count;

   121 }

   122 

   123 void QMessageStorePrivate::stateChanged(QMessageService::State newState)

   124 {

   125     if (newState == QMessageService::FinishedState) {

   126         loop.quit();

   127     }

   128 }

   129 

   130 void QMessageStorePrivate::messagesFound(const QMessageIdList &ids)

   131 {

   132     _ids = ids;

   133     loop.quit();

   134 }

   135 

   136 void QMessageStorePrivate::messagesCounted(int count)

   137 {

   138     _count = count;

   139     loop.quit();

   140 }

   141 

   142 QMessageAccountIdList QMessageStorePrivate::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const

   143 {

   144     QMessageAccountIdList idList;

   145 

   146     idList << _mtmEngine->queryAccounts(filter, sortOrder, 0, 0);

   147 

   148 #ifdef FREESTYLEMAILUSED    

   149     _fsEngine->setMtmAccountIdList(idList);

   150     idList << _fsEngine->queryAccounts(filter, sortOrder, 0, 0);

   151 #endif

   152 

   153     MessagingHelper::orderAccounts(idList, sortOrder);

   154 

   155     MessagingHelper::applyOffsetAndLimitToAccountIdList(idList, limit, offset);

   156 

   157     return idList;

   158 }

   159 

   160 int QMessageStorePrivate::countAccounts(const QMessageAccountFilter &filter) const

   161 {

   162     int count = 0;

   163 #ifdef FREESTYLEMAILUSED

   164     count += _fsEngine->countAccounts(filter);

   165 #endif

   166     count += _mtmEngine->countAccounts(filter);

   167     return count;

   168 }

   169 

   170 QMessageFolderIdList QMessageStorePrivate::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset) const

   171 {

   172     QMessageFolderIdList idList;

   173 #ifdef FREESTYLEMAILUSED

   174     idList << _fsEngine->queryFolders(filter, sortOrder, 0, 0);

   175 #endif

   176     idList << _mtmEngine->queryFolders(filter, sortOrder, 0, 0);

   177  

   178     MessagingHelper::orderFolders(idList, sortOrder);

   179 

   180     MessagingHelper::applyOffsetAndLimitToFolderIdList(idList, limit, offset);

   181 

   182     return idList;

   183 }

   184 

   185 int QMessageStorePrivate::countFolders(const QMessageFolderFilter& filter) const

   186 {

   187     int count = 0;

   188 #ifdef FREESTYLEMAILUSED

   189     count += _fsEngine->countFolders(filter);

   190 #endif

   191     count += _mtmEngine->countFolders(filter);

   192     return count;

   193 }

   194 

   195 QMessageFolder QMessageStorePrivate::folder(const QMessageFolderId& id) const

   196 {

   197     switch (idType(id)) {

   198         case EngineTypeFreestyle:

   199 #ifdef FREESTYLEMAILUSED

   200             return _fsEngine->folder(id);

   201 #else

   202             return QMessageFolder();

   203 #endif

   204             break;

   205         case EngineTypeMTM:

   206         default:

   207             return _mtmEngine->folder(id);

   208             break;

   209     }

   210 }

   211 

   212 

   213 bool QMessageStorePrivate::addMessage(QMessage *m)

   214 {

   215     switch (idType(m->parentAccountId())) {

   216     case EngineTypeFreestyle:

   217 #ifdef FREESTYLEMAILUSED

   218         return _fsEngine->addMessage(m);

   219 #else

   220             return false;

   221 #endif

   222         break;

   223     case EngineTypeMTM:

   224     default:

   225         return _mtmEngine->addMessage(m);

   226         break;

   227     }

   228 }

   229 

   230 bool QMessageStorePrivate::updateMessage(QMessage *m)

   231 {

   232     switch (idType(m->id())) {

   233     case EngineTypeFreestyle:

   234 #ifdef FREESTYLEMAILUSED

   235         return _fsEngine->updateMessage(m);

   236 #else

   237         return false;

   238 #endif

   239         break;

   240     case EngineTypeMTM:

   241     default:

   242         return _mtmEngine->updateMessage(m);

   243         break;

   244     }

   245 }

   246 

   247 bool QMessageStorePrivate::removeMessage(const QMessageId &id, QMessageManager::RemovalOption option)

   248 {

   249     switch (idType(id)) {

   250     case EngineTypeFreestyle:

   251 #ifdef FREESTYLEMAILUSED

   252         return _fsEngine->removeMessage(id, option);

   253 #else

   254         return false;

   255 #endif

   256         break;

   257     case EngineTypeMTM:

   258     default:

   259         return _mtmEngine->removeMessage(id, option);

   260         break;

   261     }

   262 }

   263 

   264 bool QMessageStorePrivate::removeMessages(const QMessageFilter &filter, QMessageManager::RemovalOption option)

   265 {

   266     bool retVal = true;

   267     

   268     QMessageIdList ids;

   269     QMessageService service;

   270     connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), this, SLOT(messagesFound(const QMessageIdList&)));

   271     if (service.queryMessages(filter)) {

   272         QObject::connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), &loop, SLOT(quit()));

   273         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));

   274         loop.exec();

   275         ids = _ids;

   276         _ids.clear();

   277         

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

   279             switch (idType(ids[i])) {

   280                 case EngineTypeFreestyle:

   281 #ifdef FREESTYLEMAILUSED

   282                     if (!_fsEngine->removeMessage(ids[i], option)) {

   283                         retVal = false;

   284                     }

   285 #else

   286                 return false;

   287 #endif

   288                     break;  

   289                 case EngineTypeMTM:

   290                     if (!_mtmEngine->removeMessage(ids[i], option)) {

   291                         retVal = false;

   292                     }

   293                     break;

   294                 default:

   295                     return false;

   296             }

   297         }

   298     } else {

   299         retVal = false;

   300     }

   301     

   302     return retVal;

   303 }

   304 

   305 QMessage QMessageStorePrivate::message(const QMessageId& id) const

   306 {

   307     switch (idType(id)) {

   308         case EngineTypeFreestyle:

   309 #ifdef FREESTYLEMAILUSED

   310             return _fsEngine->message(id);

   311 #else

   312         return QMessage();

   313 #endif

   314             break;

   315         case EngineTypeMTM:

   316         default:

   317             return _mtmEngine->message(id);

   318             break;

   319         }

   320 }

   321 

   322 QMessageAccount QMessageStorePrivate::account(const QMessageAccountId &id) const

   323 {

   324     switch (idType(id)) {

   325         case EngineTypeFreestyle:

   326 #ifdef FREESTYLEMAILUSED

   327             return _fsEngine->account(id);

   328 #else

   329         return QMessageAccount();

   330 #endif

   331             break;

   332         case EngineTypeMTM:

   333         default:

   334             return _mtmEngine->account(id);

   335             break;

   336         }

   337 }

   338 

   339 QMessageManager::NotificationFilterId QMessageStorePrivate::registerNotificationFilter(const QMessageFilter &filter)

   340 {

   341     QMessageManager::NotificationFilterId id = _mtmEngine->registerNotificationFilter(*this, filter);

   342 #ifdef FREESTYLEMAILUSED

   343     return _fsEngine->registerNotificationFilter(*this, filter, id);

   344 #else

   345     return id;

   346 #endif   

   347 }

   348 

   349 void QMessageStorePrivate::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId)

   350 {

   351 #ifdef FREESTYLEMAILUSED

   352     _fsEngine->unregisterNotificationFilter(notificationFilterId);  

   353 #endif

   354     _mtmEngine->unregisterNotificationFilter(notificationFilterId);  

   355 

   356 }

   357 

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

   359                                                const QMessageManager::NotificationFilterIdSet &matchingFilters)

   360 {

   361     switch (type) {

   362         case Added:

   363             qDebug() << "messageAdded notification" << id.toString();

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

   365             break;

   366         case Updated:

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

   368             break;

   369         case Removed:

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

   371             break;

   372     }

   373 }

   374 

   375 QMessageStore::QMessageStore(QObject *parent)

   376     : QObject(parent),

   377       d_ptr(messageStorePrivate())

   378 {

   379     Q_ASSERT(d_ptr != 0);

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

   381     d_ptr->initialize(this);

   382 }

   383 

   384 QMessageStore::~QMessageStore()

   385 {

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

   387 }

   388 

   389 QMessageStore* QMessageStore::instance()

   390 {

   391     QMessageStorePrivate *d = messageStorePrivate();

   392     Q_ASSERT(d != 0);

   393     if (!d->q_ptr)

   394         new QMessageStore();

   395     return d->q_ptr;

   396 }

   397 

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

   399 {

   400     return QMessageManager::NoError;

   401 }

   402 

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

   404 {

   405     return messageStorePrivate()->queryMessages(filter, sortOrder, limit, offset);

   406 }

   407 

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

   409 {

   410     return messageStorePrivate()->queryMessages(filter, body, matchFlags, sortOrder, limit, offset);

   411 }

   412 

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

   414 {

   415     return messageStorePrivate()->queryFolders(filter, sortOrder, limit, offset);

   416 }

   417 

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

   419 {

   420     return messageStorePrivate()->queryAccounts(filter, sortOrder, limit, offset);

   421 }

   422 

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

   424 {

   425     return messageStorePrivate()->countMessages(filter);

   426 }

   427 

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

   429 {

   430     return messageStorePrivate()->countFolders(filter);

   431 }

   432 

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

   434 {

   435     return messageStorePrivate()->countAccounts(filter);

   436 }

   437 

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

   439 {

   440     return messageStorePrivate()->removeMessage(id, option);

   441 }

   442 

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

   444 {

   445     return messageStorePrivate()->removeMessages(filter, option);

   446 }

   447 

   448 bool QMessageStore::addMessage(QMessage *m)

   449 {

   450     return messageStorePrivate()->addMessage(m);   	

   451 }

   452 

   453 bool QMessageStore::updateMessage(QMessage *m)

   454 {

   455 	return messageStorePrivate()->updateMessage(m);

   456 }

   457 

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

   459 {

   460     return messageStorePrivate()->message(id);

   461 }

   462 

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

   464 {

   465     return messageStorePrivate()->folder(id);

   466 }

   467 

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

   469 {

   470     return messageStorePrivate()->account(id);

   471 }

   472 

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

   474 {

   475     return messageStorePrivate()->registerNotificationFilter(filter);

   476 }

   477 

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

   479 {

   480     messageStorePrivate()->unregisterNotificationFilter(notificationFilterId);

   481 }

   482 

   483 #include "moc_qmessagestore_symbian_p.cpp"

   484 QTM_END_NAMESPACE