1 /*

     2 * Copyright (c) 2008 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 

    20 #include "creator_mailbox.h" 

    21 #include "creator_traces.h"

    22 

    23 #include <etelmm.h>

    24 #include <msvapi.h>

    25 

    26 static const TInt KMailboxesFieldLength = 160;

    27 

    28 _LIT(KCreatorMailboxesPrefixName, "CR_");

    29 

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

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

    32 _LIT(KInternet, "internet");

    33 

    34 

    35 //----------------------------------------------------------------------------

    36 

    37 CMailboxesParameters::CMailboxesParameters()

    38     {

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

    40 

    41     iIncomingPort = KUndef;

    42     iOutgoingPort = KUndef;

    43     iMaxEmailSize = KUndef;

    44     iSyncRate = KUndef;

    45     iAttachmentFetchSize = KUndef;

    46     iAttachmentSizeLimit = KUndef;

    47     iBodyTextSizeLimit = KUndef;

    48     iAttachmentFetchSize = KUndef;

    49     iInboxSyncLimit = -1; // -1 = All

    50     iMailboxSyncLimit = -1; // -1 = All    

    51     iToCCIncludeLimit = KUndef;

    52     iImapIdleTimeout = KUndef;

    53     

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

    55     iAccessPoint = HBufC::New(KMailboxesFieldLength);

    56     iMyMailAddress = HBufC::New(KMailboxesFieldLength);

    57     iOutgoingMailServer = HBufC::New(KMailboxesFieldLength);

    58     iUserName = HBufC::New(KMailboxesFieldLength);

    59     iPassword = HBufC::New(KMailboxesFieldLength);

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

    61     }

    62 

    63 CMailboxesParameters::~CMailboxesParameters()

    64     {

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

    66 

    67     /*delete iIncomingMailServer;

    68     delete iPassword;

    69     delete iUserName;

    70     delete iOutgoingMailServer;

    71     delete iMyMailAddress;

    72     delete iAccessPoint;

    73     delete iMailboxName;*/

    74     

    75     delete iMailboxName;

    76     delete iIncomingLoginName;

    77     delete iIncomingPassword;

    78     delete iIncomingServerName;

    79     delete iIncomingConnectionMethod;

    80     delete iIncomingFolderPath;

    81     delete iPathSeparator;

    82     delete iOutgoingLoginName;

    83     delete iOutgoingPassword;

    84     delete iOutgoingServerName;

    85     delete iOutgoingConnectionMethod;

    86     delete iOwnEmailAddress;

    87     delete iOwnEmailAlias;

    88     delete iReceiptAddress;

    89     delete iReplyToAddress;

    90     }

    91 

    92 //----------------------------------------------------------------------------

    93 

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

    95     {

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

    97     CleanupStack::Pop(self);

    98     return self;

    99     }

   100 

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

   102     {

   103     CCreatorMailboxes* self = new (ELeave) CCreatorMailboxes;

   104     CleanupStack::PushL(self);

   105     self->ConstructL(aEngine);

   106     return self;

   107     }

   108 

   109 CCreatorMailboxes::CCreatorMailboxes()

   110     {    

   111     }

   112 

   113 void CCreatorMailboxes::ConstructL(CCreatorEngine* aEngine)

   114     {

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

   116 

   117     iEngine = aEngine;

   118     }

   119 

   120 CCreatorMailboxes::~CCreatorMailboxes()

   121     {

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

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

   124         {

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

   126         }

   127     iEntryIds.Reset();

   128     iEntryIds.Close();

   129     

   130     if (iParameters)

   131         delete iParameters;

   132     }

   133 

   134 //----------------------------------------------------------------------------

   135 

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

   137     {

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

   139     if ( aCommand == ECmdDeleteMailboxes )

   140         {

   141         return iEngine->YesNoQueryDialogL( _L("Delete all mailboxes?") );

   142         }

   143     else if ( aCommand ==  ECmdDeleteCreatorMailboxes )

   144         {

   145         return iEngine->YesNoQueryDialogL( _L("Delete all mailboxes created with Creator?") );

   146         }

   147     return iEngine->EntriesQueryDialogL(aNumberOfEntries, _L("How many entries to create?"));

   148     }

   149 

   150 

   151 //----------------------------------------------------------------------------

   152 

   153 TInt CCreatorMailboxes::CreateMailboxEntryL(CMailboxesParameters *aParameters)

   154     {

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

   156 

   157       // clear any existing parameter definations

   158     delete iParameters;

   159     iParameters = NULL;

   160     

   161     CMailboxesParameters* parameters = aParameters;

   162     

   163     // random data needed if no predefined data available

   164     if (!parameters)

   165         {

   166         iParameters = new(ELeave) CMailboxesParameters;

   167         parameters = iParameters;

   168 

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

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

   171         

   172         delete parameters->iMailboxName;

   173         parameters->iMailboxName = 0;

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

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

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

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

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

   179         

   180         delete parameters->iIncomingLoginName;

   181         parameters->iIncomingLoginName = 0;

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

   183         delete parameters->iOutgoingLoginName;

   184         parameters->iOutgoingLoginName = 0;

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

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

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

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

   189         

   190         delete parameters->iIncomingPassword;

   191         parameters->iIncomingPassword = 0;

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

   193         delete parameters->iOutgoingPassword;

   194         parameters->iOutgoingPassword = 0;

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

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

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

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

   199         

   200         delete parameters->iIncomingServerName;

   201         parameters->iIncomingServerName = 0;

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

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

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

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

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

   207                 

   208         delete parameters->iIncomingConnectionMethod;

   209         parameters->iIncomingConnectionMethod = 0;

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

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

   212         

   213         delete parameters->iOutgoingServerName;

   214         parameters->iOutgoingServerName = 0;

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

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

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

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

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

   220         

   221         delete parameters->iOutgoingConnectionMethod;

   222         parameters->iOutgoingConnectionMethod = 0;

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

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

   225 

   226         delete parameters->iOwnEmailAddress;

   227         parameters->iOwnEmailAddress = 0;

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

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

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

   231         

   232         delete parameters->iOwnEmailAlias;

   233         parameters->iOwnEmailAlias = 0;

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

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

   236 

   237         delete parameters->iReceiptAddress;

   238         parameters->iReceiptAddress = 0;

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

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

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

   242         

   243         delete parameters->iReplyToAddress;

   244         parameters->iReplyToAddress = 0;

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

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

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

   248         

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

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

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

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

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

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

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

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

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

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

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

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

   261         parameters->iIncludeSignature = EFalse;

   262         parameters->iAddVCard = EFalse;

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

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

   265         

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

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

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

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

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

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

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

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

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

   275         parameters->iOutgoingPort = KDefaultSmtpPort;

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

   277         

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

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

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

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

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

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

   284         }

   285    

   286     TInt err = KErrNone;

   287     

   288     // make sure we have some IMEI stored

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

   290         {

   291         TRAP(err, GetIMEIFromThePhoneL());

   292         }

   293 

   294     // init 

   295     CImImap4Settings* imap4Set = new(ELeave) CImImap4Settings;

   296     CleanupStack::PushL(imap4Set);

   297     CImPop3Settings* pop3Set = new(ELeave) CImPop3Settings;

   298     CleanupStack::PushL(pop3Set);

   299     CImSmtpSettings* smtpSet = new(ELeave) CImSmtpSettings;

   300     CleanupStack::PushL(smtpSet);

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

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

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

   304   

   305     // Get SMTP settings:

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

   307   

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

   309     // correct type when deleting mailboxes

   310     iEntryIds.Append( parameters->iMailboxType );

   311     

   312     if (parameters->iMailboxType == EMailboxIMAP4)

   313         {

   314         // Get IMAP settings:

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

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

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

   318         account->SetDefaultSmtpAccountL(smtpAccountId);

   319 

   320         iEntryIds.Append( imapAccountId.iImapAccountId );

   321         iEntryIds.Append( imapAccountId.iImapService );

   322         iEntryIds.Append( imapAccountId.iSmtpService );      

   323         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   324         iEntryIds.Append( smtpAccountId.iSmtpService );

   325         iEntryIds.Append( smtpAccountId.iRelatedService );

   326         

   327         StoreIMEIToEntryL( imapAccountId.iImapService );

   328         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   329         }

   330     else

   331         {

   332         // Get POP settings:

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

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

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

   336         account->SetDefaultSmtpAccountL(smtpAccountId);

   337         

   338         iEntryIds.Append( popAccountId.iPopAccountId );

   339         iEntryIds.Append( popAccountId.iPopService );

   340         iEntryIds.Append( popAccountId.iSmtpService );

   341         iEntryIds.Append( smtpAccountId.iSmtpAccountId );

   342         iEntryIds.Append( smtpAccountId.iSmtpService );

   343         iEntryIds.Append( smtpAccountId.iRelatedService );

   344 

   345         StoreIMEIToEntryL( popAccountId.iPopService );

   346         StoreIMEIToEntryL( smtpAccountId.iSmtpService );

   347         }  

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

   349         

   350     return err;

   351     }

   352 

   353 void CCreatorMailboxes::PopulateImapSettingsL( 

   354             CEmailAccounts& aEmailAccount, 

   355             CImImap4Settings& aImapSettings, 

   356             CImIAPPreferences& aIApSettings, 

   357             const CMailboxesParameters& aParameters )

   358     {

   359     // Get default settings first:

   360     aEmailAccount.PopulateDefaultImapSettingsL(aImapSettings, aIApSettings);

   361     

   362     TImIAPChoice iapChoice;

   363     iapChoice.iIAP = 0;

   364     if( aParameters.iIncomingConnectionMethod == 0 || 

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

   366         {

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

   368         }

   369     else

   370         {

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

   372         }

   373     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   374     aIApSettings.AddIAPL(iapChoice);

   375     

   376     TBuf8<256> buf8;

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

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

   379     else

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

   381     aImapSettings.SetLoginNameL(buf8);  //8

   382     

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

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

   385     else

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

   387     aImapSettings.SetPasswordL(buf8);  //8

   388     

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

   390         {

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

   392         aImapSettings.SetFolderPathL(buf8);

   393         }

   394     

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

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

   397     

   398     aImapSettings.SetDisconnectedUserMode(aParameters.iDisconnectedUserMode);

   399     aImapSettings.SetSynchronise(aParameters.iSyncType);

   400     aImapSettings.SetSubscribe(aParameters.iSubscribeType);

   401     aImapSettings.SetAutoSendOnConnect(aParameters.iAutoSendOnConnect);

   402     

   403     if(aParameters.iMaxEmailSize != KUndef )

   404         aImapSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   405     

   406     aImapSettings.SetDeleteEmailsWhenDisconnecting(aParameters.iDeleteEmailsAtDisconnect);

   407     aImapSettings.SetAcknowledgeReceipts(aParameters.iAcknowledgeReceipts);

   408             

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

   410         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyText);

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

   412         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyTextAndAttachments);

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

   414         aImapSettings.SetGetMailOptions(EGetImap4EmailAttachments);

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

   416         aImapSettings.SetGetMailOptions(EGetImap4EmailBodyAlternativeText);

   417     else

   418         aImapSettings.SetGetMailOptions(EGetImap4EmailHeaders); // Default

   419     

   420     if( aParameters.iInboxSyncLimit != KUndef )

   421         aImapSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   422     

   423     if( aParameters.iMailboxSyncLimit != KUndef )

   424         aImapSettings.SetMailboxSynchronisationLimit(aParameters.iMailboxSyncLimit);

   425     

   426     aImapSettings.SetUpdatingSeenFlags(aParameters.iMarkSeenInSync);

   427     

   428     if( aParameters.iSyncRate != KUndef )

   429         aImapSettings.SetSyncRateL(aParameters.iSyncRate);

   430     

   431     if( aParameters.iAttachmentFetchSize != KUndef )

   432         aImapSettings.SetFetchSizeL(aParameters.iAttachmentFetchSize);

   433     

   434     aImapSettings.SetImapIdle(aParameters.iImapIdleCommand);

   435     if( aParameters.iImapIdleTimeout != KUndef )

   436         aImapSettings.SetImapIdleTimeoutL(aParameters.iImapIdleTimeout);

   437     

   438     if( aParameters.iBodyTextSizeLimit != KUndef )

   439         aImapSettings.SetBodyTextSizeLimitL(aParameters.iBodyTextSizeLimit);

   440     

   441     if( aParameters.iAttachmentSizeLimit != KUndef )

   442         aImapSettings.SetAttachmentSizeLimitL(aParameters.iAttachmentSizeLimit);

   443     

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

   445     aImapSettings.SetUseExpunge(aParameters.iEnableExpungeMode);

   446 #endif

   447     

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

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

   450     else

   451         aImapSettings.SetServerAddressL(KDefaultIncomingServer);

   452         

   453     if( aParameters.iIncomingPort != KUndef )

   454         aImapSettings.SetPort(aParameters.iIncomingPort);                 

   455       

   456     aImapSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   457     aImapSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);

   458     }

   459 

   460 void CCreatorMailboxes::PopulatePopSettingsL( 

   461             CEmailAccounts& aEmailAccount, 

   462             CImPop3Settings& aPopSettings, 

   463             CImIAPPreferences& aIApSettings, 

   464             const CMailboxesParameters& aParameters )

   465     {

   466     aEmailAccount.PopulateDefaultPopSettingsL(aPopSettings, aIApSettings);

   467     

   468     TImIAPChoice iapChoice;

   469     iapChoice.iIAP = 0;

   470     if( aParameters.iIncomingConnectionMethod == 0 || 

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

   472         {

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

   474         }

   475     else

   476         {

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

   478         }

   479     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   480     aIApSettings.AddIAPL(iapChoice);

   481     

   482     TBuf8<256> buf8;

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

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

   485     else

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

   487     aPopSettings.SetLoginNameL(buf8);  //8

   488         

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

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

   491     else

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

   493     aPopSettings.SetPasswordL(buf8);  //8

   494     

   495     aPopSettings.SetAutoSendOnConnect( aParameters.iAutoSendOnConnect );

   496     aPopSettings.SetApop( aParameters.iUseApop );

   497     aPopSettings.SetDisconnectedUserMode( aParameters.iDisconnectedUserMode );

   498     aPopSettings.SetDeleteEmailsWhenDisconnecting( aParameters.iDeleteEmailsAtDisconnect );

   499     aPopSettings.SetAcknowledgeReceipts( aParameters.iAcknowledgeReceipts );

   500     

   501     if( aParameters.iMaxEmailSize != KUndef )

   502         aPopSettings.SetMaxEmailSize(aParameters.iMaxEmailSize);

   503     

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

   505             aParameters.iGetEmailOptions != CMailboxesParameters::EUndef )

   506         {

   507         aPopSettings.SetGetMailOptions(EGetPop3EmailMessages);

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

   509         }

   510     else

   511         {

   512         aPopSettings.SetGetMailOptions(EGetPop3EmailHeaders); // Default

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

   514         }

   515     

   516     if( aParameters.iInboxSyncLimit != KUndef )

   517         {

   518         aPopSettings.SetInboxSynchronisationLimit(aParameters.iInboxSyncLimit);

   519         }

   520     

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

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

   523     else

   524         aPopSettings.SetServerAddressL(KDefaultIncomingServer);

   525             

   526     if( aParameters.iIncomingPort != KUndef )

   527         aPopSettings.SetPort(aParameters.iIncomingPort);                 

   528           

   529     aPopSettings.SetSecureSockets(aParameters.iIncomingSecureSockets);

   530     aPopSettings.SetSSLWrapper(aParameters.iIncomingSSLWrapper);    

   531     }

   532 

   533 void CCreatorMailboxes::PopulateSmtpSettingsL( 

   534         CEmailAccounts& aEmailAccount, 

   535         CImSmtpSettings& aSmtpSettings, 

   536         CImIAPPreferences& aIApSettings, 

   537         const CMailboxesParameters& aParameters )

   538     {    

   539     // Get default settings first: 

   540     aEmailAccount.PopulateDefaultSmtpSettingsL(aSmtpSettings, aIApSettings);

   541     TImIAPChoice iapChoice;

   542     iapChoice.iIAP = 0;

   543     if( aParameters.iOutgoingConnectionMethod == 0 || 

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

   545         {

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

   547         }

   548     else

   549         {

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

   551         }

   552     iapChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt;

   553     aIApSettings.AddIAPL(iapChoice);

   554     

   555     // set SMTP preferences

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

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

   558     

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

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

   561     

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

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

   564     

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

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

   567     

   568     aSmtpSettings.SetBodyEncoding(EMsgOutboxMIME);

   569     aSmtpSettings.SetAddVCardToEmail(aParameters.iAddVCard);

   570     aSmtpSettings.SetAddSignatureToEmail(aParameters.iIncludeSignature);

   571     aSmtpSettings.SetRequestReceipts(aParameters.iRequestReceipts);

   572     aSmtpSettings.SetSendCopyToSelf(aParameters.iSendCopyToSelf);    

   573     aSmtpSettings.SetSendMessageOption(aParameters.iSendOption);        

   574             

   575     TBuf8<256> buf8;

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

   577         {

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

   579         aSmtpSettings.SetLoginNameL(buf8);  //8

   580         }

   581     

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

   583         {

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

   585         aSmtpSettings.SetPasswordL(buf8);  //8

   586         }

   587     

   588     aSmtpSettings.SetSMTPAuth(aParameters.iSmtpAuth);

   589     if( aParameters.iToCCIncludeLimit != KUndef )

   590          aSmtpSettings.SetToCcIncludeLimitL(aParameters.iToCCIncludeLimit);

   591     

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

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

   594     else

   595         aSmtpSettings.SetServerAddressL(KDefaultOutgoingServer);

   596     

   597     if( aParameters.iOutgoingPort != KUndef )

   598         aSmtpSettings.SetPort(aParameters.iOutgoingPort);

   599                 

   600     aSmtpSettings.SetSecureSockets(aParameters.iOutgoingSecureSockets);

   601     aSmtpSettings.SetSSLWrapper(aParameters.iOutgoingSSLWrapper);

   602     }

   603 

   604 //----------------------------------------------------------------------------

   605 

   606 void CCreatorMailboxes::StoreIMEIToEntryL(const TMsvId aMailboxId)

   607     {

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

   609 

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

   611     CleanupStack::PushL(session);

   612     

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

   614     CleanupStack::PushL(centry);

   615 

   616     TMsvEntry tentry = centry->Entry();

   617     tentry.iDescription.Set(iIMEI);

   618     centry->ChangeL(tentry);

   619 

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

   621     }

   622 

   623 //----------------------------------------------------------------------------

   624 

   625 void CCreatorMailboxes::GetIMEIFromThePhoneL()

   626     {

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

   628 

   629 #ifndef __WINS__

   630 

   631     RTelServer telServer;

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

   633     CleanupClosePushL(telServer);

   634 

   635     TInt numPhones = 0;

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

   637     if ( numPhones < 1 )

   638         {

   639         User::Leave( KErrNotFound );

   640         }

   641     RTelServer::TPhoneInfo info;

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

   643     RMobilePhone mobilePhone;

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

   645     CleanupClosePushL( mobilePhone );

   646 

   647     //mobilePhone.Initialise();

   648     TUint32 identityCaps;

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

   650 

   651     if ( identityCaps & RMobilePhone::KCapsGetSerialNumber )

   652         {

   653         TRequestStatus status;

   654         RMobilePhone::TMobilePhoneIdentityV1 mobilePhoneIdentity;

   655 

   656         mobilePhone.GetPhoneId( status, mobilePhoneIdentity );

   657 

   658         User::WaitForRequest( status );

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

   660 

   661         iIMEI.Copy( mobilePhoneIdentity.iSerialNumber );

   662         }

   663     else

   664         {

   665         User::Leave( KErrNotSupported );

   666         }

   667 

   668     CleanupStack::PopAndDestroy( &mobilePhone );

   669     CleanupStack::PopAndDestroy( &telServer );

   670 

   671 #else

   672 

   673     // use fixed IMEI for emulator

   674     _LIT( KIMAEmulatorImei, "123456789012345" );

   675     iIMEI.Copy( KIMAEmulatorImei );

   676 

   677 #endif // __WINS__

   678 

   679     }

   680     

   681 //----------------------------------------------------------------------------

   682 

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

   684     {

   685     }

   686 

   687 //----------------------------------------------------------------------------

   688 void CCreatorMailboxes::DeleteAllL()

   689     {

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

   691     

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

   693     

   694     // Delete pop accounts

   695     RArray<TPopAccount> popAccountsToDelete;

   696     CleanupClosePushL( popAccountsToDelete );

   697     accountMgr->GetPopAccountsL( popAccountsToDelete );

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

   699         {

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

   701         }

   702     CleanupStack::PopAndDestroy( &popAccountsToDelete );

   703     

   704     // Delete imap accounts

   705     RArray<TImapAccount> imapAccountsToDelete;

   706     CleanupClosePushL( imapAccountsToDelete );

   707     accountMgr->GetImapAccountsL( imapAccountsToDelete );

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

   709         {

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

   711         }

   712     CleanupStack::PopAndDestroy( &imapAccountsToDelete );

   713     

   714     // Delete smtp accounts

   715     RArray<TSmtpAccount> smtpAccountsToDelete;

   716     CleanupClosePushL( smtpAccountsToDelete );

   717     accountMgr->GetSmtpAccountsL( smtpAccountsToDelete );

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

   719         {

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

   721         }

   722     CleanupStack::PopAndDestroy( &smtpAccountsToDelete );

   723 

   724     iEntryIds.Reset();

   725     

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

   727     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   728     

   729     CleanupStack::PopAndDestroy( accountMgr ); 

   730     }

   731 

   732 //----------------------------------------------------------------------------

   733 void CCreatorMailboxes::DeleteAllCreatedByCreatorL()

   734     {

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

   736     

   737     iEntryIds.Reset();

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

   739     

   740     // fetch ids of entries created by Creator

   741     iEngine->ReadEntryIdsFromStoreL( iEntryIds, KUidDictionaryUidMailbox );

   742     

   743     TInt i(0);

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

   745         {

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

   747         // one for mailbox type

   748         // 3 for imap OR pop ids

   749         // 3 for smtp ids

   750 

   751         // delete entries

   752         

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

   754         if ( type == EMailboxPOP3 )

   755             {

   756             TPopAccount popAccount;

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

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

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

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

   761             }

   762         else if ( type == EMailboxIMAP4 )

   763             {

   764             TImapAccount imapAccount;

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

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

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

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

   769             }

   770         else 

   771             {

   772             // ignore unknown mailbox types

   773             i +=3;

   774             }

   775         

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

   777         TSmtpAccount smtpAccount;

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

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

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

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

   782         }

   783 

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

   785     iEntryIds.Reset();

   786     

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

   788     iEngine->RemoveStoreL( KUidDictionaryUidMailbox );

   789 

   790     CleanupStack::PopAndDestroy( accountMgr ); 

   791     }

   792 //----------------------------------------------------------------------------

   793