/*
* Copyright (c) 2010 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 <QVariant>
#include <QList>
#include <xqconversions.h>
#include <xqsettingsmanager.h>
#include <xqcentralrepositoryutils.h>
#include <xqcentralrepositorysearchcriteria.h>
#include <pop3set.h>
#include <imapset.h>
#include <smtpset.h>
#include <iapprefs.h>
#include "ipssettingkeys.h"
#include "nmapiheaders.h"
#include <nmapisettingsmanager.h>
#include "nmapisettingsmanager_p.h"
namespace EmailClientApi
{
NmApiSettingsManagerPrivate::NmApiSettingsManagerPrivate(const quint64 mailboxId)
: mAccount(0),
mPop3Settings(0),
mImap4Settings(0),
mSmtpSettings(0),
mMailboxOffset(-1),
mMailboxId(0)
{
QT_TRAP_THROWING(mAccount = CEmailAccounts::NewL());
mMailboxId = (quint32)mailboxId;
mQSettingsManager = new XQSettingsManager();
Q_CHECK_PTR(mQSettingsManager);
checkAccountType();
QT_TRAP_THROWING(initAccountL());
calculateMailboxOffset();
}
NmApiSettingsManagerPrivate::~NmApiSettingsManagerPrivate()
{
delete mPop3Settings;
delete mImap4Settings;
delete mSmtpSettings;
delete mQSettingsManager;
delete mAccount;
}
/*!
Loads QMail specific settings.
\param mailboxId which settings are returned
\param data consists of keys and values of settings.
\return bool <true> when the setting items were found otherwise <false>.
*/
bool NmApiSettingsManagerPrivate::load(quint64 mailboxId, NmApiMailboxSettingsData &data)
{
mMailboxId = mailboxId;
return (readSetting(data) && readCenRepSetting(data));
}
/*!
Saves QMail specific settings.
\param data consists of keys and values of settings.
\return bool <true> when the setting items were successfully saved otherwise <false>.
*/
bool NmApiSettingsManagerPrivate::save(const NmApiMailboxSettingsData &data)
{
TInt err(KErrNone);
TRAP(err, writeSettingL(data));
return (!err && writeSettingToCenRep(data));
}
/*!
Finds and returns the SMTP specific setting.
\param settingItem SettingItem enum of the setting to return
\param QVariant SettingValue of the found setting value.
\return bool <true> when the setting item was found otherwise <false>.
*/
bool NmApiSettingsManagerPrivate::readSetting(NmApiMailboxSettingsData &data)
{
if (mMailboxType == NmApiMailboxTypePop) {
data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mPop3Settings->LoginName()));
data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mPop3Settings->Password()));
data.setValue(MailboxName, XQConversions::s60DescToQString(mPop3Account.iPopAccountName));
data.setValue(IncomingMailServer, XQConversions::s60DescToQString(mPop3Settings->ServerAddress()));
#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)
data.setValue(IncomingMailUsesAuthentication, mPop3Settings->POP3Auth());
#endif
data.setValue(IncomingPort, mPop3Settings->Port());
}
else if (mMailboxType == NmApiMailboxTypeImap) {
data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mImap4Settings->LoginName()));
data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mImap4Settings->Password()));
data.setValue(MailboxName, XQConversions::s60DescToQString(
mImap4Account.iImapAccountName));
data.setValue(IncomingMailServer, XQConversions::s60DescToQString(
mImap4Settings->ServerAddress()));
#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)
data.setValue(IncomingMailUsesAuthentication, mImap4Settings->IAMP4Auth());
#endif
data.setValue(IncomingPort, mImap4Settings->Port());
data.setValue(FolderPath, XQConversions::s60Desc8ToQString(mImap4Settings->FolderPath()));
}
data.setValue(IncomingMailSecurityType, security());
data.setValue(MyName, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));
data.setValue(EmailAlias, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));
data.setValue(EmailAddress, XQConversions::s60DescToQString(mSmtpSettings->EmailAddress()));
data.setValue(ReplyAddress, XQConversions::s60DescToQString(mSmtpSettings->ReplyToAddress()));
data.setValue(OutgoingMailServer, XQConversions::s60DescToQString(mSmtpSettings->ServerAddress()));
data.setValue(OutgoingPort, mSmtpSettings->Port());
data.setValue(OutgoingLoginName, XQConversions::s60Desc8ToQString(mSmtpSettings->LoginName()));
data.setValue(OutgoingPassword, XQConversions::s60Desc8ToQString(mSmtpSettings->Password()));
data.setValue(UseOutgoingAuthentication, mSmtpSettings->SMTPAuth());
data.setValue(OutgoingMailUsesAuthentication, mSmtpSettings->SMTPAuth());
data.setValue(OutgoingSecureSockets, mSmtpSettings->SecureSockets());
data.setValue(OutgoingSSLWrapper, mSmtpSettings->SSLWrapper());
data.setValue(OutgoingMailSecurityType, XQConversions::s60Desc8ToQString(mSmtpSettings->TlsSslDomain()));
return true;
}
bool NmApiSettingsManagerPrivate::readCenRepSetting(NmApiMailboxSettingsData &data)
{
bool ret = true;
QVariant tmp;
data.setValue(DownloadPictures, readFromCenRep(IpsServices::EmailKeyPreferenceDownloadPictures));
data.setValue(MessageDivider, readFromCenRep(IpsServices::EmailKeyPreferenceMessageDivider));
tmp = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);
switch(tmp.toInt()){
case 0:
data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);
break;
case 1:
data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetSE);
break;
case 2:
data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetMF);
break;
case 3:
data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetUD);
break;
default:
data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);
break;
};
data.setValue(ReceptionUserDefinedProfile, readFromCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile));
data.setValue(ReceptionInboxSyncWindow, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionInboxSyncWindow));
data.setValue(ReceptionGenericSyncWindowInMessages, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionGenericSyncWindowInMessages));
data.setValue(ReceptionWeekDays, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionWeekDays));
data.setValue(ReceptionDayStartTime, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionDayStartTime));
data.setValue(ReceptionDayEndTime, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionDayEndTime));
data.setValue(ReceptionRefreshPeriodDayTime, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionRefreshPeriodDayTime));
data.setValue(ReceptionRefreshPeriodOther, readFromCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionRefreshPeriodOther));
data.setValue(UserNameHidden, readFromCenRep(IpsServices::EmailKeyUserNameHidden));
data.setValue(EmailNotificationState, readFromCenRep(IpsServices::EmailKeyEMNState));
data.setValue(FirstEmnReceived, readFromCenRep(IpsServices::EmailKeyFirstEmnReceived));
data.setValue(EmnReceivedNotSynced, readFromCenRep(IpsServices::EmailKeyEmnReceivedNotSynced));
QString aolState = alwaysOnlineState();
if(aolState.length()>0)
data.setValue(AlwaysOnlineState, aolState);
data.setValue(AoLastSuccessfulUpdate, readFromCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL));
data.setValue(AoLastUpdateFailed, readFromCenRep(IpsServices::EmailKeyAoLastUpdateFailed));
data.setValue(AoUpdateSuccessfulWithCurSettings, readFromCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings));
return ret;
}
/*!
Writes POP3/IMAP4 specific settings.
\param data consists of keys and values of settings.
*/
bool NmApiSettingsManagerPrivate::writeSettingL(const NmApiMailboxSettingsData &data)
{
HBufC *tmp = 0;
HBufC8 *tmp8 = 0;
bool ret(false);
int key;
QVariant settingValue;
QList<int> keylist;
bool aliasSet = false;
keylist = data.listSettings();
for (int i = 0; i < keylist.size(); i++) {
key = keylist[i];
data.getValue(key, settingValue);
switch (key) {
case IncomingLoginName: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetLoginNameL(*tmp8);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetLoginNameL(*tmp8);
}
delete tmp8;
break;
}
case IncomingPassword: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetPasswordL(*tmp8);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetPasswordL(*tmp8);
}
delete tmp8;
break;
}
case MailboxName: {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Account.iPopAccountName.Copy(*tmp);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Account.iImapAccountName.Copy(*tmp);
}
delete tmp;
break;
}
case IncomingMailServer: {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetServerAddressL(*tmp);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetServerAddressL(*tmp);
}
delete tmp;
break;
}
case IncomingMailUsesAuthentication: {
#if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetPOP3Auth(settingValue.toBool());
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetIAMP4Auth(settingValue.toBool());
}
#endif
break;
}
case IncomingMailSecurityType: {
setSecurity(settingValue.toString());
break;
}
case IncomingPort: {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetPort(settingValue.toInt());
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetPort(settingValue.toInt());
}
break;
}
case OutgoingPort: {
mSmtpSettings->SetPort(settingValue.toInt());
break;
}
case IncomingSecureSockets: {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetSecureSockets(settingValue.toBool());
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetSecureSockets(settingValue.toBool());
}
break;
}
case IncomingSSLWrapper: {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetSSLWrapper(settingValue.toBool());
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings->SetSSLWrapper(settingValue.toBool());
}
break;
}
case EmailAddress: {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
mSmtpSettings->SetEmailAddressL(*tmp);
break;
}
case ReplyAddress: {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
mSmtpSettings->SetReplyToAddressL(*tmp);
break;
}
case EmailAlias: {
QVariant tmpName;
if(data.getValue(MyName,tmpName)) {
if(tmpName.toString()
==XQConversions::s60DescToQString(mSmtpSettings->EmailAlias())) {
aliasSet = true;
}
}
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
mSmtpSettings->SetEmailAliasL(*tmp);
break;
}
case MyName: {
if(!aliasSet) {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
mSmtpSettings->SetEmailAliasL(*tmp);
}
break;
}
case OutgoingMailServer: {
tmp = XQConversions::qStringToS60Desc(settingValue.toString());
mSmtpSettings->SetServerAddressL(*tmp);
break;
}
case OutgoingLoginName: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
mSmtpSettings->SetLoginNameL(*tmp8);
break;
}
case OutgoingPassword: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
mSmtpSettings->SetPasswordL(*tmp8);
break;
}
case UseOutgoingAuthentication:
case OutgoingMailUsesAuthentication: {
mSmtpSettings->SetSMTPAuth(settingValue.toBool());
break;
}
case OutgoingSecureSockets: {
mSmtpSettings->SetSecureSockets(settingValue.toBool());
break;
}
case OutgoingSSLWrapper: {
mSmtpSettings->SetSSLWrapper(settingValue.toBool());
break;
}
case OutgoingMailSecurityType: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
mSmtpSettings->SetTlsSslDomainL(*tmp8);
break;
}
case FolderPath: {
tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());
mImap4Settings->SetFolderPathL(*tmp8);
break;
}
default: {
break;
}
};
}
ret = saveSettings();
return ret;
}
/*!
Writes settings to central repository.
\param data consists of keys and values of settings.
*/
bool NmApiSettingsManagerPrivate::writeSettingToCenRep(
const NmApiMailboxSettingsData &data)
{
int key;
QVariant settingValue;
QList<int> keylist;
keylist = data.listSettings();
bool ret = false;
if(keylist.contains(ReceptionActiveProfile)) {
data.getValue(ReceptionActiveProfile,settingValue);
QVariant profileOffset = 0;
if(settingValue.toString() == EmailClientApi::EmailProfileOffsetKUTD) {
profileOffset=0;
} else if(settingValue.toString() == EmailClientApi::EmailProfileOffsetSE){
profileOffset = 1;
} else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetMF){
profileOffset = 2;
} else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetUD) {
profileOffset = 3;
}
ret = writeToCenRep(IpsServices::EmailKeyReceptionActiveProfile, profileOffset);
if(ret) {
calculateActiveProfileOffset();
}
}
if (ret) {
for (int i = 0; i < keylist.size(); i++) {
key = keylist[i];
data.getValue(key, settingValue);
switch (key) {
case DownloadPictures: {
ret = writeToCenRep(IpsServices::EmailKeyPreferenceDownloadPictures,
settingValue);
break;
}
case MessageDivider: {
ret = writeToCenRep(IpsServices::EmailKeyPreferenceMessageDivider, settingValue);
break;
}
case ReceptionUserDefinedProfile: {
ret = writeToCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile,
settingValue);
break;
}
case ReceptionInboxSyncWindow: {
ret = writeToCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionInboxSyncWindow, settingValue);
break;
}
case ReceptionGenericSyncWindowInMessages: {
ret = writeToCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionGenericSyncWindowInMessages, settingValue);
break;
}
case ReceptionWeekDays: {
ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionWeekDays,
settingValue);
break;
}
case ReceptionDayStartTime: {
ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayStartTime,
settingValue);
break;
}
case ReceptionDayEndTime: {
ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayEndTime,
settingValue);
break;
}
case ReceptionRefreshPeriodDayTime: {
ret = writeToCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionRefreshPeriodDayTime, settingValue);
break;
}
case ReceptionRefreshPeriodOther: {
ret = writeToCenRep(mActiveProfileOffset
+ IpsServices::EmailKeyReceptionRefreshPeriodOther, settingValue);
break;
}
case UserNameHidden: {
ret = writeToCenRep(IpsServices::EmailKeyUserNameHidden, settingValue);
break;
}
case EmailNotificationState: {
ret = writeToCenRep(IpsServices::EmailKeyEMNState, settingValue);
break;
}
case FirstEmnReceived: {
ret = writeToCenRep(IpsServices::EmailKeyFirstEmnReceived, settingValue);
break;
}
case EmnReceivedNotSynced: {
ret = writeToCenRep(IpsServices::EmailKeyEmnReceivedNotSynced, settingValue);
break;
}
case AlwaysOnlineState: {
setAlwaysOnlineState(settingValue);
break;
}
case AoLastSuccessfulUpdate: {
ret = writeToCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL, settingValue);
break;
}
case AoLastUpdateFailed: {
ret = writeToCenRep(IpsServices::EmailKeyAoLastUpdateFailed, settingValue);
break;
}
case AoUpdateSuccessfulWithCurSettings: {
ret = writeToCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings,
settingValue);
break;
}
case ReceptionActiveProfile:
default: {
break;
}
};
}
}
return ret;
}
/*!
Stores the POP3/IMAP4 specific settings.
\return bool <true> when the settings were succesfully written, otherwise <false>.
*/
bool NmApiSettingsManagerPrivate::saveSettings()
{
bool ret(false);
if (mMailboxType == NmApiMailboxTypePop) {
TRAPD(err, mAccount->SavePopSettingsL(mPop3Account, *mPop3Settings));
if (err == KErrNone) {
ret = true;
}
}
else if (mMailboxType == NmApiMailboxTypeImap) {
TRAPD(err, mAccount->SaveImapSettingsL(mImap4Account, *mImap4Settings));
if (err == KErrNone) {
ret = true;
}
}
return ret;
}
/*!
Reads a key value from the Central Repository.
\param key Key identifier.
\return the settings value for the given key.
*/
QVariant NmApiSettingsManagerPrivate::readFromCenRep(quint32 key) const
{
XQCentralRepositorySettingsKey settingKey(IpsServices::EmailMailboxSettingRepository,
mMailboxOffset + key);
return mQSettingsManager->readItemValue(settingKey);
}
/*!
Writes a key value to the Central Repository.
\param key Key identifier.
\param value The settings value for the given key.
\return Returns <true> if the value was succesfully written, <false> if not.
*/
bool NmApiSettingsManagerPrivate::writeToCenRep(quint32 key, const QVariant &value) const
{
XQCentralRepositorySettingsKey settingKey(IpsServices::EmailMailboxSettingRepository,
mMailboxOffset + key);
return mQSettingsManager->writeItemValue(settingKey, value);
}
void NmApiSettingsManagerPrivate::setSecurity(QString securityType)
{
if (securityType == NmApiStartTls) {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetSecureSockets(ETrue);
mPop3Settings->SetSSLWrapper(EFalse);
}
else {
mImap4Settings->SetSecureSockets(ETrue);
mImap4Settings->SetSSLWrapper(EFalse);
}
}
else if (securityType == NmApiSSLTls) {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetSecureSockets(EFalse);
mPop3Settings->SetSSLWrapper(ETrue);
}
else {
mImap4Settings->SetSecureSockets(EFalse);
mImap4Settings->SetSSLWrapper(ETrue);
}
}
else {
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings->SetSecureSockets(EFalse);
mPop3Settings->SetSSLWrapper(EFalse);
}
else {
mImap4Settings->SetSecureSockets(EFalse);
mImap4Settings->SetSSLWrapper(EFalse);
}
}
}
QString NmApiSettingsManagerPrivate::security() const
{
bool ss(false);
bool sslw(false);
QString securityType("");
if (mMailboxType == NmApiMailboxTypePop) {
ss = mPop3Settings->SecureSockets();
sslw = mPop3Settings->SSLWrapper();
}
else {
ss = mImap4Settings->SecureSockets();
sslw = mImap4Settings->SSLWrapper();
}
if (ss == true && sslw == false) {
securityType = NmApiStartTls;
}
else if (ss == false && sslw == true) {
securityType = NmApiSSLTls;
}
else {
securityType = NmApiSecurityOff;
}
return securityType;
}
/*!
*/
QString NmApiSettingsManagerPrivate::alwaysOnlineState() const
{
TInt profile = IpsServices::EmailSyncProfileManualFetch;
QString ret = NmApiOff;
QVariant state;
TInt settingValue = -1;
state = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);
settingValue = state.toInt();
if (settingValue >= 0) {
profile = settingValue;
if (profile != IpsServices::EmailSyncProfileManualFetch) {
ret = NmApiAlways;
}
}
return ret;
}
/*!
*/
void NmApiSettingsManagerPrivate::setAlwaysOnlineState(const QVariant state)
{
//only allowed to switch state off, not on.
if (state.toString() == NmApiOff) {
writeToCenRep(IpsServices::EmailKeyReceptionActiveProfile,
IpsServices::EmailSyncProfileManualFetch);
}
}
void NmApiSettingsManagerPrivate::calculateMailboxOffset()
{
// Find all the keys that match the criteria 0xZZZZZ000, where Z=don't care.
// This will give us all the keys that hold the mailbox ids, e.g. 0x00001000, 0x00002000, etc.
quint32 partialKey(0x00000000);
quint32 bitMask(0x00000FFF);
XQCentralRepositorySearchCriteria criteria(IpsServices::EmailMailboxSettingRepository,
partialKey, bitMask);
// Set the mailbox id is value criteria for the search.
criteria.setValueCriteria((int) mMailboxId);
// Find the keys.
XQCentralRepositoryUtils utils(*mQSettingsManager);
QList<XQCentralRepositorySettingsKey> foundKeys = utils.findKeys(criteria);
// We should only get one key as a result.
if (foundKeys.count() == 1) {
mMailboxOffset = foundKeys[0].key();
calculateActiveProfileOffset();
}
else {
mActiveProfileOffset = -1;
mMailboxOffset = -1;
}
}
/*!
Calculates the active reception schedule profile offset.
*/
void NmApiSettingsManagerPrivate::calculateActiveProfileOffset()
{
QVariant activeProfile = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);
mActiveProfileOffset = convertToProfileOffset(activeProfile.toInt());
}
/*!
*/
qint32 NmApiSettingsManagerPrivate::convertToProfileOffset(int profile) const
{
quint32 profileOffset(0);
// Possible values are defined in ipssettingkeys.h
switch (profile) {
case 0: {
profileOffset = IpsServices::EmailProfileOffsetKUTD;
break;
}
case 1: {
profileOffset = IpsServices::EmailProfileOffsetSE;
break;
}
case 2: {
profileOffset = IpsServices::EmailProfileOffsetMF;
break;
}
case 3: {
profileOffset = IpsServices::EmailProfileOffsetUD;
break;
}
default: {
break;
}
};
return profileOffset;
}
bool NmApiSettingsManagerPrivate::checkAccountType()
{
bool identified = false;
RArray<TImapAccount> imapAccounts;
CleanupClosePushL(imapAccounts);
TRAPD(err, mAccount->GetImapAccountsL(imapAccounts));
if (err == KErrNone) {
for (int i=0; i < imapAccounts.Count(); ++i) {
TImapAccount account = imapAccounts[i];
if (account.iImapService == mMailboxId) {
mImap4Account = account;
mMailboxType = NmApiMailboxTypeImap;
identified = true;
break;
}
}
}
CleanupStack::PopAndDestroy(&imapAccounts);
if (!identified) {
RArray<TPopAccount> popAccounts;
CleanupClosePushL(popAccounts);
TRAPD(err, mAccount->GetPopAccountsL(popAccounts));
if (err == KErrNone) {
for (int i = 0; i < popAccounts.Count(); ++i) {
TPopAccount account = popAccounts[i];
if (popAccounts[i].iPopService == mMailboxId) {
mPop3Account = account;
mMailboxType = NmApiMailboxTypePop;
identified = true;
break;
}
}
}
CleanupStack::PopAndDestroy(&popAccounts);
}
return identified;
}
void NmApiSettingsManagerPrivate::initAccountL()
{
if (mMailboxType == NmApiMailboxTypePop) {
mPop3Settings = new(ELeave) CImPop3Settings();
mAccount->LoadPopSettingsL(mPop3Account, *mPop3Settings);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mImap4Settings = new(ELeave) CImImap4Settings();
mAccount->LoadImapSettingsL(mImap4Account, *mImap4Settings);
}
mSmtpSettings = new(ELeave) CImSmtpSettings();
if (mMailboxType == NmApiMailboxTypePop) {
mAccount->GetSmtpAccountL(mPop3Account.iSmtpService, mSmtpAccount);
}
else if (mMailboxType == NmApiMailboxTypeImap) {
mAccount->GetSmtpAccountL(mImap4Account.iSmtpService, mSmtpAccount);
}
mAccount->LoadSmtpSettingsL(mSmtpAccount, *mSmtpSettings);
}
} // end namespace