/*
* Copyright (c) 2002 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: 
*     Email agent base class. common functions and data
*
*/


// INCLUDES
#include <AlwaysOnlineManagerCommon.h>
#include <AlwaysOnlineStatusQueryInterface.h>
#include <pop3set.h>
#include <imapset.h>
#include <SenduiMtmUids.h>
#include <StringLoader.h>
#include <AknGlobalNote.h>
#include <stringresourcereader.h>
#include <avkon.rsg>                            // Resouce identifiers
#include <iapprefs.h>
#include <rconnmon.h>
#include <cdbcols.h>							// for some constants
#include <MuiuMsvUiServiceUtilities.h>
#include <messagingvariant.hrh>                 // Local variation flags
#include <data_caging_path_literals.hrh>
#include <messaginginternalcrkeys.h>            // Messaging keys
#include <muiuemailtools.h>                     // MuiuEmailTools
#include <ImumInternalApi.h>
#include <ImumInSettingsData.h>
#include <ImumInSettingsKeys.h>

#include <cmconnectionmethoddef.h>
#include <cmpluginvpndef.h>
#include <ImumDaSettingsKeys.h>

#include "AlwaysOnlineEmailPluginLogging.h"
#include "AlwaysOnlineEmailLoggingTools.h"
#include "AlwaysOnlineEmailAgentBase.h"
#include "AlwaysOnlineEmailPluginTimer.h"
#include "AlwaysOnlineEmailAgent.h"
#include <AlwaysOnlineEmailPluginData.rsg>

// CONSTANTS
// Correct path is added to literal when it is used.
_LIT(KEmailPluginResource, "AlwaysOnlineEmailPluginData.rsc");
const TInt KEmailAgentBaseOperationsGranularity = 2;
const TInt KFileLoggerCounter = 100;
const TInt KMailSettingsIapPreferenceNumber     = 0;
const TInt KEmailPluginQueryTextLength    = 150;

const TInt KAoInterval5Min   = 5;
const TInt KAoInterval15Min  = 15;
const TInt KAoInterval30Min  = 30;
const TInt KAoInterval1Hour  = 60;
const TInt KAoInterval2Hours = 120;
const TInt KAoInterval4Hours = 240;
const TInt KAoInterval6Hours = 360;

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase()
// ----------------------------------------------------------------------------
CAlwaysOnlineEmailAgentBase::CAlwaysOnlineEmailAgentBase(
    CMsvSession& aSession, CClientMtmRegistry& aClientMtmRegistry,
    MAlwaysOnlineStatusQueryInterface& aAlwaysOnlineManager,
    CAlwaysOnlineEmailAgent& aEmailAgent )
    :
    iClientMtmRegistry( aClientMtmRegistry ),
    iSession( aSession ),
    iEntry ( NULL ),
    iOperations( KEmailAgentBaseOperationsGranularity ),
    iState( EEmailAgentInitialised ),
    iRetryCounter( 0 ),
    iLoggerFileCounter( KFileLoggerCounter ),
    iMailboxApi( NULL ),
    iMailboxSettings( NULL ),
    iError( KErrNone ),
    iNcnNotification ( NULL ),
    iStatusQueryInterface( aAlwaysOnlineManager ),
    iEmailAgent( aEmailAgent ),
    iFlags( NULL )
    {
    }

// ----------------------------------------------------------------------------
// ~CAlwaysOnlineEmailAgentBase ()
// ----------------------------------------------------------------------------
CAlwaysOnlineEmailAgentBase::~CAlwaysOnlineEmailAgentBase()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::~CAlwaysOnlineEmailAgentBase" );
    delete iMailboxApi;
    iMailboxApi = NULL;
    delete iMailboxSettings;
    iMailboxSettings = NULL;

    delete iNcnNotification;
    delete iEntry;

    iCmManager.Close();
    }

// ----------------------------------------------------------------------------
// ConstructL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::ConstructL( TMsvId aMailboxId )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::ConstructL" );
    iIntervalWaitId = KErrNotFound;
    iConnectOpId = KErrNotFound;
    iConnectSyncOpId = KErrNotFound;
    iSyncOpId = KErrNotFound;
    iWaitForStartOpId = KErrNotFound;
    iWaitForStopOpId = KErrNotFound;
    iStartDelayOpId = KErrNotFound;
    iConnectAndStayOnlineOpId = KErrNotFound;
    iDisconnectOpId = KErrNotFound;
    iFolderUpdateTimerOpId = KErrNotFound;
    iFolderSyncOpId = KErrNotFound;
    iFilteredPopulateOpId = KErrNotFound;

    iEntry = iSession.GetEntryL( aMailboxId );
    // Handle flags, including variation
    AlwaysOnlineFlagsL();

    iMailboxApi = CreateEmailApiL( &iSession );
    iMailboxSettings =
        iMailboxApi->MailboxServicesL().LoadMailboxSettingsL( aMailboxId );


    iRetryCounter = 0;

    iCmManager.OpenL();
    }

