1 /*

     2  * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description:

    15  *

    16  */

    17 

    18 #include <QVariant>

    19 #include <QList>

    20 

    21 #include <xqconversions.h>

    22 #include <xqsettingsmanager.h>

    23 #include <xqcentralrepositoryutils.h>

    24 #include <xqcentralrepositorysearchcriteria.h>

    25 

    26 #include <pop3set.h>

    27 #include <imapset.h>

    28 #include <smtpset.h>

    29 #include <iapprefs.h>

    30 

    31 #include "ipssettingkeys.h"

    32 #include "nmapiheaders.h"

    33 #include <nmapisettingsmanager.h>

    34 #include "nmapisettingsmanager_p.h"

    35 

    36 namespace EmailClientApi

    37 {

    38 

    39 NmApiSettingsManagerPrivate::NmApiSettingsManagerPrivate(const quint64 mailboxId)

    40     : mAccount(0),

    41     mPop3Settings(0),

    42     mImap4Settings(0),

    43     mSmtpSettings(0),

    44     mMailboxOffset(-1),

    45     mMailboxId(0)

    46 {

    47     QT_TRAP_THROWING(mAccount = CEmailAccounts::NewL());

    48     mMailboxId = (quint32)mailboxId;

    49 

    50     mQSettingsManager = new XQSettingsManager();

    51     Q_CHECK_PTR(mQSettingsManager);

    52 

    53     checkAccountType();

    54     QT_TRAP_THROWING(initAccountL());

    55     calculateMailboxOffset();

    56 

    57 }

    58 

    59 NmApiSettingsManagerPrivate::~NmApiSettingsManagerPrivate()

    60 {

    61     delete mPop3Settings;

    62     delete mImap4Settings;

    63     delete mSmtpSettings;

    64     delete mQSettingsManager;

    65     delete mAccount;

    66 }

    67 

    68 /*!

    69  Loads QMail specific settings.

    70  \param mailboxId which settings are returned

    71  \param data consists of keys and values of settings.

    72  \return bool <true> when the setting items were found otherwise <false>.

    73  */

    74 bool NmApiSettingsManagerPrivate::load(quint64 mailboxId, NmApiMailboxSettingsData &data)

    75 {

    76 	mMailboxId = mailboxId;

    77     return (readSetting(data) && readCenRepSetting(data));

    78 }

    79 

    80 /*!

    81  Saves QMail specific settings.

    82  \param data consists of keys and values of settings.

    83  \return bool <true> when the setting items were successfully saved otherwise <false>.

    84  */

    85 bool NmApiSettingsManagerPrivate::save(const NmApiMailboxSettingsData &data)

    86 {

    87     TInt err(KErrNone);

    88     TRAP(err, writeSettingL(data));

    89     return (!err && writeSettingToCenRep(data));

    90 }

    91 

    92 /*!

    93  Finds and returns the SMTP specific setting.

    94  \param settingItem SettingItem enum of the setting to return

    95  \param QVariant SettingValue of the found setting value.

    96  \return bool <true> when the setting item was found otherwise <false>.

    97  */

    98 bool NmApiSettingsManagerPrivate::readSetting(NmApiMailboxSettingsData &data)

    99 {

   100     if (mMailboxType == NmApiMailboxTypePop) {

   101         data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mPop3Settings->LoginName()));

   102         data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mPop3Settings->Password()));

   103         data.setValue(MailboxName, XQConversions::s60DescToQString(mPop3Account.iPopAccountName));

   104         data.setValue(IncomingMailServer, XQConversions::s60DescToQString(mPop3Settings->ServerAddress()));

   105 #if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

   106         data.setValue(IncomingMailUsesAuthentication, mPop3Settings->POP3Auth());

   107 #endif

   108         data.setValue(IncomingPort, mPop3Settings->Port());

   109     }

   110     else if (mMailboxType  == NmApiMailboxTypeImap) {

   111         data.setValue(IncomingLoginName, XQConversions::s60Desc8ToQString(mImap4Settings->LoginName()));

   112         data.setValue(IncomingPassword, XQConversions::s60Desc8ToQString(mImap4Settings->Password()));

   113         data.setValue(MailboxName, XQConversions::s60DescToQString(

   114                 mImap4Account.iImapAccountName));

   115         data.setValue(IncomingMailServer, XQConversions::s60DescToQString(

   116                 mImap4Settings->ServerAddress()));

   117 #if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

   118         data.setValue(IncomingMailUsesAuthentication, mImap4Settings->IAMP4Auth());

   119 #endif

   120         data.setValue(IncomingPort, mImap4Settings->Port());

   121         data.setValue(FolderPath, XQConversions::s60Desc8ToQString(mImap4Settings->FolderPath()));

   122     }

   123 

   124     data.setValue(IncomingMailSecurityType, security());

   125     data.setValue(MyName, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));

   126     data.setValue(EmailAlias, XQConversions::s60DescToQString(mSmtpSettings->EmailAlias()));

   127     data.setValue(EmailAddress, XQConversions::s60DescToQString(mSmtpSettings->EmailAddress()));

   128     data.setValue(ReplyAddress, XQConversions::s60DescToQString(mSmtpSettings->ReplyToAddress()));

   129     data.setValue(OutgoingMailServer, XQConversions::s60DescToQString(mSmtpSettings->ServerAddress()));

   130     data.setValue(OutgoingPort, mSmtpSettings->Port());

   131     data.setValue(OutgoingLoginName, XQConversions::s60Desc8ToQString(mSmtpSettings->LoginName()));

   132     data.setValue(OutgoingPassword, XQConversions::s60Desc8ToQString(mSmtpSettings->Password()));

   133     data.setValue(UseOutgoingAuthentication, mSmtpSettings->SMTPAuth());

   134     data.setValue(OutgoingMailUsesAuthentication, mSmtpSettings->SMTPAuth());

   135     data.setValue(OutgoingSecureSockets, mSmtpSettings->SecureSockets());

   136     data.setValue(OutgoingSSLWrapper, mSmtpSettings->SSLWrapper());

   137     data.setValue(OutgoingMailSecurityType, XQConversions::s60Desc8ToQString(mSmtpSettings->TlsSslDomain()));

   138     return true;

   139 }

   140 

   141 bool NmApiSettingsManagerPrivate::readCenRepSetting(NmApiMailboxSettingsData &data)

   142 {

   143     bool ret = true;

   144     QVariant tmp;

   145     data.setValue(DownloadPictures, readFromCenRep(IpsServices::EmailKeyPreferenceDownloadPictures));

   146     data.setValue(MessageDivider, readFromCenRep(IpsServices::EmailKeyPreferenceMessageDivider));

   147 

   148     tmp = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);

   149     switch(tmp.toInt()){

   150         case 0:

   151             data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);

   152             break;

   153         case 1:

   154             data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetSE);

   155             break;

   156         case 2:

   157             data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetMF);

   158             break;

   159         case 3:

   160             data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetUD);

   161             break;

   162         default:

   163             data.setValue(ReceptionActiveProfile, EmailClientApi::EmailProfileOffsetKUTD);

   164             break;

   165     };

   166 

   167     data.setValue(ReceptionUserDefinedProfile, readFromCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile));

   168     data.setValue(ReceptionInboxSyncWindow, readFromCenRep(mActiveProfileOffset

   169                         + IpsServices::EmailKeyReceptionInboxSyncWindow));

   170     data.setValue(ReceptionGenericSyncWindowInMessages, readFromCenRep(mActiveProfileOffset

   171                         + IpsServices::EmailKeyReceptionGenericSyncWindowInMessages));

   172     data.setValue(ReceptionWeekDays, readFromCenRep(mActiveProfileOffset

   173                         + IpsServices::EmailKeyReceptionWeekDays));

   174     data.setValue(ReceptionDayStartTime, readFromCenRep(mActiveProfileOffset

   175                         + IpsServices::EmailKeyReceptionDayStartTime));

   176     data.setValue(ReceptionDayEndTime, readFromCenRep(mActiveProfileOffset

   177                         + IpsServices::EmailKeyReceptionDayEndTime));

   178     data.setValue(ReceptionRefreshPeriodDayTime, readFromCenRep(mActiveProfileOffset

   179                         + IpsServices::EmailKeyReceptionRefreshPeriodDayTime));

   180     data.setValue(ReceptionRefreshPeriodOther, readFromCenRep(mActiveProfileOffset

   181                         + IpsServices::EmailKeyReceptionRefreshPeriodOther));

   182     data.setValue(UserNameHidden, readFromCenRep(IpsServices::EmailKeyUserNameHidden));

   183     data.setValue(EmailNotificationState, readFromCenRep(IpsServices::EmailKeyEMNState));

   184     data.setValue(FirstEmnReceived, readFromCenRep(IpsServices::EmailKeyFirstEmnReceived));

   185     data.setValue(EmnReceivedNotSynced, readFromCenRep(IpsServices::EmailKeyEmnReceivedNotSynced));

   186 

   187     QString aolState = alwaysOnlineState();

   188     if(aolState.length()>0)

   189         data.setValue(AlwaysOnlineState, aolState);

   190 

   191     data.setValue(AoLastSuccessfulUpdate, readFromCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL));

   192     data.setValue(AoLastUpdateFailed, readFromCenRep(IpsServices::EmailKeyAoLastUpdateFailed));

   193     data.setValue(AoUpdateSuccessfulWithCurSettings, readFromCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings));

   194     return ret;

   195 }

   196 

   197 /*!

   198  Writes POP3/IMAP4 specific settings.

   199  \param data consists of keys and values of settings.

   200  */

   201 bool NmApiSettingsManagerPrivate::writeSettingL(const NmApiMailboxSettingsData &data)

   202 {

   203     HBufC *tmp = 0;

   204     HBufC8 *tmp8 = 0;

   205     bool ret(false);

   206     int key;

   207     QVariant settingValue;

   208     QList<int> keylist;

   209     bool aliasSet = false;

   210 

   211     keylist = data.listSettings();

   212     for (int i = 0; i < keylist.size(); i++) {

   213         key = keylist[i];

   214         data.getValue(key, settingValue);

   215         switch (key) {

   216             case IncomingLoginName: {

   217                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   218                 if (mMailboxType == NmApiMailboxTypePop) {

   219                     mPop3Settings->SetLoginNameL(*tmp8);

   220                 }

   221                 else if (mMailboxType == NmApiMailboxTypeImap) {

   222                     mImap4Settings->SetLoginNameL(*tmp8);

   223                     }

   224                 delete tmp8;

   225                 break;

   226             }

   227             case IncomingPassword: {

   228                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   229                 if (mMailboxType == NmApiMailboxTypePop) {

   230                     mPop3Settings->SetPasswordL(*tmp8);

   231                 }

   232                 else if (mMailboxType == NmApiMailboxTypeImap) {

   233                     mImap4Settings->SetPasswordL(*tmp8);

   234                     }

   235                 delete tmp8;

   236                 break;

   237             }

   238             case MailboxName: {

   239                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   240                 if (mMailboxType == NmApiMailboxTypePop) {

   241                     mPop3Account.iPopAccountName.Copy(*tmp);

   242                 }

   243                 else if (mMailboxType == NmApiMailboxTypeImap) {

   244                     mImap4Account.iImapAccountName.Copy(*tmp);

   245                     }

   246                 delete tmp;

   247                 break;

   248             }

   249             case IncomingMailServer: {

   250                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   251 

   252                 if (mMailboxType == NmApiMailboxTypePop) {

   253                     mPop3Settings->SetServerAddressL(*tmp);

   254                 }

   255                 else if (mMailboxType == NmApiMailboxTypeImap) {

   256                     mImap4Settings->SetServerAddressL(*tmp);

   257                     }

   258                 delete tmp;

   259                 break;

   260             }

   261             case IncomingMailUsesAuthentication: {

   262 #if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

   263 

   264                 if (mMailboxType == NmApiMailboxTypePop) {

   265                     mPop3Settings->SetPOP3Auth(settingValue.toBool());

   266                 }

   267                 else if (mMailboxType == NmApiMailboxTypeImap) {

   268                     mImap4Settings->SetIAMP4Auth(settingValue.toBool());

   269                 }

   270 #endif

   271                 break;

   272             }

   273             case IncomingMailSecurityType: {

   274                 setSecurity(settingValue.toString());

   275                 break;

   276             }

   277             case IncomingPort: {

   278                 if (mMailboxType == NmApiMailboxTypePop) {

   279                 mPop3Settings->SetPort(settingValue.toInt());

   280                 }

   281                 else if (mMailboxType == NmApiMailboxTypeImap) {

   282                     mImap4Settings->SetPort(settingValue.toInt());

   283                 }

   284                 break;

   285             }

   286             case OutgoingPort: {

   287                 mSmtpSettings->SetPort(settingValue.toInt());

   288                 break;

   289             }

   290             case IncomingSecureSockets: {

   291                 if (mMailboxType == NmApiMailboxTypePop) {

   292                     mPop3Settings->SetSecureSockets(settingValue.toBool());

   293                  }

   294                  else if (mMailboxType == NmApiMailboxTypeImap) {

   295                     mImap4Settings->SetSecureSockets(settingValue.toBool());

   296                      }

   297                 break;

   298             }

   299             case IncomingSSLWrapper: {

   300                 if (mMailboxType == NmApiMailboxTypePop) {

   301                     mPop3Settings->SetSSLWrapper(settingValue.toBool());

   302                 }

   303                 else if (mMailboxType == NmApiMailboxTypeImap) {

   304                     mImap4Settings->SetSSLWrapper(settingValue.toBool());

   305                     }

   306                 break;

   307             }

   308             case EmailAddress: {

   309                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   310                 mSmtpSettings->SetEmailAddressL(*tmp);

   311                 break;

   312             }

   313             case ReplyAddress: {

   314                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   315                 mSmtpSettings->SetReplyToAddressL(*tmp);

   316                 break;

   317             }

   318             case EmailAlias: {

   319                 QVariant tmpName;

   320                 if(data.getValue(MyName,tmpName)) {

   321                     if(tmpName.toString()

   322                         ==XQConversions::s60DescToQString(mSmtpSettings->EmailAlias())) {

   323                         aliasSet = true;

   324                     }

   325                 }

   326                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   327                 mSmtpSettings->SetEmailAliasL(*tmp);

   328                 break;

   329             }

   330             case MyName: {

   331                 if(!aliasSet) {

   332                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   333                 mSmtpSettings->SetEmailAliasL(*tmp);

   334                 }

   335                 break;

   336             }

   337             case OutgoingMailServer: {

   338                 tmp = XQConversions::qStringToS60Desc(settingValue.toString());

   339                 mSmtpSettings->SetServerAddressL(*tmp);

   340                 break;

   341             }

   342             case OutgoingLoginName: {

   343                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   344                 mSmtpSettings->SetLoginNameL(*tmp8);

   345                 break;

   346             }

   347             case OutgoingPassword: {

   348                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   349                 mSmtpSettings->SetPasswordL(*tmp8);

   350                 break;

   351             }

   352             case UseOutgoingAuthentication:

   353             case OutgoingMailUsesAuthentication: {

   354                 mSmtpSettings->SetSMTPAuth(settingValue.toBool());

   355                 break;

   356             }

   357             case OutgoingSecureSockets: {

   358                 mSmtpSettings->SetSecureSockets(settingValue.toBool());

   359                 break;

   360             }

   361             case OutgoingSSLWrapper: {

   362                 mSmtpSettings->SetSSLWrapper(settingValue.toBool());

   363                 break;

   364             }

   365             case OutgoingMailSecurityType: {

   366                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   367                 mSmtpSettings->SetTlsSslDomainL(*tmp8);

   368                 break;

   369             }

   370             case FolderPath: {

   371                 tmp8 = XQConversions::qStringToS60Desc8(settingValue.toString());

   372                 mImap4Settings->SetFolderPathL(*tmp8);

   373                 break;

   374             }

   375             default: {

   376 				break;

   377             }

   378         };

   379     }

   380     ret = saveSettings();

   381     return ret;

   382 }

   383 

   384 /*!

   385 Writes settings to central repository.

   386 \param data consists of keys and values of settings.

   387  */

   388 bool NmApiSettingsManagerPrivate::writeSettingToCenRep(

   389     const NmApiMailboxSettingsData &data)

   390 {

   391     int key;

   392     QVariant settingValue;

   393     QList<int> keylist;

   394 

   395     keylist = data.listSettings();

   396     bool ret = false;

   397     if(keylist.contains(ReceptionActiveProfile)) {

   398         data.getValue(ReceptionActiveProfile,settingValue);

   399         QVariant profileOffset = 0;

   400         if(settingValue.toString() == EmailClientApi::EmailProfileOffsetKUTD) {

   401             profileOffset=0;

   402         } else if(settingValue.toString() == EmailClientApi::EmailProfileOffsetSE){

   403             profileOffset = 1;

   404         } else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetMF){

   405                     profileOffset = 2;

   406         } else if (settingValue.toString() == EmailClientApi::EmailProfileOffsetUD) {

   407             profileOffset = 3;

   408         }

   409         ret = writeToCenRep(IpsServices::EmailKeyReceptionActiveProfile, profileOffset);

   410         if(ret) {

   411             calculateActiveProfileOffset();

   412         }

   413     }

   414     if (ret) {

   415         for (int i = 0; i < keylist.size(); i++) {

   416             key = keylist[i];

   417             data.getValue(key, settingValue);

   418             switch (key) {

   419                 case DownloadPictures: {

   420                     ret = writeToCenRep(IpsServices::EmailKeyPreferenceDownloadPictures,

   421                         settingValue);

   422                     break;

   423                 }

   424                 case MessageDivider: {

   425                     ret = writeToCenRep(IpsServices::EmailKeyPreferenceMessageDivider, settingValue);

   426                     break;

   427                 }

   428                 case ReceptionUserDefinedProfile: {

   429                     ret = writeToCenRep(IpsServices::EmailKeyReceptionUserDefinedProfile,

   430                         settingValue);

   431                     break;

   432                 }

   433                 case ReceptionInboxSyncWindow: {

   434                     ret = writeToCenRep(mActiveProfileOffset

   435                         + IpsServices::EmailKeyReceptionInboxSyncWindow, settingValue);

   436                     break;

   437                 }

   438                 case ReceptionGenericSyncWindowInMessages: {

   439                     ret = writeToCenRep(mActiveProfileOffset

   440                         + IpsServices::EmailKeyReceptionGenericSyncWindowInMessages, settingValue);

   441                     break;

   442                 }

   443                 case ReceptionWeekDays: {

   444                     ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionWeekDays,

   445                         settingValue);

   446                     break;

   447                 }

   448                 case ReceptionDayStartTime: {

   449                     ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayStartTime,

   450                         settingValue);

   451                     break;

   452                 }

   453                 case ReceptionDayEndTime: {

   454                     ret = writeToCenRep(mActiveProfileOffset + IpsServices::EmailKeyReceptionDayEndTime,

   455                         settingValue);

   456                     break;

   457                 }

   458                 case ReceptionRefreshPeriodDayTime: {

   459                     ret = writeToCenRep(mActiveProfileOffset

   460                         + IpsServices::EmailKeyReceptionRefreshPeriodDayTime, settingValue);

   461                     break;

   462                 }

   463                 case ReceptionRefreshPeriodOther: {

   464                     ret = writeToCenRep(mActiveProfileOffset

   465                         + IpsServices::EmailKeyReceptionRefreshPeriodOther, settingValue);

   466                     break;

   467                 }

   468                 case UserNameHidden: {

   469                     ret = writeToCenRep(IpsServices::EmailKeyUserNameHidden, settingValue);

   470                     break;

   471                 }

   472                 case EmailNotificationState: {

   473                     ret = writeToCenRep(IpsServices::EmailKeyEMNState, settingValue);

   474                     break;

   475                 }

   476                 case FirstEmnReceived: {

   477                     ret = writeToCenRep(IpsServices::EmailKeyFirstEmnReceived, settingValue);

   478                     break;

   479                 }

   480                 case EmnReceivedNotSynced: {

   481                     ret = writeToCenRep(IpsServices::EmailKeyEmnReceivedNotSynced, settingValue);

   482                     break;

   483                 }

   484                 case AlwaysOnlineState: {

   485                     setAlwaysOnlineState(settingValue);

   486                     break;

   487                 }

   488                 case AoLastSuccessfulUpdate: {

   489                     ret = writeToCenRep(IpsServices::EmailKeyAoLastSuccessfulUpdateL, settingValue);

   490                     break;

   491                 }

   492                 case AoLastUpdateFailed: {

   493                     ret = writeToCenRep(IpsServices::EmailKeyAoLastUpdateFailed, settingValue);

   494                     break;

   495                 }

   496                 case AoUpdateSuccessfulWithCurSettings: {

   497                     ret = writeToCenRep(IpsServices::EmailKeyAoUpdateSuccessfulWithCurSettings,

   498                         settingValue);

   499                     break;

   500                 }

   501                 case ReceptionActiveProfile:

   502                 default: {

   503                     break;

   504                 }

   505             };

   506         }

   507     }

   508     return ret;

   509 }

   510 /*!

   511  Stores the POP3/IMAP4 specific settings.

   512  \return bool <true> when the settings were succesfully written, otherwise <false>.

   513  */

   514 bool NmApiSettingsManagerPrivate::saveSettings()

   515 {

   516     bool ret(false);

   517     if (mMailboxType == NmApiMailboxTypePop) {

   518         TRAPD(err, mAccount->SavePopSettingsL(mPop3Account, *mPop3Settings));

   519         if (err == KErrNone) {

   520             ret = true;

   521         }

   522     }

   523     else if (mMailboxType == NmApiMailboxTypeImap) {

   524         TRAPD(err, mAccount->SaveImapSettingsL(mImap4Account, *mImap4Settings));

   525         if (err == KErrNone) {

   526             ret = true;

   527         }

   528     }

   529     return ret;

   530 }

   531 

   532 /*!

   533  Reads a key value from the Central Repository.

   534  \param key Key identifier.

   535  \return the settings value for the given key.

   536  */

   537 QVariant NmApiSettingsManagerPrivate::readFromCenRep(quint32 key) const

   538 {

   539     XQCentralRepositorySettingsKey settingKey(IpsServices::EmailMailboxSettingRepository,

   540         mMailboxOffset + key);

   541     return mQSettingsManager->readItemValue(settingKey);

   542 }

   543 

   544 /*!

   545  Writes a key value to the Central Repository.

   546  \param key Key identifier.

   547  \param value The settings value for the given key.

   548  \return Returns <true> if the value was succesfully written, <false> if not.

   549  */

   550 bool NmApiSettingsManagerPrivate::writeToCenRep(quint32 key, const QVariant &value) const

   551 {

   552     XQCentralRepositorySettingsKey settingKey(IpsServices::EmailMailboxSettingRepository,

   553         mMailboxOffset + key);

   554     return mQSettingsManager->writeItemValue(settingKey, value);

   555 }

   556 

   557 void NmApiSettingsManagerPrivate::setSecurity(QString securityType)

   558 {

   559     if (securityType == NmApiStartTls) {

   560         if (mMailboxType == NmApiMailboxTypePop) {

   561             mPop3Settings->SetSecureSockets(ETrue);

   562             mPop3Settings->SetSSLWrapper(EFalse);

   563         }

   564         else {

   565             mImap4Settings->SetSecureSockets(ETrue);

   566             mImap4Settings->SetSSLWrapper(EFalse);

   567         }

   568     }

   569     else if (securityType == NmApiSSLTls) {

   570         if (mMailboxType == NmApiMailboxTypePop) {

   571             mPop3Settings->SetSecureSockets(EFalse);

   572             mPop3Settings->SetSSLWrapper(ETrue);

   573         }

   574         else {

   575             mImap4Settings->SetSecureSockets(EFalse);

   576             mImap4Settings->SetSSLWrapper(ETrue);

   577         }

   578     }

   579     else {

   580         if (mMailboxType == NmApiMailboxTypePop) {

   581             mPop3Settings->SetSecureSockets(EFalse);

   582             mPop3Settings->SetSSLWrapper(EFalse);

   583         }

   584         else {

   585             mImap4Settings->SetSecureSockets(EFalse);

   586             mImap4Settings->SetSSLWrapper(EFalse);

   587         }

   588     }

   589 }

   590 

   591 QString NmApiSettingsManagerPrivate::security() const

   592 {

   593     bool ss(false);

   594     bool sslw(false);

   595     QString securityType("");

   596 

   597     if (mMailboxType == NmApiMailboxTypePop) {

   598         ss = mPop3Settings->SecureSockets();

   599         sslw = mPop3Settings->SSLWrapper();

   600     }

   601     else {

   602         ss = mImap4Settings->SecureSockets();

   603         sslw = mImap4Settings->SSLWrapper();

   604     }

   605 

   606     if (ss == true && sslw == false) {

   607         securityType = NmApiStartTls;

   608     }

   609     else if (ss == false && sslw == true) {

   610         securityType = NmApiSSLTls;

   611     }

   612     else {

   613         securityType = NmApiSecurityOff;

   614     }

   615     return securityType;

   616 }

   617 

   618 /*!

   619 

   620  */

   621 QString NmApiSettingsManagerPrivate::alwaysOnlineState() const

   622 {

   623     TInt profile = IpsServices::EmailSyncProfileManualFetch;

   624     QString ret = NmApiOff;

   625 

   626     QVariant state;

   627     TInt settingValue = -1;

   628     state = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);

   629     settingValue = state.toInt();

   630 

   631     if (settingValue >= 0) {

   632         profile = settingValue;

   633         if (profile != IpsServices::EmailSyncProfileManualFetch) {

   634             ret = NmApiAlways;

   635         }

   636     }

   637     return ret;

   638 }

   639 

   640 /*!

   641 

   642  */

   643 void NmApiSettingsManagerPrivate::setAlwaysOnlineState(const QVariant state)

   644 {

   645     //only allowed to switch state off, not on.

   646     if (state.toString() == NmApiOff) {

   647         writeToCenRep(IpsServices::EmailKeyReceptionActiveProfile,

   648             IpsServices::EmailSyncProfileManualFetch);

   649     }

   650 }

   651 

   652 void NmApiSettingsManagerPrivate::calculateMailboxOffset()

   653 {

   654     // Find all the keys that match the criteria 0xZZZZZ000, where Z=don't care.

   655     // This will give us all the keys that hold the mailbox ids, e.g. 0x00001000, 0x00002000, etc.

   656     quint32 partialKey(0x00000000);

   657     quint32 bitMask(0x00000FFF);

   658     XQCentralRepositorySearchCriteria criteria(IpsServices::EmailMailboxSettingRepository,

   659         partialKey, bitMask);

   660     // Set the mailbox id is value criteria for the search.

   661     criteria.setValueCriteria((int) mMailboxId);

   662 

   663     // Find the keys.

   664     XQCentralRepositoryUtils utils(*mQSettingsManager);

   665     QList<XQCentralRepositorySettingsKey> foundKeys = utils.findKeys(criteria);

   666 

   667     // We should only get one key as a result.

   668     if (foundKeys.count() == 1) {

   669         mMailboxOffset = foundKeys[0].key();

   670         calculateActiveProfileOffset();

   671     }

   672     else {

   673         mActiveProfileOffset = -1;

   674         mMailboxOffset = -1;

   675     }

   676 }

   677 

   678 /*!

   679  Calculates the active reception schedule profile offset.

   680  */

   681 void NmApiSettingsManagerPrivate::calculateActiveProfileOffset()

   682 {

   683     QVariant activeProfile = readFromCenRep(IpsServices::EmailKeyReceptionActiveProfile);

   684     mActiveProfileOffset = convertToProfileOffset(activeProfile.toInt());

   685 }

   686 

   687 /*!

   688 

   689  */

   690 qint32 NmApiSettingsManagerPrivate::convertToProfileOffset(int profile) const

   691 {

   692     quint32 profileOffset(0);

   693     // Possible values are defined in ipssettingkeys.h

   694     switch (profile) {

   695         case 0: {

   696             profileOffset = IpsServices::EmailProfileOffsetKUTD;

   697             break;

   698         }

   699         case 1: {

   700             profileOffset = IpsServices::EmailProfileOffsetSE;

   701             break;

   702         }

   703         case 2: {

   704             profileOffset = IpsServices::EmailProfileOffsetMF;

   705             break;

   706         }

   707         case 3: {

   708             profileOffset = IpsServices::EmailProfileOffsetUD;

   709             break;

   710         }

   711         default: {

   712             break;

   713         }

   714     };

   715 

   716     return profileOffset;

   717 }

   718 

   719 bool NmApiSettingsManagerPrivate::checkAccountType()

   720 {

   721     bool identified = false;

   722 

   723     RArray<TImapAccount> imapAccounts;

   724     CleanupClosePushL(imapAccounts);

   725     TRAPD(err, mAccount->GetImapAccountsL(imapAccounts));

   726     if (err == KErrNone) {

   727         for (int i=0; i < imapAccounts.Count(); ++i) {

   728             TImapAccount account = imapAccounts[i];

   729             if (account.iImapService == mMailboxId) {

   730                 mImap4Account = account;

   731                 mMailboxType = NmApiMailboxTypeImap;

   732                 identified = true;

   733                 break;

   734             }

   735         }

   736     }

   737     CleanupStack::PopAndDestroy(&imapAccounts);

   738 

   739     if (!identified) {

   740         RArray<TPopAccount> popAccounts;

   741         CleanupClosePushL(popAccounts);

   742         TRAPD(err, mAccount->GetPopAccountsL(popAccounts));

   743         if (err == KErrNone) {

   744             for (int i = 0; i < popAccounts.Count(); ++i) {

   745                 TPopAccount account = popAccounts[i];

   746                 if (popAccounts[i].iPopService == mMailboxId) {

   747                     mPop3Account = account;

   748                     mMailboxType = NmApiMailboxTypePop;

   749                     identified = true;

   750                     break;

   751                 }

   752             }

   753         }

   754         CleanupStack::PopAndDestroy(&popAccounts);

   755     }

   756 

   757     return identified;

   758 }

   759 

   760 void NmApiSettingsManagerPrivate::initAccountL()

   761 {

   762     if (mMailboxType == NmApiMailboxTypePop) {

   763         mPop3Settings = new(ELeave) CImPop3Settings();

   764         mAccount->LoadPopSettingsL(mPop3Account, *mPop3Settings);

   765     }

   766     else if (mMailboxType == NmApiMailboxTypeImap) {

   767         mImap4Settings = new(ELeave) CImImap4Settings();

   768         mAccount->LoadImapSettingsL(mImap4Account, *mImap4Settings);

   769     }

   770 

   771     mSmtpSettings = new(ELeave) CImSmtpSettings();

   772 

   773     if (mMailboxType == NmApiMailboxTypePop) {

   774         mAccount->GetSmtpAccountL(mPop3Account.iSmtpService, mSmtpAccount);

   775     }

   776     else if (mMailboxType == NmApiMailboxTypeImap) {

   777         mAccount->GetSmtpAccountL(mImap4Account.iSmtpService, mSmtpAccount);

   778     }

   779     mAccount->LoadSmtpSettingsL(mSmtpAccount, *mSmtpSettings);

   780 }

   781 

   782 } // end namespace