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/qmessageservice_symbian.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4 
    48 
    48 
    49 #include "qmessageservice.h"
 
    49 #include "qmessageservice.h"
 
    50 #include "qmessageservice_symbian_p.h"
 
    50 #include "qmessageservice_symbian_p.h"
 
    51 #include "qmtmengine_symbian_p.h"
 
    51 #include "qmtmengine_symbian_p.h"
 
    52 #include "qmessage_symbian_p.h"
 
    52 #include "qmessage_symbian_p.h"
 
    53 
    53 #include "messagingutil_p.h"
 
       
    54 #include "maemohelpers_p.h" // contains non-meamo specific helpers for messaging
 
       
    55 #ifdef FREESTYLEMAILUSED
 
       
    56 #include "qfsengine_symbian_p.h"
 
       
    57 #endif
 
    54 
    58 
    55 QTM_BEGIN_NAMESPACE
 
    59 QTM_BEGIN_NAMESPACE
 
       
    60 
       
    61 using namespace SymbianHelpers;
 
    56 
    62 
    57 QMessageServicePrivate::QMessageServicePrivate(QMessageService* parent)
 
    63 QMessageServicePrivate::QMessageServicePrivate(QMessageService* parent)
 
    58  : q_ptr(parent),
 
    64  : q_ptr(parent),
 
    59    _state(QMessageService::InactiveState),
 
    65    _state(QMessageService::InactiveState),
 
    60    _active(false)
 
    66    _active(false),
 
       
    67    _pendingRequestCount(0)
 
    61 {
 
    68 {
 
    62 }
 
    69 }
 
    63       
    70       
    64 QMessageServicePrivate::~QMessageServicePrivate()
 
    71 QMessageServicePrivate::~QMessageServicePrivate()
 
    65 {
 
    72 {
 
    75     return CMTMEngine::instance()->sendMMS(message);
 
    82     return CMTMEngine::instance()->sendMMS(message);
 
    76 }
 
    83 }
 
    77 
    84 
    78 bool QMessageServicePrivate::sendEmail(QMessage &message)
 
    85 bool QMessageServicePrivate::sendEmail(QMessage &message)
 
    79 {
 
    86 {
 
    80     return CMTMEngine::instance()->sendEmail(message);
 
    87     switch (idType(message.parentAccountId())) {
 
       
    88         case EngineTypeFreestyle:
 
       
    89 #ifdef FREESTYLEMAILUSED
 
       
    90             return CFSEngine::instance()->sendEmail(message);
 
       
    91 #else
 
       
    92             return false;
 
       
    93 #endif
 
       
    94             break;
 
       
    95         case EngineTypeMTM:
 
       
    96         default:
 
       
    97             return CMTMEngine::instance()->sendEmail(message);
 
       
    98             break;
 
       
    99     }
 
    81 }
 
   100 }
 
    82 
   101 
    83 bool QMessageServicePrivate::show(const QMessageId& id)
 
   102 bool QMessageServicePrivate::show(const QMessageId& id)
 
    84 {
 
   103 {
 
    85 	return CMTMEngine::instance()->showMessage(id);
 
   104     switch (idType(id)) {
 
       
   105         case EngineTypeFreestyle:
 
       
   106 #ifdef FREESTYLEMAILUSED
 
       
   107             return CFSEngine::instance()->showMessage(id);
 
       
   108 #else
 
       
   109             return false;
 
       
   110 #endif
 
       
   111             break;
 
       
   112         case EngineTypeMTM:
 
       
   113         default:
 
       
   114             return CMTMEngine::instance()->showMessage(id);
 
       
   115             break;
 
       
   116     }
 
    86 }
 
   117 }
 
    87 
   118 
    88 bool QMessageServicePrivate::compose(const QMessage &message)
 
   119 bool QMessageServicePrivate::compose(const QMessage &message)
 
    89 {
 
   120 {
 
    90 	return CMTMEngine::instance()->composeMessage(message);
 
   121     switch (idType(message.parentAccountId())) {
 
       
   122         case EngineTypeFreestyle:
 
       
   123 #ifdef FREESTYLEMAILUSED
 
       
   124             return CFSEngine::instance()->composeMessage(message);
 
       
   125 #else
 
       
   126             return false;
 
       
   127 #endif
 
       
   128             break;
 
       
   129         case EngineTypeMTM:
 
       
   130         default:
 
       
   131             return CMTMEngine::instance()->composeMessage(message);
 
       
   132             break;
 
       
   133     }
 
    91 }
 
   134 }
 
    92 
   135 
    93 bool QMessageServicePrivate::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
   136 bool QMessageServicePrivate::queryMessages(const QMessageFilter &filter, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
    94 {
 
   137 {
 
    95     return CMTMEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, sortOrder, limit, offset);
 
   138     if (_pendingRequestCount > 0) {
 
       
   139         return false;
 
       
   140     }
 
       
   141     _pendingRequestCount = 0;
 
       
   142     _active = true;
 
       
   143     _filter = filter;
 
       
   144     _sortOrder = sortOrder;
 
       
   145     _limit = limit;
 
       
   146     _offset = offset;
 
       
   147     _filtered = true;
 
       
   148     _sorted = true;
 
       
   149 
       
   150     _pendingRequestCount++;
 
       
   151     CMTMEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, sortOrder, 0, 0);
 
       
   152 
       
   153 #ifdef FREESTYLEMAILUSED
 
       
   154     _pendingRequestCount++;
 
       
   155     CFSEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, sortOrder, 0, 0);
 
       
   156 #endif
 
       
   157 
       
   158     return _active;
 
    96 }
 
   159 }
 
    97 
   160 
    98 bool QMessageServicePrivate::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
   161 bool QMessageServicePrivate::queryMessages(const QMessageFilter &filter, const QString &body, QMessageDataComparator::MatchFlags matchFlags, const QMessageSortOrder &sortOrder, uint limit, uint offset) const
 
    99 {
 
   162 {
 
   100     return CMTMEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, body, matchFlags, sortOrder, limit, offset);
 
   163     if (_pendingRequestCount > 0) {
 
       
   164         return false;
 
       
   165     }
 
       
   166     _pendingRequestCount = 0;
 
       
   167     _active = true;
 
       
   168     _filter = filter;
 
       
   169     _sortOrder = sortOrder;
 
       
   170     _limit = limit;
 
       
   171     _offset = offset;
 
       
   172     _filtered = true;
 
       
   173     _sorted = true;
 
       
   174     
       
   175     _pendingRequestCount++;
 
       
   176     CMTMEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, body, matchFlags, sortOrder, 0, 0);
 
       
   177 
       
   178 #ifdef FREESTYLEMAILUSED
 
       
   179     _pendingRequestCount++;
 
       
   180     CFSEngine::instance()->queryMessages((QMessageServicePrivate&)*this, filter, body, matchFlags, sortOrder, 0, 0);
 
       
   181 #endif
 
       
   182 
       
   183     return _active;
 
   101 }
 
   184 }
 
   102 
   185 
   103 bool QMessageServicePrivate::countMessages(const QMessageFilter &filter)
 
   186 bool QMessageServicePrivate::countMessages(const QMessageFilter &filter)
 
   104 {
 
   187 {
 
   105     return CMTMEngine::instance()->countMessages((QMessageServicePrivate&)*this, filter);
 
   188     if (_pendingRequestCount > 0) {
 
       
   189         return false;
 
       
   190     }
 
       
   191     _pendingRequestCount = 0;
 
       
   192     _active = true;
 
       
   193     _count = 0;
 
       
   194 
       
   195     _pendingRequestCount++;
 
       
   196     CMTMEngine::instance()->countMessages((QMessageServicePrivate&)*this, filter);
 
       
   197 
       
   198 #ifdef FREESTYLEMAILUSED
 
       
   199     _pendingRequestCount++;
 
       
   200     CFSEngine::instance()->countMessages((QMessageServicePrivate&)*this, filter);
 
       
   201 #endif
 
       
   202     return _active;
 
   106 }
 
   203 }
 
   107 
   204 
   108 bool QMessageServicePrivate::retrieve(const QMessageId &messageId, const QMessageContentContainerId &id)
 
   205 bool QMessageServicePrivate::retrieve(const QMessageId &messageId, const QMessageContentContainerId &id)
 
   109 {
 
   206 {
 
   110 	return CMTMEngine::instance()->retrieve(messageId, id);
 
   207     switch (idType(messageId)) {
 
       
   208         case EngineTypeFreestyle:
 
       
   209 #ifdef FREESTYLEMAILUSED
 
       
   210             return CFSEngine::instance()->retrieve(*this, messageId, id);
 
       
   211 #else
 
       
   212             return false;
 
       
   213 #endif
 
       
   214             break;
 
       
   215         case EngineTypeMTM:
 
       
   216         default:
 
       
   217             return CMTMEngine::instance()->retrieve(*this, messageId, id);
 
       
   218             break;
 
       
   219     }
 
   111 }
 
   220 }
 
   112 
   221 
   113 bool QMessageServicePrivate::retrieveBody(const QMessageId& id)
 
   222 bool QMessageServicePrivate::retrieveBody(const QMessageId& id)
 
   114 {
 
   223 {
 
   115 	return CMTMEngine::instance()->retrieveBody(id);
 
   224     switch (idType(id)) {
 
       
   225         case EngineTypeFreestyle:
 
       
   226 #ifdef FREESTYLEMAILUSED
 
       
   227             return CFSEngine::instance()->retrieveBody(*this, id);
 
       
   228 #else
 
       
   229             return false;
 
       
   230 #endif
 
       
   231             break;
 
       
   232         case EngineTypeMTM:
 
       
   233         default:
 
       
   234             return CMTMEngine::instance()->retrieveBody(*this, id);
 
       
   235             break;
 
       
   236     }
 
   116 }
 
   237 }
 
   117 
   238 
   118 bool QMessageServicePrivate::retrieveHeader(const QMessageId& id)
 
   239 bool QMessageServicePrivate::retrieveHeader(const QMessageId& id)
 
   119 {
 
   240 {
 
   120 	return CMTMEngine::instance()->retrieveHeader(id);
 
   241     switch (idType(id)) {
 
       
   242         case EngineTypeFreestyle:
 
       
   243 #ifdef FREESTYLEMAILUSED
 
       
   244             return CFSEngine::instance()->retrieveHeader(*this, id);
 
       
   245 #else
 
       
   246             return false;
 
       
   247 #endif
 
       
   248             break;
 
       
   249         case EngineTypeMTM:
 
       
   250         default:
 
       
   251             return CMTMEngine::instance()->retrieveHeader(*this, id);
 
       
   252             break;
 
       
   253     }
 
       
   254 }
 
       
   255 
       
   256 void QMessageServicePrivate::messagesFound(const QMessageIdList &ids, bool isFiltered, bool isSorted)
 
       
   257 {
 
       
   258     _pendingRequestCount--;
 
       
   259 
       
   260     if (!isFiltered) {
 
       
   261         _filtered = false;
 
       
   262     }
 
       
   263 
       
   264     if (!isSorted) {
 
       
   265         _sorted = false;
 
       
   266     } else {
 
       
   267         if ((ids.count() > 0) && (_ids.count() > 0)) {
 
       
   268             _sorted = false;
 
       
   269         }
 
       
   270     }
 
       
   271 
       
   272     _ids.append(ids);
 
       
   273 
       
   274     if (_pendingRequestCount == 0) {
 
       
   275         if (!_filtered) {
 
       
   276             MessagingHelper::filterMessages(_ids, _filter);
 
       
   277         }
 
       
   278         if (!_sorted) {
 
       
   279             MessagingHelper::orderMessages(_ids, _sortOrder);
 
       
   280         }
 
       
   281         MessagingHelper::applyOffsetAndLimitToMessageIdList(_ids, _limit, _offset);
 
       
   282 
       
   283         emit q_ptr->messagesFound(_ids);
 
       
   284 
       
   285         setFinished(true);
 
       
   286 
       
   287         _ids.clear();
 
       
   288         _filter = QMessageFilter();
 
       
   289         _sortOrder = QMessageSortOrder();
 
       
   290     }
 
       
   291 }
 
       
   292 
       
   293 void QMessageServicePrivate::messagesCounted(int count)
 
       
   294 {
 
       
   295     _pendingRequestCount--;
 
       
   296 
       
   297     _count += count;
 
       
   298 
       
   299     if (_pendingRequestCount == 0) {
 
       
   300 
       
   301         emit q_ptr->messagesCounted(_count);
 
       
   302 
       
   303         setFinished(true);
 
       
   304 
       
   305         _count = 0;
 
       
   306     }
 
   121 }
 
   307 }
 
   122 
   308 
   123 bool QMessageServicePrivate::exportUpdates(const QMessageAccountId &id)
 
   309 bool QMessageServicePrivate::exportUpdates(const QMessageAccountId &id)
 
   124 {
 
   310 {
 
   125     return CMTMEngine::instance()->exportUpdates(id);
 
   311     switch (idType(id)) {
 
       
   312             case EngineTypeFreestyle:
 
       
   313 #ifdef FREESTYLEMAILUSED
 
       
   314                 return CFSEngine::instance()->exportUpdates(id);
 
       
   315 #else
 
       
   316                 return false;
 
       
   317 #endif
 
       
   318             case EngineTypeMTM:
 
       
   319             default:
 
       
   320                 return CMTMEngine::instance()->exportUpdates(*this, id);
 
       
   321     }
 
   126 }
 
   322 }
 
   127 
   323 
   128 void QMessageServicePrivate::setFinished(bool successful)
 
   324 void QMessageServicePrivate::setFinished(bool successful)
 
   129 {
 
   325 {
 
   130     if (!successful && (_error == QMessageManager::NoError)) {
 
   326     if (!successful && (_error == QMessageManager::NoError)) {
 
   141     : QObject(parent),
 
   337     : QObject(parent),
 
   142     d_ptr(new QMessageServicePrivate(this))
 
   338     d_ptr(new QMessageServicePrivate(this))
 
   143 {
 
   339 {
 
   144 	connect(d_ptr, SIGNAL(stateChanged(QMessageService::State)), this, SIGNAL(stateChanged(QMessageService::State)));
 
   340 	connect(d_ptr, SIGNAL(stateChanged(QMessageService::State)), this, SIGNAL(stateChanged(QMessageService::State)));
 
   145 	connect(d_ptr, SIGNAL(messagesFound(const QMessageIdList&)), this, SIGNAL(messagesFound(const QMessageIdList&)));
 
   341 	connect(d_ptr, SIGNAL(messagesFound(const QMessageIdList&)), this, SIGNAL(messagesFound(const QMessageIdList&)));
 
   146     connect(d_ptr, SIGNAL(messagesCounted(int)), this, SIGNAL(messagesCounted(int)));
 
   342     //connect(d_ptr, SIGNAL(messagesCounted(int)), this, SIGNAL(messagesCounted(int)));
 
   147 	connect(d_ptr, SIGNAL(progressChanged(uint, uint)), this, SIGNAL(progressChanged(uint, uint)));
 
   343 	connect(d_ptr, SIGNAL(progressChanged(uint, uint)), this, SIGNAL(progressChanged(uint, uint)));
 
   148 }
 
   344 }
 
   149 
   345 
   150 QMessageService::~QMessageService()
 
   346 QMessageService::~QMessageService()
 
   151 {
 
   347 {
 
   337 	bool retVal = true;
 
   533 	bool retVal = true;
 
   338 	d_ptr->_state = QMessageService::ActiveState;
 
   534 	d_ptr->_state = QMessageService::ActiveState;
 
   339 	emit stateChanged(d_ptr->_state);
 
   535 	emit stateChanged(d_ptr->_state);
 
   340 
   536 
   341 	retVal = d_ptr->retrieveHeader(id);
 
   537 	retVal = d_ptr->retrieveHeader(id);
 
   342 	
   538 	if (retVal == false) {
 
   343     d_ptr->setFinished(retVal);
 
   539 	    d_ptr->setFinished(retVal);
 
       
   540 	}
 
       
   541 	
   344     return retVal;
 
   542     return retVal;
 
   345 }
 
   543 }
 
   346 
   544 
   347 bool QMessageService::retrieveBody(const QMessageId& id)
 
   545 bool QMessageService::retrieveBody(const QMessageId& id)
 
   348 {
 
   546 {
 
   361 	bool retVal = true;
 
   559 	bool retVal = true;
 
   362 	d_ptr->_state = QMessageService::ActiveState;
 
   560 	d_ptr->_state = QMessageService::ActiveState;
 
   363 	emit stateChanged(d_ptr->_state);
 
   561 	emit stateChanged(d_ptr->_state);
 
   364 
   562 
   365 	retVal = d_ptr->retrieveBody(id);
 
   563 	retVal = d_ptr->retrieveBody(id);
 
   366 	
   564 	if (retVal == false) {
 
   367     d_ptr->setFinished(retVal);
 
   565         d_ptr->setFinished(retVal);
 
       
   566     }
 
       
   567 	
   368     return retVal;
 
   568     return retVal;
 
   369 }
 
   569 }
 
   370 
   570 
   371 bool QMessageService::retrieve(const QMessageId &messageId, const QMessageContentContainerId& id)
 
   571 bool QMessageService::retrieve(const QMessageId &messageId, const QMessageContentContainerId& id)
 
   372 {
 
   572 {
 
   385 	bool retVal = true;
 
   585 	bool retVal = true;
 
   386 	d_ptr->_state = QMessageService::ActiveState;
 
   586 	d_ptr->_state = QMessageService::ActiveState;
 
   387 	emit stateChanged(d_ptr->_state);
 
   587 	emit stateChanged(d_ptr->_state);
 
   388 
   588 
   389 	retVal = d_ptr->retrieve(messageId, id);
 
   589 	retVal = d_ptr->retrieve(messageId, id);
 
   390 	
   590     if (retVal == false) {
 
   391     d_ptr->setFinished(retVal);
 
   591         d_ptr->setFinished(retVal);
 
       
   592     }
 
       
   593 	
   392     return retVal;
 
   594     return retVal;
 
   393 }
 
   595 }
 
   394 
   596 
   395 bool QMessageService::show(const QMessageId& id)
 
   597 bool QMessageService::show(const QMessageId& id)
 
   396 {
 
   598 {
 
   433     bool retVal = true;
 
   635     bool retVal = true;
 
   434     d_ptr->_state = QMessageService::ActiveState;
 
   636     d_ptr->_state = QMessageService::ActiveState;
 
   435     emit stateChanged(d_ptr->_state);
 
   637     emit stateChanged(d_ptr->_state);
 
   436     
   638     
   437     retVal = d_ptr->exportUpdates(id);
 
   639     retVal = d_ptr->exportUpdates(id);
 
   438     
   640     if (retVal == false) {
 
   439     d_ptr->setFinished(retVal);
 
   641         d_ptr->setFinished(retVal);
 
       
   642     }
 
       
   643     
   440     return retVal;
 
   644     return retVal;
 
   441 }
 
   645 }
 
   442 
   646 
   443 QMessageService::State QMessageService::state() const
 
   647 QMessageService::State QMessageService::state() const
 
   444 {
 
   648 {
FCL/sf/mw/qtextensions