/*
* Copyright (c) 2004-2006 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 states
*
*/


// INCLUDE FILES
#include    "CVtEngStateBase.h"
#include    "CVtEngOperation.h"
#include    "CVtEngHandlerContainer.h"
#include    "TVtEngOperationUtils.h"
#include    "CVtEngStateInitializing.h"
#include    "CVtEngStateAlerting.h"
#include    "CVtEngStateRinging.h"
#include    "CVtEngStateConnected.h"
#include    "CVtEngStateClearing.h"
#include    "CVtEngStateOpen.h"
#include    "CVtEngStateNegotiating.h"
#include    "CVtEngStateIdle.h"
#include    "CVtEngSettings.h"
#include    "MVtEngSessionInfo.h"
#include    "VtEngUtils.h"
#include    "VtEngPanic.h"
#include    <cvtlogger.h>

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CVtEngStateBase::CVtEngStateBase
// C++ constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtEngStateBase::CVtEngStateBase(
    CVtEngStateManager& aStateManager,
    CVtEngEventManager& aEventManager )
    : iStateManager( aStateManager ),
      iEventManager( aEventManager )
    {
    }

// Destructor
CVtEngStateBase::~CVtEngStateBase()
    {
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::OpenL
// Changes state.
//
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::OpenL( CVtEngStateBase* aOldState )
    {
    __VTPRINTENTER( "StateBase.Open" )
    __VTPRINT( DEBUG_GEN, "StateBase. **** State Change ****" )
    iStateManager.SetState( *this );
    if ( aOldState )
        {
        aOldState->Close();
        }
    // call derived class open.
    DoOpenL();
    __VTPRINTEXIT( "StateBase.Open" )
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::Close
// Closes state.
//
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::Close()
    {
    delete this;
    }


// -----------------------------------------------------------------------------
// CVtEngStateBase::SaveToSettingsL
//
// Saves configuration to settings.
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::SaveToSettingsL( CVtEngOperation& aOp )
    {
    const TVtEngCommandId command( aOp.Command() );

    if ( command == KVtEngSetAudioVolume )
        {
        MVtEngAudio::TVtEngOutputVolume volume;
        TVtEngOpParamUtil<MVtEngAudio::TVtEngOutputVolume>::Set( volume, aOp );
        CVtEngSettings& settings = CVtEngUtility::Settings();
        settings.SetVolume( volume.iHandsetVolume, volume.iHandsfreeVolume, ETrue );
        settings.SetVolume( volume.iHandsetVolume, volume.iHandsfreeVolume, EFalse );
        }    
    }
// -----------------------------------------------------------------------------
// CVtEngStateBase::NotifyStateChangeL
// Notifies state change to event manager.
//
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::NotifyStateChange(
    MVtEngSessionInfo::TSessionState /*aNewState*/ )
    {
    iEventManager.SessionStateChanged( );
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::SetVideoEnabled
//
//
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::SetVideoEnabled( TBool aEnabled )
    {
    CVtEngSettings& settings = CVtEngUtility::Settings();
        settings.SetVideoEnabled( aEnabled );
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::HandleL
// Handles an operation when behavior is state dependent.
//
// -----------------------------------------------------------------------------
//
TBool CVtEngStateBase::HandleL( CVtEngOperation& aOp )
    {
    __VTPRINTENTER( "StateBase.Handle" )
    __VTPRINT2( DEBUG_GEN, "StateBase.Handle cmd=%d", aOp.Command() )
    TBool handled( EFalse );
    switch ( aOp.Command() )
        {
        case KVtEngSetAudioRouting:
            // Change audio routing
            AudioHandler().HandleL( aOp );
            break;

        case KVtEngSetAudioVolume:
        case KVtEngIncreaseAudioVolume:
        case KVtEngDecreaseAudioVolume:
            // Change audio volume
            MediaHandler().HandleL( aOp );
            break;
        case KVtEngTerminateSession:
        default:
            break;
        }
    __VTPRINTEXITR( "StateBase.Handle handled=%d", handled )
    return handled;
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::SessionHandler
// Returns session handler.
//
// -----------------------------------------------------------------------------
//
CVtEngSessionHandler& CVtEngStateBase::SessionHandler()
    {
    MVtEngSessionInfo& msession = iStateManager.Handlers().Session();
    CVtEngSessionHandler& handler =
        static_cast<CVtEngSessionHandler&>( msession );
    return handler;
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::MediaHandler
// Returns media handler.
//
// -----------------------------------------------------------------------------
//
CVtEngMediaHandler& CVtEngStateBase::MediaHandler()
    {
    MVtEngMedia& msession = iStateManager.Handlers().Media();
    CVtEngMediaHandler& handler =
        static_cast<CVtEngMediaHandler&>( msession );
    return handler;
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::AudioHandler
// Returns audio handler.
//
// -----------------------------------------------------------------------------
//
CVtEngAudioHandler& CVtEngStateBase::AudioHandler()
    {
    MVtEngAudio& maudio = iStateManager.Handlers().Audio();
    CVtEngAudioHandler& handler =
        static_cast<CVtEngAudioHandler&>( maudio );
    return handler;
    }
// -----------------------------------------------------------------------------
// CVtEngStateBase::SessionHandler
// Returns session handler.
//
// -----------------------------------------------------------------------------
//
CVtEngStateBase* CVtEngStateBase::NewStateL(
    const MVtEngSessionInfo::TSessionState aState )
    {
    CVtEngStateBase* newState = NULL;
    switch ( aState )
        {
        case MVtEngSessionInfo::EIdle:
            newState = new ( ELeave )
                CVtEngStateIdle( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::EInitializing:
            newState = new ( ELeave )
                CVtEngStateInitializing( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::ERemoteAlerting:
            newState = new ( ELeave )
                CVtEngStateAlerting( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::EReceiving:
            newState = new ( ELeave )
                CVtEngStateRinging( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::EConnected:
            newState = new ( ELeave )
                CVtEngStateConnected( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::ENegotiating:
            newState = new ( ELeave )
                CVtEngStateNegotiating( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::EOpen:
            newState = new ( ELeave )
                CVtEngStateOpen( iStateManager, iEventManager );
            break;
        case MVtEngSessionInfo::EClearing:
            newState = new ( ELeave )
                CVtEngStateClearing( iStateManager, iEventManager );
            break;
        default:
            Panic( EVtEngPanicInvalidSessionState );
            break;
        }
    return newState;
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::NegotiatingOrConnectedStateL
//
// -----------------------------------------------------------------------------
//
CVtEngStateBase* CVtEngStateBase::NegotiatingOrConnectedStateL(
    TBool aAcceptOnlyNegotiating )
    {
    __VTPRINTENTER( "StateBase.NegOrCon" )
    __VTPRINT2( DEBUG_GEN, "StateBase.NegOrCon %d", aAcceptOnlyNegotiating)
    const MVtCtlCallControl::TVtCtlState bearerstate =
        SessionHandler().RealState();
    CVtEngStateBase* newState = NULL;
    if ( bearerstate == MVtCtlCallControl::EConnected )
        {
        const MVtProtocolCommand::TVtProtocolState state( MediaHandler().ProtoState() );
        const CVtEngSettings& settings = CVtEngUtility::Settings();
        const TBool readyForConnect = settings.Config().iReadyForConnect;

		__VTPRINT3( DEBUG_GEN, "StateBase.NegOrCon readyForConnect:%d, state:%d", readyForConnect, state)
		__VTPRINT2( DEBUG_GEN, "StateBase.NegOrCon iIsDataportLoaned:%d", settings.Config().iIsDataportLoaned)

        if ( readyForConnect && state == MVtProtocolCommand::ESetup && settings.Config().iIsDataportLoaned )
            {
            __VTPRINT( DEBUG_GEN | DEBUG_DETAIL,
                "StateBase.NegOrCon ready & ESetup")
            const TInt res( MediaHandler().Connect() );
            if ( res == KErrNotReady )
                {
                // Cannot be done yet, need to wait for an operation
                // to complete.
                __VTPRINT( DEBUG_GEN | DEBUG_DETAIL,
                    "StateBase.NegOrCon not ready" )
                }
            else if ( res != KErrNone )
                {
                __VTPRINT( DEBUG_GEN | DEBUG_DETAIL,
                    "StateBase.NegOrCon fail")
                iEventManager.NotifyEvent( KVtEngNegotiationProblem );
                }
            else
                {
                // change to negotiating state
                newState = NewStateL( MVtEngSessionInfo::ENegotiating );
                __VTPRINT( DEBUG_GEN | DEBUG_DETAIL,
                    "StateBase.NegOrCon-->negotiating")
                }
            }
        else if ( !aAcceptOnlyNegotiating )
            {
            newState = NewStateL( MVtEngSessionInfo::EConnected );
            __VTPRINT( DEBUG_GEN | DEBUG_DETAIL,
                "StateBase.NegOrCon-->connected")
            }
        }
    __VTPRINTEXIT( "StateBase.NegOrCon" )
    return newState;
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::TerminateSessionL
//
// -----------------------------------------------------------------------------
//
void CVtEngStateBase::TerminateSessionL( CVtEngOperation& aOp )
    {
    // State transition to "clearing state" initiates disconnect on protocol.
    CVtEngStateBase* newState = NewStateL( MVtEngSessionInfo::EClearing );
    // just store aOp for callback to UI
    CVtEngMediaHandler& mHandler = MediaHandler();
    CleanupStack::PushL( newState );
    newState->OpenL( this );
    CleanupStack::Pop(); // newState
    mHandler.HandleL( aOp );
    }

// -----------------------------------------------------------------------------
// CVtEngStateBase::ValidateCommand
//
// -----------------------------------------------------------------------------
//
TBool CVtEngStateBase::ValidateCommand(
            const TVtEngCommandId aCommandId )
    {
    __VTPRINT( DEBUG_DETAIL | DEBUG_GEN, "StateBase.Validate")
    TBool okToPerform( EFalse );
    switch ( aCommandId )
        {
            // Flow through, ok to execute ==>  check the state possibilities
        case KVtEngInitializeEngine:
        case KVtEngInitializeEngineDiag:
        case KVtEngInitializeEngineTest:
        case KVtEngResetEngine:
        case KVtEngStartRenderRemote:
        case KVtEngStopRenderRemote:
        case KVtEngPrepareRemoteRender:
        case KVtEngPrepareRemoteRenderDSA:
        case KVtEngPrepareRemoteRenderDP:
        case KVtEngPrepareRemoteRenderNGA:        
        case KVtEngPrepareViewFinder:
        // Media
        case KVtEngSetUIForeground:
            okToPerform = ETrue;
            break;
        case KVtEngPrepareCamera:
        case KVtEngSetSource:
        case KVtEngSetZoomStep:
        case KVtEngStartViewFinder:
        case KVtEngFreeze:
        case KVtEngUnfreeze:
        case KVtEngSetVideoQuality:
        case KVtEngHandleLayoutChange:

        // Media object sharing
        case KVtEngInitializeShareImage:
        case KVtEngStartShareImage:
        case KVtEngStopShareImage:

        case KVtEngMuteOutgoingAudio:
        case KVtEngUnmuteOutgoingAudio:
        case KVtEngSetAudioRouting:
        case KVtEngSetAudioVolume:
        case KVtEngIncreaseAudioVolume:
        case KVtEngDecreaseAudioVolume:
        case KVtEngRequestLastRemoteFrame:

            okToPerform =
                ( MediaHandler().ValidateCommand( aCommandId ) == KErrNone );
            break;
        default:
            case KVtEngTerminateSession: // valid only in open state
            break;
        }
    return okToPerform;
    }

//  End of File