const int NmAgentMaxUnreadCount = 1; // 1 is enough

const int NmAgentIndicatorNotSet = -1;

    mIndicatorIndex = NmAgentIndicatorNotSet;

    mOutboxMails = 0;

    mInboxFolderId = 0;

    mOutboxFolderId = 0;

    mInboxCreatedMessages = 0;

    mInboxChangedMessages = 0;

    mInboxDeletedMessages = 0;

 mPluginFactory(NULL),

 mSendingState(false)

    Delayed start

*/

void NmMailAgent::delayedStart()

{

	NMLOG("NmMailAgent::delayedStart");

	if (!init()) {

		// Initialisation failed. Quit the agent.

		QCoreApplication::exit(1);

	}

}

/*!

	NMLOG("NmMailAgent::init");

    mPluginFactory = NmDataPluginFactory::instance();

    if (!mPluginFactory) {

        NMLOG("NmMailAgent::init PluginFactory not created");

    QList<QObject*> *plugins = mPluginFactory->pluginInstances();

    foreach (QObject *plugin, *plugins) {

    	if (plugin) {

			// Start listening events

			connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, const QList<NmId>&)),

				this, SLOT(handleMailboxEvent(NmMailboxEvent, const QList<NmId> &)),

				Qt::UniqueConnection);

			connect(plugin, SIGNAL(messageEvent(

					NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),

				this, SLOT(handleMessageEvent(

					NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),

				Qt::UniqueConnection);

			connect(plugin, SIGNAL(syncStateEvent(NmSyncState, const NmOperationCompletionEvent&)),

				this, SLOT(handleSyncStateEvent(NmSyncState, const NmOperationCompletionEvent&)),

				Qt::UniqueConnection);

			connect(plugin, SIGNAL(connectionEvent(NmConnectState, const NmId)),

				this, SLOT(handleConnectionEvent(NmConnectState, const NmId)),

				Qt::UniqueConnection);

    	}

    }

    NmDataPluginFactory::releaseInstance(mPluginFactory);

    QList<QObject*> *plugins = mPluginFactory->pluginInstances();

    foreach(QObject* pluginObject, *plugins) {

        NmDataPluginInterface *plugin =

            mPluginFactory->interfaceInstance(pluginObject);

        if (plugin) {

            plugin->listMailboxes(mailboxes);

        }

        // Add the indicators

        // Must be made in reverse order to show them properly in

        // HbIndicator menu

        QListIterator<NmMailbox *> i(mailboxes);

        i.toBack();

        while (i.hasPrevious()) {

            const NmMailbox *mailbox = i.previous();

            if (mailbox) {

                NmMailboxInfo *mailboxInfo = createMailboxInfo(*mailbox,plugin);

                if (mailboxInfo) {

                    mailboxInfo->mUnreadMails = getUnreadCount(mailbox->id(),NmAgentMaxUnreadCount);

                    mailboxInfo->mOutboxMails = getOutboxCount(mailbox->id());

                    // Create indicator for visible mailboxes

                    updateMailboxState(mailbox->id(),

                        isMailboxActive(*mailboxInfo),

                        false);

                }

        qDeleteAll(mailboxes);

    NmDataPluginInterface *plugin = mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

		// get inbox folder ID

		NmId inboxId = plugin->getStandardFolderId(

				mailboxId, NmFolderInbox );

		// get list of messages in inbox

		QList<NmMessageEnvelope*> messageList;

		plugin->listMessages(mailboxId, inboxId, messageList);

		foreach (const NmMessageEnvelope* envelope, messageList) {

			// if the message is not read, it is "unread"

			if (!envelope->isRead()) {

				count++;

				// No more unread mails are needed

				if (count >= maxCount) {

					break;

				}

			}

		}

		qDeleteAll(messageList);

    Get mailbox count in outbox folder

    \param mailboxId id of the mailbox

    \param maxCount max number of outbox mails that is needed

    \return number of mails in the outbox

int NmMailAgent::getOutboxCount(const NmId &mailboxId)

    NMLOG("NmMailAgent::getOutboxCount");

    int count(0);

    NmDataPluginInterface *plugin = mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

		// get outbox folder ID

		NmId outboxId = plugin->getStandardFolderId( mailboxId, NmFolderOutbox );

		// get list of messages in outbox

		QList<NmMessageEnvelope*> messageList;

		plugin->listMessages(mailboxId, outboxId, messageList);

		count = messageList.count();

		qDeleteAll(messageList);

    }

    NMLOG(QString("NmMailAgent::getOutboxCount count=%1").arg(count));

    return count;

    Update the mailbox visibility and status

    \param refreshAlways true when the indicator should be always updated

bool NmMailAgent::updateMailboxState(const NmId &mailboxId,

    bool active, bool refreshAlways)

    // Update the global sending state

    mSendingState = false;

    foreach (NmMailboxInfo *mailboxInfo, mMailboxes) {

        if (mailboxInfo->mOutboxMails>0) {

            mSendingState = true;

            break;

        }

    }

    if (mailboxInfo->mActive != active ||

        refreshAlways) {

            // Mailbox is not yet assigned to any indicator

            if (mailboxInfo->mIndicatorIndex < 0) {

                mailboxInfo->mIndicatorIndex = getIndicatorIndex();

            }

            updateIndicator(true,*mailboxInfo);

        }

        else {

            // Indicator not anymore active. Release it.

            if (mailboxInfo->mIndicatorIndex>=0) {

                updateIndicator(false,*mailboxInfo);

                mailboxInfo->mIndicatorIndex = NmAgentIndicatorNotSet;

            }

    if (mailboxInfo.mUnreadMails>0 || mailboxInfo.mOutboxMails>0) {

bool NmMailAgent::updateIndicator(bool active,

        arg(mailboxInfo.mIndicatorIndex).arg(active).arg(mailboxInfo.mUnreadMails));

    QString name = QString("com.nokia.nmail.indicatorplugin_%1/1.0").

        arg(mailboxInfo.mIndicatorIndex);

    list.append(mailboxInfo.mOutboxMails);

    list.append(mSendingState);

    Get next free indicator index, starting from 0

    @return index of the indicator that is available

 */

