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

     2 **

     3 ** Copyright (C) 2009 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 

    44 #include <QString>

    45 

    46 QTM_BEGIN_NAMESPACE

    47 

    48 Q_GLOBAL_STATIC(QMessageStorePrivate,messageStorePrivate);

    49 

    50 QMessageStorePrivate::QMessageStorePrivate()

    51   : q_ptr(0),

    52     _mtmEngine(0),

    53     _error(QMessageManager::NoError)

    54 {

    55 }

    56 

    57 QMessageStorePrivate::~QMessageStorePrivate()

    58 {

    59 }

    60 

    61 void QMessageStorePrivate::initialize(QMessageStore *store)

    62 {

    63     q_ptr = store;

    64     _mtmEngine = CMTMEngine::instance();

    65 }

    66 

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

    68 {

    69     QMessageIdList ids;

    70     QMessageService service;

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

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

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

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

    75         loop.exec();

    76         ids = _ids;

    77         _ids.clear();

    78     }

    79     return ids;

    80 }

    81 

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

    83 {

    84     QMessageIdList ids;

    85     QMessageService service;

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

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

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

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

    90         loop.exec();

    91         ids = _ids;

    92         _ids.clear();

    93     }

    94     return ids;

    95 }

    96 

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

    98 {

    99     int count = 0;

   100     QMessageService service;

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

   102     if (service.countMessages(filter)) {

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

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

   105         loop.exec();

   106         count = _count;

   107         _count = 0;

   108     }

   109     return count;

   110 }

   111 

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

   113 {

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

   115         loop.quit();

   116     }

   117 }

   118 

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

   120 {

   121     _ids = ids;

   122     loop.quit();

   123 }

   124 

   125 void QMessageStorePrivate::messagesCounted(int count)

   126 {

   127     _count = count;

   128     loop.quit();

   129 }

   130 

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

   132 {

   133     return _mtmEngine->queryAccounts(filter, sortOrder, limit, offset);

   134 }

   135 

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

   137 {

   138     return _mtmEngine->countAccounts(filter);

   139 }

   140 

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

   142 {

   143     return _mtmEngine->queryFolders(filter, sortOrder, limit, offset);

   144 }

   145 

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

   147 {

   148     return _mtmEngine->countFolders(filter);

   149 }

   150 

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

   152 {

   153     return _mtmEngine->folder(id);

   154 }

   155 

   156 

   157 bool QMessageStorePrivate::addMessage(QMessage *m)

   158 {

   159     return _mtmEngine->addMessage(m);

   160 }

   161 

   162 bool QMessageStorePrivate::updateMessage(QMessage *m)

   163 {

   164     return _mtmEngine->updateMessage(m);

   165 }

   166 

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

   168 {

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

   170 }

   171 

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

   173 {

   174     bool retVal = true;

   175     

   176     QMessageIdList ids;

   177     QMessageService service;

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

   179     if (service.queryMessages(filter)) {

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

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

   182         loop.exec();

   183         ids = _ids;

   184         _ids.clear();

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

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

   187                 retVal = false;

   188             }

   189         }

   190     } else {

   191         retVal = false;

   192     }

   193     

   194     return retVal;

   195 }

   196 

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

   198 {

   199     return _mtmEngine->message(id);

   200 }

   201 

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

   203 {

   204     return _mtmEngine->account(id);

   205 }

   206 

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

   208 {

   209     return _mtmEngine->registerNotificationFilter(*this, filter);

   210 }

   211 

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

   213 {

   214     _mtmEngine->unregisterNotificationFilter(notificationFilterId);    

   215 }

   216 

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

   218                                                const QMessageManager::NotificationFilterIdSet &matchingFilters)

   219 {

   220     switch (type) {

   221         case Added:

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

   223             break;

   224         case Updated:

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

   226             break;

   227         case Removed:

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

   229             break;

   230     }

   231 }

   232 

   233 QMessageStore::QMessageStore(QObject *parent)

   234     : QObject(parent),

   235       d_ptr(messageStorePrivate())

   236 {

   237     Q_ASSERT(d_ptr != 0);

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

   239     d_ptr->initialize(this);

   240 }

   241 

   242 QMessageStore::~QMessageStore()

   243 {

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

   245 }

   246 

   247 QMessageStore* QMessageStore::instance()

   248 {

   249     QMessageStorePrivate *d = messageStorePrivate();

   250     Q_ASSERT(d != 0);

   251     if (!d->q_ptr)

   252         new QMessageStore();

   253     return d->q_ptr;

   254 }

   255 

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

   257 {

   258     return QMessageManager::NoError;

   259 }

   260 

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

   262 {

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

   264 }

   265 

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

   267 {

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

   269 }

   270 

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

   272 {

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

   274 }

   275 

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

   277 {

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

   279 }

   280 

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

   282 {

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

   284 }

   285 

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

   287 {

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

   289 }

   290 

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

   292 {

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

   294 }

   295 

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

   297 {

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

   299 }

   300 

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

   302 {

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

   304 }

   305 

   306 bool QMessageStore::addMessage(QMessage *m)

   307 {

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

   309 }

   310 

   311 bool QMessageStore::updateMessage(QMessage *m)

   312 {

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

   314 }

   315 

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

   317 {

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

   319 }

   320 

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

   322 {

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

   324 }

   325 

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

   327 {

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

   329 }

   330 

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

   332 {

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

   334 }

   335 

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

   337 {

   338     messageStorePrivate()->unregisterNotificationFilter(notificationFilterId);

   339 }

   340 

   341 #include "moc_qmessagestore_symbian_p.cpp"

   342 QTM_END_NAMESPACE