/*
* Copyright (c) 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:  Handler utilities implementation.
*
*/



// INCLUDE FILES
#include    "TVtEngOperationUtils.h"
#include    "VtEngPanic.h"
#include    "CVtEngInitializer.h"
#include    "VtEngUtils.h"
#include    "CVtEngOperation.h"
#include    "CVtEngHandlerContainer.h"
#include    "CVtEngMediaHandler.h"
#include    "CVtEngAudioHandler.h"
#include    "CVtEngSessionHandler.h"
#include    "CVtEngStateManager.h"
#include    "CVtEngSettings.h"
#include    "cvtengmdtrcommandsender.h"
#include    <cvtlogger.h>

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

// -----------------------------------------------------------------------------
// TVtEngRenderUtil::HandleL
// unpacks and handles a rendering command
// 
// -----------------------------------------------------------------------------
//
void TVtEngRenderUtil::HandleL( 
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& aHandlers )
    {
    CVtEngMediaHandler& media =
        static_cast<CVtEngMediaHandler&>( aHandlers.Media() );

    media.HandleL( aOperation );
    }

// -----------------------------------------------------------------------------
// TVtEngRenderUtil::Cancel
// cancel the specify pending command
// 
// -----------------------------------------------------------------------------
//

void TVtEngRenderUtil::Cancel(
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& aHandlers )
    {    
    const TVtEngCommandId id = aOperation.Command();
    __VTPRINTENTER( "TVtEngRenderUtil.Cancel")
    __VTPRINT2( DEBUG_GEN, "Command id = %d", id)
    if ( id == KVtEngInitializeShareImage )        
        {
        CVtEngMediaHandler& media =
            static_cast<CVtEngMediaHandler&>( aHandlers.Media() );
            
        media.CancelInitializeShareImage();
        }
    __VTPRINTEXIT( "TVtEngRenderUtil.Cancel")
    }
// -----------------------------------------------------------------------------
// TVtEngAudioRoutingUtil::HandleL
// unpacks and handles audio routing command.
// 
// -----------------------------------------------------------------------------
//

void TVtEngAudioRoutingUtil::HandleL( 
    CVtEngOperation& aOperation )
    {
    CVtEngUtility::StateManager()->HandleOperationL( aOperation );
    }

// -----------------------------------------------------------------------------
// TVtEngAudioPlaybackUtil::HandleL
// unpacks and handles audio playback command.
// 
// -----------------------------------------------------------------------------
//
void TVtEngAudioPlaybackUtil::HandleL( 
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& aHandlers )
    {
    __VTPRINTENTER( "AudioPlaybackUtil.HandleL" )
    if ( aOperation.Command() == KVtEngSetAudioVolume ) 
        {
        CVtEngSettings& settings = CVtEngUtility::Settings();
        const TPckgC<MVtEngAudio::TVtEngOutputVolume>& pckg = 
            static_cast<const TPckgC<MVtEngAudio::TVtEngOutputVolume>&>
            ( *aOperation.Parameters() );

        settings.SetVolume( pckg().iHandsetVolume, pckg().iHandsfreeVolume,
            ETrue );
        }

    // All the commands are though passed to handler
    CVtEngMediaHandler& media =
        static_cast<CVtEngMediaHandler&>( aHandlers.Media() );
    __VTPRINT( DEBUG_DETAIL, "TVtEngAudioPlaybackUtil::HandleL:Handler fetched")

    media.HandleL( aOperation );
    __VTPRINTEXIT( "AudioPlaybackUtil.HandleL" )
    }

// -----------------------------------------------------------------------------
// TVtEngMediaTransportUtil::HandleL
// unpacks and handles media transport command.
// 
// -----------------------------------------------------------------------------
//
void TVtEngMediaTransportUtil::HandleL( 
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& aHandlers )
    {
    __VTPRINTENTER( "MediaTransportUtil.HandleL" )
    const TVtEngCommandId command( aOperation.Command() );
    if ( command == KVtEngStopDtmfTone ||
         command == KVtEngStartDtmfTone ||
		 // DTMF commands
		 command == KVtEngSetUIIDtmfSupport ||
         command == KVtEngSetUIIBasicStringSupport ||
         command == KVtEngSetUIIIA5StringSupport ||
         command == KVtEngSetUIIGeneralStringSupport )
        {
        aHandlers.Dtmf().HandleL( aOperation );
        }
        
    __VTPRINTEXIT( "MediaTransportUtil.HandleL" )
    }

// -----------------------------------------------------------------------------
// TVtEngViewFinderConfigureUtil::HandleL
// unpacks and handles 
// 
// -----------------------------------------------------------------------------
//
void TVtEngViewFinderConfigureUtil::HandleL( 
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& aHandlers )
    {
    CVtEngMediaHandler& media =
        static_cast<CVtEngMediaHandler&>( aHandlers.Media() );

    media.HandleL( aOperation );
    }

// -----------------------------------------------------------------------------
// TVtEngCameraConfigUtil::HandleL
// unpacks and handles 
// 
// -----------------------------------------------------------------------------
//
void TVtEngCameraConfigUtil::HandleL( 
    CVtEngOperation& /*aOperation*/,
    CVtEngHandlerContainer& /*aHandlers*/ )
    {
    }

// -----------------------------------------------------------------------------
// TVtEngEngineInitUtil::HandleL
// Handles engine initialization and uninitialization command.
// 
// -----------------------------------------------------------------------------
//
void TVtEngEngineInitUtil::HandleL( 
    CVtEngOperation& aOperation,
    CVtEngHandlerContainer& /* aHandlers */ )
    {
    __VTPRINTENTER( "EngineInitUtil.HandleL" )
    const TVtEngCommandId id = aOperation.Command();

    CVtEngInitializer& initializer = 
        CVtEngUtility::EngineUtils()->Initializer();

    switch ( id )
        {
        case KVtEngInitializeEngine:
        case KVtEngInitializeEngineDiag:
        case KVtEngInitializeEngineTest:
            initializer.InitializeL( aOperation );
            break;
        case KVtEngResetEngine:
            initializer.Uninitialize( aOperation );
            break;
        case KVtEngTerminateSession:
            CVtEngUtility::StateManager()->HandleOperationL( aOperation );
            break;
        case KVtEngSwitchToVoice:
            CVtEngUtility::MediatorCommands().SwitchToVoiceL( aOperation );
            break;
        default:
            Panic( EVtEngPanicIncorrectUtility );
            break;
        }
    __VTPRINTEXIT( "EngineInitUtil.HandleL" )
    }

void TVtEngEngineInitUtil::Cancel( CVtEngOperation& aOperation )
    {
    const TVtEngCommandId id = aOperation.Command();
    if ( id == KVtEngInitializeEngine )
        {
        CVtEngInitializer& initializer = 
            CVtEngUtility::EngineUtils()->Initializer();
        initializer.CancelInit();
        }
    }

// -----------------------------------------------------------------------------
// TVtEngExtensionUtil::HandleL
// handles extension operations.
//
// -----------------------------------------------------------------------------
//
void TVtEngExtensionUtil::HandleL(
    CVtEngOperation& aOperation )
    {
    CVtEngUtility::StateManager()->HandleOperationL( aOperation );
    }

//  End of File