/*

 * 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 FILES

#include "cpeaudiodata.h"

#include <AudioPreference.h>

#include <mpephonemodelinternal.h>

#include <mpedatastore.h>

#include <mpeexternaldatahandler.h>

#include <talogger.h>

#include <telmicmutestatuspskeys.h>

#include <PSVariables.h>

#include <tms.h>

#include <tmseffectobsrvr.h>

#include <tmsglobalvoleffect.h>

#include <telinformationpskeys.h>

#include "pepanic.pan"

#include "cpeaudiodtmftoneplayer.h"

#include "cpeaudioroutingmonitor.h"

#include "cpecallaudioroutinghandler.h"

#include "cpeaudiofactory.h"

#include "cpeaudioeffect.h"

#include <telinternalpskeys.h>

// CONSTANTS

//Mute Value for volume

const TInt KPEMaxVolume = 10;

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

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

// CPEAudioData::CPEAudioData

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

// might leave.

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

//

CPEAudioData::CPEAudioData(MPEPhoneModelInternal& aPhoneModel) :

    iPhoneModel(aPhoneModel)

    {

    iRouteInitialized = EFalse;

    }

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

// CPEAudioData::ConstructL

// Symbian 2nd phase constructor can leave

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

//

void CPEAudioData::ConstructL(CPEAudioFactory& aAudioFactory)

    {

    TEFLOGSTRING( KTAOBJECT, "AUD CPEAudioData::ConstructL start" );

    iAudioRoutingMonitor = CPEAudioRoutingMonitor::NewL(*this);

    iAudioRouting = aAudioFactory.CreateTelephonyAudioRoutingL(

            *iAudioRoutingMonitor);

    iAudioRoutingHandler = CPECallAudioRoutingHandler::NewL(*this);

    iAudioEffect = CPEAudioEffect::NewL(*this);

    InitializeAudioVolume();

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

    }

// Destructor

EXPORT_C CPEAudioData::~CPEAudioData()

    {

    TEFLOGSTRING( KTAOBJECT, "AUD CPEAudioData::~CPEAudioData" );

    delete iAudioRouting;

    delete iAudioRoutingMonitor;

    delete iAudioRoutingHandler;

    iPEavailableOutputs.Close();

    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 );

    }

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

// CPEAudioData::GetAudioMuteSync

// Creates synchronous request to get Audio Mute value.

// (other items were commented in a header).

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

//

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

    {

    aAudioMute = iAudioEffect->MuteState();

    TEFLOGSTRING2(

            KTAREQIN,

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

            aAudioMute);

    }

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

// CPEAudioData::GetAudioVolumeSync

// Creates synchronous request to get audio volume.

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

//

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

    {

    TEFLOGSTRING( KTAINT, "AUD CPEAudioData::GetAudioVolumeSync" );

    aAudioVolume = iAudioEffect->Volume();

    }

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

// CPEAudioData::SendErrorMessage

// Saves errorcode to member variable and sends error notification to PhoneEngine.

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

//

void CPEAudioData::SendErrorMessage(const TInt aErrorCode)

    {

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

    TEFLOGSTRING(

            KTAREQOUT,

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

    iPhoneModel.SendMessage(MEngineMonitor::EPEMessageAudioHandlingError);

    }

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

// CPEAudioData::SendMessage

// Forwards message to PhoneEngine.

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

//

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);

    }

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

// CPEAudioData::SendMessage

// Forwards message to PhoneEngine. Output mode is saved.

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

//

void CPEAudioData::SendMessage(

        const MEngineMonitor::TPEMessagesFromPhoneEngine aMessage,

        const CTelephonyAudioRouting::TAudioOutput aOutput)

    {

    TEFLOGSTRING3(

            KTAREQIN,

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

            aMessage, aOutput );

    // BT long key press requires manual re-route to handset or loudspeaker

    if (aOutput == CTelephonyAudioRouting::ENone

            && iAudioRouting->PreviousOutput()

                    == CTelephonyAudioRouting::EBTAudioAccessory)

        {

        SetRoutePreference(ETrue);

        }

    else

        {

        // update the audio values in engineinfo

        TBool status;

        iAudioRouting->GetShowNote(status);

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

                ConvertToPE(PreviousOutput()), status);

        iPhoneModel.SendMessage(aMessage);

        }

    }

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

// CPEAudioData::SendMessage

// Forwards message to PhoneEngine.

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

//

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)

        {

        iAudioRoutingHandler->HandleAudioRoutingAvailableChanged();

        }

    iPhoneModel.SendMessage(aMessage);

    }

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

// CPEAudioData::SetAudioMuteSync

// Creates synchronous request to set audio mute.

// EPEMessageAudioMuteChanged message is sent when gain is changed

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

//

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

    {

    TEFLOGSTRING( KTAINT, "AUD CPEAudioData::SetAudioMuteSync" );

    if (aAudioMute)

        {

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

        SendMessage(MEngineMonitor::EPEMessageAudioMuteChanged);

        TInt err = iAudioEffect->SetMuteState(ETrue);

        TEFLOGSTRING2(

                KTAREQOUT,

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

                err );

        }

    else

        {

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

        SendMessage(MEngineMonitor::EPEMessageAudioMuteChanged);

        TInt err = iAudioEffect->SetMuteState(EFalse);

        TEFLOGSTRING2(

                KTAREQOUT,

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

                err );

        }

    }

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

// CPEAudioData::SetAudioVolumeSync

// Creates synchronous request to set audio volume.

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

//

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

    {

    TEFLOGSTRING2(

            KTAREQIN,

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

            aAudioVolume );

    if (aAudioVolume <= KPEMaxVolume)

        {

        TEFLOGSTRING2( KTAINT,

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

                aAudioVolume );

        iAudioEffect->SetVolume(aAudioVolume);

        }

    DoHandleVolumeChange(aAudioVolume, ETrue);

    }

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

// CPEAudioData::SetAudioOutput

// Makes request to Telephony Audio Routing to set audio output path

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

//

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);

        }

    else

        {

        if (aOutput == EPEHandset)

            {

            iAudioRoutingHandler->SetAnswerToHandset(ETrue);

            }

        else

            {

            TEFLOGSTRING2( KTAERROR,

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

                    , aOutput );

            error = KErrArgument;

            }

        }

    return error;

    }

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

// CPEAudioData::SetTAROutput

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

//

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

        TBool aShowNote)

    {

    TEFLOGSTRING2(

            KTAREQIN,

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

            aOutput );

#if defined(__WINSCW__ ) && !defined(UNIT_TESTING)

    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;

        }

    iAudioRouting->SetShowNote( aShowNote );

    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

    }

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

// CPEAudioData::StartUp

// Gets initial values and inializes TAR

// StartUpL methods.

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

//

EXPORT_C void CPEAudioData::StartUp()

    {

    TEFLOGSTRING( KTAREQIN, "AUD CPEAudioData::StartUp" );

    // get available audio output paths and current audio output

    iPhoneModel.DataStore()->SetAvailableAudioOutputs(GetAvailableOutputs(

            *iAudioRouting));

    iPhoneModel.DataStore()->SetAudioOutput(ConvertToPE(

            iAudioRouting->Output()), ConvertToPE(

            iAudioRouting->PreviousOutput()), EFalse);

    }

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

// CPEAudioData::GetAvailableOutputs

// Gets Available Outputs from Audio routing framework

// Return list of available outputs

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

//

TArray<TPEAudioOutput> CPEAudioData::GetAvailableOutputs(

        CTelephonyAudioRouting& aTelephonyAudioRouting)

    {

    TEFLOGSTRING( KTAREQOUT,

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

    TArray<CTelephonyAudioRouting::TAudioOutput> availableOutputs =

            aTelephonyAudioRouting.AvailableOutputs();

    iPEavailableOutputs.Reset();

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

        {

                j,

        }

    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;

    }

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

// CPEAudioData::HandleEnergencyCallStarting

// Can be called, if new call is created before previous call is idle state

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

// voice call. Audio routing have to initialized when emergency is dialing state

// even previous call(voice or video) haven't got idle yet.

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

//

EXPORT_C TInt CPEAudioData::HandleEnergencyCallStarting()

    {

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

    TInt ret(KErrNone);

    // Always new route init

    ret = iAudioRoutingHandler->HandleAudioRoutingCallInit(EFalse);

    iRouteInitialized = ETrue;

    return ret;

    }

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

// CPEAudioData::HandleCallEnding()

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

//

EXPORT_C void CPEAudioData::HandleCallEnding()

    {

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

    if (iRouteInitialized)

        {

        iRouteInitialized = EFalse;

        TEFLOGSTRING( KTAMESINT,

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

        SetTAROutput(CTelephonyAudioRouting::ENotActive, EFalse);

        }

    }

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

// CPEAudioData::CallAudioRoutePreferenceChanged()

//

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

//

EXPORT_C TInt CPEAudioData::CallAudioRoutePreferenceChanged()

    {

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

    if (iRouteInitialized)

        {

        return iAudioRoutingHandler->HandleAudioRoutePreferenceChanged();

        }

    return KErrNotReady;

    }

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

// CPEAudioData::PreviousOutput

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

//

CTelephonyAudioRouting::TAudioOutput CPEAudioData::PreviousOutput()

    {

    return iAudioRouting->PreviousOutput();

    }

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

// CPEAudioData::Output

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

//

CTelephonyAudioRouting::TAudioOutput CPEAudioData::Output()

    {

    return iAudioRouting->Output();

    }

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

// CPEAudioData::SetRoutePreference

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

//

void CPEAudioData::SetRoutePreference(TBool aShowNote)

    {

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

    CTelephonyAudioRouting::TAudioOutput output =

            CTelephonyAudioRouting::EHandset;

    const TInt outputPreference =