/*
* Copyright (c) 2008 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:  base class for lc vt plugin states
*
*/


#include "tlcvtstatebase.h"
#include "tlcvtstates.h"
#include "tlcvtpluginstates.h"
#include "clcvtappshutter.h"
#include "mlcvtstatecontext.h"
#include <StringLoader.h>
#include <cvtlogger.h>
#include <cvtengmodel.h>
#include <vtengevents.h>
#include <mvtengcommandhandler.h>

// By default call ending command is allowed to send to call handling.

// Initially no shutdown request
TBool TLcVtStateBase::iShutdownRequested = EFalse;

// -----------------------------------------------------------------------------
// c++ constructor
// -----------------------------------------------------------------------------
//
TLcVtStateBase::TLcVtStateBase(
    MLcVtStateContext& aCtx,
    TLcVtStates& aUiStates ) : iCtx(aCtx), iUiStates( aUiStates )
    {
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
TLcVtStateBase::~TLcVtStateBase()
    {
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::LcVtStartupPhase1DoneL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::LcVtStartupPhase1DoneL()
    {
    // no default behavior
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::LcVtStartupPhase2DoneL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::LcVtStartupPhase2DoneL()
    {
    // no default behavior
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::ShutdownDoneL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::ShutdownDoneL()
    {
    // no default behavior
    }
#if 0
// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleForegroundChangedL
// -----------------------------------------------------------------------------
//
TBool TLcVtStateBase::HandleForegroundChangedL(
    const TBool /*aIsForegroung*/ )
    {
    // no default behavior
    return EFalse;
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::PreHandleForegroundChangedL
// -----------------------------------------------------------------------------
//
TBool TLcVtStateBase::PreHandleForegroundChangedL(
    const TBool /*aIsForegroung*/ )
    {
    // no default behavior
    return EFalse;
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::StartDtmfTone
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::StartDtmfTone( const TChar& /*aTone*/ )
    {
    // no default behavior
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::StopDtmfTone
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::StopDtmfTone()
    {
    // no default behavior
    }
#endif

// -----------------------------------------------------------------------------
// TLcVtStateBase::SetInitialStateL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::SetInitialStateL(
    MLcVtStateContext& aCtx,
    TLcVtStates& aUiStates )
    {
    __VTPRINTENTER( "TLcVtStateBase.SetInitialState" )
    TLcVtStateBase* initialState =
        TLcVtStateStarting::InstanceL( aCtx, aUiStates );
    aCtx.ChangeState( initialState );
    initialState->OpenL();
    __VTPRINTEXIT( "TLcVtStateBase.SetInitialState" )
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::LcVtStartupFailedL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::LcVtStartupFailedL()
    {
    __VTPRINTENTER( "TLcVtStateBase.AppUiStartupFailedL" )
    // Shutdown
    ChangeStateL( *TLcVtStateResetting::InstanceL( iCtx, iUiStates ) );
    __VTPRINTEXIT( "TLcVtStateBase.AppUiStartupFailedL" )
    }
#if 0
// -----------------------------------------------------------------------------
// TLcVtStateBase::OpenL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::OpenL()
    {
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::Close
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::Close()
    {
    }
#endif

// -----------------------------------------------------------------------------
// TLcVtStateBase::ChangeStateL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::ChangeStateL( TLcVtStateBase& aNewState )
    {
    __VTPRINTENTER( "TLcVtStateBase.ChangeStateL" )

    // Check for transition to already active state.
    TLcVtStateBase* state = &aNewState;
    if ( state == this )
        {
        __VTPRINTEXITR( "TLcVtStateBase.ChangeStateL %d", 0 )
        return;
        }
    const TVtEngCommandId pending =
        iCtx.Model().CommandHandler().PendingCommand();
    if ( pending !=  KVtEngCommandNone &&
         state == TLcVtStateResetting::InstanceL( iCtx, iUiStates ) )
        {
        // delay shutdown until engine command completes
        __VTPRINT2( DEBUG_GEN, "TLcVtStateBase.ChangeStateL, pengind command is: %d", pending );
        TLcVtStateBase::iShutdownRequested = ETrue;

        if ( pending == KVtEngInitializeShareImage )
            {
            iCtx.Model().CommandHandler().CancelCommand( pending );
            }

        __VTPRINTEXITR( "TLcVtStateBase.ChangeStateL %d", KErrNotReady )
        return;
        }
    __VTPRINT( DEBUG_GEN,
        " TLcVtStateBase.ChangeStateL !! STATE TRANSITION !!" )
    iCtx.ChangeState( &aNewState );
    Close();
    // perform entry action for new state
    aNewState.OpenL();
    __VTPRINTEXITR( "TLcVtStateBase.ChangeStateL %d", 1 )
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::CleanupResetPushL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::CleanupResetPushL()
    {
    // Shutdown if leave occurs in critical ops.
    CleanupStack::PushL(
        TCleanupItem( TransitionToReset, this ) );
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::TransitionToReset
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::TransitionToReset( TAny* aAny )
    {
    TLcVtStateBase* state = reinterpret_cast< TLcVtStateBase* >( aAny );
    TRAP_IGNORE( state->ChangeStateL( *TLcVtStateResetting::InstanceL(
        state->iCtx, state->iUiStates ) ) );
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleVTCommandPerformedL
// -----------------------------------------------------------------------------
//
TLcVtStateBase::TEventResponse TLcVtStateBase::HandleVTCommandPerformedL(
            TVtEngCommandId /*aCommand*/,
            const TInt /*aError*/ )
    {
    __VTPRINTENTER( "TLcVtStateBase.HandleVTCommandPerformedL" )
    // By default all UI is allowed to handle all command completions.
    TEventResponse handled = EEventNotHandled;

    // check if shutdown requested while command was pending
    const TVtEngCommandId pending = iCtx.Model().CommandHandler().PendingCommand();
    if ( pending == KVtEngCommandNone &&
            TLcVtStateBase::iShutdownRequested )
        {
        __VTPRINT( DEBUG_GEN, "Handling delayed shutdown" );
        ChangeStateL( *TLcVtStateResetting::InstanceL(
            iCtx, iUiStates ) );
        }
    __VTPRINTEXIT( "TLcVtStateBase.HandleVTCommandPerformedL" )
    return handled;
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleVtEventL
// -----------------------------------------------------------------------------
//
TLcVtStateBase::TEventResponse TLcVtStateBase::HandleVtEventL(
    const TInt aEvent )
    {
    __VTPRINTENTER( "TLcVtStateBase.HandleVtEventL" )
    TEventResponse handled = EEventHandled;
    switch ( aEvent )
        {
    case KVtEngDeviceLockOn:
    case KVtEngDeviceLockOff:
        HandleDeviceLockEventL( aEvent == KVtEngDeviceLockOn );
        break;
    case KVtEngRemoteDisconnect:
        /** Don't allow sending of end active call command to call handling
         *  because requesting disconnect from the network after NW originated
         *  termination violates standards.
         */
        break;
    default:
        handled = EEventNotHandled;
        break;
        }
    __VTPRINTEXIT( "TLcVtStateBase.HandleVtEventL" )
    return handled;
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleCommandL
// -----------------------------------------------------------------------------
//
TLcVtStateBase::TEventResponse TLcVtStateBase::HandleCommandL(
    const TInt /*aCommand*/ )
    {
    __VTPRINTENTER( "TLcVtStateBase.HandleCommandL" )
    TEventResponse handled = EEventNotHandled;
    __VTPRINTEXITR( "TLcVtStateBase.HandleCommandL %d", handled )
    return handled;
    }
#if 0
// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleLayoutChangedL
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::HandleLayoutChangedL( )
    {
    __VTPRINTENTER( "TLcVtStateBase.HandleLayoutChangedL" )
    // By default only indicate that layout change needs to be handled.
    iUiStates.SetLayoutChangeNeeded( ETrue );
    __VTPRINTEXIT( "TLcVtStateBase.HandleLayoutChangedL" )
    }
#endif
// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleShutdownReady
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::HandleShutdownReady()
    {
     __VTPRINTENTER( "TLcVtStateBase.HandleShutdownReady" )
    // forwarded to AppUi which handles UI framework exit
    iCtx.HandleShutdownReady();
    iCtx.ChangeState( NULL );
    // deletes current state
    Close();
     __VTPRINTEXIT( "TLcVtStateBase.HandleShutdownReady" )
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::HandleDeviceLockEventL
//
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::HandleDeviceLockEventL( const TBool aDeviceIsLocked )
    {
    __VTPRINTENTER( "TLcVtStateBase.HandleDeviceLockEventL" )
    iUiStates.SetDeviceLockOn( aDeviceIsLocked );
    if ( aDeviceIsLocked )
        {
        iCtx.ChangeApplicationFocus( EFalse );
        }
    __VTPRINTEXITR( "TLcVtStateBase.HandleDeviceLockEventL lock state=%d",
        aDeviceIsLocked )
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::CheckEndActiveCallL
// -----------------------------------------------------------------------------
//
TBool TLcVtStateBase::CheckEndActiveCallL()
    {
    __VTPRINTENTER( "TLcVtStateBase.CheckEndActiveCallL" )
    const MVtEngSessionInfo::TSessionState state = SessionState( EFalse );
    TBool shutdownStarted( EFalse );
    if ( state == MVtEngSessionInfo::EIdle )
        {
        __VTPRINT( DEBUG_GEN, "VtUi.Release bearer" )
        // h.245 session is ended
        ChangeStateL( *TLcVtStateResetting::InstanceL( iCtx, iUiStates ) );        
        shutdownStarted = ETrue;
        }
    __VTPRINTEXITR( "TLcVtStateBase.CheckEndActiveCallL %d",
        shutdownStarted )
    return shutdownStarted;
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::SessionState
// -----------------------------------------------------------------------------
//
MVtEngSessionInfo::TSessionState TLcVtStateBase::SessionState(
    const TBool aUpdate ) const
    {
    const CVtEngModel& model = iCtx.Model();
    const MVtEngSessionInfo& session = model.Session();
    return session.State( aUpdate );
    }

// -----------------------------------------------------------------------------
// TLcVtStateBase::SetExecState
// -----------------------------------------------------------------------------
//
void TLcVtStateBase::SetExecState( const TLcVtStates::TLcVtExecState aState )
    {
    __VTPRINTENTER( "TLcVtStateBase.SetExecState" )
    iUiStates.SetExecState( aState );
    __VTPRINTEXITR( "TLcVtStateBase.SetExecState %d", aState )
    }