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 

    19 #include <etelmm.h>

    20 #include <msvapi.h>

    21 

    22 #include "engine.h"

    23 #include "enginewrapper.h"

    24 #include "creator_mailbox.h" 

    25 #include "creator_traces.h"

    26 

    27 static const TInt KMailboxesFieldLength = 160;

    28 

    29 _LIT(KCreatorMailboxesPrefixName, "CR_");

    30 

    31 _LIT(KDefaultIncomingServer, "mail.example.com");

    32 _LIT(KDefaultOutgoingServer, "smtp.example.com");

    33 _LIT(KInternet, "internet");

    34 

    35 

    36 //----------------------------------------------------------------------------

    37 

    38 CMailboxesParameters::CMailboxesParameters()

    39     {

    40     LOGSTRING("Creator: CMailboxesParameters::CMailboxesParameters");

    41 

    42     iIncomingPort = KUndef;

    43     iOutgoingPort = KUndef;

    44     iMaxEmailSize = KUndef;

    45     iSyncRate = KUndef;

    46     iAttachmentFetchSize = KUndef;

    47     iAttachmentSizeLimit = KUndef;

    48     iBodyTextSizeLimit = KUndef;

    49     iAttachmentFetchSize = KUndef;

    50     iInboxSyncLimit = -1; // -1 = All

    51     iMailboxSyncLimit = -1; // -1 = All    

    52     iToCCIncludeLimit = KUndef;

    53     iImapIdleTimeout = KUndef;

    54     

    55     /*iMailboxName = HBufC::New(KMailboxesFieldLength);

    56     iAccessPoint = HBufC::New(KMailboxesFieldLength);

    57     iMyMailAddress = HBufC::New(KMailboxesFieldLength);

    58     iOutgoingMailServer = HBufC::New(KMailboxesFieldLength);

    59     iUserName = HBufC::New(KMailboxesFieldLength);

    60     iPassword = HBufC::New(KMailboxesFieldLength);

    61     iIncomingMailServer = HBufC::New(KMailboxesFieldLength);*/

    62     }

    63 

    64 CMailboxesParameters::~CMailboxesParameters()

    65     {

    66     LOGSTRING("Creator: CMailboxesParameters::~CMailboxesParameters");

    67 

    68     /*delete iIncomingMailServer;

    69     delete iPassword;

    70     delete iUserName;

    71     delete iOutgoingMailServer;

    72     delete iMyMailAddress;

    73     delete iAccessPoint;

    74     delete iMailboxName;*/

    75     

    76     delete iMailboxName;

    77     delete iIncomingLoginName;

    78     delete iIncomingPassword;

    79     delete iIncomingServerName;

    80     delete iIncomingConnectionMethod;

    81     delete iIncomingFolderPath;

    82     delete iPathSeparator;

    83     delete iOutgoingLoginName;

    84     delete iOutgoingPassword;

    85     delete iOutgoingServerName;

    86     delete iOutgoingConnectionMethod;

    87     delete iOwnEmailAddress;

    88     delete iOwnEmailAlias;

    89     delete iReceiptAddress;

    90     delete iReplyToAddress;

    91     }

    92 

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

    94 

    95 CCreatorMailboxes* CCreatorMailboxes::NewL(CCreatorEngine* aEngine)

    96     {

    97     CCreatorMailboxes* self = CCreatorMailboxes::NewLC(aEngine);

    98     CleanupStack::Pop(self);

    99     return self;

   100     }

   101 

   102 CCreatorMailboxes* CCreatorMailboxes::NewLC(CCreatorEngine* aEngine)

   103     {

   104     CCreatorMailboxes* self = new (ELeave) CCreatorMailboxes;

   105     CleanupStack::PushL(self);

   106     self->ConstructL(aEngine);

   107     return self;

   108     }

   109 

   110 CCreatorMailboxes::CCreatorMailboxes()

   111     {    

   112     }

   113 

   114 void CCreatorMailboxes::ConstructL(CCreatorEngine* aEngine)

   115     {

   116     LOGSTRING("Creator: CCreatorMailboxes::ConstructL");

   117 

   118     iEngine = aEngine;

   119     }

   120 

   121 CCreatorMailboxes::~CCreatorMailboxes()

   122     {

   123     LOGSTRING("Creator: CCreatorMailboxes::~CCreatorMailboxes");

   124     if ( iEngine && iEntryIds.Count() )

   125         {

   126         TRAP_IGNORE( iEngine->WriteEntryIdsToStoreL( iEntryIds, KUidDictionaryUidMailbox ) );

   127         }

   128     iEntryIds.Reset();

   129     iEntryIds.Close();

   130     

   131     if (iParameters)

   132         delete iParameters;

   133     }

   134 

   135 //----------------------------------------------------------------------------

   136 

   137 TBool CCreatorMailboxes::AskDataFromUserL(TInt aCommand, TInt& aNumberOfEntries)

   138     {

   139     LOGSTRING("Creator: CCreatorMailboxes::AskDataFromUserL");

   140     if ( aCommand == ECmdDeleteMailboxes )

   141         {

   142         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes?") );

   143         }

   144     else if ( aCommand ==  ECmdDeleteCreatorMailboxes )

   145         {

   146         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes created with Creator?") );

   147         }

   148     return iEngine->GetEngineWrapper()->EntriesQueryDialog(aNumberOfEntries, _L("How many entries to create?"));

   149     }

   150 

   151 

   152 //----------------------------------------------------------------------------

   153 

   154 TInt CCreatorMailboxes::CreateMailboxEntryL(CMailboxesParameters *aParameters)

   155     {

   156     LOGSTRING("Creator: CCreatorMailboxes::CreateMailboxEntryL");

   157 

   158       // clear any existing parameter definations

   159     delete iParameters;

   160     iParameters = NULL;

   161     

   162     CMailboxesParameters* parameters = aParameters;

   163     

   164     // random data needed if no predefined data available

   165     if (!parameters)

   166         {

   167         iParameters = new(ELeave) CMailboxesParameters;

   168         parameters = iParameters;

   169 

   170         TPtrC company(iEngine->RandomString(CCreatorEngine::ECompany));

   171         TPtrC firstName(iEngine->RandomString(CCreatorEngine::EFirstName));

   172         

   173         delete parameters->iMailboxName;

   174         parameters->iMailboxName = 0;

   175         parameters->iMailboxName = HBufC::NewL(KMailboxesFieldLength);

   176         parameters->iMailboxName->Des() = KCreatorMailboxesPrefixName;

   177         parameters->iMailboxName->Des().Append( company );

   178         parameters->iMailboxName->Des().Append(_L(" #"));

   179         parameters->iMailboxName->Des().AppendNum(iEngine->RandomNumber(1, 100));

   180         

   181         delete parameters->iIncomingLoginName;

   182         parameters->iIncomingLoginName = 0;

   183         parameters->iIncomingLoginName = HBufC::NewL(KMailboxesFieldLength); 

   184         delete parameters->iOutgoingLoginName;

   185         parameters->iOutgoingLoginName = 0;

   186         parameters->iOutgoingLoginName = HBufC::NewL(KMailboxesFieldLength); 

   187         parameters->iIncomingLoginName->Des() = iEngine->RandomString(CCreatorEngine::EFirstName);

   188         parameters->iIncomingLoginName->Des().LowerCase();

   189         parameters->iOutgoingLoginName->Des().Copy(parameters->iIncomingLoginName->Des());

   190         

   191         delete parameters->iIncomingPassword;

   192         parameters->iIncomingPassword = 0;

   193         parameters->iIncomingPassword = HBufC::NewL(KMailboxesFieldLength); 

   194         delete parameters->iOutgoingPassword;

   195         parameters->iOutgoingPassword = 0;

   196         parameters->iOutgoingPassword = HBufC::NewL(KMailboxesFieldLength); 

   197         parameters->iIncomingPassword->Des() = iEngine->RandomString(CCreatorEngine::ESurname);

   198         parameters->iIncomingPassword->Des().LowerCase();

   199         parameters->iOutgoingPassword->Des().Copy(parameters->iIncomingPassword->Des());

   200         

   201         delete parameters->iIncomingServerName;

   202         parameters->iIncomingServerName = 0;

   203         parameters->iIncomingServerName = HBufC::NewL(KMailboxesFieldLength); 

   204         parameters->iIncomingServerName->Des() = _L("incoming.");

   205         parameters->iIncomingServerName->Des().Append(company);

   206         parameters->iIncomingServerName->Des().Append(_L(".com"));

   207         parameters->iIncomingServerName->Des().LowerCase();

   208                 

   209         delete parameters->iIncomingConnectionMethod;

   210         parameters->iIncomingConnectionMethod = 0;

   211         parameters->iIncomingConnectionMethod = HBufC::NewL(KInternet().Length());

   212         parameters->iIncomingConnectionMethod->Des() = KInternet;  // use always this one, if it's not found, default will be used instead

   213         

   214         delete parameters->iOutgoingServerName;

   215         parameters->iOutgoingServerName = 0;

   216         parameters->iOutgoingServerName = HBufC::NewL(KMailboxesFieldLength); 

   217         parameters->iOutgoingServerName->Des() = _L("smtp.");

   218         parameters->iOutgoingServerName->Des().Append(company);

   219         parameters->iOutgoingServerName->Des().Append(_L(".com"));

   220         parameters->iOutgoingServerName->Des().LowerCase();

   221         

   222         delete parameters->iOutgoingConnectionMethod;

   223         parameters->iOutgoingConnectionMethod = 0;

   224         parameters->iOutgoingConnectionMethod = HBufC::NewL(KInternet().Length());

   225         parameters->iOutgoingConnectionMethod->Des() = KInternet;  // use always this one, if it's not found, default will be used instead

   226 

   227         delete parameters->iOwnEmailAddress;

   228         parameters->iOwnEmailAddress = 0;

   229         parameters->iOwnEmailAddress = iEngine->CreateEmailAddressLC();

   230         parameters->iOwnEmailAddress->Des().LowerCase();

   231         CleanupStack::Pop(); // parameters->iOwnEmailAddress

   232         

   233         delete parameters->iOwnEmailAlias;

   234         parameters->iOwnEmailAlias = 0;

   235         parameters->iOwnEmailAlias = HBufC::NewL(firstName.Length());        

   236         parameters->iOwnEmailAlias->Des().Copy(firstName);       

   237 

   238         delete parameters->iReceiptAddress;

   239         parameters->iReceiptAddress = 0;

   240         parameters->iReceiptAddress = iEngine->CreateEmailAddressLC();

   241         parameters->iReceiptAddress->Des().LowerCase();

   242         CleanupStack::Pop(); // parameters->iReceiptAddress

   243         

   244         delete parameters->iReplyToAddress;

   245         parameters->iReplyToAddress = 0;

   246         parameters->iReplyToAddress = iEngine->CreateEmailAddressLC();

   247         parameters->iReplyToAddress->Des().LowerCase();

   248         CleanupStack::Pop(); // parameters->iReplyToAddress

   249         

   250         parameters->iIncomingSSLWrapper = iEngine->RandomNumber(0, 1);

   251         parameters->iIncomingSecureSockets = iEngine->RandomNumber(0, 1);        

   252         parameters->iAcknowledgeReceipts = iEngine->RandomNumber(0, 1);

   253         parameters->iAutoSendOnConnect = iEngine->RandomNumber(0, 1);

   254         parameters->iDeleteEmailsAtDisconnect = iEngine->RandomNumber(0, 1);

   255         parameters->iImapIdleCommand = iEngine->RandomNumber(0, 1);

   256         parameters->iMarkSeenInSync = iEngine->RandomNumber(0, 1);

   257         parameters->iEnableExpungeMode = iEngine->RandomNumber(0, 1);

   258         parameters->iUseApop = iEngine->RandomNumber(0, 1);

   259         parameters->iDisconnectedUserMode = iEngine->RandomNumber(0, 1);                

   260         parameters->iOutgoingSSLWrapper = iEngine->RandomNumber(0, 1);

   261         parameters->iOutgoingSecureSockets = iEngine->RandomNumber(0, 1);

   262         parameters->iIncludeSignature = EFalse;

   263         parameters->iAddVCard = EFalse;

   264         parameters->iRequestReceipts = iEngine->RandomNumber(0, 1);

   265         parameters->iSmtpAuth = iEngine->RandomNumber(0, 1);

   266         

   267         parameters->iIncomingPort = iEngine->RandomNumber(25, 500);

   268         parameters->iAttachmentSizeLimit = iEngine->RandomNumber(1, KMaxTInt);

   269         parameters->iBodyTextSizeLimit = iEngine->RandomNumber(1, KMaxTInt);

   270         parameters->iAttachmentFetchSize = iEngine->RandomNumber(1, 40960);

   271         parameters->iImapIdleTimeout = iEngine->RandomNumber(10, 2000);

   272         parameters->iMaxEmailSize = iEngine->RandomNumber(1024, KMaxTInt);

   273         parameters->iSyncRate = iEngine->RandomNumber(10, 500);        

   274         parameters->iInboxSyncLimit = iEngine->RandomNumber(-1, 256);

   275         parameters->iMailboxSyncLimit = iEngine->RandomNumber(-1, 256);

   276         parameters->iOutgoingPort = KDefaultSmtpPort;

   277         parameters->iToCCIncludeLimit = iEngine->RandomNumber(0, 30);                      

   278         

   279         parameters->iGetEmailOptions = (CMailboxesParameters::TGetEmailOption) iEngine->RandomNumber(CMailboxesParameters::EUndef, CMailboxesParameters::EGetEmailOptionLast-1);

   280         parameters->iSubscribeType = (TFolderSubscribeType) iEngine->RandomNumber(EUpdateNeither, EUpdateBoth);

   281         parameters->iSyncType = (TFolderSyncType) iEngine->RandomNumber(EUseCombination, EUseRemote);

   282         parameters->iSendCopyToSelf = (TImSMTPSendCopyToSelf) iEngine->RandomNumber(ESendNoCopy, ESendCopyAsBccRecipient);

   283         parameters->iSendOption = (TImSMTPSendMessageOption) iEngine->RandomNumber(ESendMessageImmediately, ESendMessageOnRequest);

   284         parameters->iMailboxType = (TMailboxType) iEngine->RandomNumber(EMailboxPOP3, EMailboxIMAP4);

   285         }

   286    

   287     TInt err = KErrNone;

   288     

   289     // make sure we have some IMEI stored

   290     if (iIMEI.Length() == 0)

   291         {

   292         TRAP(err, GetIMEIFromThePhoneL());

   293         }

   294 

   295     // init 

   296     CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;

   297     CleanupStack::PushL(imap4Set);

   298     CImPop3Settings* pop3Set = new(ELeave) CImPop3Settings;

   299     CleanupStack::PushL(pop3Set);

   300     CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;

   301     CleanupStack::PushL(smtpSet);

   302     CImIAPPreferences* outgoingIAPSet = CImIAPPreferences::NewLC();

   303     CImIAPPreferences* incomingIAPSet = CImIAPPreferences::NewLC();

   304     CEmailAccounts* account = CEmailAccounts::NewLC();

   305   

   306     // Get SMTP settings:

   307     PopulateSmtpSettingsL(*account, *smtpSet, *outgoingIAPSet, *parameters);

   308   

   309     // appending mailbox type to array to be able to use

   310     // correct type when deleting mailboxes

   311     iEntryIds.Append( parameters->iMailboxType );

   312     

   313     if (parameters->iMailboxType == EMailboxIMAP4)

   314         {

   315         // Get IMAP settings:

   316         PopulateImapSettingsL(*account, *imap4Set, *incomingIAPSet, *parameters);

   317         TImapAccount imapAccountId = account->CreateImapAccountL(parameters->iMailboxName->Des(), *imap4Set, *incomingIAPSet, EFalse);

   318         TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(imapAccountId, *smtpSet, *outgoingIAPSet, EFalse);

   319         account->SetDefaultSmtpAccountL(smtpAccountId);

   320 

   321         iEntryIds.Append( imapAccountId.iImapAccountId );

   322         iEntryIds.Append( imapAccountId.iImapService );

   323         iEntryIds.Append( imapAccountId.iSmtpService );      

   324         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   325         iEntryIds.Append( smtpAccountId.iSmtpService );

   326         iEntryIds.Append( smtpAccountId.iRelatedService );

   327         

   328         StoreIMEIToEntryL( imapAccountId.iImapService );

   329         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   330         }

   331     else

   332         {

   333         // Get POP settings:

   334         PopulatePopSettingsL(*account, *pop3Set, *incomingIAPSet, *parameters);

   335         TPopAccount popAccountId = account->CreatePopAccountL(parameters->iMailboxName->Des(), *pop3Set, *incomingIAPSet, EFalse);

   336         TSmtpAccount smtpAccountId = account->CreateSmtpAccountL(popAccountId, *smtpSet, *outgoingIAPSet, EFalse);     

   337         account->SetDefaultSmtpAccountL(smtpAccountId);

   338         

   339         iEntryIds.Append( popAccountId.iPopAccountId );

   340         iEntryIds.Append( popAccountId.iPopService );

   341         iEntryIds.Append( popAccountId.iSmtpService );

   342         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   343         iEntryIds.Append( smtpAccountId.iSmtpService );

   344         iEntryIds.Append( smtpAccountId.iRelatedService );

   345 

   346         StoreIMEIToEntryL( popAccountId.iPopService );

   347         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   348         }  

   349     CleanupStack::PopAndDestroy(6); //imap4Set, pop3Set, smtpSet, outgoingIAPSet, incomingIAPSet, account 

   350         

   351     return err;

   352     }

   353 

   354 void CCreatorMailboxes::PopulateImapSettingsL( 

   355             CEmailAccounts& aEmailAccount, 

   356             CImImap4Settings& aImapSettings, 

   357             CImIAPPreferences& aIApSettings, 

   358             const CMailboxesParameters& aParameters )

   359     {

   360     // Get default settings first:

   361     aEmailAccount.PopulateDefaultImapSettingsL(aImapSettings, aIApSettings);

   362     

   363     TImIAPChoice iapChoice;

   364     iapChoice.iIAP = 0;

   365     if( aParameters.iIncomingConnectionMethod == 0 || 

   366         aParameters.iIncomingConnectionMethod->Des().Length() == 0 )

   367         {

   368         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( KInternet ));

   369         }

   370     else

   371         {

   372         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( aParameters.iIncomingConnectionMethod->Des()));

   373         }

   374     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   375     aIApSettings.AddIAPL(iapChoice);

   376     

   377     TBuf8<256> buf8;

   378     if( aParameters.iIncomingLoginName && aParameters.iIncomingLoginName->Length() > 0 )                

   379         buf8.Copy(aParameters.iIncomingLoginName->Des());

   380     else

   381         buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

   382     aImapSettings.SetLoginNameL(buf8);  //8

   383     

   384     if( aParameters.iIncomingPassword && aParameters.iIncomingPassword->Length() > 0 )

   385         buf8.Copy(aParameters.iIncomingPassword->Des());    

   386     else

   387         buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

   388     aImapSettings.SetPasswordL(buf8);  //8

   389     

   390     if( aParameters.iIncomingFolderPath && aParameters.iIncomingFolderPath->Length() > 0 )

   391         {

   392         buf8.Copy(aParameters.iIncomingFolderPath->Des());

   393         aImapSettings.SetFolderPathL(buf8);

   394         }

   395     

   396     if( aParameters.iPathSeparator && aParameters.iPathSeparator->Length() > 0 )

   397         aImapSettings.SetPathSeparator(aParameters.iIncomingFolderPath->Des()[0]);

   398     

   399     aImapSettings.SetDisconnectedUserMode(aParameters.iDisconnectedUserMode);

   400     aImapSettings.SetSynchronise(aParameters.iSyncType);

   401     aImapSettings.SetSubscribe(aParameters.iSubscribeType);

   402     aImapSettings.SetAutoSendOnConnect(aParameters.iAutoSendOnConnect);

   403     

   404     if(aParameters.iMaxEmailSize != KUndef )

   405         aImapSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   406     

   407     aImapSettings.SetDeleteEmailsWhenDisconnecting(aParameters.iDeleteEmailsAtDisconnect);

   408     aImapSettings.SetAcknowledgeReceipts(aParameters.iAcknowledgeReceipts);

   409             

   410     if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyText )

   411         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyText);

   412     else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyTextAndAttachments )

   413         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyTextAndAttachments);

   414     else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetAttachments )

   415         aImapSettings.SetGetMailOptions(EGetImap4EmailAttachments);

   416     else if(aParameters.iGetEmailOptions == CMailboxesParameters::EGetBodyAlternativeText )

   417         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyAlternativeText);

   418     else

   419         aImapSettings.SetGetMailOptions(EGetImap4EmailHeaders); // Default

   420     

   421     if( aParameters.iInboxSyncLimit != KUndef )

   422         aImapSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   423     

   424     if( aParameters.iMailboxSyncLimit != KUndef )

   425         aImapSettings.SetMailboxSynchronisationLimit(aParameters.iMailboxSyncLimit);

   426     

   427     aImapSettings.SetUpdatingSeenFlags(aParameters.iMarkSeenInSync);

   428     

   429     if( aParameters.iSyncRate != KUndef )

   430         aImapSettings.SetSyncRateL(aParameters.iSyncRate);

   431     

   432     if( aParameters.iAttachmentFetchSize != KUndef )

   433         aImapSettings.SetFetchSizeL(aParameters.iAttachmentFetchSize);

   434     

   435     aImapSettings.SetImapIdle(aParameters.iImapIdleCommand);

   436     if( aParameters.iImapIdleTimeout != KUndef )

   437         aImapSettings.SetImapIdleTimeoutL(aParameters.iImapIdleTimeout);

   438     

   439     if( aParameters.iBodyTextSizeLimit != KUndef )

   440         aImapSettings.SetBodyTextSizeLimitL(aParameters.iBodyTextSizeLimit);

   441     

   442     if( aParameters.iAttachmentSizeLimit != KUndef )

   443         aImapSettings.SetAttachmentSizeLimitL(aParameters.iAttachmentSizeLimit);

   444     

   445 #if(!defined __SERIES60_30__ && !defined __SERIES60_31__)

   446     aImapSettings.SetUseExpunge(aParameters.iEnableExpungeMode);

   447 #endif

   448     

   449     if(aParameters.iIncomingServerName && aParameters.iIncomingServerName->Length() > 0 )

   450         aImapSettings.SetServerAddressL(aParameters.iIncomingServerName->Des());

   451     else

   452         aImapSettings.SetServerAddressL(KDefaultIncomingServer);

   453         

   454     if( aParameters.iIncomingPort != KUndef )

   455         aImapSettings.SetPort(aParameters.iIncomingPort);                 

   456       

   457     aImapSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   458     aImapSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);

   459     }

   460 

   461 void CCreatorMailboxes::PopulatePopSettingsL( 

   462             CEmailAccounts& aEmailAccount, 

   463             CImPop3Settings& aPopSettings, 

   464             CImIAPPreferences& aIApSettings, 

   465             const CMailboxesParameters& aParameters )

   466     {

   467     aEmailAccount.PopulateDefaultPopSettingsL(aPopSettings, aIApSettings);

   468     

   469     TImIAPChoice iapChoice;

   470     iapChoice.iIAP = 0;

   471     if( aParameters.iIncomingConnectionMethod == 0 || 

   472         aParameters.iIncomingConnectionMethod->Des().Length() == 0 )

   473         {

   474         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( KInternet ));

   475         }

   476     else

   477         {

   478         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( aParameters.iIncomingConnectionMethod->Des() ));

   479         }

   480     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   481     aIApSettings.AddIAPL(iapChoice);

   482     

   483     TBuf8<256> buf8;

   484     if( aParameters.iIncomingLoginName && aParameters.iIncomingLoginName->Length() > 0 )                

   485         buf8.Copy(aParameters.iIncomingLoginName->Des());

   486     else

   487         buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

   488     aPopSettings.SetLoginNameL(buf8);  //8

   489         

   490     if( aParameters.iIncomingPassword && aParameters.iIncomingPassword->Length() > 0 )

   491         buf8.Copy(aParameters.iIncomingPassword->Des());    

   492     else

   493         buf8.Copy(iEngine->RandomString(CCreatorEngine::EFirstName));

   494     aPopSettings.SetPasswordL(buf8);  //8

   495     

   496     aPopSettings.SetAutoSendOnConnect( aParameters.iAutoSendOnConnect );

   497     aPopSettings.SetApop( aParameters.iUseApop );

   498     aPopSettings.SetDisconnectedUserMode( aParameters.iDisconnectedUserMode );

   499     aPopSettings.SetDeleteEmailsWhenDisconnecting( aParameters.iDeleteEmailsAtDisconnect );

   500     aPopSettings.SetAcknowledgeReceipts( aParameters.iAcknowledgeReceipts );

   501     

   502     if( aParameters.iMaxEmailSize != KUndef )

   503         aPopSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   504     

   505     if(aParameters.iGetEmailOptions != CMailboxesParameters::EGetHeaders && 

   506             aParameters.iGetEmailOptions != CMailboxesParameters::EUndef )

   507         {

   508         aPopSettings.SetGetMailOptions(EGetPop3EmailMessages);

   509         aPopSettings.SetPopulationLimitL( -1 ); // -1 = body and attachment

   510         }

   511     else

   512         {

   513         aPopSettings.SetGetMailOptions(EGetPop3EmailHeaders); // Default

   514         aPopSettings.SetPopulationLimitL( -2 ); // -2 = headers only

   515         }

   516     

   517     if( aParameters.iInboxSyncLimit != KUndef )

   518         {

   519         aPopSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   520         }

   521     

   522     if(aParameters.iIncomingServerName && aParameters.iIncomingServerName->Length() > 0 )

   523         aPopSettings.SetServerAddressL(aParameters.iIncomingServerName->Des());

   524     else

   525         aPopSettings.SetServerAddressL(KDefaultIncomingServer);

   526             

   527     if( aParameters.iIncomingPort != KUndef )

   528         aPopSettings.SetPort(aParameters.iIncomingPort);                 

   529           

   530     aPopSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   531     aPopSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);    

   532     }

   533 

   534 void CCreatorMailboxes::PopulateSmtpSettingsL( 

   535         CEmailAccounts& aEmailAccount, 

   536         CImSmtpSettings& aSmtpSettings, 

   537         CImIAPPreferences& aIApSettings, 

   538         const CMailboxesParameters& aParameters )

   539     {    

   540     // Get default settings first: 

   541     aEmailAccount.PopulateDefaultSmtpSettingsL(aSmtpSettings, aIApSettings);

   542     TImIAPChoice iapChoice;

   543     iapChoice.iIAP = 0;

   544     if( aParameters.iOutgoingConnectionMethod == 0 || 

   545         aParameters.iOutgoingConnectionMethod->Des().Length() == 0 )

   546         {

   547         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( KInternet ));

   548         }

   549     else

   550         {

   551         TRAP_IGNORE( iapChoice.iIAP = iEngine->AccessPointNameToIdL( aParameters.iOutgoingConnectionMethod->Des() ));

   552         }

   553     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   554     aIApSettings.AddIAPL(iapChoice);

   555     

   556     // set SMTP preferences

   557     if( aParameters.iOwnEmailAlias && aParameters.iOwnEmailAlias->Length() > 0 )

   558         aSmtpSettings.SetEmailAliasL(aParameters.iOwnEmailAlias->Des());

   559     

   560     if( aParameters.iOwnEmailAddress && aParameters.iOwnEmailAddress->Length() > 0 )    

   561         aSmtpSettings.SetEmailAddressL(aParameters.iOwnEmailAddress->Des());

   562     

   563     if( aParameters.iReplyToAddress && aParameters.iReplyToAddress->Length() > 0 )

   564         aSmtpSettings.SetReplyToAddressL(aParameters.iReplyToAddress->Des());

   565     

   566     if( aParameters.iReceiptAddress && aParameters.iReceiptAddress->Length() > 0 )

   567         aSmtpSettings.SetReceiptAddressL(aParameters.iReceiptAddress->Des());    

   568     

   569     aSmtpSettings.SetBodyEncoding(EMsgOutboxMIME);

   570     aSmtpSettings.SetAddVCardToEmail(aParameters.iAddVCard);

   571     aSmtpSettings.SetAddSignatureToEmail(aParameters.iIncludeSignature);

   572     aSmtpSettings.SetRequestReceipts(aParameters.iRequestReceipts);

   573     aSmtpSettings.SetSendCopyToSelf(aParameters.iSendCopyToSelf);    

   574     aSmtpSettings.SetSendMessageOption(aParameters.iSendOption);        

   575             

   576     TBuf8<256> buf8;

   577     if( aParameters.iOutgoingLoginName && aParameters.iOutgoingLoginName->Length() > 0 )

   578         {

   579         buf8.Copy(aParameters.iOutgoingLoginName->Des());

   580         aSmtpSettings.SetLoginNameL(buf8);  //8

   581         }

   582     

   583     if( aParameters.iOutgoingPassword && aParameters.iOutgoingPassword->Length() > 0)

   584         {

   585         buf8.Copy(aParameters.iOutgoingPassword->Des());

   586         aSmtpSettings.SetPasswordL(buf8);  //8

   587         }

   588     

   589     aSmtpSettings.SetSMTPAuth(aParameters.iSmtpAuth);

   590     if( aParameters.iToCCIncludeLimit != KUndef )

   591          aSmtpSettings.SetToCcIncludeLimitL(aParameters.iToCCIncludeLimit);

   592     

   593     if( aParameters.iOutgoingServerName && aParameters.iOutgoingServerName->Length() > 0 )

   594         aSmtpSettings.SetServerAddressL(aParameters.iOutgoingServerName->Des());

   595     else

   596         aSmtpSettings.SetServerAddressL(KDefaultOutgoingServer);

   597     

   598     if( aParameters.iOutgoingPort != KUndef )

   599         aSmtpSettings.SetPort(aParameters.iOutgoingPort);

   600                 

   601     aSmtpSettings.SetSecureSockets(aParameters.iOutgoingSecureSockets);

   602     aSmtpSettings.SetSSLWrapper(aParameters.iOutgoingSSLWrapper);

   603     }

   604 

   605 //----------------------------------------------------------------------------

   606 

   607 void CCreatorMailboxes::StoreIMEIToEntryL(const TMsvId aMailboxId)

   608     {

   609     LOGSTRING("Creator: CCreatorMailboxes::StoreIMEIToEntryL");

   610 

   611     CMsvSession* session = CMsvSession::OpenSyncL(*this);

   612     CleanupStack::PushL(session);

   613     

   614     CMsvEntry* centry = session->GetEntryL(aMailboxId);

   615     CleanupStack::PushL(centry);

   616 

   617     TMsvEntry tentry = centry->Entry();

   618     tentry.iDescription.Set(iIMEI);

   619     centry->ChangeL(tentry);

   620 

   621     CleanupStack::PopAndDestroy(2); // centry, session

   622     }

   623 

   624 //----------------------------------------------------------------------------

   625 

   626 void CCreatorMailboxes::GetIMEIFromThePhoneL()

   627     {

   628     LOGSTRING("Creator: CCreatorMailboxes::GetIMEIFromThePhoneL");

   629 

   630 #ifndef __WINS__

   631 

   632     RTelServer telServer;

   633     User::LeaveIfError( telServer.Connect() );

   634     CleanupClosePushL(telServer);

   635 

   636     TInt numPhones = 0;

   637     User::LeaveIfError( telServer.EnumeratePhones( numPhones ) );

   638     if ( numPhones < 1 )

   639         {

   640         User::Leave( KErrNotFound );

   641         }

   642     RTelServer::TPhoneInfo info;

   643     User::LeaveIfError( telServer.GetPhoneInfo( 0, info ) );

   644     RMobilePhone mobilePhone;

   645     User::LeaveIfError( mobilePhone.Open( telServer, info.iName ) );

   646     CleanupClosePushL( mobilePhone );

   647 

   648     //mobilePhone.Initialise();

   649     TUint32 identityCaps;

   650     User::LeaveIfError( mobilePhone.GetIdentityCaps( identityCaps ) );

   651 

   652     if ( identityCaps & RMobilePhone::KCapsGetSerialNumber )

   653         {

   654         TRequestStatus status;

   655         RMobilePhone::TMobilePhoneIdentityV1 mobilePhoneIdentity;

   656 

   657         mobilePhone.GetPhoneId( status, mobilePhoneIdentity );

   658 

   659         User::WaitForRequest( status );

   660         User::LeaveIfError( status.Int() );

   661 

   662         iIMEI.Copy( mobilePhoneIdentity.iSerialNumber );

   663         }

   664     else

   665         {

   666         User::Leave( KErrNotSupported );

   667         }

   668 

   669     CleanupStack::PopAndDestroy( &mobilePhone );

   670     CleanupStack::PopAndDestroy( &telServer );

   671 

   672 #else

   673 

   674     // use fixed IMEI for emulator

   675     _LIT( KIMAEmulatorImei, "123456789012345" );

   676     iIMEI.Copy( KIMAEmulatorImei );

   677 

   678 #endif // __WINS__

   679 

   680     }

   681     

   682 //----------------------------------------------------------------------------

   683 

   684 void CCreatorMailboxes::HandleSessionEventL(TMsvSessionEvent /*aEvent*/, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/) // from MMsvSessionObserver

   685     {

   686     }

   687 

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

   689 void CCreatorMailboxes::DeleteAllL()

   690     {

   691     LOGSTRING("Creator: CCreatorMailboxes::DeleteAllL");

   692     

   693     CEmailAccounts* accountMgr = CEmailAccounts::NewLC();

   694     

   695     // Delete pop accounts

   696     RArray<TPopAccount> popAccountsToDelete;

   697     CleanupClosePushL( popAccountsToDelete );

   698     accountMgr->GetPopAccountsL( popAccountsToDelete );

   699     for ( TInt i = 0; i < popAccountsToDelete.Count(); i++ )

   700         {

   701         accountMgr->DeletePopAccountL( popAccountsToDelete[i] );

   702         }

   703     CleanupStack::PopAndDestroy( &popAccountsToDelete );

   704     

   705     // Delete imap accounts

   706     RArray<TImapAccount> imapAccountsToDelete;

   707     CleanupClosePushL( imapAccountsToDelete );

   708     accountMgr->GetImapAccountsL( imapAccountsToDelete );

   709     for ( TInt i = 0; i < imapAccountsToDelete.Count(); i++ )

   710         {

   711         accountMgr->DeleteImapAccountL( imapAccountsToDelete[i] );

   712         }

   713     CleanupStack::PopAndDestroy( &imapAccountsToDelete );

   714     

   715     // Delete smtp accounts

   716     RArray<TSmtpAccount> smtpAccountsToDelete;

   717     CleanupClosePushL( smtpAccountsToDelete );

   718     accountMgr->GetSmtpAccountsL( smtpAccountsToDelete );

   719     for ( TInt i = 0; i < smtpAccountsToDelete.Count(); i++ )

   720         {

   721         accountMgr->DeleteSmtpAccountL( smtpAccountsToDelete[i] );

   722         }

   723     CleanupStack::PopAndDestroy( &smtpAccountsToDelete );

   724 

   725     iEntryIds.Reset();

   726     

   727     // all entries deleted, remove the Mailbox related registry

   728     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   729     

   730     CleanupStack::PopAndDestroy( accountMgr ); 

   731     }

   732 

   733 //----------------------------------------------------------------------------

   734 void CCreatorMailboxes::DeleteAllCreatedByCreatorL()

   735     {

   736     LOGSTRING("Creator: CCreatorMailboxes::DeleteAllCreatedByCreatorL");

   737     

   738     iEntryIds.Reset();

   739     CEmailAccounts* accountMgr = CEmailAccounts::NewLC();

   740     

   741     // fetch ids of entries created by Creator

   742     iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidMailbox );

   743     

   744     TInt i(0);

   745     while ( i < iEntryIds.Count() && iEntryIds.Count() > 6 ) 

   746         {

   747         // there should be at least 7 items in the array:

   748         // one for mailbox type

   749         // 3 for imap OR pop ids

   750         // 3 for smtp ids

   751 

   752         // delete entries

   753         

   754         TInt type = iEntryIds[i++]; // TMailboxType

   755         if ( type == EMailboxPOP3 )

   756             {

   757             TPopAccount popAccount;

   758             popAccount.iPopAccountId = iEntryIds[i++];

   759             popAccount.iPopService = iEntryIds[i++];            

   760             popAccount.iSmtpService = iEntryIds[i++];

   761             TRAP_IGNORE( accountMgr->DeletePopAccountL( popAccount ) );            

   762             }

   763         else if ( type == EMailboxIMAP4 )

   764             {

   765             TImapAccount imapAccount;

   766             imapAccount.iImapAccountId = iEntryIds[i++];

   767             imapAccount.iImapService = iEntryIds[i++];

   768             imapAccount.iImapService = iEntryIds[i++];

   769             TRAP_IGNORE( accountMgr->DeleteImapAccountL( imapAccount ) );

   770             }

   771         else 

   772             {

   773             // ignore unknown mailbox types

   774             i +=3;

   775             }

   776         

   777         // There should be one smtp service for each pop and imap service

   778         TSmtpAccount smtpAccount;

   779         smtpAccount.iSmtpAccountId = iEntryIds[i++];

   780         smtpAccount.iSmtpService = iEntryIds[i++];

   781         smtpAccount.iRelatedService = iEntryIds[i++];

   782         TRAP_IGNORE( accountMgr->DeleteSmtpAccountL( smtpAccount ) );

   783         }

   784 

   785     // reset must be done here, because iEntryIds is stored in destructor

   786     iEntryIds.Reset();

   787     

   788     // all entries deleted, remove the mailbox related registry

   789     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   790 

   791     CleanupStack::PopAndDestroy( accountMgr ); 

   792     }

   793 //----------------------------------------------------------------------------

   794