* Copyright (c) 2002-2010 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: This module contains the implementation of AudioData class

 *              member functions

 *

 */

#include <tms.h>

#include <tmseffectobsrvr.h>

#include <tmsglobalvoleffect.h>

#include <telinformationpskeys.h>

#include "cpeaudiofactory.h"

#include "cpeaudioeffect.h"

CPEAudioData::CPEAudioData(MPEPhoneModelInternal& aPhoneModel) :

    iPhoneModel(aPhoneModel)

void CPEAudioData::ConstructL(CPEAudioFactory& aAudioFactory)

    iAudioRoutingMonitor = CPEAudioRoutingMonitor::NewL(*this);

    iAudioRouting = aAudioFactory.CreateTelephonyAudioRoutingL(

            *iAudioRoutingMonitor);

    iAudioRoutingHandler = CPECallAudioRoutingHandler::NewL(*this);

    iAudioEffect = CPEAudioEffect::NewL(*this);

    InitializeAudioVolume();

    TEFLOGSTRING( KTAINT, "AUD CPEAudioData::ConstructL  complete" );

    delete iAudioEffect;

// CPEAudioData::InitializeAudioVolume

// Gets audio volume value

//

void CPEAudioData::InitializeAudioVolume()

    TInt volume = iAudioEffect->Volume();

    iPhoneModel.DataStore()->SetAudioVolume(volume);

    TEFLOGSTRING2( KTAINT,

            "AUD CPEAudioData::InitializeAudioVolumes, volume = %d",

            volume );

EXPORT_C void CPEAudioData::GetAudioMuteSync(TBool& aAudioMute) const

    aAudioMute = iAudioEffect->MuteState();

    TEFLOGSTRING2(

            KTAREQIN,

            "AUD CPEAudioData::GetAudioMuteSync: value = %d",

            aAudioMute);

EXPORT_C void CPEAudioData::GetAudioVolumeSync(TInt& aAudioVolume) const

    aAudioVolume = iAudioEffect->Volume();

void CPEAudioData::SendErrorMessage(const TInt aErrorCode)

    iPhoneModel.DataStore()->SetErrorCode(aErrorCode);

    TEFLOGSTRING(

            KTAREQOUT,

            "AUD CPEAudioData::SendErrorMessage: iPhoneModel.SendMessage( MEngineMonitor::EPEMessageAudioHandlingError )" );

    iPhoneModel.SendMessage(MEngineMonitor::EPEMessageAudioHandlingError);

void CPEAudioData::SendMessage(

        const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage)

    TEFLOGSTRING2( KTAREQIN,

            "AUD CPEAudioData::SendMessage: aMessage = %d", aMessage );

    if (aMessage == MEngineMonitor::EPEMessageAudioVolumeChanged)

        // update volume

        TInt volume = iPhoneModel.DataStore()->AudioVolume();

        TEFLOGSTRING2( KTAINT,

                "AUD CPEAudioData::SendMessage: volume = %d",

                volume );

        }

    iPhoneModel.SendMessage(aMessage);

void CPEAudioData::SendMessage(

        const CTelephonyAudioRouting::TAudioOutput aOutput)

    TEFLOGSTRING3(

            KTAREQIN,

            "AUD CPEAudioData::SendMessage: aMessage = %d, aOutput = %d",

            aMessage, aOutput );

    if (aOutput == CTelephonyAudioRouting::ENone

            && iAudioRouting->PreviousOutput()

                    == CTelephonyAudioRouting::EBTAudioAccessory)

        SetRoutePreference(ETrue);

        iAudioRouting->GetShowNote(status);

        iPhoneModel.DataStore()->SetAudioOutput(ConvertToPE(aOutput),

                ConvertToPE(PreviousOutput()), status);

        iPhoneModel.SendMessage(aMessage);

//

void CPEAudioData::SendMessage(

        const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,

        CTelephonyAudioRouting& aTelephonyAudioRouting)

    TEFLOGSTRING2(

            KTAREQIN,

            "AUD CPEAudioData::SendMessage: aMessage = %d, available outputs changed ", aMessage );

    iPhoneModel.DataStore()->SetAvailableAudioOutputs(GetAvailableOutputs(

            aTelephonyAudioRouting));

    if (iRouteInitialized && aMessage

            == MEngineMonitor::EPEMessageAvailableAudioOutputsChanged)

    iPhoneModel.SendMessage(aMessage);

EXPORT_C void CPEAudioData::SetAudioMuteSync(const TBool aAudioMute) // Mute value to be set

    if (aAudioMute)

        iPhoneModel.DataStore()->SetAudioMute(aAudioMute);

        SendMessage(MEngineMonitor::EPEMessageAudioMuteChanged);

        TInt err = iAudioEffect->SetMuteState(ETrue);

        TEFLOGSTRING2(

                KTAREQOUT,

                "AUD CPEAudioData::SetAudioMuteSync: error = %d",

                err );

        iPhoneModel.DataStore()->SetAudioMute(aAudioMute);

        SendMessage(MEngineMonitor::EPEMessageAudioMuteChanged);

        TInt err = iAudioEffect->SetMuteState(EFalse);

        TEFLOGSTRING2(

                KTAREQOUT,

                "AUD CPEAudioData::SetAudioMuteSync: error = %d",

                err );

