ipsservices/ipssossettings/src/ipssetgwizardadapter.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Wed, 09 Jun 2010 09:22:57 +0300
branchRCL_3
changeset 29 6b8f3b30d0ec
parent 24 b5fbb9b25d57
permissions -rw-r--r--
Revision: 201021 Kit: 2010123

/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
*  Description: This file implements class CIpsSetWizardAdapter.
*
*/


//INCLUDES
#include "emailtrace.h"
#include <e32base.h>
#include <SendUiConsts.h>
#include <centralrepository.h>      // CRepository
#include <AlwaysOnlineManagerClient.h>
#include <cmdestination.h> 

#include "ipssetwizardadapter.h"
#include "ipssetdatamanager.h"
#include "ipssetuiitemaccesspoint.h"
#include "ipssetutils.h"
#include "ipssetdataextension.h"


#include "ipssetdata.h"


// becuase of RD_IPS_AO_PLUGIN flag, can be removed
// when flag is removed
#include "ipsplgsosbaseplugin.hrh"

//CONSTANTS
const TInt KMaxMailboxes = 10;
const TInt KImapDefFoldersRetrieve = 50; // Default value for retrieve From other folders

// security enums in fs wizard cenrep cenrep
// Security protocol (0 = OFF, 1 = StartTLS, 2 = SSL/TLS)
const TInt KWizardDataSecurityOff = 0;
const TInt KWizardDataSecurityTLS = 1;
const TInt KWizardDataSecuritySSL = 2;

const TInt KWizardTCPMaxPort = 65535;