// ----------------------------------------------------------------------------
// OpCompleted
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::OpCompleted(
    CMsvSingleOpWatcher& aOpWatcher,
    TInt /*aCompletionCode*/ )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::OpCompleted" );
    CMsvOperation* op=&aOpWatcher.Operation();
    TMsvOp opId = op->Id();
    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::OpCompleted() Op Id: %d", opId);
    const TInt count = iOperations.Count();

    for ( TInt i = count - 1; i >= 0; i-- )
        {
        // We need to check the id of a completed operation that it
        // matches to what we expect, because there may be several
        // simultaneous operations and there is no guarantee that
        // they comlete in the order we think they do.
        CMsvOperation& oper = iOperations[i]->Operation();

        if ( oper.Id() == opId )
            {
            CMsvSingleOpWatcher* opWatcher = iOperations[i];
            KAOEMAIL_LOGGER_WRITE_FORMAT(">>>> iOperations count before : %d", iOperations.Count());
            iOperations.Delete( i );
            // The operations matches, handle it
            HandleCompletingOperation( opId, *op, op->Mtm() );
            KAOEMAIL_LOGGER_WRITE_FORMAT(">>>> iOperations count after : %d", iOperations.Count());
            delete opWatcher;

            break;
            }
        }

    // Change the state
    TRAPD( err, ChangeNextStateL() );
    if ( err != KErrNone )
        {
        //not much to do if this fails for some reason. Just reset all and restart
        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::OpCompleted() ChangeNextStateL returned error: %d , resetting all!", err );
        ResetAll();
        iState = EEmailAgentInitialised;

        // Just catch the possible leaving and continue execution
        TRAP( err, CreateCompletedOpL() );
        }

    }

// ----------------------------------------------------------------------------
// AppendWatcherAndSetOperationL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::AppendWatcherAndSetOperationL(
    CMsvSingleOpWatcher* aWatcher,
    CMsvOperation* aOperation )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::AppendWatcherAndSetOperationL" );
    iOperations.AppendL( aWatcher );
    aWatcher->SetOperation( aOperation ); // takes immediately ownership

    KAOEMAIL_LOGGER_WRITE( "-------------------<APPEND: OpInfo>-----------------" );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aOpId: %d", aOperation->Id() );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aUid: %d", aOperation->Mtm().iUid );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: Op Count: %d", iOperations.Count() );
    KAOEMAIL_LOGGER_WRITE( "-------------------<APPEND: OpInfo>-----------------" );
    }

// ----------------------------------------------------------------------------
// MailboxId
// ----------------------------------------------------------------------------
TMsvId CAlwaysOnlineEmailAgentBase::MailboxId() const
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::MailboxId" );
    return iEntry->Entry().Id();
    }

//-----------------------------------------------------------------------------
// EmailAddress
//-----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::EmailAddress( TDes& aEmailAddress )
    {
    iMailboxSettings->GetAttr(
        TImumDaSettings::EKeyEmailAddress, aEmailAddress );
    }

//-----------------------------------------------------------------------------
// Username
//-----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::Username( TDes8& aUsername )
    {
    // trap ignored, only leave descriptor empty in case of error
    TRAP_IGNORE( aUsername = LoadSettingL<TImumDaSettings::TTextUserName>( // CSI: 59 # trap has leaving code
                 TImumDaSettings::EKeyUsername, ETrue); );
    }


//-----------------------------------------------------------------------------
// ServerAddress
//-----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::ServerAddress( TDes& aServer )
    {
    // leave descriptor empty in case of error
    TRAP_IGNORE( aServer = LoadSettingL<TImumDaSettings::TTextServerAddress>( // CSI: 59 # trap has leaving code
                 TImumDaSettings::EKeyServer, ETrue); );
    }

//-----------------------------------------------------------------------------
// StartTimerOperationL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::StartTimerOperationL(
    const TTime& aTime,
    TMsvOp& aOpId )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::StartTimerOperationL" );
    CMsvSingleOpWatcher* watcher = CMsvSingleOpWatcher::NewL(*this);
    CleanupStack::PushL( watcher );

    CAlwaysOnlineEmailPluginTimer* timer = 
        CAlwaysOnlineEmailPluginTimer::NewL( iSession, watcher->iStatus );
    CleanupStack::PushL( timer );
    KAOEMAIL_LOGGER_WRITE_DATETIME("CAlwaysOnlineEmailAgentBase::StartTimerOperationL() Expires at: ", aTime);
    timer->At( aTime );  // CSI: 1 # not an array

    aOpId = timer->Id();

    AppendWatcherAndSetOperationL( watcher, timer ); // takes immediately ownership
    CleanupStack::Pop( 2, watcher ); // timer // CSI: 12,47 # nothing worng
    }


// ---------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::AoState()
// ---------------------------------------------------------------------------
//
TInt CAlwaysOnlineEmailAgentBase::AoState() const
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::AoState" );
    TInt state = 0;
    iMailboxSettings->GetAttr(
        TImumDaSettings::EKeyAutoRetrieval, state );
    return state;
    }

// ---------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::EmnState()
// ---------------------------------------------------------------------------
//
TInt CAlwaysOnlineEmailAgentBase::EmnState() const
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::EmnState" );
    TInt state = 0;
    iMailboxSettings->GetAttr(
        TImumDaSettings::EKeyAutoNotifications, state );
    return state;
    }