EXPORT_C void CPEAudioData::SetAudioVolumeSync(const TInt aAudioVolume) // Volume to be set

    TEFLOGSTRING2(

            KTAREQIN,

    if (aAudioVolume <= KPEMaxVolume)

        {

        TEFLOGSTRING2( KTAINT,

                "AUD CPEAudioData::SetAudioVolumeSync, aAudioVolume = %d",

        iAudioEffect->SetVolume(aAudioVolume);

        }

    DoHandleVolumeChange(aAudioVolume, ETrue);

EXPORT_C TInt CPEAudioData::SetAudioOutput(const TPEAudioOutput aOutput,

        TBool aShowNote)

    TEFLOGSTRING2(

            KTAREQIN,

            "AUD CPEAudioData::SetAudioOutput: aOutput = %d",

            aOutput );

    TInt error(KErrNone);

    TEFLOGSTRING2( KTAERROR,

            "AUD CPEAudioData::SetAudioOutput: iRouteInitialized (%d)"

            , iRouteInitialized );

    if (iRouteInitialized && iPhoneModel.DataStore()->AudioOutputAvailable(

            aOutput))

        SetTAROutput(ConvertToTAR(aOutput), aShowNote);

        if (aOutput == EPEHandset)

            iAudioRoutingHandler->SetAnswerToHandset(ETrue);

                    "AUD CPEAudioData::SetAudioOutput: Requested audio path not available (%d)"

                    , aOutput );

            error = KErrArgument;

void CPEAudioData::SetTAROutput(CTelephonyAudioRouting::TAudioOutput aOutput,

        TBool aShowNote)

    TEFLOGSTRING2(

            KTAREQIN,

            "AUD CPEAudioData::SetTAROutput: aOutput = %d",

            aOutput );

    iAudioRouting->SetShowNote(aShowNote);

    SendMessage(MEngineMonitor::EPEMessageAudioOutputChanged, aOutput);

#else

    CTelephonyAudioRouting::TAudioOutput output = iAudioRouting->Output();

    if ( output == aOutput )

        {

        // audio routing cannot changed

        TEFLOGSTRING2( KTAERROR,

                "AUD CPEAudioData::SetTAROutput: audio path already (%d)"

                , aOutput );

        return;

        }

    TRAPD( err, iAudioRouting->SetOutputL( aOutput ) );

    if( err )

        {

        TEFLOGSTRING2( KTAERROR,

                "AUD CPEAudioData::SetTAROutput:Leave.1 (%d)", err );

        switch ( aOutput )

            {

            case CTelephonyAudioRouting::ELoudspeaker:

            case CTelephonyAudioRouting::EWiredAudioAccessory:

            case CTelephonyAudioRouting::EBTAudioAccessory:

                // if leave try handset

                TRAPD( err2, iAudioRouting->SetOutputL( CTelephonyAudioRouting::EHandset ) );

                if( err2 )

                    {

                    TEFLOGSTRING2( KTAERROR,

                            "AUD CPEAudioData::SetTAROutput:Leave.2 (%d)", err );

                    }

                break;

            default:

                // None

                break;

            }

#endif

    iPhoneModel.DataStore()->SetAvailableAudioOutputs(GetAvailableOutputs(

            *iAudioRouting));

    iPhoneModel.DataStore()->SetAudioOutput(ConvertToPE(

            iAudioRouting->Output()), ConvertToPE(

            iAudioRouting->PreviousOutput()), EFalse);

TArray<TPEAudioOutput> CPEAudioData::GetAvailableOutputs(

        CTelephonyAudioRouting& aTelephonyAudioRouting)

    TEFLOGSTRING( KTAREQOUT,

            "AUD CPEAudioData::GetAvailableOutputs > CTelephonyAudioRouting::AvailableOutputs()" );

    TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputs =

            aTelephonyAudioRouting.AvailableOutputs();

    for (TInt j = 0; j < availableOutputs.Count(); j++)

        TInt err = iPEavailableOutputs.Append(ConvertToPE(availableOutputs[j]));

        TEFLOGSTRING4( KTAINT,

                "AUD CPEAudioData::GetAvailableOutputs, index: %d, available: %d, err: %d",

                j,

                availableOutputs[j],

                err );

        if(err != KErrNone)

            {

            // Do nothing. Here for just to suppress the compile warning.

            }

        }

    return iPEavailableOutputs.Array();

// CPEAudioData::HandleCallStarting

EXPORT_C TInt CPEAudioData::HandleCallStarting(TBool aVideoCall)

    TEFLOGSTRING( KTAMESINT, "AUD CPEAudioData::HandleCallStarting()" );

    TInt ret(KErrNone);

    if (!iRouteInitialized) // if route not already initialized

        { // Not new route init for multi calls

        iRouteInitialized = ETrue;

        ret = iAudioRoutingHandler->HandleAudioRoutingCallInit(aVideoCall);

    return ret;

// One used situation is that emergency call is dialed during the video call or

//

    TInt ret(KErrNone);

    ret = iAudioRoutingHandler->HandleAudioRoutingCallInit(EFalse);

    return ret;

//

    if (iRouteInitialized)

        TEFLOGSTRING( KTAMESINT,

                "AUD CPEAudioData::HandleCallEnding() > CTelephonyAudioRouting::ENotActive" );

        SetTAROutput(CTelephonyAudioRouting::ENotActive, EFalse);

//

//

    if (iRouteInitialized)

        return iAudioRoutingHandler->HandleAudioRoutePreferenceChanged();

    }