--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/vtuis/lcvtplugin/src/states/tlcvtstatebase.cpp	Tue Aug 31 15:16:10 2010 +0300
@@ -0,0 +1,382 @@
+/*
+* 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 )
+    }