// ----------------------------------------------------------------------------
// ConnectL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::ConnectL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::ConnectL" );
    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgentBase::ConnectL");

    if ( MsvUiServiceUtilities::DiskSpaceBelowCriticalLevelWithOverheadL(
            iSession, 0, KAOSafetyMargin ) && !IsTemporary() )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(): Disk full, setting AO of.");
        DisplayGlobalErrorNoteL( EEmailAgentOutOfDisk );
        SwitchAutoUpdateOffL();
        return;
        }

    TBool allowed = ETrue;

    TBool offline =
        reinterpret_cast<TBool>( iStatusQueryInterface.QueryStatusL(
            EAOManagerStatusQueryOffline ) );

    if ( offline )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(). Trying to connect while offline mode! Not allowing!");
        allowed = EFalse;
        }

    TAlwaysOnlineEmailIAPNotes invalidity;

    if ( allowed && IsIAPInvalidL( invalidity ) )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(). Accesspoint faulty or prompting password, switching off!");
        DisplayGlobalErrorNoteL( invalidity );
        SwitchAutoUpdateOffL();
        return;
        }


    if ( allowed && AoState() == TImumDaSettings::EValueAutoOff &&
        EmnState() == TImumDaSettings::EValueNotificationsOff )
        {
        // User is propably in settings, and we're turned off.
        // Wait timer event just has been running and completed while
        // user launched settings. Don't connect.
        allowed = EFalse;
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(). Settings dialog seems to be open. Won't connect.");
        }

    // UI takes care that either AO or EMN is turned on.
    if ( allowed && (AoState() == TImumDaSettings::EValueAutoHomeNetwork ||
        EmnState() == TImumDaSettings::EValueNotificationsHome) )
        {
        TInt networkStatus =
            reinterpret_cast< TInt >( iStatusQueryInterface.QueryStatusL(
                EAOManagerStatusQueryNetwork ) );

        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::ConnectL() Network status: %d", networkStatus );

        if( networkStatus != ENetworkRegistrationHomeNetwork )
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(). We're not on home network. Won't connect");
            allowed = EFalse;
            }
        }

    if ( !allowed )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectL(). Connect not allowed -> idle");
        iState = EEmailAgentIdle;
        CreateCompletedOpL();
        return;
        }

    ConnectAndUpdateHeadersL();
    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgentBase::ConnectL");
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::CleanOperation()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::CleanOperation( TMsvOp& aOpId )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CleanOperation" );
    const TInt count = iOperations.Count();

    for ( TInt i=0; i < count; i++ )
        {
        if ( iOperations[i]->Operation().Id() == aOpId )
            {
            KAOEMAIL_LOGGER_WRITE( "-------------------<REMOVE: OpInfo>-----------------" );
            KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aOpId: %d", aOpId );
            KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aUid: %d", iOperations[i]->Operation().Mtm().iUid );

            // First set id to KErrNotFound so OpCompleted won't
            // take any action because of this
            aOpId = KErrNotFound;
            delete iOperations[i];
            iOperations[i] = NULL;
            iOperations.Delete(i);

            KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: Op Count: %d", iOperations.Count() );
            KAOEMAIL_LOGGER_WRITE( "-------------------<REMOVE: OpInfo>-----------------" );
            break;
            }//if
        }//for
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::LaunchStartTimerL()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::LaunchStartTimerL(
    TTime& aClock,
    const TTimeIntervalSeconds& aSeconds )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::LaunchStartTimerL" );
    //wait for start
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::LaunchStartTimerL() Checking for wait for START schedule");

    // The connection is on, and the connection is required, this means
    // the mailbox in online during the time it should not be
    if ( iConnectAndStayOnlineOpId != KErrNotFound )
        {
        DisconnectL( ETrue );
        }

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::LaunchStartTimerL. Minutes to wait ( time ): %d ",( aSeconds.Int()/60 ) ); // CSI: 47 # seconds to minutes

    aClock += aSeconds;
    StartTimerOperationL( aClock, iWaitForStartOpId );

    KAOEMAIL_LOGGER_WRITE_DATETIME("Started waitForStartTimer. Expiring at: ", aClock);

    iState = EEmailAgentTimerWaitingForStart;
    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::LaunchStartTimerL. Setting state:  %d ",iState );

    CleanOperation( iWaitForStopOpId );
    iWaitForStopOpId = KErrNotFound;//set to KErrNotFound

    // If waiting for start, we don't need to connect after saving settings,
    // thus set this to false.
    iFlags->ClearFlag( EAOBFConnectNow );
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::LaunchStopTimerL()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::LaunchStopTimerL(
    TTime& aClock,
    const TTimeIntervalSeconds& aSeconds )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::LaunchStopTimerL" );
    //wait for stop
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::LaunchStopTimerL() Checking for wait for STOP schedule");

    if( aSeconds.Int() == 0)
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::LaunchStopTimerL() All days and all hours scheduled");
        iState = EEmailAgentTimerWaitingForStart;//causes us to connect
        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::LaunchStopTimerL(). Setting state:  %d ",iState );
        CreateCompletedOpL();//creates completed operation
        return;
        }
    else
        {
        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::LaunchStopTimerL. Minutes to wait ( time ): %d ",( aSeconds.Int()/60 + 0.5 ) ); // CSI: 47 # seconds to minutes
        aClock += aSeconds;
        StartTimerOperationL( aClock, iWaitForStopOpId );

        CleanOperation( iWaitForStartOpId );
        iWaitForStartOpId = KErrNotFound;//set to KErrNotFound

        KAOEMAIL_LOGGER_WRITE_DATETIME("Started waitForStopTimer. Expiring at: ", aClock);
        }
    }

// ----------------------------------------------------------------------------
// CheckAndHandleSchedulingL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::CheckAndHandleSchedulingL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CheckAndHandleSchedulingL" );
    TTime clock;
    clock.HomeTime();

    TTimeIntervalSeconds secondsInterval;
    TInt64 connectionState = 0x00;
    iMailboxApi->MailboxUtilitiesL().NextAlwaysOnlineIntervalL(
        iEntry->Entry().Id(),
        connectionState, secondsInterval );

    KAOEMAIL_LOGGER_WRITE_FORMAT( "Stop Timer: %d", iWaitForStopOpId );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Start Timer: %d", iWaitForStartOpId );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Interval Timer: %d", iIntervalWaitId );

    if ( iWaitForStopOpId != KErrNotFound )
        {
        KAOEMAIL_LOGGER_WRITE( "* Cleaning stop timer *" );
        CleanOperation( iWaitForStopOpId );
        }

    if ( iWaitForStartOpId != KErrNotFound )
        {
        KAOEMAIL_LOGGER_WRITE( "* Cleaning start timer *" );
        CleanOperation( iWaitForStartOpId );
        }

    if( iIntervalWaitId != KErrNotFound )
        {
        KAOEMAIL_LOGGER_WRITE( "* Cleaning interval timer *" );
        CleanOperation( iIntervalWaitId );
        }

    // Not connected and should connect
    if ( connectionState & MImumInMailboxUtilities::EFlagWaitingToConnect )
        {
        LaunchStartTimerL( clock, secondsInterval );
        }
    // Connected and should disconnect
    else
        {
        LaunchStopTimerL( clock, secondsInterval );
        }
    }

