Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / 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.
qtmobility/src/messaging/qmessagestore_symbian.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4 
    38 ** $QT_END_LICENSE$
 
    38 ** $QT_END_LICENSE$
 
    39 **
 
    39 **
 
    40 ****************************************************************************/
 
    40 ****************************************************************************/
 
    41 #include "qmessagestore_symbian_p.h"
 
    41 #include "qmessagestore_symbian_p.h"
 
    42 #include "qmtmengine_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
 
    43 
    48 
    44 #include <QString>
 
    49 #include <QString>
 
    45 
    50 
    46 QTM_BEGIN_NAMESPACE
 
    51 QTM_BEGIN_NAMESPACE
 
       
    52 
       
    53 using namespace SymbianHelpers;
 
       
    54 
    47 
    55 
    48 Q_GLOBAL_STATIC(QMessageStorePrivate,messageStorePrivate);
 
    56 Q_GLOBAL_STATIC(QMessageStorePrivate,messageStorePrivate);
 
    49 
    57 
    50 QMessageStorePrivate::QMessageStorePrivate()
 
    58 QMessageStorePrivate::QMessageStorePrivate()
 
    51   : q_ptr(0),
 
    59   : q_ptr(0),
 
    60 
    68 
    61 void QMessageStorePrivate::initialize(QMessageStore *store)
 
    69 void QMessageStorePrivate::initialize(QMessageStore *store)
 
    62 {
 
    70 {
 
    63     q_ptr = store;
 
    71     q_ptr = store;
 
    64     _mtmEngine = CMTMEngine::instance();
 
    72     _mtmEngine = CMTMEngine::instance();
 
       
    73 #ifdef FREESTYLEMAILUSED
 
       
    74     _fsEngine = CFSEngine::instance();
 
       
    75 #endif
 
    65 }
 
    76 }
 
    66 
    77 
    67 QMessageIdList QMessageStorePrivate::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
    78 QMessageIdList QMessageStorePrivate::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
    68 {
 
    79 {
 
    69     QMessageIdList ids;
 
    80     QMessageIdList ids;
 
   128     loop.quit();
 
   139     loop.quit();
 
   129 }
 
   140 }
 
   130 
   141 
   131 QMessageAccountIdList QMessageStorePrivate::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const
 
   142 QMessageAccountIdList QMessageStorePrivate::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const
 
   132 {
 
   143 {
 
   133     return _mtmEngine->queryAccounts(filter, sortOrder, limit, offset);
 
   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;
 
   134 }
 
   158 }
 
   135 
   159 
   136 int QMessageStorePrivate::countAccounts(const QMessageAccountFilter &filter) const
 
   160 int QMessageStorePrivate::countAccounts(const QMessageAccountFilter &filter) const
 
   137 {
 
   161 {
 
   138     return _mtmEngine->countAccounts(filter);
 
   162     int count = 0;
 
       
   163 #ifdef FREESTYLEMAILUSED
 
       
   164     count += _fsEngine->countAccounts(filter);
 
       
   165 #endif
 
       
   166     count += _mtmEngine->countAccounts(filter);
 
       
   167     return count;
 
   139 }
 
   168 }
 
   140 
   169 
   141 QMessageFolderIdList QMessageStorePrivate::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset) const
 
   170 QMessageFolderIdList QMessageStorePrivate::queryFolders(const QMessageFolderFilter &filter, const QMessageFolderSortOrder &sortOrder, uint limit, uint offset) const
 
   142 {
 
   171 {
 
   143     return _mtmEngine->queryFolders(filter, sortOrder, limit, offset);
 
   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;
 
   144 }
 
   183 }
 
   145 
   184 
   146 int QMessageStorePrivate::countFolders(const QMessageFolderFilter& filter) const
 
   185 int QMessageStorePrivate::countFolders(const QMessageFolderFilter& filter) const
 
   147 {
 
   186 {
 
   148     return _mtmEngine->countFolders(filter);
 
   187     int count = 0;
 
       
   188 #ifdef FREESTYLEMAILUSED
 
       
   189     count += _fsEngine->countFolders(filter);
 
       
   190 #endif
 
       
   191     count += _mtmEngine->countFolders(filter);
 
       
   192     return count;
 
   149 }
 
   193 }
 
   150 
   194 
   151 QMessageFolder QMessageStorePrivate::folder(const QMessageFolderId& id) const
 
   195 QMessageFolder QMessageStorePrivate::folder(const QMessageFolderId& id) const
 
   152 {
 
   196 {
 
   153     return _mtmEngine->folder(id);
 
   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     }
 
   154 }
 
   210 }
 
   155 
   211 
   156 
   212 
   157 bool QMessageStorePrivate::addMessage(QMessage *m)
 
   213 bool QMessageStorePrivate::addMessage(QMessage *m)
 
   158 {
 
   214 {
 
   159     return _mtmEngine->addMessage(m);
 
   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     }
 
   160 }
 
   228 }
 
   161 
   229 
   162 bool QMessageStorePrivate::updateMessage(QMessage *m)
 
   230 bool QMessageStorePrivate::updateMessage(QMessage *m)
 
   163 {
 
   231 {
 
   164     return _mtmEngine->updateMessage(m);
 
   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     }
 
   165 }
 
   245 }
 
   166 
   246 
   167 bool QMessageStorePrivate::removeMessage(const QMessageId &id, QMessageManager::RemovalOption option)
 
   247 bool QMessageStorePrivate::removeMessage(const QMessageId &id, QMessageManager::RemovalOption option)
 
   168 {
 
   248 {
 
   169     return _mtmEngine->removeMessage(id, option);
 
   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     }
 
   170 }
 
   262 }
 
   171 
   263 
   172 bool QMessageStorePrivate::removeMessages(const QMessageFilter &filter, QMessageManager::RemovalOption option)
 
   264 bool QMessageStorePrivate::removeMessages(const QMessageFilter &filter, QMessageManager::RemovalOption option)
 
   173 {
 
   265 {
 
   174     bool retVal = true;
 
   266     bool retVal = true;
 
   180         QObject::connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), &loop, SLOT(quit()));
 
   272         QObject::connect(&service, SIGNAL(messagesFound(const QMessageIdList&)), &loop, SLOT(quit()));
 
   181         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));
 
   273         QObject::connect(&service, SIGNAL(stateChanged(QMessageService::State)), this, SLOT(stateChanged(QMessageService::State)));
 
   182         loop.exec();
 
   274         loop.exec();
 
   183         ids = _ids;
 
   275         ids = _ids;
 
   184         _ids.clear();
 
   276         _ids.clear();
 
       
   277         
   185         for (int i=0; i < ids.count(); i++) {
 
   278         for (int i=0; i < ids.count(); i++) {
 
   186             if (!_mtmEngine->removeMessage(ids[i], option)) {
 
   279             switch (idType(ids[i])) {
 
   187                 retVal = false;
 
   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;
 
   188             }
 
   296             }
 
   189         }
 
   297         }
 
   190     } else {
 
   298     } else {
 
   191         retVal = false;
 
   299         retVal = false;
 
   192     }
 
   300     }
 
   194     return retVal;
 
   302     return retVal;
 
   195 }
 
   303 }
 
   196 
   304 
   197 QMessage QMessageStorePrivate::message(const QMessageId& id) const
 
   305 QMessage QMessageStorePrivate::message(const QMessageId& id) const
 
   198 {
 
   306 {
 
   199     return _mtmEngine->message(id);
 
   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         }
 
   200 }
 
   320 }
 
   201 
   321 
   202 QMessageAccount QMessageStorePrivate::account(const QMessageAccountId &id) const
 
   322 QMessageAccount QMessageStorePrivate::account(const QMessageAccountId &id) const
 
   203 {
 
   323 {
 
   204     return _mtmEngine->account(id);
 
   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         }
 
   205 }
 
   337 }
 
   206 
   338 
   207 QMessageManager::NotificationFilterId QMessageStorePrivate::registerNotificationFilter(const QMessageFilter &filter)
 
   339 QMessageManager::NotificationFilterId QMessageStorePrivate::registerNotificationFilter(const QMessageFilter &filter)
 
   208 {
 
   340 {
 
   209     return _mtmEngine->registerNotificationFilter(*this, filter);
 
   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   
   210 }
 
   347 }
 
   211 
   348 
   212 void QMessageStorePrivate::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId)
 
   349 void QMessageStorePrivate::unregisterNotificationFilter(QMessageManager::NotificationFilterId notificationFilterId)
 
   213 {
 
   350 {
 
   214     _mtmEngine->unregisterNotificationFilter(notificationFilterId);    
   351 #ifdef FREESTYLEMAILUSED
 
       
   352     _fsEngine->unregisterNotificationFilter(notificationFilterId);  
       
   353 #endif
 
       
   354     _mtmEngine->unregisterNotificationFilter(notificationFilterId);  
       
   355 
   215 }
 
   356 }
 
   216 
   357 
   217 void QMessageStorePrivate::messageNotification(QMessageStorePrivate::NotificationType type, const QMessageId& id,
 
   358 void QMessageStorePrivate::messageNotification(QMessageStorePrivate::NotificationType type, const QMessageId& id,
 
   218                                                const QMessageManager::NotificationFilterIdSet &matchingFilters)
 
   359                                                const QMessageManager::NotificationFilterIdSet &matchingFilters)
 
   219 {
 
   360 {
 
   220     switch (type) {
 
   361     switch (type) {
 
   221         case Added:
 
   362         case Added:
 
       
   363             qDebug() << "messageAdded notification" << id.toString();
 
   222             emit q_ptr->messageAdded(id, matchingFilters);
 
   364             emit q_ptr->messageAdded(id, matchingFilters);
 
   223             break;
 
   365             break;
 
   224         case Updated:
 
   366         case Updated:
 
   225             emit q_ptr->messageUpdated(id, matchingFilters);
 
   367             emit q_ptr->messageUpdated(id, matchingFilters);
 
   226             break;
 
   368             break;
FCL/sf/mw/qtextensions