/*

* 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 );

        }

    }