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)

   138     {

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

   140     

   141     CCreatorModuleBase::AskDataFromUserL( aCommand );//ignore retval

   142     

   143     if ( aCommand == ECmdDeleteMailboxes )

   144         {

   145         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes?"), this, ECreatorModuleDelete );

   146         }

   147     else if ( aCommand ==  ECmdDeleteCreatorMailboxes )

   148         {

   149         return iEngine->GetEngineWrapper()->YesNoQueryDialog( _L("Delete all mailboxes created with Creator?"), this, ECreatorModuleDelete );

   150         }

   151     return iEngine->GetEngineWrapper()->EntriesQueryDialog( &iEntriesToBeCreated, _L("How many entries to create?"), EFalse, this, ECreatorModuleStart );

   152     }

   153 

   154 

   155 //----------------------------------------------------------------------------

   156 

   157 TInt CCreatorMailboxes::CreateMailboxEntryL(CMailboxesParameters *aParameters)

   158     {

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

   160 

   161       // clear any existing parameter definations

   162     delete iParameters;

   163     iParameters = NULL;

   164     

   165     CMailboxesParameters* parameters = aParameters;

   166     

   167     // random data needed if no predefined data available

   168     if (!parameters)

   169         {

   170         iParameters = new(ELeave) CMailboxesParameters;

   171         parameters = iParameters;

   172 

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

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

   175         

   176         delete parameters->iMailboxName;

   177         parameters->iMailboxName = 0;

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

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

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

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

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

   183         

   184         delete parameters->iIncomingLoginName;

   185         parameters->iIncomingLoginName = 0;

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

   187         delete parameters->iOutgoingLoginName;

   188         parameters->iOutgoingLoginName = 0;

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

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

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

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

   193         

   194         delete parameters->iIncomingPassword;

   195         parameters->iIncomingPassword = 0;

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

   197         delete parameters->iOutgoingPassword;

   198         parameters->iOutgoingPassword = 0;

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

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

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

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

   203         

   204         delete parameters->iIncomingServerName;

   205         parameters->iIncomingServerName = 0;

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

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

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

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

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

   211                 

   212         delete parameters->iIncomingConnectionMethod;

   213         parameters->iIncomingConnectionMethod = 0;

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

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

   216         

   217         delete parameters->iOutgoingServerName;

   218         parameters->iOutgoingServerName = 0;

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

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

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

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

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

   224         

   225         delete parameters->iOutgoingConnectionMethod;

   226         parameters->iOutgoingConnectionMethod = 0;

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

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

   229 

   230         delete parameters->iOwnEmailAddress;

   231         parameters->iOwnEmailAddress = 0;

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

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

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

   235         

   236         delete parameters->iOwnEmailAlias;

   237         parameters->iOwnEmailAlias = 0;

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

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

   240 

   241         delete parameters->iReceiptAddress;

   242         parameters->iReceiptAddress = 0;

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

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

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

   246         

   247         delete parameters->iReplyToAddress;

   248         parameters->iReplyToAddress = 0;

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

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

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

   252         

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

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

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

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

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

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

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

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

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

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

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

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

   265         parameters->iIncludeSignature = EFalse;

   266         parameters->iAddVCard = EFalse;

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

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

   269         

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

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

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

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

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

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

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

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

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

   279         parameters->iOutgoingPort = KDefaultSmtpPort;

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

   281         

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

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

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

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

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

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

   288         }

   289    

   290     TInt err = KErrNone;

   291     

   292     // make sure we have some IMEI stored

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

   294         {

   295         TRAP(err, GetIMEIFromThePhoneL());

   296         }

   297 

   298     // init 

   299     CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;

   300     CleanupStack::PushL(imap4Set);

   301     CImPop3Settings* pop3Set = new(ELeave) CImPop3Settings;

   302     CleanupStack::PushL(pop3Set);

   303     CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;

   304     CleanupStack::PushL(smtpSet);

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

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

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

   308   

   309     // Get SMTP settings:

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

   311   

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

   313     // correct type when deleting mailboxes

   314     iEntryIds.Append( parameters->iMailboxType );

   315     

   316     if (parameters->iMailboxType == EMailboxIMAP4)

   317         {

   318         // Get IMAP settings:

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

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

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

   322         account->SetDefaultSmtpAccountL(smtpAccountId);

   323 

   324         iEntryIds.Append( imapAccountId.iImapAccountId );

   325         iEntryIds.Append( imapAccountId.iImapService );

   326         iEntryIds.Append( imapAccountId.iSmtpService );      

   327         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   328         iEntryIds.Append( smtpAccountId.iSmtpService );

   329         iEntryIds.Append( smtpAccountId.iRelatedService );

   330         

   331         StoreIMEIToEntryL( imapAccountId.iImapService );

   332         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   333         }

   334     else

   335         {

   336         // Get POP settings:

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

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

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

   340         account->SetDefaultSmtpAccountL(smtpAccountId);

   341         

   342         iEntryIds.Append( popAccountId.iPopAccountId );

   343         iEntryIds.Append( popAccountId.iPopService );

   344         iEntryIds.Append( popAccountId.iSmtpService );

   345         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   346         iEntryIds.Append( smtpAccountId.iSmtpService );

   347         iEntryIds.Append( smtpAccountId.iRelatedService );

   348 

   349         StoreIMEIToEntryL( popAccountId.iPopService );

   350         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   351         }  

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

   353         

   354     return err;

   355     }

   356 

   357 void CCreatorMailboxes::PopulateImapSettingsL( 

   358             CEmailAccounts& aEmailAccount, 

   359             CImImap4Settings& aImapSettings, 

   360             CImIAPPreferences& aIApSettings, 

   361             const CMailboxesParameters& aParameters )

   362     {

   363     // Get default settings first:

   364     aEmailAccount.PopulateDefaultImapSettingsL(aImapSettings, aIApSettings);

   365     

   366     TImIAPChoice iapChoice;

   367     iapChoice.iIAP = 0;

   368     if( aParameters.iIncomingConnectionMethod == 0 || 

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

   370         {

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

   372         }

   373     else

   374         {

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

   376         }

   377     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   378     aIApSettings.AddIAPL(iapChoice);

   379     

   380     TBuf8<256> buf8;

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

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

   383     else

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

   385     aImapSettings.SetLoginNameL(buf8);  //8

   386     

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

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

   389     else

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

   391     aImapSettings.SetPasswordL(buf8);  //8

   392     

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

   394         {

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

   396         aImapSettings.SetFolderPathL(buf8);

   397         }

   398     

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

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

   401     

   402     aImapSettings.SetDisconnectedUserMode(aParameters.iDisconnectedUserMode);

   403     aImapSettings.SetSynchronise(aParameters.iSyncType);

   404     aImapSettings.SetSubscribe(aParameters.iSubscribeType);

   405     aImapSettings.SetAutoSendOnConnect(aParameters.iAutoSendOnConnect);

   406     

   407     if(aParameters.iMaxEmailSize != KUndef )

   408         aImapSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   409     

   410     aImapSettings.SetDeleteEmailsWhenDisconnecting(aParameters.iDeleteEmailsAtDisconnect);

   411     aImapSettings.SetAcknowledgeReceipts(aParameters.iAcknowledgeReceipts);

   412             

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

   414         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyText);

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

   416         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyTextAndAttachments);

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

   418         aImapSettings.SetGetMailOptions(EGetImap4EmailAttachments);

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

   420         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyAlternativeText);

   421     else

   422         aImapSettings.SetGetMailOptions(EGetImap4EmailHeaders); // Default

   423     

   424     if( aParameters.iInboxSyncLimit != KUndef )

   425         aImapSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   426     

   427     if( aParameters.iMailboxSyncLimit != KUndef )

   428         aImapSettings.SetMailboxSynchronisationLimit(aParameters.iMailboxSyncLimit);

   429     

   430     aImapSettings.SetUpdatingSeenFlags(aParameters.iMarkSeenInSync);

   431     

   432     if( aParameters.iSyncRate != KUndef )

   433         aImapSettings.SetSyncRateL(aParameters.iSyncRate);

   434     

   435     if( aParameters.iAttachmentFetchSize != KUndef )

   436         aImapSettings.SetFetchSizeL(aParameters.iAttachmentFetchSize);

   437     

   438     aImapSettings.SetImapIdle(aParameters.iImapIdleCommand);

   439     if( aParameters.iImapIdleTimeout != KUndef )

   440         aImapSettings.SetImapIdleTimeoutL(aParameters.iImapIdleTimeout);

   441     

   442     if( aParameters.iBodyTextSizeLimit != KUndef )

   443         aImapSettings.SetBodyTextSizeLimitL(aParameters.iBodyTextSizeLimit);

   444     

   445     if( aParameters.iAttachmentSizeLimit != KUndef )

   446         aImapSettings.SetAttachmentSizeLimitL(aParameters.iAttachmentSizeLimit);

   447     

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

   449     aImapSettings.SetUseExpunge(aParameters.iEnableExpungeMode);

   450 #endif

   451     

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

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

   454     else

   455         aImapSettings.SetServerAddressL(KDefaultIncomingServer);

   456         

   457     if( aParameters.iIncomingPort != KUndef )

   458         aImapSettings.SetPort(aParameters.iIncomingPort);                 

   459       

   460     aImapSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   461     aImapSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);

   462     }

   463 

   464 void CCreatorMailboxes::PopulatePopSettingsL( 

   465             CEmailAccounts& aEmailAccount, 

   466             CImPop3Settings& aPopSettings, 

   467             CImIAPPreferences& aIApSettings, 

   468             const CMailboxesParameters& aParameters )

   469     {

   470     aEmailAccount.PopulateDefaultPopSettingsL(aPopSettings, aIApSettings);

   471     

   472     TImIAPChoice iapChoice;

   473     iapChoice.iIAP = 0;

   474     if( aParameters.iIncomingConnectionMethod == 0 || 

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

   476         {

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

   478         }

   479     else

   480         {

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

   482         }

   483     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   484     aIApSettings.AddIAPL(iapChoice);

   485     

   486     TBuf8<256> buf8;

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

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

   489     else

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

   491     aPopSettings.SetLoginNameL(buf8);  //8

   492         

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

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

   495     else

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

   497     aPopSettings.SetPasswordL(buf8);  //8

   498     

   499     aPopSettings.SetAutoSendOnConnect( aParameters.iAutoSendOnConnect );

   500     aPopSettings.SetApop( aParameters.iUseApop );

   501     aPopSettings.SetDisconnectedUserMode( aParameters.iDisconnectedUserMode );

   502     aPopSettings.SetDeleteEmailsWhenDisconnecting( aParameters.iDeleteEmailsAtDisconnect );

   503     aPopSettings.SetAcknowledgeReceipts( aParameters.iAcknowledgeReceipts );

   504     

   505     if( aParameters.iMaxEmailSize != KUndef )

   506         aPopSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   507     

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

   509             aParameters.iGetEmailOptions != CMailboxesParameters::EUndef )

   510         {

   511         aPopSettings.SetGetMailOptions(EGetPop3EmailMessages);

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

   513         }

   514     else

   515         {

   516         aPopSettings.SetGetMailOptions(EGetPop3EmailHeaders); // Default

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

   518         }

   519     

   520     if( aParameters.iInboxSyncLimit != KUndef )

   521         {

   522         aPopSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   523         }

   524     

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

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

   527     else

   528         aPopSettings.SetServerAddressL(KDefaultIncomingServer);

   529             

   530     if( aParameters.iIncomingPort != KUndef )

   531         aPopSettings.SetPort(aParameters.iIncomingPort);                 

   532           

   533     aPopSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   534     aPopSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);    

   535     }

   536 

   537 void CCreatorMailboxes::PopulateSmtpSettingsL( 

   538         CEmailAccounts& aEmailAccount, 

   539         CImSmtpSettings& aSmtpSettings, 

   540         CImIAPPreferences& aIApSettings, 

   541         const CMailboxesParameters& aParameters )

   542     {    

   543     // Get default settings first: 

   544     aEmailAccount.PopulateDefaultSmtpSettingsL(aSmtpSettings, aIApSettings);

   545     TImIAPChoice iapChoice;

   546     iapChoice.iIAP = 0;

   547     if( aParameters.iOutgoingConnectionMethod == 0 || 

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

   549         {

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

   551         }

   552     else

   553         {

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

   555         }

   556     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   557     aIApSettings.AddIAPL(iapChoice);

   558     

   559     // set SMTP preferences

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

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

   562     

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

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

   565     

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

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

   568     

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

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

   571     

   572     aSmtpSettings.SetBodyEncoding(EMsgOutboxMIME);

   573     aSmtpSettings.SetAddVCardToEmail(aParameters.iAddVCard);

   574     aSmtpSettings.SetAddSignatureToEmail(aParameters.iIncludeSignature);

   575     aSmtpSettings.SetRequestReceipts(aParameters.iRequestReceipts);

   576     aSmtpSettings.SetSendCopyToSelf(aParameters.iSendCopyToSelf);    

   577     aSmtpSettings.SetSendMessageOption(aParameters.iSendOption);        

   578             

   579     TBuf8<256> buf8;

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

   581         {

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

   583         aSmtpSettings.SetLoginNameL(buf8);  //8

   584         }

   585     

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

   587         {

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

   589         aSmtpSettings.SetPasswordL(buf8);  //8

   590         }

   591     

   592     aSmtpSettings.SetSMTPAuth(aParameters.iSmtpAuth);

   593     if( aParameters.iToCCIncludeLimit != KUndef )

   594          aSmtpSettings.SetToCcIncludeLimitL(aParameters.iToCCIncludeLimit);

   595     

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

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

   598     else

   599         aSmtpSettings.SetServerAddressL(KDefaultOutgoingServer);

   600     

   601     if( aParameters.iOutgoingPort != KUndef )

   602         aSmtpSettings.SetPort(aParameters.iOutgoingPort);

   603                 

   604     aSmtpSettings.SetSecureSockets(aParameters.iOutgoingSecureSockets);

   605     aSmtpSettings.SetSSLWrapper(aParameters.iOutgoingSSLWrapper);

   606     }

   607 

   608 //----------------------------------------------------------------------------

   609 

   610 void CCreatorMailboxes::StoreIMEIToEntryL(const TMsvId aMailboxId)

   611     {

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

   613 

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

   615     CleanupStack::PushL(session);

   616     

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

   618     CleanupStack::PushL(centry);

   619 

   620     TMsvEntry tentry = centry->Entry();

   621     tentry.iDescription.Set(iIMEI);

   622     centry->ChangeL(tentry);

   623 

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

   625     }

   626 

   627 //----------------------------------------------------------------------------

   628 

   629 void CCreatorMailboxes::GetIMEIFromThePhoneL()

   630     {

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

   632 

   633 #ifndef __WINS__

   634 

   635     RTelServer telServer;

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

   637     CleanupClosePushL(telServer);

   638 

   639     TInt numPhones = 0;

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

   641     if ( numPhones < 1 )

   642         {

   643         User::Leave( KErrNotFound );

   644         }

   645     RTelServer::TPhoneInfo info;

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

   647     RMobilePhone mobilePhone;

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

   649     CleanupClosePushL( mobilePhone );

   650 

   651     //mobilePhone.Initialise();

   652     TUint32 identityCaps;

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

   654 

   655     if ( identityCaps & RMobilePhone::KCapsGetSerialNumber )

   656         {

   657         TRequestStatus status;

   658         RMobilePhone::TMobilePhoneIdentityV1 mobilePhoneIdentity;

   659 

   660         mobilePhone.GetPhoneId( status, mobilePhoneIdentity );

   661 

   662         User::WaitForRequest( status );

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

   664 

   665         iIMEI.Copy( mobilePhoneIdentity.iSerialNumber );

   666         }

   667     else

   668         {

   669         User::Leave( KErrNotSupported );

   670         }

   671 

   672     CleanupStack::PopAndDestroy( &mobilePhone );

   673     CleanupStack::PopAndDestroy( &telServer );

   674 

   675 #else

   676 

   677     // use fixed IMEI for emulator

   678     _LIT( KIMAEmulatorImei, "123456789012345" );

   679     iIMEI.Copy( KIMAEmulatorImei );

   680 

   681 #endif // __WINS__

   682 

   683     }

   684     

   685 //----------------------------------------------------------------------------

   686 

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

   688     {

   689     }

   690 

   691 //----------------------------------------------------------------------------

   692 void CCreatorMailboxes::DeleteAllL()

   693     {

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

   695     

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

   697     

   698     // Delete pop accounts

   699     RArray<TPopAccount> popAccountsToDelete;

   700     CleanupClosePushL( popAccountsToDelete );

   701     accountMgr->GetPopAccountsL( popAccountsToDelete );

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

   703         {

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

   705         }

   706     CleanupStack::PopAndDestroy( &popAccountsToDelete );

   707     

   708     // Delete imap accounts

   709     RArray<TImapAccount> imapAccountsToDelete;

   710     CleanupClosePushL( imapAccountsToDelete );

   711     accountMgr->GetImapAccountsL( imapAccountsToDelete );

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

   713         {

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

   715         }

   716     CleanupStack::PopAndDestroy( &imapAccountsToDelete );

   717     

   718     // Delete smtp accounts

   719     RArray<TSmtpAccount> smtpAccountsToDelete;

   720     CleanupClosePushL( smtpAccountsToDelete );

   721     accountMgr->GetSmtpAccountsL( smtpAccountsToDelete );

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

   723         {

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

   725         }

   726     CleanupStack::PopAndDestroy( &smtpAccountsToDelete );

   727 

   728     iEntryIds.Reset();

   729     

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

   731     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   732     

   733     CleanupStack::PopAndDestroy( accountMgr ); 

   734     }

   735 

   736 //----------------------------------------------------------------------------

   737 void CCreatorMailboxes::DeleteAllCreatedByCreatorL()

   738     {

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

   740     

   741     iEntryIds.Reset();

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

   743     

   744     // fetch ids of entries created by Creator

   745     iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidMailbox );

   746     

   747     TInt i(0);

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

   749         {

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

   751         // one for mailbox type

   752         // 3 for imap OR pop ids

   753         // 3 for smtp ids

   754 

   755         // delete entries

   756         

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

   758         if ( type == EMailboxPOP3 )

   759             {

   760             TPopAccount popAccount;

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

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

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

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

   765             }

   766         else if ( type == EMailboxIMAP4 )

   767             {

   768             TImapAccount imapAccount;

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

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

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

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

   773             }

   774         else 

   775             {

   776             // ignore unknown mailbox types

   777             i +=3;

   778             }

   779         

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

   781         TSmtpAccount smtpAccount;

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

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

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

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

   786         }

   787 

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

   789     iEntryIds.Reset();

   790     

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

   792     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   793 

   794     CleanupStack::PopAndDestroy( accountMgr ); 

   795     }

   796 //----------------------------------------------------------------------------

   797