/*

* 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:  Audio handler implementation.

*

*/

// INCLUDE FILES

#include    "CVtEngAudioHandler.h"

#include    "CVtEngSettings.h"

#include    "CVtEngEventManager.h"

#include    "VtEngUtils.h"

#include    <cvtlogger.h>

#include    <featmgr.h>

#include    <mmf/server/sounddevice.h>

#include    <AudioPreference.h>

#include    "VtEngUtils.h"

#include    "CVtEngStateManager.h"

#include    "MVtEngSessionInfo.h"

#include    "CVtEngHandlerContainer.h"

// CONSTANTS

// For DevSound initialization

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

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

// CVtEngAudioHandler::CVtEngAudioHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVtEngAudioHandler::CVtEngAudioHandler()

    {

    __VTPRINT( DEBUG_CONSTRUCT | DEBUG_AUDIO, "AH.c++" )

    }

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

// CVtEngAudioHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVtEngAudioHandler::ConstructL()

    {

    iAccHandler = &CVtEngUtility::AccessoryHandler();

    iAccHandler->RegisterObserverL( this );

    iTelephonyAudioRouting = CTelephonyAudioRouting::NewL( *this );

    iCurrentAudioOutput = iTelephonyAudioRouting->Output();

    // Fetch the mode.

    User::LeaveIfError( iAccHandler->AccessoryMode( iAccMode ) );

    __VTPRINT2( DEBUG_AUDIO, "AH.iAccMode %d", ( TInt )iAccMode.iAccessoryMode )

    UpdateCurrentVolume();

    }

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

// CVtEngAudioHandler::NewL

// Two-phased constructor.

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

//