const TInt KWizardMaxUidValue = 50;

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
CIpsSetWizardAdapter* CIpsSetWizardAdapter::NewL( 
    CRepository& aRepository, CMsvSession& aSession ) 
    {
    FUNC_LOG;
    CIpsSetWizardAdapter* self = CIpsSetWizardAdapter::NewLC( 
        aRepository, aSession );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
CIpsSetWizardAdapter* CIpsSetWizardAdapter::NewLC( 
    CRepository& aRepository, CMsvSession& aSession )
    {
    FUNC_LOG;
    CIpsSetWizardAdapter* self = new( 
        ELeave ) CIpsSetWizardAdapter( aRepository, aSession );
    CleanupStack::PushL( self );
    self->ConstructL( );
    return self;
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
CIpsSetWizardAdapter::~CIpsSetWizardAdapter()
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
CIpsSetWizardAdapter::CIpsSetWizardAdapter( 
    CRepository& aRepository, CMsvSession& aSession ) 
    : iWizardCenRep( aRepository ), iSession( aSession ) 
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::ConstructL()
    {
    FUNC_LOG;
    ClearFields();
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::ClearFields()
    {
    FUNC_LOG;
    iAccountNumber = 0;
    iMaxAccounts = 0;
    iEmailAddress.Zero();
    iUsername.Zero();
    iPassword.Zero();
    iIncomingServer.Zero();
    iProtocol = 0;
    iInSecurityAuth = 0;
    iInSecurityProtocol = 0;
    iInIncomingPort = 0;
    iProviderOutgoingServer.Zero();
    iProviderOutSecurityAuth = 0;
    iProviderOutSecurityProtocol = 0;
    iProviderOutgoingPort = 0;
    iOperatorOutgoingServer.Zero();
    iOperatorOutSecurityAuth = 0;
    iOperatorOutSecurityProtocol = 0;
    iOperatorOutgoingPort = 0;
    iHiddenData = EFalse;
    iRecomendedAP.Zero();
    iMailboxName.Zero();
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::ReadWizardSettignsL()
    {
    FUNC_LOG;
    ClearFields();
    
    TIpsSetUtilsTextPlain tempText;
    TInt error = KErrNone;
     
    error = GetIntFromCenRepL( ECRKAccountsConfigured, iAccountNumber );
    if ( error != KErrNone )
        {
        iAccountNumber = KCRKAccountsConfiguredDefault;
        }
    
    error = GetIntFromCenRepL( ECRKMaxAccountsReached, iMaxAccounts );
    if ( error != KErrNone )
        {
        iMaxAccounts = KCRKMaxAccountsReachedDefault;
        }
    
    error = GetTextFromCenRepL( ECRKPopImapEmailAddressId, iEmailAddress );
    if ( error != KErrNone )
        {
        iEmailAddress = KCRKPopImapEmailAddressIdDefault;
        }
    
    tempText.Zero();
    error = GetTextFromCenRepL( ECRKPopImapUsernameId, tempText );
    if ( error != KErrNone )
        {
        tempText = KCRKPopImapUsernameIdDefault;
        }
    ChangeAsciiPrintable( tempText, iUsername );
    
    tempText.Zero();
    error = GetTextFromCenRepL( ECRKPopImapPasswordId, tempText );
    if ( error != KErrNone )
        {
        tempText = KCRKPopImapPasswordIdDefault;
        }
    ChangeAsciiPrintable( tempText, iPassword );
    
    tempText.Zero();
    error = GetTextFromCenRepL( ECRKPopImapIncomingServerId, tempText );
    if ( error != KErrNone )
        {
        tempText = KCRKPopImapIncomingServerIdDefault;
        }
    ChangeAsciiPrintable( tempText, iIncomingServer );
    
    error = GetIntFromCenRepL( ECRKPopImapProtocolIndicatorId, iProtocol );
    if ( error != KErrNone )
        {
        iProtocol = KCRKPopImapProtocolIndicatorIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapIncomingSecurityAuthId, iInSecurityAuth );
    if ( error != KErrNone )
        {
        iInSecurityAuth = KCRKPopImapIncomingSecurityAuthIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapIncomingSecurityProtocolId, 
            iInSecurityProtocol );
    if ( error != KErrNone )
        {
        iInSecurityProtocol = KCRKPopImapIncomingSecurityProtocolIdDefault;
        }
    
    error = GetIntFromCenRepL(  ECRKPopImapIncomingPortId, iInIncomingPort );
    if ( error != KErrNone )
        {
        iInIncomingPort = KCRKPopImapIncomingPortIdDefault;
        }

    tempText.Zero();
    error = GetTextFromCenRepL( ECRKPopImapOutgoingServerId, tempText );
    if ( error != KErrNone )
        {
        tempText = KCRKPopImapOutgoingServerIdDefault;
        }
    ChangeAsciiPrintable( tempText, iProviderOutgoingServer );
    
    error = GetIntFromCenRepL( ECRKPopImapOutgoingSecurityAuthId, 
            iProviderOutSecurityAuth );
    if ( error != KErrNone )
        {
        iProviderOutSecurityAuth = KCRKPopImapOutgoingSecurityAuthIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapOutgoingSecurityProtocolId, 
            iProviderOutSecurityProtocol );
    if ( error != KErrNone )
        {
        iProviderOutSecurityProtocol = KCRKPopImapOutgoingSecurityProtocolIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapOutgoingPortId, iProviderOutgoingPort );
    if ( error != KErrNone )
        {
        iProviderOutgoingPort = KCRKPopImapOutgoingPortIdDefault;
        }
    
    error = GetTextFromCenRepL( ECRKPopImapOperatorOutgoingServerId, 
            iOperatorOutgoingServer );
    if ( error != KErrNone )
        {
        iOperatorOutgoingServer = KCRKPopImapOperatorOutgoingServerIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapOperatorSecurityAuthId, 
            iOperatorOutSecurityAuth );
    if ( error != KErrNone )
        {
        iOperatorOutSecurityAuth = KCRKPopImapOperatorSecurityAuthIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapOperatorSecurityProtocolId, 
            iOperatorOutSecurityProtocol );
    if ( error != KErrNone )
        {
        iOperatorOutSecurityProtocol = KCRKPopImapOperatorSecurityProtocolIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKPopImapOperatorPortId,  
            iOperatorOutgoingPort );
    if ( error != KErrNone )
        {
        iOperatorOutgoingPort = KCRKPopImapOperatorPortIdDefault;
        }
    
    error = GetIntFromCenRepL( ECRKHideUsernameInSettings,  
            iHiddenData );
    if ( error != KErrNone )
        {
        iHiddenData = KCRKPopImapDataHideDefault;
        }
    
    error = GetTextFromCenRepL( ECRKPopImapAccessPointId, iRecomendedAP );
    if ( error != KErrNone )
        {
        iRecomendedAP = KCRKPopImapAccessPointIdDefault;
        }
        
    tempText.Zero();
    error = GetTextFromCenRepL( ECRKPopImapMailboxName, tempText );
    if ( error != KErrNone )
        {
        tempText = KCRKPopImapMailboxNameDefault;
        }
    ChangeUnicodePrintable( tempText, iMailboxName );
    
    EmptyWizardCenRep();
    } 
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TInt CIpsSetWizardAdapter::GetIntFromCenRepL( TIpsSetWizardSettings aSetting, 
                                              TInt& aVariable )
    {
    FUNC_LOG;
    if ( &iWizardCenRep )
        {
        return iWizardCenRep.Get( aSetting, aVariable );
        }
    return KErrNone;
    }
        
        
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TInt CIpsSetWizardAdapter::GetTextFromCenRepL( TIpsSetWizardSettings aSetting, 
                                 TIpsSetUtilsTextPlain& aVariable )
    {
    FUNC_LOG;
    if ( &iWizardCenRep )
        {
        return iWizardCenRep.Get( aSetting, aVariable );
        }
    return KErrNone;
    }
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::EmptyWizardCenRep()
    {
    FUNC_LOG;
    if ( &iWizardCenRep )
        {
        iWizardCenRep.Set( ECRKPopImapEmailAddressId, KNullDesC );
        iWizardCenRep.Set( ECRKPopImapUsernameId, KNullDesC );
        iWizardCenRep.Set( ECRKPopImapPasswordId, KNullDesC );
        iWizardCenRep.Set( ECRKPopImapIncomingServerId, KNullDesC );
        iWizardCenRep.Set( 
                ECRKPopImapProtocolIndicatorId, KErrNotFound );
        iWizardCenRep.Set( 
                ECRKPopImapIncomingSecurityAuthId, KErrNotFound );
        iWizardCenRep.Set( 
                ECRKPopImapIncomingSecurityProtocolId, KErrNotFound );
        iWizardCenRep.Set( ECRKPopImapIncomingPortId, KErrNotFound );
        iWizardCenRep.Set( ECRKPopImapOutgoingServerId, KNullDesC );
        iWizardCenRep.Set( 
                ECRKPopImapOutgoingSecurityAuthId, KErrNotFound );
        iWizardCenRep.Set( 
                ECRKPopImapOutgoingSecurityProtocolId, KErrNotFound );
        iWizardCenRep.Set( ECRKPopImapOutgoingPortId, KErrNotFound );
        iWizardCenRep.Set( 
                ECRKPopImapOperatorOutgoingServerId, KNullDesC );
        iWizardCenRep.Set( 
                ECRKPopImapOperatorSecurityAuthId, KErrNotFound );
        iWizardCenRep.Set( 
                ECRKPopImapOperatorSecurityProtocolId, KErrNotFound );
        iWizardCenRep.Set( ECRKPopImapOperatorPortId, KErrNotFound );
        iWizardCenRep.Set( ECRKPopImapAccessPointId, KNullDesC );  
        iWizardCenRep.Set( ECRKPopImapMailboxName, KNullDesC );  
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::SetSettingsL( CIpsSetData& aSetData )
    {
    FUNC_LOG;
    TImIAPChoice iap;
    TPortValue port;
    TSecurityValue security;
    
    aSetData.SetProtocol( 
        (iProtocol == 0) ? KSenduiMtmPop3Uid : KSenduiMtmImap4Uid );
        
    if(iProtocol == 0)// KSenduiMtmPop3Uid - for Pop account- default is Headers Only
        {
        aSetData.SetDownloadSizeL( CIpsSetData::EHeaders,KIpsSetDataHeadersOnly);
        }
    else 
        {
        aSetData.SetDownloadSizeL( CIpsSetData::EHeadersPlus, KIpsSetDataDefaultDownloadSizeKb );

        TInt retImFolders = aSetData.RetrieveLimit(CIpsSetData::EImap4Folders); //TRetrieveLimit
        if(retImFolders==-1)
            {
            TInt retPopInbox = aSetData.RetrieveLimit(CIpsSetData::EPop3Limit); 
            TInt retImInbox  = aSetData.RetrieveLimit(CIpsSetData::EImap4Inbox); 
            aSetData.SetRetrieveLimit(retPopInbox,retImInbox,KImapDefFoldersRetrieve);
            }
        }
    aSetData.SetEmailAddressL( iEmailAddress );
    aSetData.SetUserNameL( iUsername, iUsername );
    aSetData.SetUserPwdL( iPassword, iPassword );
    aSetData.SetMailServerL( iIncomingServer, iProviderOutgoingServer );
    
    security = SetSecurityValues( iInSecurityProtocol, iProviderOutSecurityProtocol );
    aSetData.SetSecurity( security.inSecurity, security.outSecurity );

    port = CheckPortValues( iProtocol, 
                            iInIncomingPort, 
                            iProviderOutgoingPort, 
                            security );
    aSetData.SetPort( port.inport, port.outport );                             
    
    aSetData.SetDataHide( iHiddenData );
    aSetData.SetMailboxName( CheckMailboxNamesL( iMailboxName ) );
    aSetData.SetUserAuthentication( CIpsSetData::EUseIncoming );

    iap = SetIAPByNameL( iRecomendedAP );
    
    TBool setIAP = ETrue;

    RCmManager cmmgr;
    cmmgr.OpenLC();
    TCmDefConnValue defConnValue;
    cmmgr.ReadDefConnL( defConnValue );

    //if IAP isn't set by SettingWizard, we try to get the SNAP.
    if ( iap.iIAP <= 0 )
        {
        //Use SNAP when we got it and it does contain access point.
        //For other situations as below, we set 'ask when need' or default IAP
        //1. defConnValue.iType == ECmDefConnAskOnce
        //2. Got SNAP, but it does not contain any access point
        //3. Got default IAP when defConnValue.iType == ECmDefConnConnectionMethod
        iap.iDialogPref = ECommDbDialogPrefPrompt;
        iap.iIAP = 0;        

        //Check default connection is destination or connection method
        if ( defConnValue.iType == ECmDefConnDestination )
            {
            //Get SNAP from cmmgr
            RCmDestination destination;
            CleanupClosePushL( destination );
            destination = cmmgr.DestinationL( defConnValue.iId );
            //check if SNAP has IAPs
            if ( destination.ConnectionMethodCount() > 0 )
                {
                //if SNAP contain access point, we use SNAP
                CImIAPPreferences* iapPref = CImIAPPreferences::NewLC();
                iapPref->SetSNAPL( defConnValue.iId );
              
                aSetData.SetIapL( *iapPref, *iapPref );
                CleanupStack::PopAndDestroy( iapPref );
                 
                setIAP = EFalse;
                }
                CleanupStack::PopAndDestroy( &destination );             
            }
        else if( defConnValue.iType == ECmDefConnConnectionMethod ) 
            {
            iap.iDialogPref = ECommDbDialogPrefDoNotPrompt;
            iap.iIAP = defConnValue.iId;
            }
        }
    else
        {
        // recommended IAP is defined
        // try setting SNAP that contains the IAP
        TBool found( EFalse );
        RArray< TUint32 > destArray;
        CleanupClosePushL( destArray );
     
        //Get list of all destinations
        cmmgr.AllDestinationsL( destArray );
     
        TInt arrayCount( destArray.Count() );

        CMManager::TSnapMetadataField metaFieldPurpose( CMManager::ESnapMetadataPurpose );
        CMManager::TSnapMetadataField metaFieldLocalized( CMManager::ESnapMetadataDestinationIsLocalised );

        //Traverse list of destinations
        for ( TInt i = 0; i < arrayCount && !found; ++i )
            {
            RCmDestination destination = cmmgr.DestinationL( destArray[ i ] );
            CleanupClosePushL( destination );
            
            TUint32  destinationPurpose = destination.MetadataL ( metaFieldPurpose );
            TUint32  destinationLocalized = destination.MetadataL ( metaFieldLocalized );
            
            TInt iapCount ( destination.ConnectionMethodCount() );
            if ( destinationPurpose == CMManager::ESnapPurposeInternet &&
                 destinationLocalized == CMManager::ELocalisedDestInternet && 
                 iapCount )
                {
                // found the Internet destination and it has at least one access point
                for ( TInt c=0;c < iapCount && !found; c++ )
                    {
                    RCmConnectionMethod connMethod = destination.ConnectionMethodL( c );
                    CleanupClosePushL( connMethod );
                    
                    TUint32 iapId = connMethod.GetIntAttributeL( CMManager::ECmIapId );
                    HBufC* connName = connMethod.GetStringAttributeL( CMManager::ECmName );
                    CleanupStack::PushL( connName );
                    CleanupStack::PopAndDestroy( connName ); 
                    if ( iapId == iap.iIAP )
                        {
                        CImIAPPreferences* iapPref = CImIAPPreferences::NewLC();
                        INFO_1( "Setting SNAP %d by IAP", destination.Id() )
                        iapPref->SetSNAPL( destination.Id());
                        aSetData.SetIapL( *iapPref, *iapPref );   
                        found = ETrue;
                        setIAP = EFalse;
                        CleanupStack::PopAndDestroy( iapPref );
                        }
                    CleanupStack::PopAndDestroy( &connMethod ); 
                    }
                }
            CleanupStack::PopAndDestroy( &destination );
            }
        CleanupStack::PopAndDestroy( &destArray );
        }    

        //If no valid IAP or destination, set zero.
        if ( setIAP )
            {
            INFO_1( "IAP is uncategorized, using IAP: %d", iap.iIAP )
            aSetData.SetIapL( iap, iap );                
            }
    CleanupStack::PopAndDestroy( &cmmgr );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TSecurityValue CIpsSetWizardAdapter::SetSecurityValues( 
    const TInt aInSecurity, const TInt aOutSecurity )
    {
    FUNC_LOG;
    TSecurityValue values;


    switch( aInSecurity )
        {
        case KWizardDataSecurityOff:
            {
            values.inSecurity = CIpsSetData::ESecurityOff;
            break;
            }
        case KWizardDataSecurityTLS:
            {
            values.inSecurity = CIpsSetData::EStartTls;
            break;
            }
        case KWizardDataSecuritySSL:
            {
            values.inSecurity = CIpsSetData::ESslTls;
            break;
            }
        default:
            {
            values.inSecurity = CIpsSetData::ESecurityOff;
            break;
            }
        }
        
    switch( aOutSecurity )
        {
        case KWizardDataSecurityOff:
            {
            values.outSecurity = CIpsSetData::ESecurityOff;
            break;
            }
        case KWizardDataSecurityTLS:
            {
            values.outSecurity = CIpsSetData::EStartTls;
            break;
            }
        case KWizardDataSecuritySSL:
            {
            values.outSecurity = CIpsSetData::ESslTls;
            break;
            }
        default:
            {
            values.outSecurity = CIpsSetData::ESecurityOff;
            break;
            }
        }
    return values;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TPortValue CIpsSetWizardAdapter::CheckPortValues( const TInt aProtocol, 
    const TInt aInport, const TInt aOutport, const TSecurityValue aSecurity )
    {
    FUNC_LOG;
    TPortValue values;
        
    if( aInport <= 0 || aInport > KWizardTCPMaxPort )
        {
        values.inport = IpsSetUtils::GetDefaultSecurityPort( 
            aSecurity.inSecurity, ETrue, aProtocol );
        }
    else
        {
        values.inport = aInport;
        }        
        
    if( aOutport <= 0 || aOutport > KWizardTCPMaxPort )
        {
        values.outport = IpsSetUtils::GetDefaultSecurityPort( 
            aSecurity.outSecurity, EFalse, aProtocol );
        }
    else
        {
        values.outport = aOutport;
        }
    return values;
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TImIAPChoice CIpsSetWizardAdapter::SetIAPByNameL( TDes& aIAPName )
    {
    FUNC_LOG;
    TInt iapcount;
    TImIAPChoice iap;
    TBuf<KWizardMaxUidValue> buf;
    CIpsSetUiItemAccessPoint* ipsSetAP = CIpsSetUiItemAccessPoint::NewLC();
    //Initial IAP list
    ipsSetAP->InitializeSelectionL();
    
    iapcount = ipsSetAP->iIapList.Count();

    //Set default AP to always ask
    iap.iDialogPref = ECommDbDialogPrefPrompt;
    iap.iIAP = 0;   

    //run through all found access points
    TBool found( EFalse );
    for( TInt i = 0;!found &&  i < iapcount; i++ )
        {
        HBufC* name( ipsSetAP->AccessPointNameLC( i ) );
        // If AP stored in cenrep key as UID value, we need to do
        // comparison by UID also -> Used in TP wizard
        buf.Zero();
        buf.Num( ipsSetAP->iIapList[i] );
        if( ( name && aIAPName.Compare( name->Des() ) == 0 ) ||
                aIAPName.Compare( buf ) == 0 )
            {
            //AP found!
            found = ETrue;
            iap.iDialogPref = ECommDbDialogPrefDoNotPrompt;
            iap.iIAP = ipsSetAP->iIapList[i];
            }
        CleanupStack::PopAndDestroy( name );
        }
    CleanupStack::PopAndDestroy( ipsSetAP );
    return iap;
    }
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::CreateEmailAccountL( CIpsSetData& aSetData )
    {
    FUNC_LOG;
    TInt accountcount;
    
    CIpsSetDataManager* setManager = CIpsSetDataManager::NewLC( iSession );
    
    //create mailbox
    User::LeaveIfError( setManager->CreateEmailAccount( aSetData, EFalse ) );
    
    CEmailAccounts* accounts = CEmailAccounts::NewLC();    
    RArray<TSmtpAccount> RIpsSmtpArray;        
    accounts->GetSmtpAccountsL( RIpsSmtpArray );
    accountcount = RIpsSmtpArray.Count();

    //increase mailbox count
    if ( &iWizardCenRep )
        { 
        iWizardCenRep.Set( ECRKAccountsConfigured, accountcount );
        }
    
    if( accountcount >= KMaxMailboxes && &iWizardCenRep )
        {
        iWizardCenRep.Set( ECRKMaxAccountsReached, ETrue );
        }
   
    RIpsSmtpArray.Close();
    CleanupStack::PopAndDestroy( accounts );
    CleanupStack::PopAndDestroy( setManager );
    
    // notify ao about new mailbox
    TInt mailboxId = KErrNotFound;
    if ( aSetData.ExtendedSettings() )
        {
        mailboxId = aSetData.ExtendedSettings()->MailboxId();
        }
    
    RAlwaysOnlineClientSession aosession; 
    TInt err = aosession.Connect();
    CleanupClosePushL( aosession );
    if ( mailboxId != KErrNotFound && err == KErrNone )
        {
        TPckgBuf<TMsvId> mboxBuf( mailboxId );
        TRAP( err, aosession.RelayCommandL( 
                EServerAPIEmailTurnOn, 
               mboxBuf ) );
        }
    CleanupStack::PopAndDestroy( &aosession );
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
TDes& CIpsSetWizardAdapter::CheckMailboxNamesL( TDes& aName )
    {
    FUNC_LOG;
    RArray<TSmtpAccount> RIpsSmtpArray;
    CEmailAccounts* accounts = CEmailAccounts::NewLC();
    TInt endNumber = 0; 
    
    accounts->GetSmtpAccountsL( RIpsSmtpArray );
    
    TIpsSetUtilsTextPlain tempName = aName;
    
    //Run through all mailboxes
    for ( TInt mailboxCount = RIpsSmtpArray.Count()-1; mailboxCount >= 0; mailboxCount-- )
        {
        TIpsSetUtilsTextPlain mailbox = 
            RIpsSmtpArray[mailboxCount].iSmtpAccountName;    
        
        if( !tempName.Compare( mailbox ) )
            {
            //if mailbox name already exists increase value after name
            tempName = aName;
            endNumber++;
            tempName.AppendNum( endNumber );
            //reset mailbox counter
            mailboxCount = RIpsSmtpArray.Count();
            }
        }
    aName = tempName;
    RIpsSmtpArray.Reset();
    CleanupStack::PopAndDestroy( accounts );
    return aName;
    }
 
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::HandleWizardDataL()
    {
    FUNC_LOG;
    // This leaves if reading is not successfull
    ReadWizardSettignsL();
    
    if( iMaxAccounts == EFalse )
        {
        //create settings
        CIpsSetData *setData = CIpsSetData::NewLC();
        SetSettingsL( *setData );

        //create mailbox
        CreateEmailAccountL( *setData ); 

        CleanupStack::PopAndDestroy( setData );
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::ChangeAsciiPrintable(
        const TDesC16& aOrgText, TDes& aValText )
     {
    FUNC_LOG;
     aValText.Zero();
     const TInt KMax7BitValue = 126;
     const TInt KMin7BitValue = 32;

     const TInt length = aOrgText.Length();
     const TText16* pText = aOrgText.Ptr();

     const TInt valMax = aValText.MaxLength();
     TInt valIndex = 0;
     for(TInt i=0; i<length; i++)
        {
        if ( valIndex >= valMax )
            {
            break;
            }
        if  (!((pText[i] > KMax7BitValue) || (pText[i] < KMin7BitValue)) )
            {
            aValText.Append( pText[i] );
            ++valIndex;
            }
        }
    }

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
void CIpsSetWizardAdapter::ChangeUnicodePrintable(
        const TDesC16& aOrgText, TDes& aValText )
    {
    FUNC_LOG;
    aValText.Zero();
    const TText16* pText = aOrgText.Ptr();
    const TInt orgLength = aOrgText.Length();
    
    const TInt valMax = aValText.MaxLength();
    TInt valIndex = 0;
    
    for(TInt i =0; i < orgLength ; ++i) 
      {
      if ( valIndex >= valMax )
          {
          break;
          }
      
      TChar aChar = pText[i]; 
      if ( aChar.IsPrint() ) 
         { 
         aValText.Append( aChar );
         } 
      } 
    }