diff -r 890b5dd735f8 -r f15ac8e65a02 vtuis/lcvtplugin/src/states/tlcvtstatebase.cpp --- /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 +#include +#include +#include +#include + +// 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 ) + }