/*
* 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:  waiting details application state
*
*/


#include "tvtuistates.h"
#include "tvtuiappstates.h"
#include "mvtuistatecontext.h"
#include "videotelui.hrh"
#include "cvtuiappshutter.h"
#include <cvtlogger.h>
#include <vtengevents.h>
#include <vtengcommands.h>
#include <cvtengmodel.h>
#include <mvtengsessioninfo.h>


TVtUiStateStarting* TVtUiStateStarting::iInstance = NULL;

// c++ constructor
TVtUiStateStarting::TVtUiStateStarting(
    MVtUiStateContext& aCtx, TVtUiStates& aUiStates ) 
    : TVtUiAppStateBase( aCtx, aUiStates )
    {
    iPreconditions.Set( EWaitingCLI );
    iPreconditions.Set( EWaitingPhase1ToComplete );
    }

// Destructor
TVtUiStateStarting::~TVtUiStateStarting()
    {
    delete iStartCallback;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::InstanceL
//
// -----------------------------------------------------------------------------
//
TVtUiStateStarting * TVtUiStateStarting::InstanceL(
    MVtUiStateContext& aCtx, TVtUiStates& aUiStates )
    {
    __VTPRINTENTER( "TVtUiStateStarting.InstanceL" )
    if ( iInstance == NULL )
        {
        iInstance = new ( ELeave ) TVtUiStateStarting( aCtx, aUiStates );
        }
    __VTPRINTEXIT( "TVtUiStateStarting.InstanceL" )
    return iInstance;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::AppUiStartupPhase1DoneL
//
// Phase 1 of application startup is completed, check if we can proceed to
// phase 2.
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::AppUiStartupPhase1DoneL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.AppUiStartupPhase1DoneL" )
    // From startup phase point of view we're ready to proceed
    // to phase 2. Clear that precondition and proceed if otherwise ready.
    CheckPhase2StartupL( EWaitingPhase1ToComplete );
    __VTPRINTEXIT( "TVtUiStateStarting.AppUiStartupPhase1DoneL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::AppUiStartupPhase2DoneL
//
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::AppUiStartupPhase2DoneL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.AppUiStartupPhase2DoneL" )
    // Phase 2 completed, proceed to next state
    ChangeStateL( *TVtUiStateRunning::InstanceL( iCtx, iUiStates ) );
    __VTPRINTEXIT( "TVtUiStateStarting.AppUiStartupPhase2DoneL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::HandleVtEventL
//
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TEventResponse TVtUiStateStarting::HandleVtEventL(
    const TInt aEvent )
    {
    __VTPRINTENTER( "TVtUiStateStarting.HandleVtEventL" )
    TEventResponse handled = EEventHandled;
    switch ( aEvent )
        {
    case KVtEngRemoteDisconnect:
        // base class handles this.
        handled = TVtUiAppStateBase::HandleVtEventL( aEvent );
        break;
    case KVtEngSessionStateChanged:
        {
        // check if session state is proper for proceeding to next phase
        // in startup.
        CheckSessionStateL();
        }
        break;
    case KVtEngRemoteVideoStarted:
        // allow to start remote video rendering
    case KVtEngSourceChanged:
        // allow handling of source changed event
        handled = EEventNotHandled; 
        break;
    case KVtEngCLIAvailable:
        HandleCLIReceivedL();
        break;
        
    case KVtEngRemoteUIIIA5StringSupport:
        break;
    case KVtEngDeviceLockOn:
    case KVtEngDeviceLockOff:
    default:
        handled = TVtUiAppStateBase::HandleVtEventL( aEvent );
        break;
        }
    __VTPRINTEXIT( "TVtUiStateStarting.HandleVtEventL" )
    return handled;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::HandleCommandL
//
// -----------------------------------------------------------------------------
//
TVtUiAppStateBase::TEventResponse TVtUiStateStarting::HandleCommandL(
    const TInt /*aCommand*/ )
    {
    __VTPRINTENTER( "TVtUiStateStarting.HandleCommandL" )
    __VTPRINTEXIT( "TVtUiStateStarting.HandleCommandL" )
    return EEventNotHandled;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::HandleForegroundChangedL
//
// -----------------------------------------------------------------------------
//
TBool TVtUiStateStarting::HandleForegroundChangedL( const TBool aIsForeground )
    {
    __VTPRINTENTER( "TVtUiStateStarting.HandleForegroundChangedL" )
        
    SetLightsState( aIsForeground );
    iCtx.RefreshL( MVtUiStateContext::ENaviPane );
    
    // behave as in background if CLI (=details) has not yet received
    TBool handleAsForeground( aIsForeground && iUiStates.IsDetailsReceived() ); 
    TVtUiAppStateBase::ExecuteEngineCommand( KVtEngSetUIForeground, 
        handleAsForeground );
    
    __VTPRINTEXIT( "TVtUiStateStarting.HandleForegroundChangedL" )
    return handleAsForeground;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::OpenL
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::OpenL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.OpenL" )
    iStartCallback = new ( ELeave ) CAsyncCallBack (
            TCallBack( &AsynchOpen, this ),
            CActive::EPriorityStandard );
    iStartCallback->CallBack();  
    __VTPRINTEXIT( "TVtUiStateStarting.OpenL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::AsynchOpen
// asynchronous entry to the state.
// -----------------------------------------------------------------------------
//
TInt TVtUiStateStarting::AsynchOpen( TAny* aAny )
    {
    __VTPRINTENTER( "TVtUiStateStarting.AsynchOpen" )
    TVtUiStateStarting* state = reinterpret_cast<TVtUiStateStarting*>( aAny );
    delete state->iStartCallback;
    state->iStartCallback = NULL;
    TRAPD( res, state->DoOpenL() );
    __VTPRINTEXITR( "TVtUiStateStarting.AsynchOpen err=%d>", res )
    return res;
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::DoOpenL
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::DoOpenL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.DoOpenL" )
    if ( !CheckEndActiveCallL() )
        {
        // not shutting down, proceed to phase 1
        iCtx.StartupPhase1L();
        }
    __VTPRINTEXIT( "TVtUiStateStarting.DoOpenL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::CheckSessionStateL
// Resolve action based on session state change in the engine.
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::CheckSessionStateL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.CheckSessionStateL" )
    const MVtEngSessionInfo::TSessionState state = SessionState( EFalse );
    switch ( state )
        {
    case MVtEngSessionInfo::EConnected:
    case MVtEngSessionInfo::ENegotiating:
    case MVtEngSessionInfo::EOpen:
        // From session state point of view we're ready to proceed.
        // Clear precondition and proceed if otherwise ready.
        CheckPhase2StartupL( EWaitingSessionState );
        break;
    default:
        // Is session state such that we need to shutdown?
        CheckEndActiveCallL();
        break;
        }
    __VTPRINTEXIT( "TVtUiStateStarting.CheckSessionStateL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::CheckPhase2StartupL
//
// mark precondition passed and if no more preconditions exist proceed
// in startup.
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::CheckPhase2StartupL(
    const TPreconditions aCond )
    {
    __VTPRINTENTER( "TVtUiStateStarting.CheckPhase2StartupL" )
    // First check that at least one precondition holds
    if ( iPreconditions.Value() )
        {
        iPreconditions.Clear( aCond );
        if ( !iPreconditions.Value() )
            {
            CleanupResetPushL();  // start shutdown if StartupPhase2L leaves
            iCtx.StartupPhase2L();
            CleanupStack::Pop(); // CleanupResetPushL
            }
        }
#ifdef VTDEBUG
    else {
        __VTPRINT( DEBUG_GEN, "TVtUiStateStarting.CheckPhase2StartupL NoOp!" )
        }
#endif // VTDEBUG
    __VTPRINTEXITR( "TVtUiStateStarting.CheckPhase2StartupL cond=%d",
        (TInt) iPreconditions.Value() )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::HandleCLIReceivedL
// CLI reception from engine is one of the two preconditions for proceeding
// to phase2 startup.
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::HandleCLIReceivedL()
    {
    __VTPRINTENTER( "TVtUiStateStarting.HandleCLIReceivedL" )
    const MVtEngSessionInfo& session = iCtx.Model().Session();
    MVtEngSessionInfo::TCLI cli;
    if ( session.GetCLI( cli ) == KErrNone )
        {
        iUiStates.SetDetailsReceived( ETrue );
        iUiStates.SetCLIReceived( cli.iVoiceCallPossible );
        iCtx.SetCallIdL( cli.iCallId );
        iCtx.SetCallNameL( cli.iName );
        }
    CheckPhase2StartupL( EWaitingCLI );
    __VTPRINTEXIT( "TVtUiStateStarting.HandleCLIReceivedL" )
    }

// -----------------------------------------------------------------------------
// TVtUiStateStarting::Close
// -----------------------------------------------------------------------------
//
void TVtUiStateStarting::Close()
    {
    __VTPRINTENTER( "TVtUiStateStarting.Close" )
    if ( TVtUiStateStarting::iInstance )
        {
        delete TVtUiStateStarting::iInstance;
        TVtUiStateStarting::iInstance = NULL;
        }
    __VTPRINTEXIT( "TVtUiStateStarting.Close" )
    }