FCL/sf/app/commonemail: comparison emailuis/nmhswidget/src/nmhswidgetemailengine.cpp

equal deleted inserted replaced

-:6c59112cfd31
+:38bf5461e270
 #include "nmcommon.h"
 #include "nmmessageenvelope.h"
 #include "nmhswidgetemailengine.h"
 #include "nmdataplugininterface.h"
 #include "nmmailbox.h"
+#include "nmmessage.h"
 #include "nmfolder.h"
 #include "nmdatapluginfactory.h"
 #include "nmhswidgetconsts.h"
 #include "emailtrace.h"
+#include "nmhswidgetlistmodel.h"
 /*!
 Constructor
 */
 NmHsWidgetEmailEngine::NmHsWidgetEmailEngine(const NmId& monitoredMailboxId) :
 mFolderId(0),
 mAccountName(),
 mUnreadCount(-1),
 mEmailInterface(0),
 mFactory(0),
-mAccountEventReceivedWhenSuspended(false),
+mAccountDataNeedsUpdate(false),
-mMessageEventReceivedWhenSuspended(false),
+mMessageDataNeedsUpdate(false),
 mSuspended(false),
-mUpdateTimer(0),
 mAiwRequest(0)
 {
 NM_FUNCTION;
 }
 if (!constructNmPlugin()) {
 //if plugin connection fails, there's no reason to proceed
 return false;
 }
 updateData();
+updateUnreadCount();
 updateAccount();
