diff -r e7aa27f58ae1 -r 578830873419 emailservices/nmclientapi/src/nmapiengine.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/emailservices/nmclientapi/src/nmapiengine.cpp	Fri Apr 16 14:51:52 2010 +0300
@@ -0,0 +1,336 @@
+/*
+ * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ * All rights reserved.
+ * This component and the accompanying materials are made available
+ * under the terms of "Eclipse Public License v1.0"
+ * which accompanies this distribution, and is available
+ * at the URL "http://www.eclipse.org/legal/epl-v10.html".
+ *
+ * Initial Contributors:
+ * Nokia Corporation - initial contribution.
+ *
+ * Contributors:
+ *
+ * Description:
+ *
+ */
+
+
+#include "nmapitypesconverter.h"
+#include "nmapidataplugininterface.h"
+#include "nmapidatapluginfactory.h"
+#include "nmapiengine.h"
+
+
+NmEngine *NmEngine::mInstance = NULL;
+quint32 NmEngine::mReferenceCount = 0;
+
+/*!
+ \class NmEngine
+ \brief The NmEngine class provides access to data for
+ mailboxes, folders and messages. If the dataplugin can't be loaded, fatal assert is called.
+
+ */
+
+/*!
+ Private constructor
+ */
+NmEngine::NmEngine() :
+    mFactory(NULL)
+{
+    mFactory = NmDataPluginFactory::instance();
+    Q_ASSERT(mFactory->pluginInstances()->count() > 0);
+}
+
+/*!
+ Destructor
+ */
+NmEngine::~NmEngine()
+{
+    NmDataPluginFactory::releaseInstance(mFactory);
+}
+
+/*!
+ * Creates instance of NmEngine and prvide pointer to it.
+ * 
+ * If engine exist, it increase references count and provide pointer to it.
+ * 
+ * \return Instance of engine
+ */
+NmEngine* NmEngine::instance()
+{
+    if (!mInstance) {
+        mInstance = new NmEngine();
+    }
+    mReferenceCount++;
+    return mInstance;
+}
+
+/*!
+ * Creates connections for events from email store.
+ */
+void NmEngine::startCollectingEvents()
+{
+    QList<QObject*>* pluginList = mFactory->pluginInstances();
+    for (int i = 0; i < pluginList->count(); i++) {
+        QObject* plugin = pluginList->at(i);
+
+        QObject::connect(plugin, SIGNAL(messageEvent(NmMessageEvent, NmId, QList<NmId> , NmId)),
+            this, SLOT(messageChangedArrived(NmMessageEvent, NmId, QList<NmId> , NmId)),
+            Qt::UniqueConnection);
+
+        connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, QList<NmId> )), this, SLOT(
+            mailboxChangedArrived(NmMailboxEvent, QList<NmId> )), Qt::UniqueConnection);
+
+    }
+
+}
+
+/*!
+ * It process mailbox ids from email store for given event.
+ * On end it emit \sa emailStoreEvent
+ * 
+ * \arg Event of mailbox change
+ * \arg List of mailbox ids for that event 
+ */
+void NmEngine::mailboxChangedArrived(NmMailboxEvent mailboxEvent, const QList<NmId> &mailboxIds)
+{
+    NmApiMessage message;
+    message.objectType = EMailbox;
+    switch (mailboxEvent) {
+        case NmMailboxCreated: {
+            message.action = ENew;
+        }
+            break;
+        case NmMailboxDeleted: {
+            message.action = EDeleted;
+        }
+            break;
+        case NmMailboxChanged: {
+            message.action = EChange;
+        }
+            break;
+        default:
+            break;
+    }
+
+    message.folderId = 0;
+    message.mailboxId = 0;
+
+    for (int i = 0; i < mailboxIds.count(); i++) {
+        message.objectIds.append(mailboxIds.at(i).id());
+    }
+
+    emit emailStoreEvent(message);
+}
+
+/*!
+ * It process message ids from email store for given event.
+ * On end it emit \sa emailStoreEvent
+ * 
+ * \arg Event of message change
+ * \arg List of message ids for that event 
+ */
+void NmEngine::messageChangedArrived(
+    NmMessageEvent messageEvent,
+    const NmId &folderId,
+    const QList<NmId> &messageIds,
+    const NmId &mailboxId)
+{
+    NmApiMessage message;
+    message.objectType = EMessage;
+    switch (messageEvent) {
+        case NmMessageCreated: {
+            message.action = ENew;
+        }
+            break;
+        case NmMessageDeleted: {
+            message.action = EDeleted;
+        }
+            break;
+        case NmMessageChanged: {
+            message.action = EChange;
+        }
+            break;
+        default:
+            break;
+    }
+
+    message.folderId = folderId.id();
+    message.mailboxId = mailboxId.id();
+
+    for (int i = 0; i < messageIds.count(); i++) {
+        message.objectIds.append(messageIds.at(i).id());
+    }
+
+    emit emailStoreEvent(message);
+}
+
+/*!
+ * Release instance of engine if there are not referenced objects. 
+ * If there are refenced objects it only decrease refenced count.
+ * 
+ * \arg Instance of engine
+ */
+void NmEngine::releaseInstance(NmEngine *&instance)
+{
+    //can't have passed out instances if we don't have any
+    if (mInstance) {
+        if (instance == mInstance) {
+            instance = NULL;
+            mReferenceCount--;
+        }
+        if (0 >= mReferenceCount) {
+            delete mInstance;
+            mInstance = NULL;
+        }
+    }
+}
+
+/*!
+ *    It get all mailboxes from email store
+ *    
+ *    \sa EmailClientApi::NmMailbox
+ *    \arg List of mailboxes to be filled.
+ */
+void NmEngine::listMailboxes(QList<EmailClientApi::NmMailbox> &mailboxList)
+{
+    QList<NmMailbox*> mailboxFromPlugin;
+    int count = mFactory->pluginInstances()->count();
+    for (int i = 0; i < count; i++) {
+        NmDataPluginInterface *instance = mFactory->interfaceInstance(
+            mFactory->pluginInstances()->at(i));
+        if (instance) {
+            instance->listMailboxes(mailboxFromPlugin);
+        }
+    }
+    while (mailboxFromPlugin.isEmpty() == false) {
+        NmMailbox* tempNmMailbox = mailboxFromPlugin.takeFirst();
+        mailboxList << NmToApiConverter::NmMailbox2ApiNmMailbox(*tempNmMailbox);
+        delete tempNmMailbox;
+    }
+}
+
+/*!
+ *    It get all folders from email store for given mailbox
+ *    
+ *    \sa EmailClientApi::NmFolder
+ *    \arg Mailbox id from where folders should be returned
+ *    \arg List of folders to be filled.
+ */
+void NmEngine::listFolders(const quint64 mailboxId, QList<EmailClientApi::NmFolder> &folderList)
+{
+    QList<NmFolder*> folderFromPlugin;
+    NmDataPluginInterface *instance = mFactory->interfaceInstance(mailboxId);
+    if (instance) {
+        instance->listFolders(mailboxId, folderFromPlugin);
+    }
+
+    while (folderFromPlugin.isEmpty() == false) {
+        NmFolder* tempNmFolder = folderFromPlugin.takeFirst();
+        folderList << NmToApiConverter::NmFolder2ApiNmFolder(*tempNmFolder);
+        delete tempNmFolder;
+    }
+}
+
+/*!
+ *    It get all envelopes from email store for given mailbox and folder
+ *    
+ *    \sa EmailClientApi::NmMessageEnvelope
+ *    \arg Mailbox id from where envelope should be returned
+ *    \arg Folder id from where envelope should be returned
+ *    \arg List of envelopes to be filled.
+ */
+void NmEngine::listEnvelopes(const quint64 mailboxId, const quint64 folderId, QList<
+    EmailClientApi::NmMessageEnvelope> &messageEnvelopeList)
+{
+    QList<NmMessageEnvelope*> envelopes;
+    NmDataPluginInterface *instance = mFactory->interfaceInstance(folderId);
+    if (instance) {
+        instance->listMessages(mailboxId, folderId, envelopes);
+    }
+
+    while (!envelopes.isEmpty()) {
+        NmMessageEnvelope* env = envelopes.takeFirst();
+
+        EmailClientApi::NmMessageEnvelope nmEnvelope =
+            NmToApiConverter::NmMessageEnvelope2ApiEnvelope(*env);
+        NmMessage* message = new NmMessage();
+        instance->getMessageById(mailboxId, folderId, nmEnvelope.id(), message);
+
+        QString plainText = QString();
+        if (message->plainTextBodyPart()) {
+            plainText = message->plainTextBodyPart()->textContent();
+        }
+
+        nmEnvelope.setPlainText(plainText);
+        nmEnvelope.setFetchedSize(message->fetchedSize());
+        nmEnvelope.setTotalSize(message->size());
+
+        messageEnvelopeList << nmEnvelope;
+        delete env;
+    }
+}
+
+/*!
+ * Return envelope given by mailbox, folder and envelope id.
+ * 
+ * \arg Mailbox id from where envlope should come
+ * \arg Folder id from where envlope should come
+ * \arg Id of envelope which should be returned
+ * \arg Envelope to fill.
+ * 
+ * \return Return true if it will find any envelope
+ */
+bool NmEngine::envelopeById(
+    const quint64 mailboxId,
+    const quint64 folderId,
+    const quint64 envelopeId,
+    EmailClientApi::NmMessageEnvelope& envelope)
+{
+    QList<EmailClientApi::NmMessageEnvelope> envelopes;
+    listEnvelopes(mailboxId, folderId, envelopes);
+
+    //flag indicating that envelope with given id was found
+    bool found = false;
+
+    for (int i = 0; i < envelopes.count(); i++) {
+        if (envelopes.at(i).id() == envelopeId) {
+            envelope = envelopes.at(i);
+            found = true;
+            break;
+        }
+    }
+
+    return found ? true : false;
+}
+
+/*!
+ * Return mailbox given by mailbox id.
+ * 
+ * \arg Id of Mailbox which should be returned
+ * \arg Mailbox to fill.
+ * 
+ * \return Return true if it will find any envelope
+ */
+bool NmEngine::mailboxById(const quint64 mailboxId, EmailClientApi::NmMailbox &mailbox)
+{
+    NmDataPluginInterface *instance = mFactory->interfaceInstance(mailboxId);
+
+    if (!instance) {
+        return false;
+    }
+
+    NmMailbox *nmmailbox;
+    instance->getMailboxById(NmId(mailboxId), nmmailbox);
+
+    if (!nmmailbox) {
+        return false;
+    }
+
+    mailbox = NmToApiConverter::NmMailbox2ApiNmMailbox(*nmmailbox);
+
+    return true;
+
+}
+