/*
* Copyright (c) 2006 - 2007 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:  Open state handle interfaces implementation
*
*/


// INCLUDE FILES
#include    "CVtEngStateOpen.h"
#include    "CVtEngOperation.h"
#include    "CVtEngAudioHandler.h"
#include    <cvtlogger.h>

#include    "CVtEngExtensions.h"

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

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

// Destructor
CVtEngStateOpen::~CVtEngStateOpen()
    {
    __VTPRINT( DEBUG_DESTRUCT, "~StateOpen")
    }


// -----------------------------------------------------------------------------
// CVtEngStateOpen::UpdateL
// Updates state
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CVtEngStateOpen::UpdateL()
    {
    __VTPRINTENTER( "StateOpen.Update" )
    const MVtCtlCallControl::TVtCtlState bearerstate = 
        SessionHandler().RealState();

    const MVtProtocolCommand::TVtProtocolState protoState( MediaHandler().ProtoState() );
    const TBool bearerIdle = ( bearerstate == MVtCtlCallControl::EIdle ||
        bearerstate == MVtCtlCallControl::EUnknown );
    const TBool bearerDisconnecting = 
        ( bearerstate == MVtCtlCallControl::EDisconnecting );

    CVtEngStateBase* newState = NULL;

    if ( protoState == MVtProtocolCommand::ESetup || 
         protoState == MVtProtocolCommand::EIdle  || 
         bearerIdle )
        {
        newState = NewStateL( MVtEngSessionInfo::EIdle );
        }
    else if ( bearerDisconnecting || protoState == MVtProtocolCommand::EDisconnecting ) 
        {
        newState = NewStateL( MVtEngSessionInfo::EClearing );
        }
    if ( newState )
        {
        newState->OpenL( this );
        }
    __VTPRINTEXIT( "StateOpen.Update" )
    }

// -----------------------------------------------------------------------------
// CVtEngStateOpen::OpenL
// State transition to open.
// -----------------------------------------------------------------------------
//
void CVtEngStateOpen::DoOpenL()
    {
    __VTPRINTENTER( "StateOpen.Open" )
    
    // set audio routing (and ouput volume)
    RouteAudioL( NULL );

    NotifyStateChange( MVtEngSessionInfo::EOpen );
    __VTPRINTEXIT( "StateOpen.Open" )
    }

// -----------------------------------------------------------------------------
// CVtEngStateOpen::ValidateCommand
// Returns if a command is valid in open state.
// 
// -----------------------------------------------------------------------------
//
TBool CVtEngStateOpen::ValidateCommand(
            const TVtEngCommandId aCommandId )
    {
    __VTPRINT( DEBUG_DETAIL | DEBUG_GEN, "StateOpen.Validate")
    TBool okToPerform( EFalse );
    switch ( aCommandId )
        {
        case KVtEngInitializeEngine: // temporary     
        case KVtEngPrepareCamera:
        case KVtEngSetZoomStep:
        case KVtEngStartViewFinder:
        case KVtEngPauseViewFinder:
        case KVtEngStopViewFinder:
        case KVtEngStartRenderRemote: 
        case KVtEngStopRenderRemote: 
        case KVtEngPauseRenderRemote:
        case KVtEngTerminateSession:
        case KVtEngStartDtmfTone:
        case KVtEngStopDtmfTone:
        // Handling of different UIIs, support is there
        case KVtEngSetUIIDtmfSupport:
        case KVtEngSetUIIBasicStringSupport:
        case KVtEngSetUIIIA5StringSupport:
        case KVtEngSetUIIGeneralStringSupport:
        case KVtEngSwitchToVoice:
            okToPerform = ETrue;
            break;

        // Extension commands
        case KVtEngSetContrast:
        case KVtEngSetBrightness:
        case KVtEngSetWhiteBalance:
        case KVtEngSetColorTone:
#if defined ( RD_VT_RTF )
        case KVtEngStartRecord:
        case KVtEngStopRecord:
#endif // RD_VT_RTF
        	{
        	// Get extension handle from Utils
        	__VTPRINT(DEBUG_GEN, "StateOpen extension->ValidateCommand")
            okToPerform = CVtEngUtility::Extensions()->ValidateCommand(
            	aCommandId );
            break;
        	}

        default:
            okToPerform = CVtEngStateBase::ValidateCommand( aCommandId );
            break;
        }
    return okToPerform;
    }

