/*

* Copyright (c) 2002-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:  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 "pepanic.pan"

#include "cpeaudiodtmftoneplayer.h"

#include "cpeaudioroutingmonitor.h"

#include "cpecallaudioroutinghandler.h"

#include "cpeaudiofactory.h"	

#include <telinternalpskeys.h>

// CONSTANTS

//Mute Value for volume

const TInt KPEDefaultVolume = 4;

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;

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

    //Gets audio volumes from repository

    InitializeAudioVolumes();

    RProperty::TType type( RProperty::EInt );

    TSecurityPolicy readPolicy( ECapability_None );

    TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );

    RProperty::Define( KPSUidTelMicrophoneMuteStatus, 

        KTelMicrophoneMuteState,

        type,

        readPolicy,

        writePolicy );

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

    }

// Destructor

EXPORT_C CPEAudioData::~CPEAudioData()

    {

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

    delete iAudioRouting;

    delete iAudioRoutingMonitor;

    delete iAudioRoutingHandler;

    iPEavailableOutputs.Close();

    }

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

// CPEAudioData::InitializeAudioVolumes

// Gets audio volume values from reporitory

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

//   

void CPEAudioData::InitializeAudioVolumes()

    {

// Connect to CPEGsmExternalDataHandler missing from TEPhoneEngineTestUtils wrapper !!!

    TInt volume;

    iPhoneModel.DataStoreExt()->Get( 

        EPEIncallLoudspeakerVolumeSetting, volume ); 

    iLoudspeakerVolume = volume;

    TEFLOGSTRING2( KTAINT, 

        "AUD CPEAudioData::CPEAudioData, DataStoreExt()->Get, iLoudspeakerVolume = %d",

         iLoudspeakerVolume );

    iPhoneModel.DataStoreExt()->Get( 

        EPEIncallEarVolumeSetting, volume ); 

    iHeadSetVolume = volume;

    TEFLOGSTRING2( KTAINT, 

        "AUD CPEAudioData::CPEAudioData, DataStoreExt()->Get, iLoudspeakerVolume = %d",

         iHeadSetVolume );

    }

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

// 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 

    {

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

    if ( IsMuted() ) 

        {

        //mute is on

        aAudioMute = ETrue;

        }

    else

        {

        aAudioMute = EFalse;

        }

    }

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

// CPEAudioData::GetAudioVolumeSync

// Creates synchronous request to get audio volume.

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

//

EXPORT_C void CPEAudioData::GetAudioVolumeSync(

        TInt& aAudioVolume ) const

    {

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

    if ( iPhoneModel.DataStore()->AudioOutput() == EPELoudspeaker )

        {

        iPhoneModel.DataStoreExt()->Get( 

            EPEIncallLoudspeakerVolumeSetting, aAudioVolume );

        TEFLOGSTRING( KTAINT, 

            "AUD CPEAudioData::GetAudioVolumeSync: EPEIncallLoudspeakerVolumeSetting");

        }

    else 

        {

        iPhoneModel.DataStoreExt()->Get( 

            EPEIncallEarVolumeSetting, aAudioVolume );

        TEFLOGSTRING( KTAINT, 

            "AUD CPEAudioData::GetAudioVolumeSync: EPEIncallEarVolumeSetting");            

        }

    }

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

// 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

	    if ( iPhoneModel.DataStore()->AudioOutput() == EPELoudspeaker )

	        {

	        iLoudspeakerVolume = iPhoneModel.DataStore()->AudioVolume();

	        TEFLOGSTRING2( KTAINT, 

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

	            iLoudspeakerVolume );

	        }

	    else 

	        {

	        iHeadSetVolume = iPhoneModel.DataStore()->AudioVolume();

	        TEFLOGSTRING2( KTAINT, 

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

	            iHeadSetVolume );

	        }	

       	if ( !iAudioOutputChanged )

            {

            // EPEMessageAudioVolumeChanged message must not be sent 

            // while audio output change is being processed

            iPhoneModel.SendMessage( aMessage );	

            }

	   }

    else 

        {

        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

        {

        // store the old audio path volume

        if ( iPhoneModel.DataStore()->AudioOutput() == EPELoudspeaker )

            {

            iLoudspeakerVolume = iPhoneModel.DataStore()->AudioVolume();

            TEFLOGSTRING2( KTAINT, 

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

                iLoudspeakerVolume );

            }

        else 

            {

            iHeadSetVolume = iPhoneModel.DataStore()->AudioVolume();

            TEFLOGSTRING2( KTAINT, 

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

                iHeadSetVolume );

            }

        // update the audio values in engineinfo

        TBool status;

        iAudioRouting->GetShowNote( status );

        iPhoneModel.DataStore()->SetAudioOutput( ConvertToPE( aOutput ), ConvertToPE( PreviousOutput() ), status );

        // Set audio output change flag 

        iAudioOutputChanged = ( MEngineMonitor::EPEMessageAudioOutputChanged == aMessage );

        // restore the stored volume for the new path

        if ( aOutput == CTelephonyAudioRouting::ELoudspeaker )

            {

            // restore the stored volume for the new path

            SetAudioVolumeSync( iLoudspeakerVolume );

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

            TEFLOGSTRING2( KTAINT, 

                "AUD CPEAudioData::SendMessage: DataStoreExt()->Set, iLoudspeakerVolume = %d", 

                iLoudspeakerVolume );

            iPhoneModel.DataStoreExt()->Set( EPEIncallLoudspeakerVolumeSetting,

                iLoudspeakerVolume );

            }

        else 

            {

            // restore the stored volume for the new path

            SetAudioVolumeSync( iHeadSetVolume );

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

            TEFLOGSTRING2( KTAINT, 

                "AUD CPEAudioData::SendMessage: DataStoreExt()->Set, iHeadSetVolume  = %d", 

                iHeadSetVolume );

            iPhoneModel.DataStoreExt()->Set( EPEIncallEarVolumeSetting,

                iHeadSetVolume );

            }

        // Reset audio output change flag 

        iAudioOutputChanged = EFalse;                                                

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

        // Inform VoIP/PE Videocallmanager mute state. Error code not handled.

        TInt err = RProperty::Set( 

            KPSUidTelMicrophoneMuteStatus, 

            KTelMicrophoneMuteState,

            EPSTelMicMuteOn );

            TEFLOGSTRING2( 

                KTAREQOUT, 

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

                err );            

        }

    else

        {

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

        SendMessage( MEngineMonitor::EPEMessageAudioMuteChanged );

        TInt err = RProperty::Set( 

            KPSUidTelMicrophoneMuteStatus, 

            KTelMicrophoneMuteState,

            EPSTelMicMuteOff );

        TEFLOGSTRING2( 

            KTAREQOUT, 

            "AUD CPEAudioData::SetAudioMuteSync: EPSTelephonyMicMuteOff, 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 );

        if ( iPhoneModel.DataStore()->AudioOutput() == EPELoudspeaker )

            {

            iPhoneModel.DataStoreExt()->Set( 

                EPEIncallLoudspeakerVolumeSetting, 

                aAudioVolume );

            TEFLOGSTRING( KTAINT, 

                "AUD CPEAudioData::SetAudioVolumeSync: EPEIncallLoudspeakerVolumeSetting");

            }

        else 

            {

            iPhoneModel.DataStoreExt()->Set( 

                EPEIncallEarVolumeSetting, 

                aAudioVolume );

            TEFLOGSTRING( KTAINT, 

                "AUD CPEAudioData::SetAudioVolumeSync: EPEIncallEarVolumeSetting");

            }

		}            

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

    DoHandleVolumeChange( aAudioVolume );

    SendMessage( MEngineMonitor::EPEMessageAudioVolumeChanged );

    }

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

// 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