/*
* Copyright (c) 2007 - 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 application states
*
*/


#include "tvtuiappstates.h"
#include "videotelui.hrh"
#include "tvtuistates.h"
#include "cvtuiappshutter.h"
#include "mvtuistatecontext.h"
#include <videotelui.rsg>
#include <AknQueryDialog.h>
#include <StringLoader.h>
#include <cvtlogger.h>
#include <cvtengmodel.h>
#include <vtengevents.h>
#include <mvtengcommandhandler.h>
#include <coreapplicationuisdomainpskeys.h>

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

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

// -----------------------------------------------------------------------------
// c++ constructor
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TVtUiAppStateBase(
    MVtUiStateContext& aCtx,
    TVtUiStates& aUiStates ) : iCtx(aCtx), iUiStates( aUiStates )
    {
    }

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

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::AppUiStartupPhase1DoneL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::AppUiStartupPhase1DoneL()
    {
    // no default behavior
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::AppUiStartupPhase2DoneL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::AppUiStartupPhase2DoneL()
    {
    // no default behavior
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::ShutdownDoneL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::ShutdownDoneL()
    {
    // no default behavior
    }

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

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

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

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::StopDtmfTone
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::StopDtmfTone()
    {
    // no default behavior
    }


// -----------------------------------------------------------------------------
// TVtUiAppStateBase::SetInitialStateL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::SetInitialStateL(
    MVtUiStateContext& aCtx,
    TVtUiStates& aUiStates )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.SetInitialState" )
    TVtUiAppStateBase* initialState =
        TVtUiStateStarting::InstanceL( aCtx, aUiStates );
    aCtx.ChangeState( initialState );
    initialState->OpenL();
    __VTPRINTEXIT( "TVtUiAppStateBase.SetInitialState" )
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::AppUiStartupFailedL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::AppUiStartupFailedL()
    {
    __VTPRINTENTER( "TVtUiAppStateBase.AppUiStartupFailedL" )
    // Shutdown
    ChangeStateL( *TVtUiStateResetting::InstanceL( iCtx, iUiStates ) );
    __VTPRINTEXIT( "TVtUiAppStateBase.AppUiStartupFailedL" )
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::OpenL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::OpenL()
    {
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::Close
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::Close()
    {
    }

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

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

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

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

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

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

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::HandleVTCommandPerformedL
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TEventResponse TVtUiAppStateBase::HandleVTCommandPerformedL(
            TVtEngCommandId /*aCommand*/,
            const TInt /*aError*/ )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.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 &&
          TVtUiAppStateBase::iShutdownRequested )
        {
        __VTPRINT( DEBUG_GEN, "Handling delayed shutdown" );
        ChangeStateL( *TVtUiStateResetting::InstanceL(
            iCtx, iUiStates ) );
        }
    __VTPRINTEXIT( "TVtUiAppStateBase.HandleVTCommandPerformedL" )
    return handled;
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::HandleVtEventL
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TEventResponse TVtUiAppStateBase::HandleVtEventL(
    const TInt aEvent )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.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( "TVtUiAppStateBase.HandleVtEventL" )
    return handled;
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::HandleCommandL
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TEventResponse TVtUiAppStateBase::HandleCommandL(
    const TInt /*aCommand*/ )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.HandleCommandL" )
    TEventResponse handled = EEventNotHandled;
    __VTPRINTEXITR( "TVtUiAppStateBase.HandleCommandL %d", handled )
    return handled;
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::HandleLayoutChangedL
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::HandleLayoutChangedL( )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.HandleLayoutChangedL" )
    // By default only indicate that layout change needs to be handled.
    iUiStates.SetLayoutChangeNeeded( ETrue );
    __VTPRINTEXIT( "TVtUiAppStateBase.HandleLayoutChangedL" )
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::HandleShutdownReady
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::HandleShutdownReady()
    {
     __VTPRINTENTER( "TVtUiAppStateBase.HandleShutdownReady" )
    // forwarded to AppUi which handles UI framework exit
    iCtx.HandleShutdownReady();
    iCtx.ChangeState( NULL );
    // deletes current state
    Close();
     __VTPRINTEXIT( "TVtUiAppStateBase.HandleShutdownReady" )
    }

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

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::CheckEndActiveCallL
// -----------------------------------------------------------------------------
//
TBool TVtUiAppStateBase::CheckEndActiveCallL()
    {
    __VTPRINTENTER( "TVtUiAppStateBase.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( *TVtUiStateResetting::InstanceL( iCtx, iUiStates ) );        
        shutdownStarted = ETrue;
        }
    __VTPRINTEXITR( "TVtUiAppStateBase.CheckEndActiveCallL %d",
        shutdownStarted )
    return shutdownStarted;
    }

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

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::SetLightsState
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::SetLightsState( const TBool aOn )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.SetLightsState" )
    const TInt value = aOn ? EForcedLightsOn : EForcedLightsOff;
    RProperty::Set(
            KPSUidCoreApplicationUIs,
            KLightsVTForcedLightsOn,
            value );
    __VTPRINTEXIT( "TVtUiAppStateBase.SetLightsState" )
    }

// -----------------------------------------------------------------------------
// TVtUiAppStateBase::SetExecState
// -----------------------------------------------------------------------------
//
void TVtUiAppStateBase::SetExecState( const TVtUiStates::TVtUiExecState aState )
    {
    __VTPRINTENTER( "TVtUiAppStateBase.SetExecState" )
    iUiStates.SetExecState( aState );
    __VTPRINTEXITR( "TVtUiAppStateBase.SetExecState %d", aState )
    }