/*

* Copyright (c) 2004,2006 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:  Implements the TAOState class

*

*/

// INCLUDE FILES

#include <e32property.h>

#include "taostate.h"

#include "logger.h"

#include "maoconnectionmanager.h"

#include "maostatecontext.h"

#include "maotimer.h"

#include "maostatepool.h"

#include "maosettings.h"

#include "maogpds.h"

#include "pdpcontextmanagerpskeys.h"

// ======== MEMBER FUNCTIONS ========

// --------------------------------------------------------------------------

// Constructor

// --------------------------------------------------------------------------

//

TAOState::TAOState( MAOStateContext& aStateContext, 

                    MAOStatePool& aStatePool ):

    iStateContext( aStateContext ),

    iStatePool( aStatePool ),

    iFlags( 0 )

    {

    LOG_1( _L("TAOState::TAOState") );

    }

// --------------------------------------------------------------------------

// TAOState::HandlePDPContextActivatedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandlePDPContextActivatedL()

    {

    LOG_1( _L("TAOState::HandlePDPContextActivatedL") );

    return NULL;    

    }

// --------------------------------------------------------------------------

// TAOState::HandlePDPContextActivationFailedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandlePDPContextActivationFailedL()

    {

    LOG_1( _L("TAOState::HandlePDPContextActivationFailedL") );

    return NULL;

    }

// --------------------------------------------------------------------------

// TAOState::HandlePDPContextDisconnectedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandlePDPContextDisconnectedL( TInt /*aReason*/ )

    {

    LOG_1( _L("TAOState::HandlePDPContextDisconnectedL") );

    return NULL;

    }

// --------------------------------------------------------------------------

// TAOState::HandleNetworkChangedL

// --------------------------------------------------------------------------

//

#ifdef LOGGING_ENABLED

TAOState* TAOState::HandleNetworkChangedL(

    MAOConnectionManager::TNetworkType aNetworkType )

#else

TAOState* TAOState::HandleNetworkChangedL(

    MAOConnectionManager::TNetworkType /*aNetworkType*/ )

#endif

    {

    LOG_2( _L("TAOState::HandleNetworkChangedL: aNetworkType: %d"), 

              aNetworkType );

    // PLMN change notification

    // Cancel all requests

    CancelAll();

    return iStatePool.ChangeState( EStateStarting );

    }

// --------------------------------------------------------------------------

// TAOState::HandleSuccesfulRAUEventL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleSuccesfulRAUEventL()

    {

    LOG_1( _L("TAOState::HandleSuccesfulRAUEventL") );

    TAOState* newState = NULL;

    // If we don't have PDP context active try to activate it

    if ( !iStateContext.ConnectionManager().IsPDPContextActive() )

        {

        CancelAll();

        newState = DoActivatePDPContextL();

        }

    return newState;

    }

// --------------------------------------------------------------------------

// TAOState::HandleRetryTimerTriggeredL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleRetryTimerTriggeredL()

    {

    LOG_1( _L("TAOState::HandleRetryTimerTriggeredL") );

    return NULL;

    }

// --------------------------------------------------------------------------

// TAOState::HandleConnectionTimerTriggeredL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleConnectionTimerTriggeredL()

    {

    LOG_1( _L("TAOState::HandleConnectionTimerTriggeredL") );

    return NULL;

    }

// --------------------------------------------------------------------------

// TAOState::HandleSettingsReceivedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleSettingsReceivedL()

    {

    LOG_1( _L("TAOState::HandleSettingsReceivedL") );

    // By default if settings are changed OTA

    // cancel all requests and switch to starting state    

    CancelAll();

    // Set Always-On mode to cellmo side

    SetAlwaysOnModeL();

    return iStatePool.ChangeState( EStateStarting );

    }

// --------------------------------------------------------------------------

// TAOState::HandlePDPContextTemporarilyBlockedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandlePDPContextTemporarilyBlockedL()

    {

    LOG_1( _L("TAOState::HandlePDPContextTemporarilyBlockedL") );

    return NULL;

    }

// --------------------------------------------------------------------------

// TAOState::HandleGeneralError

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleGeneralError()

    {

    LOG_1( _L("TAOState::HandleGeneralError") );

    // Error occured:

    // Cancel all operations and go to disconnected state

    CancelAll();

    return iStatePool.ChangeState( EStateDisconnected );

    }

// --------------------------------------------------------------------------

// TAOState::CancelAll

// --------------------------------------------------------------------------

//

void TAOState::CancelAll()

    {

    LOG_1( _L("TAOState::CancelAll") );

    // Cancel timers

    CancelTimers();

    // Close current connection    

    iStateContext.ConnectionManager().CloseConnection();

    }

// --------------------------------------------------------------------------

// TAOState::SetAlwaysOnModeL

// --------------------------------------------------------------------------

//

void TAOState::SetAlwaysOnModeL()

    {

    LOG_1( _L("TAOState::SetAlwaysOnModeL") );

    MAOGpds::TAlwaysOnMode mode = MAOGpds::ENeither;

    MAOSettings& settings = iStateContext.Settings();

    if ( settings.AlwaysOnSupportedInHPLMN() )

        {

        mode = MAOGpds::EHPLMN;

        }

    if ( settings.AlwaysOnSupportedInVPLMN() )

        {

        if ( mode == MAOGpds::EHPLMN )

            {

            mode = MAOGpds::EBoth;

            }

        else

            {

            mode = MAOGpds::EVPLMN;

            }

        }

    iStateContext.Gpds().SetAlwaysOnModeL( mode );

    }