CVtEngAudioHandler* CVtEngAudioHandler::NewL()

    {

    CVtEngAudioHandler* self = new( ELeave ) CVtEngAudioHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CVtEngAudioHandler::~CVtEngAudioHandler

// Destructor.

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

//

CVtEngAudioHandler::~CVtEngAudioHandler()

    {

    __VTPRINT( DEBUG_AUDIO, "AH.~<" )

    delete iRoutingEnabler;

    delete iTelephonyAudioRouting;

    if ( iAccHandler )

    	{

    	iAccHandler->RemoveObserver( this );

    	}

    __VTPRINT( DEBUG_AUDIO, "AH.~>" )

    }

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

// CVtEngAudioHandler::HandleL

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

//

void CVtEngAudioHandler::HandleL( CVtEngOperation& aOperation )

    {

    __VTPRINT2( DEBUG_AUDIO, "AH.HandleL op=%d", ( TInt )iOperation )

    if ( iOperation )

        {

        // While operation is ongoing, another call should not be made.

        User::Leave( KErrArgument );

        }

    MVtEngAudio::TVtEngRoutingSetting routeSetting;

    TVtEngOpParamUtil<MVtEngAudio::TVtEngRoutingSetting>::Set(

        routeSetting, aOperation );

    switch( routeSetting )

        {

        case EActivateHandsfree:

            SetLoudspeakerL( ETrue, ETrue );

            break;

        case EDeactivateHansfree:

            SetLoudspeakerL( EFalse, ETrue );

            break;

        case EActivateBT:

            SetBluetoothL( ETrue ); // asynchronous

            break;

        case EDeactivateBT:

            SetBluetoothL( EFalse );

            break;

        }

    iOperation = &aOperation;

    __VTPRINT( DEBUG_AUDIO | DEBUG_RETURN, "AH.HandleL" )

    }

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

// CVtEngAudioHandler::SetRoutingEnablerL

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

//

void CVtEngAudioHandler::SetRoutingEnablerL( const TBool aEnable )

    {

    __VTPRINTENTER( "AHRout.SetRoutingEnablerL" )

    if ( aEnable && !iRoutingEnabler )

        {

        // Before connected state audio routing can be changed by the user

        // only in MO calls. Create temporary devsound only if call is such.

        const CVtEngHandlerContainer& handlers =

            CVtEngUtility::StateManager()->Handlers();

        const MVtEngSessionInfo& session = handlers.Session();

        MVtEngSessionInfo::TDirection direction =

            MVtEngSessionInfo::EDirectionNone; // init to MO, if

        const TInt err( session.GetDirection( direction ) );

        if ( err == KErrNone && direction == MVtEngSessionInfo::EDirectionMO )

            {

            iRoutingEnabler = CRoutingEnabler::NewL();

            }

        }

    else if ( !aEnable )

        {

        delete iRoutingEnabler;

        iRoutingEnabler = NULL;

        }

    __VTPRINTEXIT( "AHRout.ReleaseRoutingEnablerL" )

    }

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

// CVtEngAudioHandler::IncreaseVolume

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

//

TBool CVtEngAudioHandler::IncreaseVolume()

    {

    __VTPRINTENTER( "AH.IncreaseVolume" )

    TBool adjustOk( AdjustVolume( 1 ) );

    if ( !adjustOk )

        {

        // only reason for AdjustVolume to fail is that volume is max already

        CVtEngEventManager::NotifyEvent( KVtEngAudioVolumeMax );

        }

    __VTPRINTEXITR( "AH.IncreaseVolume %d", adjustOk )

    return adjustOk;

    }

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

// CVtEngAudioHandler::DecreaseVolume

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

//

TBool CVtEngAudioHandler::DecreaseVolume()

    {

    __VTPRINTENTER( "AH.DecreaseVolume" )

    TBool adjustOk( AdjustVolume( -1 ) );

    if ( !adjustOk )

        {

        // only reason for AdjustVolume to fail is that volume is min already

        CVtEngEventManager::NotifyEvent( KVtEngAudioVolumeMin );

        }

    __VTPRINTEXITR( "AH.DecreaseVolume %d", adjustOk )

    return adjustOk;

    }

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

// CVtEngAudioHandler::AdjustVolume

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

//

TBool CVtEngAudioHandler::AdjustVolume( const TInt aDelta )

    {

    __VTPRINTENTER( "AH.AdjustVolume" )

    __VTPRINT2( DEBUG_AUDIO, "AH.AdjustVolume aDelta = %d", aDelta )

    TBool result( EFalse );

    CVtEngSettings& settings( CVtEngUtility::Settings() );

    TVtEngOutputVolume volume;

    settings.GetVolume( volume.iHandsetVolume, EFalse, EFalse );

    settings.GetVolume( volume.iHandsfreeVolume, ETrue, EFalse );

    TAudioRoutingState routingState;

    GetRoutingState( routingState );

    TInt& value( ( routingState == EAudioLoudspeaker ) ?

        volume.iHandsfreeVolume : volume.iHandsetVolume );

    value += aDelta;

    TInt validValue( settings.ValidVolume( value ) );

    if ( validValue == value )

        {

        settings.SetVolume(

            volume.iHandsetVolume,

            volume.iHandsfreeVolume,

            ETrue );

        settings.SetVolume(

            volume.iHandsetVolume,

            volume.iHandsfreeVolume,

            EFalse );

        result = ETrue;

        }

    __VTPRINTEXITR( "AH.AdjustVolume %d", result )

    return result;

    }

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

// CVtEngAudioHandler::GetRoutingState

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

//

TInt CVtEngAudioHandler::GetRoutingState(

        TAudioRoutingState& aAudioRoutingState )

    {

    switch ( iCurrentAudioOutput )

        {

        // Wired headset has the highest priority.

        case CTelephonyAudioRouting::EWiredAudioAccessory:

            __VTPRINT( DEBUG_CONSTRUCT | DEBUG_AUDIO, "AH.GRS.wired" )

            aAudioRoutingState = EAudioWiredHeadset;

            break;

        // Then bluetooth handsfree.

        case CTelephonyAudioRouting::EBTAudioAccessory:

            __VTPRINT( DEBUG_CONSTRUCT | DEBUG_AUDIO, "AH.GRS.bt" )

            aAudioRoutingState = EAudioBT;

            break;

        // Loudspeaker.

        case CTelephonyAudioRouting::ELoudspeaker:

            __VTPRINT( DEBUG_CONSTRUCT | DEBUG_AUDIO, "AH.GRS.IHF" )

            aAudioRoutingState = EAudioLoudspeaker;

            break;

        // Handset as fallback.

        default:

            __VTPRINT( DEBUG_CONSTRUCT | DEBUG_AUDIO, "AH.GRS.Handset" )

            aAudioRoutingState = EAudioHandset;

            break;

        }

    return KErrNone;

    }

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

// CVtEngAudioHandler::GetRoutingAvailability

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

//

TInt CVtEngAudioHandler::GetRoutingAvailability(

        const TAudioRoutingState aAudioRoutingState,

        TBool& aAvailable )

    {

    TAudioRoutingState currentRouting;

    GetRoutingState( currentRouting ); // always succeeds

    if ( currentRouting == aAudioRoutingState )

        {

        // It is possible to route to itself, although it does not make

        // much sense.

        aAvailable = ETrue;

        }

    else if ( currentRouting == EAudioWiredHeadset )

        {

        // For wired headset, audio routings are not possible.

        aAvailable = EFalse;

        }

    else

        {

        switch ( aAudioRoutingState )

            {

            case EAudioHandset:

            case EAudioLoudspeaker:

                // Handset & loudspeaker are always available.

                aAvailable = ETrue;

                break;

            case EAudioBT:

                aAvailable = IsOutputAvailable( CTelephonyAudioRouting::EBTAudioAccessory );

                break;

            case EAudioWiredHeadset:

                // Wired headset can not be routed to. When headset is

                // attached, routing happens automatically.

                aAvailable = EFalse;

                break;

            }

        }

    __VTPRINT3( DEBUG_AUDIO, "AH.GRA state %d availability=%d",

        aAudioRoutingState, aAvailable )

    return KErrNone;

    }

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

// CVtEngAudioHandler::GetHeadsetType

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

//

TInt CVtEngAudioHandler::GetHeadsetType(

        TWiredHeadsetType& aHeadsetType )

    {

    switch ( iAccMode.iAccessoryMode )

        {

        case EAccModeWiredHeadset:

        case EAccModeWiredCarKit:

        case EAccModeMusicStand:

            aHeadsetType = EWiredHeadset;

            break;

        case EAccModeLoopset:

            aHeadsetType = EWiredLoopset;

            break;

        case EAccModeTextDevice:

            aHeadsetType = EWiredTty;

            break;

        case EAccModeHandPortable:

        case EAccModeWirelessHeadset:

        case EAccModeWirelessCarKit:

        default:

            // Not wired headset.

            aHeadsetType = EWiredNone;

            break;

        }

    __VTPRINT2( DEBUG_AUDIO, "AH.HeadsetType=%d", aHeadsetType )

    return KErrNone;

    }

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

// CVtEngAudioHandler::OutputVolume

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

//

TInt CVtEngAudioHandler::OutputVolume(

        const TBool aHandsetVolume ) const

    {

    __VTPRINT2( DEBUG_AUDIO, "AH.OutputVolume isHandset=%d", aHandsetVolume )

    TInt vol = 0;

    CVtEngSettings& setting = CVtEngUtility::Settings();

    TInt err( setting.GetVolume( vol, !aHandsetVolume, EFalse ) );

    if ( err != KErrNone )

        {

        vol = err;

        }

    __VTPRINT2( DEBUG_AUDIO, "AH.OutputVolume vol=%d",vol )

    return vol;

    }

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

// CVtEngAudioHandler::SetLoudspeakerL

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

//

void CVtEngAudioHandler::SetLoudspeakerL( TBool aTurnOn, TBool /*aShowNote*/ )

    {

    __VTPRINTENTER(	"AH.SetLoudspeakerL" )

    __VTPRINT2( DEBUG_AUDIO, "AH.SetLoudspeakerL %d", aTurnOn )

    TBool available( EFalse );

    GetRoutingAvailability( EAudioLoudspeaker, available );

    if ( !available )

        {

        User::Leave( KErrNotSupported );

        }

    // Set shownote flag up in telephony audiorouting, before calling SetOutputL.

    User::LeaveIfError( iTelephonyAudioRouting->SetShowNote( ETrue ) );

    if( aTurnOn )

        {

        iTelephonyAudioRouting->SetOutputL( CTelephonyAudioRouting::ELoudspeaker );

        }

    else

        {

        iTelephonyAudioRouting->SetOutputL( CTelephonyAudioRouting::EHandset );

        }

    __VTPRINTEXIT( "AH.SetLoudspeakerL" )

    }

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

// CVtEngAudioHandler::SetBluetoothL

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

//

void CVtEngAudioHandler::SetBluetoothL( TBool aTurnOn )

    {

    __VTPRINTENTER( "AH.SetBluetoothL" )

    TBool available( EFalse );

    GetRoutingAvailability( EAudioBT, available );

    if ( !available )

        {

        User::Leave( KErrNotSupported );

        }

    // Set shownote flag up in telephony audiorouting, before calling SetOutputL.

    User::LeaveIfError( iTelephonyAudioRouting->SetShowNote( ETrue ) );

    if( aTurnOn )

        {

        iTelephonyAudioRouting->SetOutputL( CTelephonyAudioRouting::EBTAudioAccessory );

        }

    else

        {

        iTelephonyAudioRouting->SetOutputL( CTelephonyAudioRouting::EHandset );

        }

    __VTPRINTEXIT( "AH.SetBluetoothL" )

    }

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

// CVtEngAudioHandler::AvailableOutputsChanged

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

//

void CVtEngAudioHandler::AvailableOutputsChanged(

    CTelephonyAudioRouting& /*aTelephonyAudioRouting*/ )

    {

    __VTPRINTENTER( "AH.AvailableOutputsChanged" )

    CVtEngEventManager::NotifyEvent( KVtEngAudioRoutingAvailabilityChanged );

    __VTPRINTEXIT( "AH.AvailableOutputsChanged" )

    }

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

// CVtEngAudioHandler::OutputChanged

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

//

void CVtEngAudioHandler::OutputChanged(

    CTelephonyAudioRouting& aTelephonyAudioRouting )

    {

    __VTPRINTENTER( "AH.OutputChanged" )

    CTelephonyAudioRouting::TAudioOutput

        previousAudioOutput( iCurrentAudioOutput );

    iCurrentAudioOutput = aTelephonyAudioRouting.Output();

    CVtEngEventManager::NotifyEvent( KVtEngAudioRoutingChanged );

    // HandSet -> IHF

    if( ( previousAudioOutput == CTelephonyAudioRouting::EHandset ) &&

        ( iCurrentAudioOutput == CTelephonyAudioRouting::ELoudspeaker ) )

        {

        __VTPRINT( DEBUG_AUDIO, "AH.OutputChanged signalling HandSet to IHF" )

        }

    // IHF -> HandSet

    else if( ( previousAudioOutput == CTelephonyAudioRouting::ELoudspeaker ) &&

        ( iCurrentAudioOutput == CTelephonyAudioRouting::EHandset ) )

        {

        __VTPRINT( DEBUG_AUDIO, "AH.OutputChanged signalling IHF to HandSet" )

        }

    UpdateCurrentVolume();

    __VTPRINTEXITR( "AH.OutputChanged %d", iCurrentAudioOutput )

    }

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

// CVtEngAudioHandler::SetOutputComplete

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

//

void CVtEngAudioHandler::SetOutputComplete(

    CTelephonyAudioRouting& aTelephonyAudioRouting,

    TInt aError )

    {

    __VTPRINTENTER( "AH.SetOutputComplete" )

    if ( aError == KErrNone )

        {

        OutputChanged( aTelephonyAudioRouting );

        }

    CompleteOperation( aError );

    __VTPRINTEXIT( "AH.SetOutputComplete" )

    }

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

// CVtEngAudioHandler::CompleteOperation

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

//

void CVtEngAudioHandler::CompleteOperation( TInt aResult )

    {

    __VTPRINT3( DEBUG_AUDIO, "AH.CompleteOperation op=%d,res=%d" ,

        ( TInt )iOperation, aResult )

    if ( iOperation )

        {

        iOperation->HandleOpComplete( aResult );

        iOperation = NULL;

        }

    }

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

// CVtEngAudioHandler::UpdateCurrentVolume

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

//

void CVtEngAudioHandler::UpdateCurrentVolume()

    {

    __VTPRINTENTER( "AH.UpdateCurrentVolume" )

    TAudioRoutingState currentRouting = EAudioHandset;

    GetRoutingState( currentRouting );

    const TBool currentVolume = ( currentRouting == EAudioLoudspeaker );

    CVtEngSettings& setting = CVtEngUtility::Settings();

    setting.SetCurrentVolume( currentVolume );

    __VTPRINTEXITR( "AH.UpdateCurrentVolume output is IHF=%d", currentVolume )