1 /*

     2 * Copyright (c) 2007 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: This file implements class CIpsSetData.

    15 *

    16 */

    17 

    18 

    19 #include "emailtrace.h"

    20 #include <smtpset.h>

    21 #include <pop3set.h>

    22 #include <imapset.h>

    23 #include <txtrich.h>            // CRichText

    24 #include <SendUiConsts.h>

    25 #include <StringLoader.h>

    26 #include <ipssossettings.rsg>

    27 

    28 #include "ipssetdataapi.h"

    29 #include "ipssetdata.h"

    30 #include "ipssetdatasignature.h"

    31 #include "ipssetdataextension.h"

    32 #include "ipssetdatamanager.h"

    33 #include "ipssetutils.h"

    34 #include "ipssetutilsconsts.h"

    35 #include "ipssetutilsconsts.hrh"

    36 

    37 

    38 

    39 

    40 // ============================ MEMBER FUNCTIONS ===============================

    41 

    42 // ----------------------------------------------------------------------------

    43 // CIpsSetData::CIpsSetData()

    44 // ----------------------------------------------------------------------------

    45 //

    46 CIpsSetData::CIpsSetData()

    47     {

    48     FUNC_LOG;

    49     }

    50 

    51 // ----------------------------------------------------------------------------

    52 // CIpsSetData::~CIpsSetData()

    53 // ----------------------------------------------------------------------------

    54 //

    55 CIpsSetData::~CIpsSetData()

    56     {

    57     FUNC_LOG;

    58     iName.Close();

    59     iTempStore.Close();

    60     delete iSignature;

    61     delete iImap4Settings;

    62     delete iPop3Settings;

    63     delete iSmtpSettings;

    64     delete iExtendedSettings;

    65     delete iIncomingIapPref;

    66     delete iOutgoingIapPref;    

    67     }

    68 

    69 // ----------------------------------------------------------------------------

    70 // CIpsSetData::ConstructL()

    71 // ----------------------------------------------------------------------------

    72 //

    73 void CIpsSetData::ConstructL()

    74     {

    75     FUNC_LOG;

    76     iName.CreateL( KIpsSetUiMaxSettingsTextLength );

    77     iTempStore.CreateL( KIPsSetUiMaxSettingsUsrNameLength );

    78     iSignature = CIpsSetDataSignature::NewL();

    79     iSignature->CreateEmptyRichTextL();

    80     iSmtpSettings = new ( ELeave ) CImSmtpSettings;

    81     iPop3Settings = new ( ELeave ) CImPop3Settings;

    82     iImap4Settings = new ( ELeave ) CImImap4Settings;

    83     iIncomingIapPref = CImIAPPreferences::NewLC();

    84     CleanupStack::Pop( iIncomingIapPref );

    85     iOutgoingIapPref = CImIAPPreferences::NewLC();

    86     CleanupStack::Pop( iOutgoingIapPref );

    87     iExtendedSettings = CIpsSetDataExtension::NewL();

    88     SetDefaultDataL();

    89     }

    90 

    91 // ----------------------------------------------------------------------------

    92 // CIpsSetData::NewL()

    93 // ----------------------------------------------------------------------------

    94 //

    95 CIpsSetData* CIpsSetData::NewL()

    96     {

    97     FUNC_LOG;

    98     CIpsSetData* self = NewLC();

    99     CleanupStack::Pop( self );

   100 

   101     return self;

   102     }

   103 

   104 // ----------------------------------------------------------------------------

   105 // CIpsSetData::NewLC()

   106 // ----------------------------------------------------------------------------

   107 //

   108 CIpsSetData* CIpsSetData::NewLC()

   109     {

   110     FUNC_LOG;

   111     CIpsSetData* self = new ( ELeave ) CIpsSetData();

   112     CleanupStack::PushL( self );

   113     self->ConstructL();

   114 

   115     return self;

   116     }

   117     

   118 // ===================== New functions ========================

   119 

   120 // ---------------------------------------------------------------------------

   121 // CIpsSetData::SetDefaultDataL()

   122 // ---------------------------------------------------------------------------

   123 //

   124 void CIpsSetData::SetDefaultDataL()

   125     {

   126     FUNC_LOG;

   127     

   128     CEmailAccounts* accounts = CEmailAccounts::NewL();

   129     CleanupStack::PushL( accounts );

   130     accounts->PopulateDefaultImapSettingsL( *iImap4Settings, *iIncomingIapPref );

   131     accounts->PopulateDefaultPopSettingsL( *iPop3Settings, *iIncomingIapPref );

   132     CleanupStack::PopAndDestroy( accounts );

   133     

   134     // POP3 preset settings

   135     iPop3Settings->SetAutoSendOnConnect( ETrue );

   136     iPop3Settings->SetDisconnectedUserMode( ETrue );

   137     iPop3Settings->SetDeleteEmailsWhenDisconnecting( EFalse );

   138     iPop3Settings->SetAcknowledgeReceipts( EFalse );

   139     iPop3Settings->SetGetMailOptions( EGetPop3EmailHeaders );

   140     iPop3Settings->SetInboxSynchronisationLimit( 

   141             KIpsSetFetchHeadersDefaultLimit );

   142     iPop3Settings->SetPopulationLimitL( KIpsSetDataFullBodyAndAttas );

   143     

   144     // IMAP4 preset settings

   145     iImap4Settings->SetAutoSendOnConnect( ETrue );

   146     iImap4Settings->SetDisconnectedUserMode( ETrue );

   147     iImap4Settings->SetDeleteEmailsWhenDisconnecting( EFalse );

   148     iImap4Settings->SetAcknowledgeReceipts( EFalse );

   149     iImap4Settings->SetSynchronise( EUseLocal );

   150     iImap4Settings->SetInboxSynchronisationLimit( 

   151             KIpsSetFetchHeadersDefaultLimit );

   152     iImap4Settings->SetBodyTextSizeLimitL( KIpsSetDataFullBodyAndAttas );

   153     

   154     // SMTP Preset parameters

   155     iSmtpSettings->SetBodyEncoding( EMsgOutboxMIME );

   156     iSmtpSettings->SetAddVCardToEmail( EFalse );

   157     iSmtpSettings->SetAddSignatureToEmail( EFalse );

   158     iSmtpSettings->SetRequestReceipts( EFalse );

   159     iSmtpSettings->SetSMTPAuth( ETrue );

   160     // <cmail> "To" an "Cc" needs to be included 

   161     // in header of reply/forward mail's body

   162     iSmtpSettings->SetToCcIncludeLimitL( KSmtpToCcIncludeLimitMax );

   163     // </cmail>

   164     

   165     // Extended Preset parameters

   166     iExtendedSettings->PopulateDefaults();

   167     }

   168     

   169 

   170 // ---------------------------------------------------------------------------

   171 // CIpsSetData::LoadL()

   172 // ---------------------------------------------------------------------------

   173 //

   174 void CIpsSetData::LoadL( const TMsvId aMailboxId, CMsvSession& aSession )

   175     {

   176     FUNC_LOG;

   177     CIpsSetDataManager* manager = CIpsSetDataManager::NewLC( aSession );

   178 

   179     TMsvEntry mbox = IpsSetUtils::GetMailboxEntryL( aSession, aMailboxId );

   180     manager->LoadEmailSettingsL( mbox, *this );

   181     

   182     CleanupStack::PopAndDestroy( manager );

   183     manager = NULL;

   184     }

   185 

   186 // ---------------------------------------------------------------------------

   187 // CIpsSetData::SaveL()

   188 // ---------------------------------------------------------------------------

   189 //

   190 void CIpsSetData::SaveL( CMsvSession& aSession )

   191     {

   192     FUNC_LOG;

   193     CIpsSetDataManager* manager = CIpsSetDataManager::NewLC( aSession );

   194 

   195     manager->SaveEmailSettingsL( *this );

   196     

   197     CleanupStack::PopAndDestroy( manager );

   198     manager = NULL;

   199     }

   200 

   201 // ---------------------------------------------------------------------------

   202 // CIpsSetData::IncomingIapPref()

   203 // ---------------------------------------------------------------------------

   204 //

   205 CImIAPPreferences* CIpsSetData::IncomingIapPref() const

   206     {

   207     FUNC_LOG;

   208     return iIncomingIapPref;

   209     }

   210 

   211 // ---------------------------------------------------------------------------

   212 // CIpsSetData::OutgoingIapPref()

   213 // ---------------------------------------------------------------------------

   214 //

   215 CImIAPPreferences* CIpsSetData::OutgoingIapPref() const

   216     {

   217     FUNC_LOG;

   218     return iOutgoingIapPref;

   219     }

   220 

   221 

   222 // ---------------------------------------------------------------------------

   223 // CIpsSetData::Imap4Settings()

   224 // ---------------------------------------------------------------------------

   225 //

   226 CImImap4Settings* CIpsSetData::Imap4Settings()

   227     {

   228     FUNC_LOG;

   229     return iImap4Settings;

   230     }

   231 

   232 // ---------------------------------------------------------------------------

   233 // CIpsSetData::Pop3Settings()

   234 // ---------------------------------------------------------------------------

   235 //

   236 CImPop3Settings* CIpsSetData::Pop3Settings()

   237     {

   238     FUNC_LOG;

   239     return iPop3Settings;

   240     }

   241 

   242 

   243 // ---------------------------------------------------------------------------

   244 // CIpsSetData::SmtpSettings()

   245 // ---------------------------------------------------------------------------

   246 //

   247 CImSmtpSettings* CIpsSetData::SmtpSettings()

   248     {

   249     FUNC_LOG;

   250     return iSmtpSettings;

   251     }

   252 

   253 // ---------------------------------------------------------------------------

   254 // CIpsSetData::ExtendedSettings()

   255 // ---------------------------------------------------------------------------

   256 //

   257 CIpsSetDataExtension* CIpsSetData::ExtendedSettings()

   258     {

   259     FUNC_LOG;

   260     return iExtendedSettings;

   261     }

   262 

   263 

   264 // ---------------------------------------------------------------------------

   265 // CIpsSetData::IsOk()

   266 // ---------------------------------------------------------------------------

   267 //

   268 TBool CIpsSetData::IsOk()

   269     {

   270     FUNC_LOG;

   271     return ETrue;

   272     }

   273 

   274 // ---------------------------------------------------------------------------

   275 // CIpsSetData::Protocol()

   276 // ---------------------------------------------------------------------------

   277 //

   278 const TUid& CIpsSetData::Protocol() const

   279     {

   280     FUNC_LOG;

   281     return iProtocol;

   282     }

   283 

   284 

   285 // ---------------------------------------------------------------------------

   286 // CIpsSetData::ImapAccount()

   287 // ---------------------------------------------------------------------------

   288 //

   289 TImapAccount& CIpsSetData::ImapAccount()

   290     {

   291     FUNC_LOG;

   292     return iImap4AccountId;

   293     }

   294     

   295 // ---------------------------------------------------------------------------

   296 // CIpsSetData::ImapAccount()

   297 // ---------------------------------------------------------------------------

   298 //

   299 const TImapAccount& CIpsSetData::ImapAccount() const

   300     {

   301     FUNC_LOG;

   302     return iImap4AccountId;

   303     }

   304     

   305 

   306 // ---------------------------------------------------------------------------

   307 // CIpsSetData::PopAccount()

   308 // ---------------------------------------------------------------------------

   309 //

   310 TPopAccount& CIpsSetData::PopAccount()

   311     {

   312     FUNC_LOG;

   313     return iPop3AccountId; 

   314     }

   315        

   316 // ---------------------------------------------------------------------------

   317 // CIpsSetData::PopAccount()

   318 // ---------------------------------------------------------------------------

   319 //

   320 const TPopAccount& CIpsSetData::PopAccount() const

   321     {

   322     FUNC_LOG;

   323     return iPop3AccountId; 

   324     }

   325 

   326 // ---------------------------------------------------------------------------

   327 // CIpsSetData::SmtpAccount()

   328 // ---------------------------------------------------------------------------

   329 //

   330 TSmtpAccount& CIpsSetData::SmtpAccount()

   331     {

   332     FUNC_LOG;

   333     return iSmtpAccountId;

   334     }

   335     

   336 // ---------------------------------------------------------------------------

   337 // CIpsSetData::SmtpAccount()

   338 // ---------------------------------------------------------------------------

   339 //

   340 const TSmtpAccount& CIpsSetData::SmtpAccount() const

   341     {

   342     FUNC_LOG;

   343     return iSmtpAccountId;

   344     }

   345             

   346 // ---------------------------------------------------------------------------

   347 // CIpsSetData::EmailAddress()

   348 // ---------------------------------------------------------------------------

   349 //

   350 const TDesC& CIpsSetData::EmailAddress() const

   351     {

   352     FUNC_LOG;

   353     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   354     temp.Copy( iSmtpSettings->EmailAddress() );

   355     return iTempStore;

   356     }

   357 

   358 // ---------------------------------------------------------------------------

   359 // CIpsSetData::ReplyToAddress()

   360 // ---------------------------------------------------------------------------

   361 //

   362 const TDesC& CIpsSetData::ReplyToAddress() const

   363     {

   364     FUNC_LOG;

   365     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   366     temp.Copy( iSmtpSettings->ReplyToAddress() );

   367     return iTempStore;

   368     }

   369 

   370 // ---------------------------------------------------------------------------

   371 // CIpsSetData::MailboxName()

   372 // ---------------------------------------------------------------------------

   373 //

   374 const TDesC& CIpsSetData::MailboxName() const

   375     {

   376     FUNC_LOG;

   377     return iSmtpAccountId.iSmtpAccountName;

   378     }

   379 

   380 // ---------------------------------------------------------------------------

   381 // CIpsSetData::MyName()

   382 // ---------------------------------------------------------------------------

   383 //

   384 const TDesC& CIpsSetData::MyName() const

   385     {

   386     FUNC_LOG;

   387     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   388     temp.Copy( iSmtpSettings->EmailAlias() );

   389     return iTempStore;

   390     }

   391 

   392 // ---------------------------------------------------------------------------

   393 // CIpsSetData::IncludeSignature()

   394 // ---------------------------------------------------------------------------

   395 //

   396 TBool CIpsSetData::IncludeSignature() const

   397     {

   398     FUNC_LOG;

   399     return iSmtpSettings->AddSignatureToEmail() ? EIpsSetUiOn : EIpsSetUiOff;

   400     }

   401 

   402 // ---------------------------------------------------------------------------

   403 // CIpsSetData::Signature()

   404 // ---------------------------------------------------------------------------

   405 //

   406 CIpsSetDataSignature& CIpsSetData::Signature()

   407     {

   408     FUNC_LOG;

   409     return *iSignature;

   410     }

   411 

   412 // ---------------------------------------------------------------------------

   413 // CIpsSetData::Signature()

   414 // ---------------------------------------------------------------------------

   415 //

   416 const CIpsSetDataSignature& CIpsSetData::Signature() const

   417     {

   418     FUNC_LOG;

   419     return *iSignature;

   420     }

   421 

   422 // ---------------------------------------------------------------------------

   423 // CIpsSetData::UserName()

   424 // ---------------------------------------------------------------------------

   425 //

   426 const TDesC& CIpsSetData::UserName( const TBool aIncoming ) const

   427     {

   428     FUNC_LOG;

   429     // The method is const type, but we have to store the text into a

   430     // temporary storage, so cast the constness away from the variable.

   431     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   432     

   433     if ( aIncoming )

   434         {        

   435         if ( iProtocol == KSenduiMtmImap4Uid )

   436             {

   437             temp.Copy( iImap4Settings->LoginName() );

   438             return iTempStore;

   439             }

   440         else

   441             {            

   442             temp.Copy( iPop3Settings->LoginName() );

   443             return iTempStore;

   444             }

   445         }

   446     else

   447         {

   448         temp.Copy( iSmtpSettings->LoginName() );

   449         return iTempStore;

   450         }       

   451     }

   452 

   453 // ---------------------------------------------------------------------------

   454 // CIpsSetData::UserPwd()

   455 // ---------------------------------------------------------------------------

   456 //

   457 const TDesC& CIpsSetData::UserPwd( const TBool aIncoming ) const

   458     {

   459     FUNC_LOG;

   460     // The method is const type, but we have to store the text into a

   461     // temporary storage, so cast the constness away from the variable.

   462     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   463     

   464     if ( aIncoming )

   465         {        

   466         if ( iProtocol == KSenduiMtmImap4Uid )

   467             {

   468             temp.Copy( iImap4Settings->Password() );

   469             return iTempStore;

   470             }

   471         else

   472             {            

   473             temp.Copy( iPop3Settings->Password() );

   474             return iTempStore;

   475             }

   476         }

   477     else

   478         {

   479         temp.Copy( iSmtpSettings->Password() );

   480         return iTempStore;

   481         }       

   482     }

   483 

   484 // ---------------------------------------------------------------------------

   485 // CIpsSetData::MailServer()

   486 // ---------------------------------------------------------------------------

   487 //

   488 const TDesC& CIpsSetData::MailServer( const TBool aIncoming ) const

   489     {

   490     FUNC_LOG;

   491     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   492     

   493     if ( aIncoming )

   494         {        

   495         if ( iProtocol == KSenduiMtmImap4Uid )

   496             {

   497             temp.Copy( iImap4Settings->ServerAddress() );

   498             return iTempStore;

   499             }

   500         else

   501             {

   502             temp.Copy( iPop3Settings->ServerAddress() );

   503             return iTempStore;

   504             }

   505         }

   506     else

   507         {

   508         temp.Copy( iSmtpSettings->ServerAddress() );

   509         return iTempStore;

   510         }       

   511     }

   512 

   513 // ---------------------------------------------------------------------------

   514 // CIpsSetData::Iap()

   515 // ---------------------------------------------------------------------------

   516 //

   517 TImIAPChoice CIpsSetData::Iap( const TBool aIncoming ) const

   518     {

   519     FUNC_LOG;

   520     

   521     TImIAPChoice ret;

   522     ret.iDialogPref = ECommDbDialogPrefPrompt;

   523     ret.iIAP = 0;

   524     if ( aIncoming )

   525         {

   526         

   527         if ( iIncomingIapPref->NumberOfIAPs() > 0 )

   528             {

   529             ret = iIncomingIapPref->IAPPreference(0);

   530             }

   531         }

   532     else

   533         {

   534         if ( iOutgoingIapPref->NumberOfIAPs() > 0 )

   535             {

   536             ret = iOutgoingIapPref->IAPPreference(0);   

   537             }

   538          

   539         }

   540     return ret;

   541     }

   542 

   543 // ---------------------------------------------------------------------------

   544 // CIpsSetData::Security()

   545 // ---------------------------------------------------------------------------

   546 //

   547 TInt CIpsSetData::Security( const TBool aIncoming ) const

   548     {

   549     FUNC_LOG;

   550     const CImBaseEmailSettings& settings = !aIncoming ? 

   551         *iSmtpSettings : 

   552         iProtocol == KSenduiMtmImap4Uid ? 

   553             *static_cast<const CImBaseEmailSettings*>( iImap4Settings ) : 

   554             *static_cast<const CImBaseEmailSettings*>( iPop3Settings );

   555     return settings.SecureSockets() ? 

   556         EStartTls : settings.SSLWrapper() ? ESslTls : ESecurityOff;

   557     }

   558 

   559 // ---------------------------------------------------------------------------

   560 // CIpsSetData::Port()

   561 // ---------------------------------------------------------------------------

   562 //

   563 TInt CIpsSetData::Port( const TBool aIncoming ) const

   564     {

   565     FUNC_LOG;

   566     if ( aIncoming )

   567         {        

   568         if ( iProtocol == KSenduiMtmImap4Uid )

   569             {

   570             return iImap4Settings->Port();

   571             }

   572         else

   573             {

   574             return iPop3Settings->Port();

   575             }

   576         }

   577     else

   578         {

   579         return iSmtpSettings->Port();

   580         }       

   581     }

   582 

   583 // ---------------------------------------------------------------------------

   584 // CIpsSetData::APop()

   585 // ---------------------------------------------------------------------------

   586 //

   587 TInt CIpsSetData::APop() const

   588     {

   589     FUNC_LOG;

   590     if ( iProtocol == KSenduiMtmImap4Uid )

   591         {

   592         return KErrNotFound;

   593         }

   594     else

   595         {

   596         return iPop3Settings->Apop() ? EIpsSetUiOn : EIpsSetUiOff;

   597         }

   598     }

   599 

   600 // ---------------------------------------------------------------------------

   601 // CIpsSetData::UserAuthentication()

   602 // ---------------------------------------------------------------------------

   603 //

   604 TInt CIpsSetData::UserAuthentication() const

   605     {

   606     FUNC_LOG;

   607     return iExtendedSettings->OutgoingLogin();

   608     }

   609 

   610 // ---------------------------------------------------------------------------

   611 // CIpsSetData::ImapPath()

   612 // ---------------------------------------------------------------------------

   613 //

   614 const TDesC& CIpsSetData::ImapPath() const

   615     {

   616     FUNC_LOG;

   617     // The method is const type, but we have to store the text into a

   618     // temporary storage, so cast the constness away from the variable.

   619     RBuf& temp = *const_cast<RBuf*>( &iTempStore );

   620     

   621     if ( iProtocol == KSenduiMtmImap4Uid )

   622         {        

   623         temp.Copy( iImap4Settings->FolderPath() );

   624         

   625         // If path is not set, use default string

   626         if ( !temp.Length() )

   627             {

   628             HBufC* text = NULL;

   629             TRAP_IGNORE( text = StringLoader::LoadL( R_FSE_SETTINGS_MAIL_FOLDER_PATH ) );

   630             temp.Copy( *text );

   631             delete text;

   632             text = NULL;

   633             }

   634         

   635         return iTempStore;

   636         }

   637     else

   638         {

   639         return KNullDesC;

   640         }

   641     }

   642 

   643 // ---------------------------------------------------------------------------

   644 // CIpsSetData::DownloadSize()

   645 // ---------------------------------------------------------------------------

   646 //

   647 TInt CIpsSetData::DownloadSize() const

   648     {

   649     FUNC_LOG;

   650     TInt ret(0);

   651     if ( iProtocol == KSenduiMtmImap4Uid ) 

   652         {

   653         ret = iImap4Settings->BodyTextSizeLimit();

   654         }

   655     else

   656         {

   657         ret = iPop3Settings->PopulationLimit();

   658         }

   659         

   660     return ret;                

   661     }

   662 

   663 // ---------------------------------------------------------------------------

   664 // CIpsSetData::RetrieveLimit()

   665 // ---------------------------------------------------------------------------

   666 //

   667 TInt CIpsSetData::RetrieveLimit( const TRetrieveLimit aType ) const

   668     {

   669     FUNC_LOG;

   670     TInt ret = 0;

   671     switch ( aType )

   672         {

   673         case EPop3Limit: 

   674             ret = iPop3Settings->InboxSynchronisationLimit();

   675             break;

   676         case EImap4Inbox: 

   677             ret = iImap4Settings->InboxSynchronisationLimit();

   678             break;

   679         case EImap4Folders:

   680             ret = iImap4Settings->MailboxSynchronisationLimit();

   681             break;

   682         default:

   683             break;

   684         }

   685     return ret;        

   686     }

   687 

   688 // ---------------------------------------------------------------------------

   689 // CIpsSetData::Schedule()

   690 // ---------------------------------------------------------------------------

   691 //

   692 TInt CIpsSetData::Schedule() const

   693     {

   694     FUNC_LOG;

   695     // First, check if notifications are on, one button off from the checks

   696     if ( iExtendedSettings->EmailNotificationState() != EMailEmnOff )

   697         {

   698         return ENotification;

   699         }

   700     // EMN is off, maybe its manual mode

   701     else if ( iExtendedSettings->AlwaysOnlineState() == EMailAoOff )

   702         {

   703         return EManual;

   704         }

   705     // Nope, its the interval    

   706     else            

   707         {            

   708         switch ( iExtendedSettings->InboxRefreshTime() )

   709             {

   710             case KIpsSetDataFiveMinutes:            return E5Mins;

   711             case KIpsSetDataTenMinutes:             return E10Mins;

   712             case KIpsSetDataFifteenMinutes:         return E15Mins;

   713             case KIpsSetDataThirtyMinutes:          return E30Mins;

   714             case KIpsSetDataMinutesInHour:          return E1Hour;

   715             case KIpsSetDataMinutesInFourHours:     return E4Hours;

   716             case KIpsSetDataMinutesInTwelveHours:   return E12Hours;

   717             case KIpsSetDataMinutesInOneDay:        return E1Day;

   718             default: break;

   719             }

   720         }

   721         

   722     return E1Hour;        

   723     }

   724 

   725 // ---------------------------------------------------------------------------

   726 // CIpsSetData::Days()

   727 // ---------------------------------------------------------------------------

   728 //

   729 TInt CIpsSetData::Days() const

   730     {

   731     FUNC_LOG;

   732     return iExtendedSettings->SelectedWeekDays();

   733     }

   734 

   735 // ---------------------------------------------------------------------------

   736 // CIpsSetData::Hours()

   737 // ---------------------------------------------------------------------------

   738 //

   739 TTime CIpsSetData::Hours( const TBool aStartTime ) const

   740     {

   741     FUNC_LOG;

   742     return aStartTime ? 

   743         iExtendedSettings->SelectedTimeStart() :

   744         iExtendedSettings->SelectedTimeStop();

   745     }

   746 

   747 // ---------------------------------------------------------------------------

   748 // CIpsSetData::Roaming()

   749 // ---------------------------------------------------------------------------

   750 //

   751 TBool CIpsSetData::Roaming() const

   752     {

   753     FUNC_LOG;

   754     return ( iExtendedSettings->AlwaysOnlineState() == EMailAoHomeOnly ||

   755         iExtendedSettings->EmailNotificationState() == EMailEmnHomeOnly );

   756     }

   757 

   758 // ---------------------------------------------------------------------------

   759 // CIpsSetData::SetProtocol()

   760 // ---------------------------------------------------------------------------

   761 //

   762 void CIpsSetData::SetProtocol( const TUid& aProtocol )

   763     {

   764     FUNC_LOG;

   765     iProtocol = aProtocol;

   766     }

   767 

   768 // ---------------------------------------------------------------------------

   769 // CIpsSetData::SetEmailAddressL()

   770 // ---------------------------------------------------------------------------

   771 //

   772 void CIpsSetData::SetEmailAddressL( const TDesC& aEmailAddress )

   773     {

   774     FUNC_LOG;

   775     iSmtpSettings->SetEmailAddressL( aEmailAddress );

   776     iExtendedSettings->SetEmailAddress( aEmailAddress );

   777     }

   778 

   779 // ---------------------------------------------------------------------------

   780 // CIpsSetData::SetReplyToAddressL()

   781 // ---------------------------------------------------------------------------

   782 //

   783 void CIpsSetData::SetReplyToAddressL( const TDesC& aReplyToAddress )

   784     {

   785     FUNC_LOG;

   786     iSmtpSettings->SetReplyToAddressL( aReplyToAddress );

   787     }

   788     

   789 // ---------------------------------------------------------------------------

   790 // CIpsSetData::SetMailboxName()

   791 // ---------------------------------------------------------------------------

   792 //

   793 void CIpsSetData::SetMailboxName( const TDesC& aMailboxName )

   794     {

   795     FUNC_LOG;

   796     if ( iProtocol == KSenduiMtmImap4Uid )

   797         {

   798         iImap4AccountId.iImapAccountName.Copy( aMailboxName );

   799         }

   800     else

   801         {

   802         iPop3AccountId.iPopAccountName.Copy( aMailboxName );

   803         }            

   804         

   805     iSmtpAccountId.iSmtpAccountName.Copy( aMailboxName );

   806     }

   807 

   808 // ---------------------------------------------------------------------------

   809 // CIpsSetData::SetMyNameL()

   810 // ---------------------------------------------------------------------------

   811 //

   812 void CIpsSetData::SetMyNameL( const TDesC& aMyName )

   813     {

   814     FUNC_LOG;

   815     iSmtpSettings->SetEmailAliasL( aMyName );

   816     }

   817 

   818 // ---------------------------------------------------------------------------

   819 // CIpsSetData::SetIncludeSignature()

   820 // ---------------------------------------------------------------------------

   821 //

   822 void CIpsSetData::SetIncludeSignature( TBool aIncludeSignature )

   823     {

   824     FUNC_LOG;

   825     iSmtpSettings->SetAddSignatureToEmail( aIncludeSignature == EIpsSetUiOn );

   826     }

   827 

   828 // ---------------------------------------------------------------------------

   829 // CIpsSetData::SetSignatureL()

   830 // ---------------------------------------------------------------------------

   831 //

   832 void CIpsSetData::SetSignatureL( const TDesC& aSignature )

   833     {

   834     FUNC_LOG;

   835     iSignature->iRichText->Reset();

   836     iSignature->iRichText->InsertL( 0, aSignature );

   837     }

   838 

   839 // ---------------------------------------------------------------------------

   840 // CIpsSetData::SetUserNameL()

   841 // ---------------------------------------------------------------------------

   842 //

   843 void CIpsSetData::SetUserNameL( 

   844     const TDesC& aIncomingName, 

   845     const TDesC& aOutgoingName )

   846     {

   847     FUNC_LOG;

   848     TBuf8<KIPsSetUiMaxSettingsUsrNameLength> temp;

   849     if ( iProtocol == KSenduiMtmImap4Uid )

   850         {

   851         temp.Copy( aIncomingName );

   852         iImap4Settings->SetLoginNameL( temp );

   853         }

   854     else

   855         {

   856         temp.Copy( aIncomingName );

   857         iPop3Settings->SetLoginNameL( temp );

   858         }

   859     

   860     temp.Copy( aOutgoingName );

   861     iSmtpSettings->SetLoginNameL( temp );

   862     }

   863 

   864 // ---------------------------------------------------------------------------

   865 // CIpsSetData::SetUserPwdL()

   866 // ---------------------------------------------------------------------------

   867 //

   868 void CIpsSetData::SetUserPwdL( 

   869     const TDesC& aIncomingPassword, 

   870     const TDesC& aOutgoingPassword )

   871     {

   872     FUNC_LOG;

   873     TBuf8<KIpsSetUiMaxSettingsTextLength> temp;

   874     if ( iProtocol == KSenduiMtmImap4Uid )

   875         {

   876         temp.Copy( aIncomingPassword );

   877         iImap4Settings->SetPasswordL( temp );

   878         }

   879     else

   880         {

   881         temp.Copy( aIncomingPassword );

   882         iPop3Settings->SetPasswordL( temp );

   883         }

   884     

   885     temp.Copy( aOutgoingPassword );

   886     iSmtpSettings->SetPasswordL( temp );

   887     }

   888 

   889 // ---------------------------------------------------------------------------

   890 // CIpsSetData::SetMailServerL()

   891 // ---------------------------------------------------------------------------

   892 //

   893 void CIpsSetData::SetMailServerL( 

   894     const TDesC& aIncomingServer, 

   895     const TDesC& aOutgoingServer )

   896     {

   897     FUNC_LOG;

   898     if ( iProtocol == KSenduiMtmImap4Uid )

   899         {

   900         iImap4Settings->SetServerAddressL( aIncomingServer );

   901         }

   902     else

   903         {

   904         iPop3Settings->SetServerAddressL( aIncomingServer );

   905         }

   906         

   907     iSmtpSettings->SetServerAddressL( aOutgoingServer );        

   908     }

   909 

   910 // ---------------------------------------------------------------------------

   911 // CIpsSetData::SetIapL()

   912 // ---------------------------------------------------------------------------

   913 //

   914 void CIpsSetData::SetIapL( 

   915     const TImIAPChoice aIncomingIap, 

   916     const TImIAPChoice aOutgoingIap )

   917     {

   918     FUNC_LOG;

   919     // This is not ideal choice, but current situation forces to do this,

   920     // until Reset() funcion is exported from class CImIAPPreferences

   921     delete iIncomingIapPref;

   922     iIncomingIapPref = NULL;

   923     delete iOutgoingIapPref;

   924     iOutgoingIapPref = NULL;

   925 

   926     iIncomingIapPref = CImIAPPreferences::NewLC();

   927     CleanupStack::Pop( iIncomingIapPref );

   928     iOutgoingIapPref = CImIAPPreferences::NewLC();

   929     CleanupStack::Pop( iOutgoingIapPref );

   930 

   931     iIncomingIapPref->AddIAPL( aIncomingIap );

   932     iOutgoingIapPref->AddIAPL( aOutgoingIap );

   933     }

   934 

   935 // ---------------------------------------------------------------------------

   936 // CIpsSetData::SetSecurity()

   937 // ---------------------------------------------------------------------------

   938 //

   939 void CIpsSetData::SetSecurity( 

   940     const TInt aIncomingSecurity, 

   941     const TInt aOutgoingSecurity )

   942     {

   943     FUNC_LOG;

   944     CImBaseEmailSettings& settings = ( iProtocol == KSenduiMtmImap4Uid ) ?

   945         *static_cast<CImBaseEmailSettings*>( iImap4Settings ): 

   946         *static_cast<CImBaseEmailSettings*>( iPop3Settings );

   947     

   948     DoSetSecurity( aIncomingSecurity, settings );

   949     DoSetSecurity( aOutgoingSecurity, *iSmtpSettings );

   950     }

   951 

   952 // ---------------------------------------------------------------------------

   953 // CIpsSetData::DoSetSecurity()

   954 // ---------------------------------------------------------------------------

   955 //

   956 void CIpsSetData::DoSetSecurity( 

   957     const TInt aSecurity,

   958     CImBaseEmailSettings& aSettings )

   959     {

   960     FUNC_LOG;

   961      switch( aSecurity )

   962         {

   963         case EStartTls:

   964             aSettings.SetSecureSockets( ETrue );

   965             aSettings.SetSSLWrapper( EFalse );

   966             break;

   967 

   968         case ESslTls:

   969             aSettings.SetSecureSockets( EFalse );

   970             aSettings.SetSSLWrapper( ETrue );

   971             break;

   972 

   973         case ESecurityOff:

   974             aSettings.SetSecureSockets( EFalse );

   975             aSettings.SetSSLWrapper( EFalse );

   976             break;

   977 

   978         default:

   979             break;

   980         }      

   981     }

   982 

   983 // ---------------------------------------------------------------------------

   984 // CIpsSetData::SetPort()

   985 // ---------------------------------------------------------------------------

   986 //

   987 void CIpsSetData::SetPort( 

   988     const TInt aIncomingPort, 

   989     const TInt aOutgoingPort )

   990     {

   991     FUNC_LOG;

   992     if ( iProtocol == KSenduiMtmImap4Uid )

   993         {

   994         iImap4Settings->SetPort( aIncomingPort );

   995         }

   996     else

   997         {

   998         iPop3Settings->SetPort( aIncomingPort );

   999         }

  1000     

  1001     iSmtpSettings->SetPort( aOutgoingPort );

  1002     }

  1003 

  1004 // ---------------------------------------------------------------------------

  1005 // CIpsSetData::SetAPop()

  1006 // ---------------------------------------------------------------------------

  1007 //

  1008 void CIpsSetData::SetAPop( TInt aAPop )

  1009     {

  1010     FUNC_LOG;

  1011     if ( iProtocol == KSenduiMtmImap4Uid )

  1012         {

  1013         // Do nothing

  1014         }

  1015     else

  1016         {

  1017         iPop3Settings->SetApop( aAPop == EIpsSetUiOn );

  1018         }

  1019     }

  1020 

  1021 // ---------------------------------------------------------------------------

  1022 // CIpsSetData::SetUserAuthentication()

  1023 // ---------------------------------------------------------------------------

  1024 //

  1025 void CIpsSetData::SetUserAuthentication( TInt aUserAuthentication )

  1026     {

  1027     FUNC_LOG;

  1028     iExtendedSettings->SetOutgoingLogin( aUserAuthentication );

  1029     }

  1030 

  1031 // ---------------------------------------------------------------------------

  1032 // CIpsSetData::SetImapPathL()

  1033 // ---------------------------------------------------------------------------

  1034 //

  1035 void CIpsSetData::SetImapPathL( const TDesC& aImapPath )

  1036     {

  1037     FUNC_LOG;

  1038     if ( iProtocol == KSenduiMtmImap4Uid )

  1039         {

  1040         TBuf8<KIpsSetUiMaxSettingsTextLength> temp;

  1041         

  1042         HBufC* text = StringLoader::LoadL( R_FSE_SETTINGS_MAIL_FOLDER_PATH );

  1043         

  1044         if( !text->Compare( aImapPath ) )

  1045             {

  1046             //If the text matches with the default text, clean the text field

  1047             temp.Zero();

  1048             }

  1049         else

  1050             {

  1051             temp.Copy( aImapPath );

  1052             }

  1053         

  1054         delete text;

  1055         text = NULL;

  1056         iImap4Settings->SetFolderPathL( temp );

  1057         }

  1058     }

  1059 

  1060 // ---------------------------------------------------------------------------

  1061 // CIpsSetData::SetDownloadSizeL()

  1062 // ---------------------------------------------------------------------------

  1063 //

  1064 void CIpsSetData::SetDownloadSizeL( 

  1065     const TInt aDownloadControl,

  1066     const TInt aDownloadSize )

  1067     {

  1068     FUNC_LOG;

  1069     TInt size = 0;

  1070     if ( aDownloadControl == CIpsSetData::EHeaders ) 

  1071         {

  1072         size = KIpsSetDataHeadersOnly;

  1073         }

  1074     else if ( aDownloadControl == CIpsSetData::EWholeBody )

  1075         {

  1076         size = KIpsSetDataFullBodyAndAttas;

  1077         }

  1078    //<cmail>

  1079     else if ( iProtocol == KSenduiMtmPop3Uid && aDownloadControl == CIpsSetData::EHeadersPlus )

  1080     	{

  1081     	// fix for POP that has only 2 radio (IMAP has 3) 

  1082     	// and the second should have value of EWholeBody instead of EHeadersPlus 

  1083     	size = KIpsSetDataFullBodyAndAttas; 

  1084     	}

  1085     //</cmail>	

  1086     else

  1087         {

  1088         size = aDownloadSize;

  1089         }

  1090     

  1091     if ( iProtocol == KSenduiMtmImap4Uid )

  1092         {

  1093         iImap4Settings->SetBodyTextSizeLimitL( size );

  1094         }

  1095     else

  1096         {

  1097         iPop3Settings->SetPopulationLimitL( size );

  1098         }

  1099     }

  1100 

  1101 // ---------------------------------------------------------------------------

  1102 // CIpsSetData::SetRetrieveLimit()

  1103 // ---------------------------------------------------------------------------

  1104 //

  1105 void CIpsSetData::SetRetrieveLimit( 

  1106     TInt aRetrieveLimitPop,

  1107     TInt aRetrieveLimitImapInbox,

  1108     TInt aRetrieveLimitImapFolders )

  1109     {

  1110     FUNC_LOG;

  1111     if ( iProtocol == KSenduiMtmImap4Uid )

  1112         {

  1113         iImap4Settings->SetInboxSynchronisationLimit( 

  1114             aRetrieveLimitImapInbox );

  1115         iImap4Settings->SetMailboxSynchronisationLimit( 

  1116             aRetrieveLimitImapFolders );

  1117         }

  1118     else

  1119         {

  1120         iPop3Settings->SetInboxSynchronisationLimit( aRetrieveLimitPop );

  1121         }            

  1122     }

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // CIpsSetData::SetSchedule()

  1126 // ---------------------------------------------------------------------------

  1127 //

  1128 void CIpsSetData::SetSchedule( 

  1129     const TInt aSchedule,

  1130     const TBool aRoaming )

  1131     {

  1132     FUNC_LOG;

  1133     TInt time = 0;

  1134     switch ( aSchedule )