// -----------------------------------------------------------------------------
// CVtEngStateOpen::State
// Returns session state.
// 
// -----------------------------------------------------------------------------
//
MVtEngSessionInfo::TSessionState CVtEngStateOpen::State() const
    {
    return MVtEngSessionInfo::EOpen;
    }

// -----------------------------------------------------------------------------
// CVtEngStateOpen::HandleL
// Handles an operation when behavior is state dependent.
// 
// -----------------------------------------------------------------------------
//
TBool CVtEngStateOpen::HandleL( CVtEngOperation& aOp )
    {
    __VTPRINTENTER( "StateOpen.HandleL" )
    TBool handled( CVtEngStateBase::HandleL( aOp ) );
    switch ( aOp.Command() )
        {
        case KVtEngTerminateSession:
            TerminateSessionL( aOp );
            handled = ETrue;
            break;
      
        case KVtEngSwitchToVoice:
            {
            CVtEngStateBase* newState = 
                NewStateL( MVtEngSessionInfo::EClearing );
            CleanupStack::PushL( newState );
            newState->OpenL( this );        
            CleanupStack::Pop();
            // aOp is not passed to media handler because mediator command
            // sender signals completion, see
            // CVtEngMdtrCommandSender::HandleVtEventL
            }
            break;
            
        // Extension commands
        case KVtEngSetContrast:
        case KVtEngSetBrightness:
        case KVtEngSetWhiteBalance:
        case KVtEngSetColorTone:
#if defined ( RD_VT_RTF )
        case KVtEngStartRecord:
        case KVtEngStopRecord:
#endif // RD_VT_RTF
            CallExtensionL( &aOp);
            break;
        default:
            break;
        }
    __VTPRINTEXITR( "StateOpen.HandleL %d", handled )
    return handled;
    }

// -----------------------------------------------------------------------------
// CVtEngStateOpen::RouteAudioL
// Handles audio routing operation.
// 
// -----------------------------------------------------------------------------
//
void CVtEngStateOpen::RouteAudioL( 
    CVtEngOperation* aOp )
    {
    __VTPRINTENTER( "StateOpen.RouteAudioL" )
    CVtEngSettings& settings = CVtEngUtility::Settings();
    const CVtEngSettings::TVtEngVideoCallConfig& config = settings.Config();

    CVtEngAudioHandler& audioHandler = AudioHandler();
    MVtEngAudio::TAudioRoutingState routingState( MVtEngAudio::EAudioWiredHeadset );
    audioHandler.GetRoutingState( routingState );

    TBool routeAudio( ETrue );
    TInt volume( config.iAudio.iVolume.iHandsfreeVolume );
    switch ( routingState )
        {
        case MVtEngAudio::EAudioWiredHeadset:
             routeAudio = EFalse;
             // fall thru
        case MVtEngAudio::EAudioHandset:
        case MVtEngAudio::EAudioBT:
            volume = config.iAudio.iVolume.iHandsetVolume;
            break;
        // use default values
        case MVtEngAudio::EAudioLoudspeaker:
        default:
            break;
        }
    __VTPRINT3( DEBUG_GEN | DEBUG_DETAIL, 
        "StateOpen.RouteAudioL route=%d,vol=%d", routeAudio,volume )
    if ( aOp == NULL || ( aOp && routeAudio ) )
        {
        // set volume if state was changed (called from DoOpenL) or
        // audio routing will be changed
        __VTPRINT( DEBUG_GEN | DEBUG_DETAIL, "StateOpen.RouteAudioL SetVol" )
        MediaHandler().SetVolume( volume );
        }

    // *** AUDIO && ( aOp != NULL ) ***
    if ( routeAudio && ( aOp != NULL ) )
        {
        if ( aOp )
            {
            audioHandler.HandleL( *aOp );
            }
        }
    __VTPRINTEXIT( "StateOpen.RouteAudioL" )
    }

    
// -----------------------------------------------------------------------------
// CVtEngStateOpen::CallExtensionL
// Handles extension operations.
//
// -----------------------------------------------------------------------------
//
void CVtEngStateOpen::CallExtensionL(
    CVtEngOperation* aOp)
    {
    __VTPRINTENTER( "StateOpen.CallExtensionL" )
    CVtEngUtility::Extensions()->OfferOperationL( aOp );
    __VTPRINTEXIT( "StateOpen.CallExtensionL" )
    }

// End of File