-mUpdateTimer = new QTimer(this);
-mUpdateTimer->setInterval(NmHsWidgetEmailEngineUpdateTimerValue);
-connect(mUpdateTimer, SIGNAL(timeout()), this, SLOT(handleUpdateTimeout()) );
 return true;
 }
 /*!
 SLOT( handleMailboxEvent(NmMailboxEvent, const QList<NmId>&) ));
 return true;
 }
-/*!
-Reset envelope list
-\post mEnvelopeList.isEmpty() == true && all contained objects are deleted
-*/
-void NmHsWidgetEmailEngine::resetEnvelopeList()
-{
-NM_FUNCTION;
-while (!mEnvelopeList.isEmpty()) {
-delete mEnvelopeList.takeFirst();
-}
-}
 /*!
 Destructor
 */
 NmHsWidgetEmailEngine::~NmHsWidgetEmailEngine()
 {
 NM_FUNCTION;
-resetEnvelopeList();
 if (mFactory) {
 NmDataPluginFactory::releaseInstance(mFactory);
 }
-if (mUpdateTimer){
+}
-mUpdateTimer->stop();
-delete mUpdateTimer;
-}
-}
-/*!
-getEnvelopes() provides message envelopes as a list of stack objects
-Amount of message envelopes in the list parameter is the smallest of the following factors:
-'KMaxNumberOfEnvelopesProvided', 'maxEnvelopeAmount', 'amount of available envelopes'.
-\param list list to be filled with message envelopes
-\param maxEnvelopeAmount Client side limit for amount of message envelope count.
-\return count of envelopes added to list
-*/
-int NmHsWidgetEmailEngine::getEnvelopes(QList<NmMessageEnvelope*> &list, int maxEnvelopeAmount)
-{
-NM_FUNCTION;
-list.clear(); //Reset the parameter list to avoid side effects
-list.append(mEnvelopeList.mid(0, maxEnvelopeAmount));
-return list.count();
-}
 /*!
 UnreadCount
 \return count of unread mails, or -1 if there are no mails at all in the mailbox.
 {
 NM_FUNCTION;
 return mAccountName;
 }
-/*!
-Refresh email data.
+bool NmHsWidgetEmailEngine::updateUnreadCount()
-\post mEnvelopeList is refreshed with valid content so that it has
+{
-valid data with maximum of KMaxNumberOfEnvelopesProvided envelopes.
-- emits exceptionOccured(NmEngineExcFailure) if fatal error occurs.
-- emits mailDataChanged() if new mail data is set into mEnvelopeList
-- emits unreadCountChanged(mUnreadCount), if mUnreadCount is updated
-\return true if everything succeeded, otherwise false
-*/
-bool NmHsWidgetEmailEngine::updateData()
-{
-NM_FUNCTION;
-if (!mEmailInterface) {
-NM_ERROR(1,"NmHsWidgetEmailEngine::updateData() -- Interface missing");
-emit exceptionOccured(NmEngineExcFailure); //fatal error
-return false; //if interface is missing there's nothing to do
-}
-//reset envelope list before retrieving new items
-resetEnvelopeList();
-//get messages from inbox
-int msgErr = mEmailInterface->listMessages(mMailboxId, mFolderId, mEnvelopeList,
-KMaxNumberOfEnvelopesProvided);
-if (msgErr) {
-//retrieval of messages failed.
-return false;
-}
-//emit signal about new message data right away
-emit mailDataChanged();
 //retrieve new unread count to mUnreadCount
 NmFolder* folder = NULL;
 int folderErr = mEmailInterface->getFolderById(mMailboxId, mFolderId, folder);
 if (folderErr) {
 //retrieval of valid folder failed.
 return false;
 }
 if (folder) {
 //If messageCount in the folder is zero we must indicate unread count to be -1
-if (mEnvelopeList.count() == 0) {
+if (folder->messageCount() == 0) {
 mUnreadCount = -1;
 }
 else {
 mUnreadCount = folder->unreadMessageCount();
 }
 return false;
 }
 return true;
 }
+/*!
+* TODO: UPDATE THIS
+Refresh email data.
+\post mEnvelopeList is refreshed with valid content so that it has
+valid data with maximum of KMaxNumberOfEnvelopesProvided envelopes.
+- emits exceptionOccured(NmEngineExcFailure) if fatal error occurs.
+- emits mailDataChanged() if new mail data is set into mEnvelopeList
+- emits unreadCountChanged(mUnreadCount), if mUnreadCount is updated
+\return true if everything succeeded, otherwise false
+*/
+bool NmHsWidgetEmailEngine::updateData()
+{
+NM_FUNCTION;
+if (!mEmailInterface) {
+NM_ERROR(1,"NmHsWidgetEmailEngine::updateData() -- Interface missing");
+emit exceptionOccured(NmEngineExcFailure); //fatal error
+return false; //if interface is missing there's nothing to do
+}
+QList<NmMessageEnvelope*> envelopeList;
+//get messages from inbox
+int msgErr = mEmailInterface->listMessages(mMailboxId, mFolderId, envelopeList,
+KMaxNumberOfEnvelopesProvided);
+if (msgErr) {
+//retrieval of messages failed.
+return false;
+}
+//emit signal about new message data right away
+	emit mailDataRefreshed(envelopeList);
+return true;
+}
 /*!
 handleMessageEvent slot.
 */
 void NmHsWidgetEmailEngine::handleMessageEvent(
 NmMessageEvent event,
 const NmId &folderId,
 const QList<NmId> &messageIds,
 const NmId& mailboxId)
 {
 NM_FUNCTION;
-Q_UNUSED(event);
-Q_UNUSED(messageIds);
 if (!mEmailInterface) {
 NM_ERROR(1,"NmHsWidgetEmailEngine::handleMessageEvent() -- Interface missing");
 emit exceptionOccured(NmEngineExcFailure); //fatal error
 return; //if interface is missing there's nothing to do
 //so let's get the id now as we received first mail event
 mFolderId = mEmailInterface->getStandardFolderId(mMailboxId, NmFolderInbox);
 }
 if ((folderId == mFolderId) && (mailboxId == mMailboxId)) {
 //Data is updated only if the engine is not suspended
 if (mSuspended) {
-mMessageEventReceivedWhenSuspended = true;
+mMessageDataNeedsUpdate = true;
-}
+return; //no further actions
-else {
+}
-//start or restart the timer. Update is started when timer expires
+updateUnreadCount();
-mUpdateTimer->start();
+switch(event){
-}
+case(NmMessageCreated):
-}
+emit mailsReceived(getEnvelopesFromIds(messageIds));
-}
+break;
+case(NmMessageChanged):
+emit mailsUpdated(getEnvelopesFromIds(messageIds));
+break;
+case(NmMessageDeleted):
+emit mailsDeleted(messageIds);
+break;
+}
+}
+}
+QList<NmMessageEnvelope*> NmHsWidgetEmailEngine::getEnvelopesFromIds(const QList<NmId> messageIds)
+{
+NM_FUNCTION;
+QList<NmMessageEnvelope*> ret;
+foreach(NmId id, messageIds){
+NmMessageEnvelope *msgEnvelope = NULL;
+msgEnvelope = envelopeById(id);
+if(msgEnvelope){
+ret.append(msgEnvelope);
+}
+}
+return ret;
+}
+/*!
+Get new NmMessageEnvelope object by id \a messageId from any folder.
+Ownership is transferred to the caller. NULL pointer is returned if
+message id is not found.
+*/
+NmMessageEnvelope *NmHsWidgetEmailEngine::envelopeById(const NmId &messageId)
+{
+NM_FUNCTION;
+NmMessageEnvelope *msgEnvelope(NULL);
+NmMessage *newMessageObject(NULL);
+int retVal(NmNotFoundError);
+retVal = mEmailInterface->getMessageById(mMailboxId, mFolderId, messageId, newMessageObject);
+if (retVal < NmNoError || !newMessageObject) {
+// Return null object if fetching failed
+delete newMessageObject;
+newMessageObject = NULL;
+return NULL;
+}
+msgEnvelope = new NmMessageEnvelope(newMessageObject->envelope());
+delete newMessageObject;
+newMessageObject = NULL;
+return msgEnvelope;
+}
 /*!
 handleFolderEvent slot.
 If the monitored folder is deleted, clear the envelope list and unread count.
 Also the mFolderId is set to 0 to indicate the current state so that in device boot up
 {
 NM_FUNCTION;
 //react only if the monitored folder for monitored account is deleted
 if (event == NmFolderIsDeleted && mailboxId == mMailboxId && folderIds.contains(mFolderId) )
 {
-resetEnvelopeList();    //cached envelopes to be cleared
+emit mailDataCleared(); //emit mail data clearance
 mUnreadCount = 0;       //unread count to 0
 mFolderId = NmId(0);    //folder id to zero (indicates the situation where folder is not available)
-emit mailDataChanged(); //emit data change for UI
 emit unreadCountChanged(mUnreadCount); // emit unread count change to UI
 }
 }
 NM_FUNCTION;
 if (mailboxIds.contains(mMailboxId)) {
 switch (event) {
 case (NmMailboxChanged): {
 if (mSuspended) {
-mAccountEventReceivedWhenSuspended = true;
+mAccountDataNeedsUpdate = true;
 }
 else {
 updateAccount();
 }
 break;
 break;
 }
 }
 }
-/*!
-* handleUpdateTimeout slot
-*/
-void NmHsWidgetEmailEngine::handleUpdateTimeout()
-{
-NM_FUNCTION;
-if (mUpdateTimer){
-mUpdateTimer->stop();
-}
-updateData();
-}
 /*!
 Update Account data
 \post if mEmailInterface exists, the mAccountName is refreshed from adapter
 and accountNameChanged signal is emitted.
 emit accountNameChanged(mAccountName);
 }
 return true;
 }
+/*!
+forceUpdate slot.
+\post If engine is not suspended, this will force full update immediately.
+*/
+void NmHsWidgetEmailEngine::forceUpdate()
+{
+NM_FUNCTION;
+if(mSuspended){
+mMessageDataNeedsUpdate = true; //this is enough to force update when activated
+}else{
+updateData();
+updateUnreadCount();
+}
+}
 /*!
 suspend slot.
 \post engine will not emit signals or refresh its data during suspension.
 */
 void NmHsWidgetEmailEngine::suspend()
 */
 void NmHsWidgetEmailEngine::activate()
 {
 NM_FUNCTION;
 mSuspended = false;
-if (mAccountEventReceivedWhenSuspended) {
+if (mAccountDataNeedsUpdate) {
-mAccountEventReceivedWhenSuspended = false;
+mAccountDataNeedsUpdate = false;
 updateAccount();
 }
-if (mMessageEventReceivedWhenSuspended) {
+if (mMessageDataNeedsUpdate) {
-mMessageEventReceivedWhenSuspended = false;
+mMessageDataNeedsUpdate = false;
 updateData();
-}
+updateUnreadCount();
 }
+}
 /*!
 launchMailAppInboxView slot.
 \post Mail application is launched to inbox view corresponding widget's mailbox id
 */

changeset 76	38bf5461e270
parent 74	6c59112cfd31