// ----------------------------------------------------------------------------
// ResetAll
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::ResetAll()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::ResetAll" );
    KAOEMAIL_LOGGER_WRITE_FORMAT("ResetAll() Reset All called. Operation count: %d", iOperations.Count() );

    iOperations.ResetAndDestroy();

    //if we're still connected, do sync disconnet. Connect check is inside this function
    //can leave, so trap. ResetAll() is not leaving function
    TRAP_IGNORE( DoSyncDisconnectL() );

    iIntervalWaitId = KErrNotFound;
    iConnectOpId = KErrNotFound;
    iConnectSyncOpId = KErrNotFound;
    iSyncOpId = KErrNotFound;
    iWaitForStartOpId = KErrNotFound;
    iWaitForStopOpId = KErrNotFound;
    iConnectAndStayOnlineOpId = KErrNotFound;
    iDisconnectOpId = KErrNotFound;
    iFolderUpdateTimerOpId = KErrNotFound;
    iFolderSyncOpId = KErrNotFound;
    iFilteredPopulateOpId = KErrNotFound;
    }


// ----------------------------------------------------------------------------
// Suspend
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::Suspend()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::Suspend" );
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::SuspendL() Suspend called. Resetting and going to idle");
    ResetAll();
    iState = EEmailAgentIdle;
    // We may start up suspended, so set this to false.
    iFlags->ClearFlag( EAOBFConnectNow );
    }

// ----------------------------------------------------------------------------
// ResumeL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::ResumeL( const TBool aConnectNow )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::ResumeL" );
    // We are here, because agent got resume command, so we need to refresh our
    // settings objects by deleting current settings. New settings objects are
    // created and loaded when certain setting is used first time after resume.
    // iAlwaysOnlineEmailScheduler's settings reference is also updated, this
    // happens in ExtensionSettings() function.

    // Update the settings here
    delete iMailboxSettings;
    iMailboxSettings = NULL;

    iMailboxSettings =
        iMailboxApi->MailboxServicesL().LoadMailboxSettingsL(
            iEntry->Entry().Id() );

    // Set connection status, so the connection can be made, if needed
    iFlags->ChangeFlag( EAOBFConnectNow, aConnectNow );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::ResumeL() iState: %d", iState );
    if ( iState == EEmailAgentIdle )
        {
        if ( AoState() != TImumDaSettings::EValueAutoOn )
            {
            //check does roaming setting allow us to resume
            TInt networkStatus =
                reinterpret_cast<TInt>( iStatusQueryInterface.QueryStatusL(
                    EAOManagerStatusQueryNetwork ) );

            KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::ResumeL() Network status: %d", networkStatus );
            if ( networkStatus != ENetworkRegistrationHomeNetwork )
                {
                //not going to resume, stay idle
                KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ResumeL() Resume called. Home only setting won't allow us to resume. Still idling");
                return;
                }//if
            }//if
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ResumeL() Resume called. Settings state to Initialised ( 0 )");
        iState = EEmailAgentInitialised;
        CreateCompletedOpL();
        }
    }

// ----------------------------------------------------------------------------
// HandleRoamingEventL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::HandleRoamingEventL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::HandleRoamingEventL" );
    // UI takes care that either AO or EMN is turned on.
    if ( AoState() != TImumDaSettings::EValueAutoOn ||
         EmnState() != TImumDaSettings::EValueNotificationsOn )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleRoamingEventL() Roaming started and we're not set to update during roaming, going to idle");
        ResetAll();
        iState = EEmailAgentIdle;
        }
    }


// ----------------------------------------------------------------------------
// HandleOutOfDiskEventL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::HandleOutOfDiskEventL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::HandleOutOfDiskEventL" );
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleOutOfDiskEventL() Ran out of disk! Switching off!");
    // Check if agent is temporary, which means that we are not allowed to show
    // any notes. Only IMAP mailbox can have temporary agent.
    if ( !IsTemporary() )
        {
        DisplayGlobalErrorNoteL(
            TAlwaysOnlineEmailIAPNotes( EEmailAgentOutOfDisk ) );
        SwitchAutoUpdateOffL();
        }
    }

// ----------------------------------------------------------------------------
// SwitchOffL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::SwitchOffL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::SwitchOffL" );
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::SwitchOffL() ORDERED TO SWITCH OFF, COMPLYING!");
    SwitchAutoUpdateOffL();
    }

// ----------------------------------------------------------------------------
// HandleHomeNetworkEventL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::HandleHomeNetworkEventL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::HandleHomeNetworkEventL" );
    // This might be true when there is a temporary mail agent.
    if ( AoState() != TImumDaSettings::EValueAutoOn ||
         EmnState() != TImumDaSettings::EValueNotificationsOn )
        {
        if( iState == EEmailAgentIdle )
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleHomeNetworkEventL() HomeNetwork event received, starting up");
            iState = EEmailAgentInitialised;
            CreateCompletedOpL();
            }
        else
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleHomeNetworkEventL() HomeNetwork event received But we're running already...ignore");
            }
        }
    }

// ----------------------------------------------------------------------------
// SetLastSuccessfulUpdate
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::SetLastSuccessfulUpdate()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::SetLastSuccessfulUpdate" );
    TBool lastUpdateFailed = EFalse;
    TTime time = TTime();
    TBool updSuccess = ETrue;
    time.HomeTime();
    iMailboxSettings->SetAttr(
        TImumInSettings::EKeyInfoLastUpdateFailed,
        lastUpdateFailed );
    iMailboxSettings->SetAttr(
        TImumInSettings::EKeyInfoLastSuccessfulUpdate,
        time.Int64() );
    iMailboxSettings->SetAttr(
        TImumInSettings::EKeyAoUpdateSuccessfulWithCurSettings, updSuccess );

    TRAP_IGNORE( iMailboxApi->MailboxServicesL().SaveMailboxSettingsL( *iMailboxSettings ) );
    }

