/*

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

*

*/

#include "tlcvtstates.h"

#include "tlcvtpluginstates.h"

#include "mlcvtstatecontext.h"

#include "clcvtappshutter.h"

#include <cvtlogger.h>

#include <vtengevents.h>

#include <vtengcommands.h>

#include <cvtengmodel.h>

#include <mvtengsessioninfo.h>

TLcVtStateStarting* TLcVtStateStarting::iInstance = NULL;

// c++ constructor

TLcVtStateStarting::TLcVtStateStarting(

    MLcVtStateContext& aCtx, TLcVtStates& aUiStates ) 

    : TLcVtStateBase( aCtx, aUiStates )

    {

    iPreconditions.Set( EWaitingCLI );

    iPreconditions.Set( EWaitingPhase1ToComplete );

    iStartCallback = NULL;

    }

// Destructor

    TLcVtStateStarting::~TLcVtStateStarting()

    {

    delete iStartCallback;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::InstanceL

//

// -----------------------------------------------------------------------------

//

TLcVtStateStarting * TLcVtStateStarting::InstanceL(

    MLcVtStateContext& aCtx, TLcVtStates& aUiStates )

    {

    __VTPRINTENTER( "TLcVtStateStarting.InstanceL" )

    if ( iInstance == NULL )

        {

        iInstance = new ( ELeave ) TLcVtStateStarting( aCtx, aUiStates );

        }

    __VTPRINTEXIT( "TLcVtStateStarting.InstanceL" )

    return iInstance;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::LcVtStartupPhase1DoneL

//

// Phase 1 of application startup is completed, check if we can proceed to

// phase 2.

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::LcVtStartupPhase1DoneL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.LcVtStartupPhase1DoneL" )

    // 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( "TLcVtStateStarting.LcVtStartupPhase1DoneL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::LcVtStartupPhase2DoneL

//

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::LcVtStartupPhase2DoneL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.LcVtStartupPhase2DoneL" )

    // Phase 2 completed, proceed to next state

    ChangeStateL( *TLcVtStateRunning::InstanceL( iCtx, iUiStates ) );

    __VTPRINTEXIT( "TLcVtStateStarting.LcVtStartupPhase2DoneL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::HandleVtEventL

//

// -----------------------------------------------------------------------------

//

TLcVtStateBase::TEventResponse TLcVtStateStarting::HandleVtEventL(

    const TInt aEvent )

    {

    __VTPRINTENTER( "TLcVtStateStarting.HandleVtEventL" )

    TEventResponse handled = EEventHandled;

    switch ( aEvent )

        {

    case KVtEngRemoteDisconnect:

        // base class handles this.

        handled = TLcVtStateBase::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 KVtEngDeviceLockOn:

    case KVtEngDeviceLockOff:

    default:

        handled = TLcVtStateBase::HandleVtEventL( aEvent );

        break;

        }

    __VTPRINTEXIT( "TLcVtStateStarting.HandleVtEventL" )

    return handled;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::HandleCommandL

//

// -----------------------------------------------------------------------------

//

TLcVtStateBase::TEventResponse TLcVtStateStarting::HandleCommandL(

    const TInt /*aCommand*/ )

    {

    __VTPRINTENTER( "TLcVtStateStarting.HandleCommandL" )

    __VTPRINTEXIT( "TLcVtStateStarting.HandleCommandL" )

    //return EEventNotHandled;

    return EEventHandled;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::HandleForegroundChangedL

//

// -----------------------------------------------------------------------------

//

TBool TLcVtStateStarting::HandleForegroundChangedL( const TBool aIsForeground )

    {

    __VTPRINTENTER( "TLcVtStateStarting.HandleForegroundChangedL" )        

    iCtx.RefreshL( MLcVtStateContext::ENaviPane );

    // behave as in background if CLI (=details) has not yet received

    TBool handleAsForeground( aIsForeground && iUiStates.IsDetailsReceived() ); 

    TLcVtStateBase::ExecuteEngineCommand( KVtEngSetUIForeground, 

        handleAsForeground );

    __VTPRINTEXIT( "TLcVtStateStarting.HandleForegroundChangedL" )

    return handleAsForeground;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::PreHandleForegroundChangedL

// -----------------------------------------------------------------------------

//

TBool TLcVtStateStarting::PreHandleForegroundChangedL(

    const TBool /*aIsForegroung*/ )

    {

    // no default behavior

    return EFalse;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::OpenL

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::OpenL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.OpenL" )

    iStartCallback = new ( ELeave ) CAsyncCallBack (

            TCallBack( &AsynchOpen, this ),

            CActive::EPriorityStandard );

    iStartCallback->CallBack();  

    __VTPRINTEXIT( "TLcVtStateStarting.OpenL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::AsynchOpen

// asynchronous entry to the state.

// -----------------------------------------------------------------------------

//

TInt TLcVtStateStarting::AsynchOpen( TAny* aAny )

    {

    __VTPRINTENTER( "TLcVtStateStarting.AsynchOpen" )

    TLcVtStateStarting* state = reinterpret_cast<TLcVtStateStarting*>( aAny );

    delete state->iStartCallback;

    state->iStartCallback = NULL;

    TRAPD( res, state->DoOpenL() );

    __VTPRINTEXITR( "TLcVtStateStarting.AsynchOpen err=%d", res )

    return res;

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::DoOpenL

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::DoOpenL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.DoOpenL" )

    if ( !CheckEndActiveCallL() )

        {

        // not shutting down, proceed to phase 1

        iCtx.StartupPhase1L();

        }

    __VTPRINTEXIT( "TLcVtStateStarting.DoOpenL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::CheckSessionStateL

// Resolve action based on session state change in the engine.

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::CheckSessionStateL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.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( "TLcVtStateStarting.CheckSessionStateL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::CheckPhase2StartupL

//

// mark precondition passed and if no more preconditions exist proceed

// in startup.

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::CheckPhase2StartupL(

    const TPreconditions aCond )

    {

    __VTPRINTENTER( "TLcVtStateStarting.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, "TLcVtStateStarting.CheckPhase2StartupL NoOp!" )

        }

#endif // VTDEBUG

    __VTPRINTEXITR( "TLcVtStateStarting.CheckPhase2StartupL cond=%d",

        (TInt) iPreconditions.Value() )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::HandleCLIReceivedL

// CLI reception from engine is one of the two preconditions for proceeding

// to phase2 startup.

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::HandleCLIReceivedL()

    {

    __VTPRINTENTER( "TLcVtStateStarting.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 );

        iCtx.SetCallNumberL( cli.iCallNumber );

        }

    CheckPhase2StartupL( EWaitingCLI );

    __VTPRINTEXIT( "TLcVtStateStarting.HandleCLIReceivedL" )

    }

// -----------------------------------------------------------------------------

// TLcVtStateStarting::Close

// -----------------------------------------------------------------------------

//

void TLcVtStateStarting::Close()

    {

    __VTPRINTENTER( "TLcVtStateStarting.Close" )

    delete TLcVtStateStarting::iInstance;

    TLcVtStateStarting::iInstance = NULL;

    __VTPRINTEXIT( "TLcVtStateStarting.Close" )

    }