// --------------------------------------------------------------------------

// TAOState::HandleEnableAlwaysOnL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleEnableAlwaysOnL()

    {

    LOG_1( _L("TAOState::HandleEnableAlwaysOnL") );

    TAOState* newState = NULL;

    if ( EnableAlwaysOn() )

        {

        // start PDP connection

        newState = DoActivatePDPContextL();

        }

    else

        {

        newState = iStatePool.ChangeState( TAOState::EStateDisabled );

        }

    return newState;

    }

// --------------------------------------------------------------------------

// TAOState::HandleSwitchFromDisconnectedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleSwitchFromDisconnectedL(

    MAOConnectionManager::TFailureReason /*aReason*/ )

    {

    LOG_1( _L("TAOState::HandleSwitchFromDisconnectedL") );

    return NULL;    

    }

// --------------------------------------------------------------------------

// TAOState::HandleConnectionDeletedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleConnectionDeletedL()

    {

    LOG_1( _L("TAOState::HandleConnectionDeletedL") );

    return NULL;    

    }

// --------------------------------------------------------------------------

// TAOState::HandleResetFactorySettingsL

// --------------------------------------------------------------------------

//

TAOState* TAOState::HandleResetFactorySettingsL( TBool aReset )

    {

    LOG_1( _L("TAOState::HandleResetFactorySettingsL") );

    TAOState* newState = NULL;

    if ( aReset )

        {

        // Close connection

        CancelAll();

        // Respond to Rfs that connection has been torn down and rfs sequence

        // can continue

        RProperty::Set(

            KPDPContextManager2,

            KPDPContextManagerFactorySettingsReset,

            EPDPContextManagerFactorySettingsResetStartReply );

        newState = iStatePool.ChangeState( EStateResetFactorySettings );

        }

    else

        {

        newState = DoActivatePDPContextL();

        }

    return newState;

    }

// --------------------------------------------------------------------------

// TAOState::EnableAlwaysOn

// --------------------------------------------------------------------------

//

TBool TAOState::EnableAlwaysOn()

    {

    LOG_1( _L("TAOState::EnableAlwaysOn") );

    TBool enabled = EFalse;

    MAOConnectionManager& connectionManager =

        iStateContext.ConnectionManager();

    MAOSettings& settings = iStateContext.Settings();

    // If new state is in starting state, we'll check

    // whether Always-On should be supported in current

    // network

    MAOConnectionManager::TNetworkType nwType =

        connectionManager.NetworkType();

    switch ( nwType )

        {

        case MAOConnectionManager::EHPLMN:

            {

            if ( settings.AlwaysOnSupportedInHPLMN() )

                {

                enabled = ETrue;

                }

            break;

            }

        case MAOConnectionManager::EVPLMN:

            {

            if ( settings.AlwaysOnSupportedInVPLMN() )

                {

                enabled = ETrue;

                }

            break;

            }

        default:

            {

            // Not enabled

            break;

            }

        }

    LOG_2( _L("TAOState::EnableAlwaysOn >> Enabled: %d"), enabled );

    return enabled;

    }

// --------------------------------------------------------------------------

// TAOState::CancelTimers

// --------------------------------------------------------------------------

//

void TAOState::CancelTimers()

    {

    LOG_1( _L("TAOState::CancelTimers") );

    iStateContext.Timer().StopConnectionTimer();

    iStateContext.Timer().StopRetryTimer();

    iStateContext.Timer().StopUnconnectTimer();

    }

// --------------------------------------------------------------------------

// TAOState::DoActivatePDPContextL

// --------------------------------------------------------------------------

//

TAOState* TAOState::DoActivatePDPContextL()

    {

    LOG_1( _L("TAOState::DoActivatePDPContextL") );

    iStateContext.Timer().StartConnectionTimer();

    iStateContext.ConnectionManager().ActivatePDPContextL();

    return iStatePool.ChangeState( TAOState::EStateConnecting );

    }

// --------------------------------------------------------------------------

// TAOState::DoHandleConnectionDeletedL

// --------------------------------------------------------------------------

//

TAOState* TAOState::DoHandleConnectionDeletedL()

    {

    LOG_1( _L("TAOState::DoHandleConnectionDeletedL") );

    MAOConnectionManager& connectionManager =

        iStateContext.ConnectionManager();

    TAOState* newState = NULL;

    if ( !connectionManager.IsPDPContextActive() )

        {

        CancelAll();

        newState = DoActivatePDPContextL();

        }

    return newState;

    }

// ---------------------------------------------------------------------------

// TAOState::HandleExternalConnectionCreatedL

// ---------------------------------------------------------------------------

//

TAOState* TAOState::HandleExternalConnectionCreatedL()

    {

    LOG_1( _L("TAOState::HandleExternalConnectionCreatedL") );

    CancelAll();

    return iStatePool.ChangeState( TAOState::EStateExternalConnection );

    }

// ---------------------------------------------------------------------------

// TAOState::HandleUnconnectTimerExpiredL

// ---------------------------------------------------------------------------

//

TAOState* TAOState::HandleUnconnectTimerExpiredL()

    {

    LOG_1( _L("TAOState::HandleUnconnectTimerExpiredL") );

    return NULL;

    }

// End of file