// ----------------------------------------------------------------------------
// SetLastUpdateFailedL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::SetLastUpdateFailed()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::SetLastUpdateFailed" );
    TBool updateFailed = LoadSettingL<TInt>(
        TImumInSettings::EKeyInfoLastUpdateFailed, EFalse );

    if ( !updateFailed )
        {
        iMailboxSettings->SetAttr(
            TImumInSettings::EKeyInfoLastUpdateFailed,
            ETrue );
        TRAP_IGNORE( iMailboxApi->MailboxServicesL().SaveMailboxSettingsL(
            *iMailboxSettings ) );
        }

    }

// ----------------------------------------------------------------------------
// DisplayGlobalErrorNoteL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::DisplayGlobalErrorNoteL(
        TAlwaysOnlineEmailIAPNotes aInvalidity )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::DisplayGlobalErrorNoteL" );
    //NOTE: WHEN USING THIS FUNCTION TO SHOW ERROR NOTES,
    //STRINGS MUST CONTAIN %U PARAMETER FOR MAILBOX NAME

    TFileName resourceFile;
    TParse tp;
    tp.Set( KEmailPluginResource, &KDC_RESOURCE_FILES_DIR, NULL );
    resourceFile.Copy( tp.FullName() );
    CStringResourceReader* resourceReader = NULL;
    TRAPD( err, resourceReader = CStringResourceReader::NewL( resourceFile ) );
    if ( err != KErrNone )
        {
        //if resource not present for some reason, just return.
        //User will not see error note, but no other harm done.
        return;
        }
    CleanupStack::PushL( resourceReader );//can't use LC in TRAPD

    TBuf<KEmailPluginQueryTextLength> tempText;

    switch ( aInvalidity )
        {
        case EEmailAgentCSDIAP:
            tempText = resourceReader->ReadResourceString(
                R_EMAIL_PLUGIN_INVALID_AP_BEARER );
            break;
        case EEmailAgentOutOfDisk:
            tempText = resourceReader->ReadResourceString(
                R_EMAIL_PLUGIN_OUT_OF_DISK );
            break;
        case EEmailAgentInvalidInterval:
        case EEmailAgentEMNFatalError:
        case EEmailAgentOtherInvalidity:
        default:
            tempText = resourceReader->ReadResourceString(
                R_EMAIL_PLUGIN_ALWAYS_INCORRECT );
            break;
        }

    TBuf<KEmailPluginQueryTextLength> noteText;
    StringLoader::Format(
        noteText,
        tempText,
        -1,
        iEntry->Entry().iDetails.Left(
                    KEmailPluginQueryTextLength - tempText.Length() )
        );

    CAknGlobalNote* note = CAknGlobalNote::NewL();
    CleanupStack::PushL( note );
    note->SetSoftkeys( R_AVKON_SOFTKEYS_OK_EMPTY__OK );
    note->ShowNoteL( EAknGlobalErrorNote, noteText );
    CleanupStack::PopAndDestroy( 2, resourceReader ); // note // CSI: 12,47 # nothing wrong
    }


// ----------------------------------------------------------------------------
// QueryAndHandleAOServerInfoL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::QueryAndHandleAOServerInfoL( TBool& aSuspended )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::QueryAndHandleAOServerInfoL" );
    TInt networkStatus =
        reinterpret_cast<TInt>( iStatusQueryInterface.QueryStatusL(
            EAOManagerStatusQueryNetwork ) );

    KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::QueryAndHandleAOServerInfoL() Network status: %d", networkStatus );

    TBool offline =
        reinterpret_cast<TBool>( iStatusQueryInterface.QueryStatusL(
            EAOManagerStatusQueryOffline ) );

    aSuspended = EFalse;

    if ( offline )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::QueryAndHandleAOServerInfoL() We are in offline mode. Going into susped");
        Suspend();
        aSuspended = ETrue;
        }

    if ( !aSuspended &&
         ( CheckIfAgentHomeOnly() &&
           networkStatus != ENetworkRegistrationHomeNetwork ) )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::QueryAndHandleAOServerInfoL() We are not in home network and HomeNetworkOnly is selected. Going into suspend");
        Suspend();
        aSuspended = ETrue;
        }
    }

// ----------------------------------------------------------------------------
// CheckAgentHomeNetwork
// ----------------------------------------------------------------------------
TBool CAlwaysOnlineEmailAgentBase::CheckIfAgentHomeOnly()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CheckIfAgentHomeOnly" );
    if ( AoState() == TImumDaSettings::EValueAutoHomeNetwork ||
         EmnState() == TImumDaSettings::EValueNotificationsHome )
        {
        return ETrue;
        }
    return EFalse;
    }

// ----------------------------------------------------------------------------
// SwitchAutoUpdateOffL
// ----------------------------------------------------------------------------
void CAlwaysOnlineEmailAgentBase::SwitchAutoUpdateOffL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::SwitchAutoUpdateOffL" );
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::SwitchAutoUpdateOffL() Switching Auto Update OFF!");

    //first call suspend so all timer operations will be deleted
    Suspend();

    if ( IsEmn() )
        {
        iMailboxSettings->SetAttr(
            TImumDaSettings::EKeyAutoNotifications,
            TImumDaSettings::EValueNotificationsOff );
        }
    else
        {
        iMailboxSettings->SetAttr(
            TImumDaSettings::EKeyAutoRetrieval,
            TImumDaSettings::EValueAutoOff );
        }

    iMailboxApi->MailboxServicesL().SaveMailboxSettingsL(
        *iMailboxSettings );


    RemoveMe();//completely removes us
    }


