/*

#include "emailtrace.h"

#include "nmmailagentheaders.h"

#include "nmmailagent.h"

#include <xqaiwdeclplat.h>

#include <xqapplicationmanager.h>

#include <xqaiwrequest.h>

#include <xqsettingsmanager.h>

#include <xqcentralrepositoryutils.h>

#include <xqsystemtoneservice.h>

#include <xqsettingskey.h>

#include <ProfileEngineInternalCRKeys.h>

const int NmAgentIndicatorNotSet = -1;

const int NmAgentAlertToneTimer = 60000; // 60s

const int NmAgentDefaultVibraDuration = 1000; // 1 second

static const quint32 NmRepositoryId = 0x2002C326;

static const QString NmMailboxIndicatorType = "com.nokia.nmail.indicatorplugin_%1/1.0";

static const QString NmSendIndicatorName = "com.nokia.nmail.indicatorplugin.send/1.0";

static const QString NmUnreadIndicatorName = "com.nokia.nmail.indicatorplugin.unread/1.0";

const XQCentralRepositorySettingsKey NmSilenceModeKey(KCRUidProfileEngine.iUid, KProEngSilenceMode);

const int NmSilenceModeOn = 1;

/*!

    Helper method for finding out if XQSettingsKey and XQCentralRepositorySettingsKey points to

    same key.

bool keysEqual(const XQSettingsKey& settingKey, const XQCentralRepositorySettingsKey& cenrepSettingKey)

{

    return ((settingKey.target() == cenrepSettingKey.target()) &&

}

/*!

    \class NmMailAgent

NmMailAgent::NmMailAgent() :

/*!

void NmMailAgent::delayedStart()

{

    NM_FUNCTION;

}

/*!

bool NmMailAgent::init()

{

    NM_FUNCTION;

    mPluginFactory = NmDataPluginFactory::instance();

    if (!mPluginFactory) {

        NM_ERROR(1,"NmMailAgent::init(): PluginFactory not created");

        return false;

    }

    // Check status of silent mode.

    delete mSettingManager;

    mSettingManager = NULL;

    mSettingManager = new XQSettingsManager();

    QVariant silenceMode = mSettingManager->readItemValue(NmSilenceModeKey,

        XQSettingsManager::TypeInt);

    mSilenceMode = silenceMode.toInt();

    // Start monitoring silence mode key.

    bool monitoring(mSettingManager->startMonitoring(NmSilenceModeKey, XQSettingsManager::TypeInt));

    monitoring &= connect(mSettingManager,

                          this,

                          Qt::UniqueConnection);

    // If silence mode monitoring can't be started, then change silence mode on to be sure

    // that no tone is played if silence mode is turned on at somepoint.

    if (!monitoring) {

        mSilenceMode = NmSilenceModeOn;

    }

    delete mSystemTone;

    mSystemTone = NULL;

    mSystemTone = new XQSystemToneService();

    delete mIndicator;

    mIndicator = NULL;

    mIndicator = new HbIndicator();

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

    foreach (QObject *plugin, *plugins) {

    }

    // Construct the vibra interface instance.

    delete mVibra;

    mVibra = NULL;

    TRAP_IGNORE(mVibra = CHWRMVibra::NewL());

    // load all current mailboxes

    initMailboxStatus();

    return true;

}

NmMailAgent::~NmMailAgent()

{

    NM_FUNCTION;

    delete mVibra;

    delete mSystemTone;

    if (mSettingManager) {

        mSettingManager->stopMonitoring(NmSilenceModeKey);

        delete mSettingManager;

    }

    qDeleteAll(mMailboxes);

    NmDataPluginFactory::releaseInstance(mPluginFactory);

}

/*!

void NmMailAgent::initMailboxStatus()

{

    NM_FUNCTION;

    QList<NmMailbox*> mailboxes;

    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) {

                if (mailboxInfo) {

                    bool activate = updateUnreadCount(mailbox->id(), *mailboxInfo);

                    bool wasActive = isMailboxActive(mailbox->id());

                    if (activate) {

                            // do not activate the mailbox if it was left as hidden last time

                            activate = false;

                        }

                        else {

                            // otherwise, activate the mailbox and show inbox state

                            mailboxInfo->mInboxActive = true;

                        }

                    }

                    if (mailboxInfo->mOutboxMails > 0 && wasActive) {

                        activate = true;

                    }

                }

            }

        }

        qDeleteAll(mailboxes);

    }

    updateUnreadIndicator();

    updateSendIndicator();

}

/*!

    \param mailboxId id of the mailbox

    \param mailboxInfo contains the list of unread messages

    \return true if new unread mails was found

bool NmMailAgent::updateUnreadCount(const NmId &mailboxId, NmMailboxInfo &mailboxInfo)

{

    NM_FUNCTION;

    int newUnreadMessages(0);

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

    if (plugin) {

        mailboxInfo.mUnreadMailIdList = newUnreadMessageIdList;

    }

    NM_COMMENT(QString("NmMailAgent::getUnreadCount(): count=%1, new=%2").

        arg(mailboxInfo.mUnreadMailIdList.count()).arg(newUnreadMessages));

    return (newUnreadMessages > 0);

}

/*!

    \param mailboxId id of the mailbox

    \return number of mails in the outbox

{

    NM_FUNCTION;

    int count(0);

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

    if (plugin) {

    }

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

    return count;

}

/*!

	\returns total number of unread mails

int NmMailAgent::getTotalUnreadCount() const

{

    NM_FUNCTION;

    int unreads = 0;

    foreach (const NmMailboxInfo *mailbox, mMailboxes) {

        if (mailbox->mActive && mailbox->mInboxActive) {

            unreads += mailbox->mUnreadMailIdList.count();

        }

    }

    return unreads;

}

/*!

    \return true if the indicator was activated

bool NmMailAgent::updateUnreadIndicator()

{

    NM_FUNCTION;

    int unreads = getTotalUnreadCount();

    return updateUnreadIndicator(unreads>0);

}

/*!

    \param mailboxId id of the mailbox

    \param active visibility state of the mailbox

    \param refreshAlways true when the indicator should be always updated

    \return true if the mailbox state was changed

bool NmMailAgent::updateMailboxState(const NmId &mailboxId,

    bool active, bool refreshAlways)

{

    NM_FUNCTION;

    NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId);

    bool changed = false;

    if (mailboxInfo->mActive != active ||

        refreshAlways) {

        storeMailboxActive(mailboxId, active);

        mailboxInfo->mActive = active;

        changed = true;

        if (active) {

            // Mailbox is not yet assigned to any indicator

            if (mailboxInfo->mIndicatorIndex < 0) {

                mailboxInfo->mIndicatorIndex = getFreeIndicatorIndex();

            }

            updateIndicator(true,*mailboxInfo);

        }

        else {

            // Indicator not anymore active. Release it.

            if (mailboxInfo->mIndicatorIndex>=0) {

                updateIndicator(false,*mailboxInfo);

                mailboxInfo->mIndicatorIndex = NmAgentIndicatorNotSet;

            }

        }

    }

    return changed;

}

/*!

    \param mailboxIndex index of the item shown in indicator menu

    \param active indicator visibility state

    \param mailboxInfo information of the mailbox

    \return true if indicator was updated with no errors

bool NmMailAgent::updateIndicator(bool active,

    const NmMailboxInfo& mailboxInfo)

{

    NM_FUNCTION;

    NM_COMMENT(QString("NmMailAgent::updateIndicator(): index=%1, active=%2").

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

    bool ok = false;

    QString name = QString(NmMailboxIndicatorType).

        arg(mailboxInfo.mIndicatorIndex);

    QList<QVariant> list;

    list.append(mailboxInfo.mId.id());

    list.append(mailboxInfo.mName);

    list.append(mailboxInfo.mUnreadMailIdList.count());

    list.append(mailboxInfo.mSyncState);

    list.append(mailboxInfo.mConnectState);

    list.append(mailboxInfo.mOutboxMails);

    list.append(mailboxInfo.mIconName);

    list.append(mLastOutboxCount);

    if (active) {

        ok = mIndicator->activate(name,list);

    }

    else {

        ok = mIndicator->deactivate(name,list);

    }

    updateUnreadIndicator();

    return ok;

}

/*!

    \return true if the indicator was activated

bool NmMailAgent::updateUnreadIndicator(bool active)

{

    NM_FUNCTION;

    bool activated = false;

    if (active != mUnreadIndicatorActive) {

        if (active) {

            mIndicator->activate(NmUnreadIndicatorName);

            activated = true;

        }