int NmMailAgent::getIndicatorIndex()

{

    int index = 0;

    bool found(false);

    do {

        found = false;

        foreach (NmMailboxInfo *mailbox, mMailboxes) {

            if (mailbox->mIndicatorIndex == index &&

                mailbox->mActive) {

                found = true;

                index++;

            }

        }

    }

    while( found );

    return index;

}

/*!

                NmDataPluginInterface *plugin = mPluginFactory->interfaceInstance(mailboxId);

                if (plugin) {

					plugin->getMailboxById(mailboxId,mailbox);

                }

                        if (mailboxInfo->mActive) {

                            // Update the status of the mailbox

                            updateMailboxState(mailboxId, true, true);

                        }

                // Will hide also the indicator

                removeMailboxInfo(mailboxId);

    \sa NmFrameworkAdapter

    bool updateNeeded = false;

        case NmMessageCreated: {

            NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId);

            if (folderId==mailboxInfo->mInboxFolderId) {

                mailboxInfo->mInboxCreatedMessages++;

            }

            // When created a new mail in the outbox, we are in sending state

            if (mailboxInfo->mOutboxFolderId == folderId) {

                // The first mail created in the outbox

                if (mailboxInfo->mOutboxMails <= 0) {

                    updateNeeded = true;

                }

                mailboxInfo->mOutboxMails += messageIds.count();

            }

            break;

        }

            if (folderId==mailboxInfo->mInboxFolderId) {

                mailboxInfo->mInboxChangedMessages++;

            }

                // check the unread status again

                mailboxInfo->mUnreadMails = getUnreadCount(mailboxId,NmAgentMaxUnreadCount);

                updateNeeded = true;

        case NmMessageDeleted: {

            NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId);

            if (folderId==mailboxInfo->mInboxFolderId) {

                mailboxInfo->mInboxDeletedMessages++;

            }

            // Deleted mails from the outbox

            if (mailboxInfo->mOutboxFolderId == folderId) {

                mailboxInfo->mOutboxMails -= messageIds.count();

                // Sanity check for the outbox count

                if (mailboxInfo->mOutboxMails < 0) {

                    mailboxInfo->mOutboxMails = 0;

                }

                // The last mail was now deleted

                if (mailboxInfo->mOutboxMails == 0) {

                    updateNeeded = true;

                }

            }

            break;

        }

    if (updateNeeded) {

        NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId);

        updateMailboxState(mailboxId,

            isMailboxActive(*mailboxInfo), true /* force refresh */);

    }

    \sa NmFrameworkAdapter

            const NmOperationCompletionEvent &event)

    NMLOG(QString("NmMailAgent::handleSyncStateEvent %1 %2").arg(state).arg(event.mMailboxId.id()));

    NmMailboxInfo *info = getMailboxInfo(event.mMailboxId);

        if (state==Synchronizing) {

            // Reset counters when sync is started

            info->mInboxCreatedMessages = 0;

            info->mInboxChangedMessages = 0;

            info->mInboxDeletedMessages = 0;

        } 

        else if (state==SyncComplete) {

            // Check the unread status here again

            info->mUnreadMails = getUnreadCount(event.mMailboxId,NmAgentMaxUnreadCount);

            // Refresh the indicator if messages created or changed

            NMLOG(QString(" created=%1, changed=%1, deleted=%1").

                arg(info->mInboxCreatedMessages).

                arg(info->mInboxChangedMessages).

                arg(info->mInboxDeletedMessages));

            bool refresh = (info->mInboxCreatedMessages > 0) || (info->mInboxChangedMessages > 0);

            updateMailboxState(event.mMailboxId, isMailboxActive(*info), refresh);