// ----------------------------------------------------------------------------
// GetConnectionMethodL
// ----------------------------------------------------------------------------
RCmConnectionMethod CAlwaysOnlineEmailAgentBase::GetConnectionMethodLC()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::GetIapIdL" );
    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgentBase::GetIapIdL");

    CImIAPPreferences* apPrefs = CImIAPPreferences::NewLC();
    CEmailAccounts* accounts = CEmailAccounts::NewLC();

    // Load account settings according to used protocol
    if ( iFlags->Flag( EAOBFIsImap4 ) )
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::GetIapIdL(): Load Imap IAP settings");
        TImapAccount account;
        accounts->GetImapAccountL( iEntry->Entry().Id(), account );
        accounts->LoadImapIapSettingsL( account, *apPrefs );
        }
    else // POP3
        {
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::GetIapIdL(): Load Pop IAP settings");
        TPopAccount account;
        accounts->GetPopAccountL( iEntry->Entry().Id(), account );
        accounts->LoadPopIapSettingsL( account, *apPrefs );
        }
    CleanupStack::PopAndDestroy( accounts ); // accounts

    // Check ap preferences
    TInt iapId;
    if ( apPrefs->NumberOfIAPs()>0 )
        {
        TImIAPChoice iapChoice = apPrefs->IAPPreference( KMailSettingsIapPreferenceNumber );
        iapId = iapChoice.iIAP;
        }
    else if( apPrefs->SNAPDefined() )
        {
        iapId = apPrefs->SNAPPreference();
        }
    else
        {
        iapId = 0;
        }
    

    // if iapId is 0, assume default connection
    // else the iapId points to the actual iap
    if( iapId == 0 )
        {
        // Default Connection is in use
        TCmDefConnValue defConSetting;
        iCmManager.ReadDefConnL( defConSetting );
        if( defConSetting.iType == ECmDefConnAlwaysAsk ||
            defConSetting.iType == ECmDefConnAskOnce )
            {
            // always ask not supported in always online plugin
        	User::Leave( KErrNotSupported );
        	}
        else
        	{
        	iapId = defConSetting.iId;
        	}
    	}

    RCmConnectionMethod connMethod = iCmManager.ConnectionMethodL( iapId );
    CleanupStack::PopAndDestroy( apPrefs ); // apPrefs
    CleanupClosePushL( connMethod );

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgentBase::GetIapIdL");
    return connMethod;
    }

// ----------------------------------------------------------------------------
// IsIAPInvalidL
// ----------------------------------------------------------------------------
TBool CAlwaysOnlineEmailAgentBase::IsIAPInvalidL( TAlwaysOnlineEmailIAPNotes& aInvalidity )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::IsIAPInvalidL" );
    TBool retVal = EFalse;

    // Get the connection method that's used, leaves if no
    // connection methods found
    RCmConnectionMethod connectionMethod = GetConnectionMethodLC();

    // << VARIATED FEATURE START
    // Check for CSD type
    // Always online can be activated for CSD only if EAOLFAlwaysOnlineCSD
    // flag is on
    TInt bearerType = connectionMethod.GetIntAttributeL( CMManager::ECmBearerType );
    if ( !iFlags->LF( EAOLFAlwaysOnlineCSD ) )
    	{
    	if( bearerType == KCommDbBearerCSD )
    		{
    		// IAP is invalid, feature flag is off but bearer type is
    		// still CSD
    		CleanupStack::PopAndDestroy(); // connMethod // CSI: 12 # RClass not checked 
    		aInvalidity = EEmailAgentCSDIAP;
    		return ETrue;
    		}
    	}
    // CSD VARIATED FEATURE END >>

    // VPN APs should make the same checks, for example CSD
    if( bearerType == KPluginVPNBearerTypeUid )
    	{
    	TInt homeIAP = connectionMethod.GetIntAttributeL( CMManager::EVpnIapId );

    	RCmManager connMan;
    	connMan.OpenLC();
    	RCmConnectionMethod vpnMethod = connMan.ConnectionMethodL( homeIAP );
    	CleanupClosePushL( vpnMethod );
    	TInt vpnBearerType = vpnMethod.GetIntAttributeL( CMManager::ECmBearerType );

        if ( !iFlags->LF( EAOLFAlwaysOnlineCSD ) )
        	{
        	if( vpnBearerType == KCommDbBearerCSD )
        		{
        		// IAP is invalid, feature flag is off but the VPN home
        		// IAP's bearer type is still CSD
        		CleanupStack::PopAndDestroy( 2 ); // vpnMethod, connectionMethod // CSI: 12,47 # RClass not checked 
        		aInvalidity = EEmailAgentCSDIAP;
        		return ETrue;
        		}
        	}
    	CleanupStack::PopAndDestroy(); // vpnMethod // CSI: 12 # RClass not checked 
    	}

    CleanupStack::PopAndDestroy(); // connectionMethod // CSI: 12 # RClass not checked 
    return retVal;
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::IsBearerCSDL()
// ----------------------------------------------------------------------------
TBool CAlwaysOnlineEmailAgentBase::IsBearerCSDL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::IsBearerCSDL" );
    TBool csdIAP = EFalse;

    // Get the connection method that's used, leaves if no
    // connection methods found
    RCmConnectionMethod connectionMethod = GetConnectionMethodLC();
    TInt bearerType = connectionMethod.GetIntAttributeL( CMManager::ECmBearerType );

	if( bearerType == KCommDbBearerCSD )
		{
		// IAP is invalid, feature flag is off but bearer type is
		// still CSD
		csdIAP = ETrue;
		}

    CleanupStack::PopAndDestroy(); // connectionMethod // CSI: 12 # RClass not checked

    return csdIAP;
    }


// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::RemoveMe()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::RemoveMe()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::RemoveMe" );
    KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::RemoveMe() EmailAgent signalled to remove us!");
    //refresh will see that our setting is "not enabled" and removes us
    iEmailAgent.DeleteMailbox( iEntry->Entry().Id() );
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::CreateSingleOpWatcherLC()
// ----------------------------------------------------------------------------
//
CMsvSingleOpWatcher* CAlwaysOnlineEmailAgentBase::CreateSingleOpWatcherLC()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CreateSingleOpWatcherLC" );
    CMsvSingleOpWatcher* watcher = CMsvSingleOpWatcher::NewL(*this);
    CleanupStack::PushL( watcher );
    return watcher;
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::HandleCompletingOperation()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::HandleCompletingOperation(
    const TMsvOp& aOpId,
    CMsvOperation& aOp,
    const TUid& aUid )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::HandleCompletingOperation" );
    TInt error = aOp.iStatus.Int();

    KAOEMAIL_LOGGER_WRITE( "-------------------<COMPLETE: OpInfo>-----------------" );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aOpId: %d", aOpId );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: aUid: %d", aUid.iUid );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "Completing operation: error: %d", error );
    KAOEMAIL_LOGGER_WRITE( "-------------------<COMPLETE: OpInfo>-----------------" );

    // Check if we are using IMAP4
    if( error == KErrNone )
        {
        if ( aUid == KSenduiMtmImap4Uid )
            {
            TPckgBuf<TImap4CompoundProgress> prgBuf;
            TRAP( error, prgBuf.Copy( aOp.ProgressL() ) );

            // Check that we have the descriptor with us
            if ( error == KErrNone )
                {
                const TImap4CompoundProgress& opPrg = prgBuf();
                const TImap4GenericProgress& genProg =
                opPrg.iGenericProgress;
                error = genProg.iErrorCode;
                }
            }
        // Check if we are using POP3
        else if( aUid == KSenduiMtmPop3Uid )
            {
            TPckgBuf<TPop3Progress> paramPack;
            TRAP( error, paramPack.Copy( aOp.ProgressL() ) );

            // Check that we have the descriptor with us
            if ( error == KErrNone )
                {
                const TPop3Progress& progress = paramPack();
                error = progress.iErrorCode;
                }
            }
        }

    // Handle operation completion
    HandleOpCompleted( aOpId, error );
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::ConnectIfAllowed()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL( const TMsvOp& aOperation )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL" );
    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL");
    if( aOperation == KErrNotFound )
        {
        if ( !IsEmn() )
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL(): Not EMN -> Check scheduling");
            // Starts schedule timers and sets state accordingly
            CheckAndHandleSchedulingL();

            // No start or stop waiters, all times
            if( iWaitForStopOpId != KErrNotFound ||
                  ( iWaitForStopOpId == KErrNotFound &&
                  iWaitForStartOpId == KErrNotFound ) )
                {
                ConnectL();
                }
            }
        else
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL(): EMN -> ConnectL");
            // When EMN used, we don't have to care about scheduling,
            // just connect
            ConnectL();
            }
        }

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgentBase::ConnectIfAllowedL");
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::CallNewMessagesL()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::CallNewMessagesL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CallNewMessagesL" );
    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgentBase::CallNewMessagesL");

    // Create a dummy array. It is not currently used to anything.
    CDesCArrayFlat* dummyArray = new (ELeave) CDesCArrayFlat( 1 );
    CleanupStack::PushL( dummyArray );

    if ( !iNcnNotification )
        {
        // If notification haven't been created let's do it now!
        TRAPD(error, iNcnNotification =
                MNcnInternalNotification::CreateMNcnInternalNotificationL() );
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::CallNewMessagesL(): NCN notification connection retry");
        if ( error != KErrNone )
            {
            // if construction wasn't fully successful
            delete iNcnNotification;
            iNcnNotification = NULL;
            }
        }

    if ( iNcnNotification )
        {
        TInt result = iNcnNotification->NewMessages(
            EMailMessage, iEntry->Entry().Id(), *dummyArray );
        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::CallNewMessagesL(): NewMessages result = %d", result );
        }
    else
        {
        // write log if we couldn't create notification
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::CallNewMessagesL(): NewMessages not called!, retry faild");
        }

    CleanupStack::PopAndDestroy( dummyArray );
    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgentBase::CallNewMessagesL");
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::AlwaysOnlineFlagsL()
// ----------------------------------------------------------------------------
//
CMuiuFlags* CAlwaysOnlineEmailAgentBase::AlwaysOnlineFlagsL()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::AlwaysOnlineFlagsL" );
    KAOEMAIL_LOGGER_FN1("CAlwaysOnlineEmailAgentBase::AlwaysOnlineFlagsL()");
    TMuiuLocalFeatureArray locals;

    TMuiuGlobalFeatureArray globals;

    // EAOLFAlwaysOnlineCSD
    TMuiuLocalFeatureItem temp = {
        KCRUidMuiuVariation, KMuiuEmailConfigFlags,
        KEmailFeatureIdAlwaysOnlineCSD, ETrue };
    locals.Append( temp );

    // EAOLFAlwaysOnlineVPN
    temp.iFlag = KEmailFeatureIdEmailVPNAllowed;
    locals.Append( temp );

    iFlags = CMuiuFlags::NewL( &globals, &locals );
    globals.Reset();
    locals.Reset();

    KAOEMAIL_LOGGER_WRITE( "********************* FEATURES *******************" );
    KAOEMAIL_LOGGER_WRITE_FORMAT( "CSD support: %d", iFlags->LF( EAOLFAlwaysOnlineCSD ) );

    KAOEMAIL_LOGGER_WRITE_FORMAT( "VPN support: %d", iFlags->LF( EAOLFAlwaysOnlineVPN )  );
    KAOEMAIL_LOGGER_WRITE( "********************* FEATURES *******************" );

    KAOEMAIL_LOGGER_FN2("CAlwaysOnlineEmailAgentBase::AlwaysOnlineFlagsL()");
    return iFlags;
    }


// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::AlwaysOnlineDynamicFlags()
// ----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::CloseServices()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::CloseServices()
	{
	AOLOG_IN( "CAlwaysOnlineEmailAgentBase::CloseServices" );
    iOperations.ResetAndDestroy();
	}

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::IsTemporary()
// ----------------------------------------------------------------------------
//
TBool CAlwaysOnlineEmailAgentBase::IsTemporary() const
	{
	AOLOG_IN( "CAlwaysOnlineEmailAgentBase::IsTemporary" );
	KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::IsTemporary: Default EFalse" );
    return EFalse;
	}



// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::HandleDefaultError()
// ----------------------------------------------------------------------------
//
void CAlwaysOnlineEmailAgentBase::HandleDefaultError()
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::HandleDefaultError" );

    if ( iError == KErrAoServerNotFound )
        {
        // there have been one connection attempt, incement iRetryCounter
        ++iRetryCounter;
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. KErrAoServerNotFound catched" );
        // if connection have been successful with current settings keep trying forever
        // else ao is shut down immediatelly

        TBool wasSuccess = LoadSettingL<TInt>(
            TImumInSettings::EKeyAoUpdateSuccessfulWithCurSettings, EFalse );

        if ( wasSuccess && !IsEmn() )
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. KErrAoServerNotFound, but keep trying" );
            iState = EEmailAgentConnectFailed;
            }
        else
            {
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. KErrAoServerNotFound, ao will go off" );
            iState = EEmailAgentFatalError;
            iRetryCounter = 0;
            }

        }
    //try to reconnect only if we were connecting
    else if ( iState == EEmailAgentConnecting ||
              iState == EEmailAgentPlainConnecting ||
              iState == EEmailAgentConnectingToStayOnline )
        {
        iRetryCounter++;
        KAOEMAIL_LOGGER_WRITE_FORMAT("CAlwaysOnlineEmailAgentBase::HandleDefaultError. Default error handling, retry counter: %d .",iRetryCounter );

        // if connection have been tried three times whitout success
        if ( (iRetryCounter % KAOMaxRetries)==0 )
            {

            // always online should switch off if no successful update in last 15 attempts,
            // but if ao have before updated succesfully, then keep trying forever

        TBool wasSuccess = LoadSettingL<TInt>(
            TImumInSettings::EKeyAoUpdateSuccessfulWithCurSettings, EFalse );

            if ( iRetryCounter >= KAOMaxRetriesSwitchOff && !wasSuccess )
                {
                //ao will be shutted down immediatelly
                iState = EEmailAgentFatalError;
                iRetryCounter = 0;
                KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. EEailAgentFatalError Ao is goingt to shut down " );

                }
            else
                {
                // keep trying
                iState = EEmailAgentConnectFailed;
                KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. Ao connection failed, but keep trying" );
                }
            }
        else
            {
            // reconnect in few seconds
            iState = EEmailAgentReconnecting;
            KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. State EEmailAgentReconnecting " );
            }
        }
    else
        {
        //make sure that something is done in case if() didn't catch
        iState = EEmailAgentConnTerminated;
        KAOEMAIL_LOGGER_WRITE("CAlwaysOnlineEmailAgentBase::HandleDefaultError. If did not catch, setting state: EEmailAgentConnTerminated ");
        }
    }

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::IsReconnectAfterError()
// ----------------------------------------------------------------------------
//
TBool CAlwaysOnlineEmailAgentBase::IsReconnectAfterError()
{
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::IsReconnectAfterError" );
    // switch - case set this boolean true if we should disconnect
    TBool isReconnect = ETrue;

    //if manually connected or emn is not on, then always reconnect
    if ( IsEmn() && !IsTemporary() )
        {
        switch ( iState )
            {
            case EEmailAgentQueued:
            case EEmailAgentReconnecting:
                // if allready tried KAOMaxRetries time, give up
                isReconnect = iRetryCounter < KAOMaxRetries;
                break;
            case EEmailAgentAutoDisconnecting:
            case EEmailAgentConnectFailed:
            case EEmailAgentUserDisconnecting:
            case EEmailAgentConnTerminated:
            default:
                isReconnect = EFalse;
                break;
            }
        }

    return isReconnect;
}

// ----------------------------------------------------------------------------
// CAlwaysOnlineEmailAgentBase::RetrievalIntervalInMinutes()
// ----------------------------------------------------------------------------
//
TInt CAlwaysOnlineEmailAgentBase::RetrievalIntervalInMinutes( TInt aIntervalIndex )
    {
    AOLOG_IN( "CAlwaysOnlineEmailAgentBase::RetrievalIntervalInMinutes" );
    
    switch( aIntervalIndex )
        {
        case TImumDaSettings::EValue5Minutes:
            {
            return KAoInterval5Min;
            }

        case TImumDaSettings::EValue15Minutes:
            {
            return KAoInterval15Min;
            }
        
        case TImumDaSettings::EValue30Minutes:
            {
            return KAoInterval30Min;
            }
        
        case TImumDaSettings::EValue1Hour:
            {
            return KAoInterval1Hour;
            }
        
        case TImumDaSettings::EValue2Hours:
            {
            return KAoInterval2Hours;
            }
        
        case TImumDaSettings::EValue4Hours:
            {
            return KAoInterval4Hours;
            }
        
        case TImumDaSettings::EValue6Hours:
            {
            return KAoInterval6Hours;
            }
        }
    
    // default
    return KAoInterval1Hour;
    }

//EOF
