// Copyright (c) 2006-2009 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:

 //

 //  INCLUDES

 #include <mmf/server/sounddevice.h>

 #include "sounddevicebody.h"

 /*

  *  Default Constructor.

  */

 CMMFDevSound::CMMFDevSound()

 	{

 	}

 /*

  *  Destructor.

  */

 EXPORT_C CMMFDevSound::~CMMFDevSound()

 	{

 	delete iBody;

 	}

 /*

  *  CMMFDevSound::NewL

  *

  *  Constructs and returns a pointer to a new CMMFDevSound object.

  */

 EXPORT_C CMMFDevSound* CMMFDevSound::NewL()

 	{

 	CMMFDevSound* self = new (ELeave) CMMFDevSound;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /*

  *  CMMFDevSound::ConstructL

  *

  *  Second phase constructor.

  */

 void CMMFDevSound::ConstructL()

 	{

 	iBody = CBody::NewL();

 	}

 /*

  *  CMMFDevSound::InitializeL

  *

  *  Initializes CMMFDevSound object. On completion of Initialization will

  *  call InitializeComplete() on aDevSoundObserver.

  *

  *  @param  aDevSoundObserver. A reference to the DevSound Observer instance.

  *  @param  aMode. A mode for which this object will be used.

  */

 EXPORT_C void CMMFDevSound::InitializeL(MDevSoundObserver& aDevSoundObserver,TMMFState aMode)

 	{

 	iBody->InitializeL(aDevSoundObserver,aMode);

 	}

 /*

  *  CMMFDevSound::InitializeL

  *

  *  Initializes CMMFDevSound object with hardware device aHWDev. On completion

  *  of Initialization will call InitializeComplete() on aDevSoundObserver.

  *

  *	Method is deprecated from OS release 9.5

  *

  *  @param  aDevSoundObserver. A reference to the DevSound Observer instance.

  *  @param  aHWDev. CMMFHwDevice implementation identifier.

  *  @param  aMode. A mode for which this object will be used.

  */

 EXPORT_C void CMMFDevSound::InitializeL(

 							MDevSoundObserver& /*aDevSoundObserver*/,

 							TUid /*aHWDev*/,

 							TMMFState /*aMode*/)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /*

  *  CMMFDevSound::InitializeL

  *

  *  Initializes CMMFDevSound object with hardware device with hardware

  *  device's FourCC code. On completion of Initialization will call

  *  InitializeComplete() on aDevSoundObserver.

  *

  *  @param  aDevSoundObserver. A reference to the DevSound Observer instance.

  *  @param  aDesiredFourCC. CMMFHwDevice implementation FourCC.

  *  @param  aMode. A mode for which this object will be used.

  */

 EXPORT_C void CMMFDevSound::InitializeL(

 							MDevSoundObserver& aDevSoundObserver,

 							TFourCC aDesiredFourCC,

 							TMMFState aMode)

 	{

 	iBody->InitializeL(aDevSoundObserver, aDesiredFourCC, aMode);

 	}

 /*

  *  CMMFDevSound::Capabilities

  *

  *  Returns supported Audio settings.

  *

  *  @return TMMFCapabilities device settings.

  */

 EXPORT_C TMMFCapabilities CMMFDevSound::Capabilities()

 	{

 	return iBody->Capabilities();

 	}

 /*

  *  CMMFDevSound::Config

  *

  *  Returns current audio settings.

  *

  *  @return TMMFCapabilities device settings.

  */

 EXPORT_C TMMFCapabilities CMMFDevSound::Config() const

 	{

 	return iBody->Config();

 	}

 /*

  *  CMMFDevSound::SetConfigL

  *

  *  ConfigureS CMMFDevSound object with the settings in aConfig.

  *

  *  Use this to set sampling rate, Encoding and Mono/Stereo.

  *

  *  @param  aConfig. CMMFDevSound configuration settings.

  */

 EXPORT_C void CMMFDevSound::SetConfigL(const TMMFCapabilities& aConfig)

 	{

 	iBody->SetConfigL(aConfig);

 	}

 /*

  *  CMMFDevSound::MaxVolume

  *

  *  Returns an integer representing the maximum volume.

  *

  *  This is the maximum volume which can be passed to CMMFDevSound::SetVolume.

  *

  *  @return TInt

  *          The maximum volume. This value is platform dependent but is always

  *          greater than or equal to one.

  */

 EXPORT_C TInt CMMFDevSound::MaxVolume()

 	{

 	return iBody->MaxVolume();

 	}

 /*

  *  CMMFDevSound::Volume

  *

  *  Returns an integer representing current volume level.

  *

  *  @return TInt

  *          Current volume level.

  */

 EXPORT_C TInt CMMFDevSound::Volume()

 	{

 	return iBody->Volume();

 	}

 /*

  *  CMMFDevSound::SetVolume

  *

  *  Changes current volume level to the specified value.

  *

  *  The volume can be changed before or during playback and is effective

  *  immediately.

  *

  *  @param  TInt

  *          The volume setting. This can be any value between zero and the

  *          value returned by the call to CMMFDevSound::MaxVolume(). If the

  *          volume is out of range, it is automatically set to the minimum or

  *          maximum level closest to the value being passed in. Setting a zero

  *          value mutes the sound.

  */

 EXPORT_C void CMMFDevSound::SetVolume(TInt aVolume)

 	{

 	iBody->SetVolume(aVolume);

 	}

 /*

  *  CMMFDevSound::MaxGain

  *

  *  Returns an integer representing the maximum microphone gain.

  *

  *  This is the maximum value which can be passed to CMMFDevSound::SetGain.

  *

  *  @return TInt

  *          The maximum gain. This value is platform dependent but is always

  *          greater than or equal to one.

  */

 EXPORT_C TInt CMMFDevSound::MaxGain()

 	{

 	return iBody->MaxGain();

 	}

 /*

  *  CMMFDevSound::Gain

  *

  *  Returns an integer representing current gain.

  *

  *  @return TInt

  *          The current gain level.

  */

 EXPORT_C TInt CMMFDevSound::Gain()

 	{

 	return iBody->Gain();

 	}

 /*

  *  CMMFDevSound::SetGain

  *

  *  Changes current recording gain to a specified value.

  *

  *  The gain can be changed before or during recording and is effective

  *  immediately.

  *

  *  @param  aGain. This can be any value between zero and the

  *          value returned by the call to CMMFDevSound::MaxGain(). If the

  *          gain is out of range, it is automatically set to minimum or maximum

  *          value closest to the value that is being passed.

  *          Setting a zero value mutes the microphone.

  */

 EXPORT_C void CMMFDevSound::SetGain(TInt aGain)

 	{

 	iBody->SetGain(aGain);

 	}

 /*

  *  CMMFDevSound::GetPlayBalanceL

  *

  *  Returns the speaker balance set for playing.

  *

  *  @param  aLeftPercentage. On return contains the left speaker volume percentage.

  *  @param  aRightPercentage. On return contains the left speaker volume percentage.

  */

 EXPORT_C void CMMFDevSound::GetPlayBalanceL(TInt& aLeftPercentage,TInt& aRightPercentage)

 	{

 	iBody->GetPlayBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *  CMMFDevSound::SetPlayBalanceL

  *

  *  Sets the speaker balance for playing.

  *

  *  The speaker balance can be changed before or during playback and is

  *  effective immediately.

  *

  *  @param  aLeftPercentage. Left speaker volume perecentage. This can be any value between

  *          zero and 100. Setting a zero value mutes the sound on the left

  *          speaker.

  *  @param  aRightPercentage. Right speaker volume perecentage. This can be any value between

  *          zero and 100. Setting a zero value mutes the sound on the right

  *          speaker.

  */

 EXPORT_C void CMMFDevSound::SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage)

 	{

 	iBody->SetPlayBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *  CMMFDevSound::GetRecordBalanceL

  *

  *  Returns the microphone gain balance set for recording.

  *

  *  @param  aLeftPercentage. On return contains the left microphone gain percentage.

  *  @param  aRightPercentage. On return contains the right microphone gain percentage.

  */

 EXPORT_C void CMMFDevSound::GetRecordBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage)

 	{

 	iBody->GetRecordBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *  CMMFDevSound::SetRecordBalanceL

  *

  *  Sets the microphone gain balance for recording.

  *

  *  The microphone gain balance can be changed before or during recording and

  *  is effective immediately.

  *

  *  @param  aLeftPercentage. Left microphone gain precentage. This can be any value between zero

  *          and 100. Setting a zero value mutes the gain on the left microphone.

  *  @param  aRightPercentage. Right microphone gain precentage. This can be any value between zero

  *          and 100. Setting a zero value mutes the gain on the right microphone

  */

 EXPORT_C void CMMFDevSound::SetRecordBalanceL(TInt aLeftPercentage,TInt aRightPercentage)

 	{

 	iBody->SetRecordBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *  CMMFDevSound::PlayInitL

  *

  *  Initializes audio device and starts the playback. Before playback can be

  *  started, its current client's access priority is first verified by the

  *  audio policy. In case of an error during the policy initialization, the

  *  PlayError() method will be called on the observer with KErrAccessDenied

  *  error code, otherwise BufferToBeFilled() method will be called with a

  *  buffer reference. After filling the buffer with the data, the client

  *  should call PlayData() to start playback.

  *

  *  The amount of data that can be played is specified in

  *  CMMFBuffer::RequestSize(). Any data that is read into the buffer beyond

  *  this size will be ignored.

  *

  */

 EXPORT_C void CMMFDevSound::PlayInitL()

 	{

 	iBody->PlayInitL();

 	}

 /*

  *  CMMFDevSound::RecordInitL

  *

  *  Initializes audio device and starts the recording. Before recording can be

  *  started, its current client's access priority is first verified by the

  *  audio policy. In case of an error during the policy initialization, the

  *  RecordError() method will be called on the observer with KErrAccessDenied

  *  error code, otherwise BufferToBeEmptied() method will be called with a

  *  buffer reference. This buffer contains recorded or encoded data. After

  *  processing the data in the buffer, the client should call RecordData()

  *  to continue recording process.

  *

  *  The amount of data that is available is specified in

  *  CMMFBuffer::RequestSize().

  *

  */

 EXPORT_C void CMMFDevSound::RecordInitL()

 	{

 	iBody->RecordInitL();

 	}

 /*

  *  CMMFDevSound::PlayData

  *

  *  Plays data in the buffer. The client should fill the buffer with a stream

  *  of sampled audio data before calling this method. The observer gets the

  *  reference to the buffer along with BufferToBeFilled() callback. When

  *  playing of the audio sample is complete, with success or not, the

  *  PlayError() method is called on the observer.

  */

 EXPORT_C void CMMFDevSound::PlayData()

 	{

 	iBody->PlayData();

 	}

 /*

  *  CMMFDevSound::RecordData

  *

  *  Records audio data. Once the buffer is filled with recorded sampled audio

  *  data, the observer gets reference to the buffer along with

  *  BufferToBeEmptied() callback. After processing of the buffer (copying over

  *  to a different buffer or writing to a file) the client should call this

  *  method again to continue recording process.

  */

 EXPORT_C void CMMFDevSound::RecordData()

 	{

 	iBody->RecordData();

 	}

 /*

  *  CMMFDevSound::Stop

  *

  *  Stops the ongoing operation (Play, Record, TonePlay)

  */

 EXPORT_C void CMMFDevSound::Stop()

 	{

 	iBody->Stop();

 	}

 /*

  *  CMMFDevSound::Pause

  *

  *  Temporarily suspends the ongoing operation (Play, Record, TonePlay)

  */

 EXPORT_C void CMMFDevSound::Pause()

 	{

 	iBody->Pause();

 	}

 /*

  *  CMMFDevSound::SamplesRecorded

  *

  *  Returns the number of recorded samples up to this point.

  *

  *  @return TInt

  *          Value representing recorded samples.

  */

 EXPORT_C TInt CMMFDevSound::SamplesRecorded()

 	{

 	return iBody->SamplesRecorded();

 	}

 /*

  *  CMMFDevSound::SamplesPlayed

  *

  *  Returns the number of played samples up to this point.

  *

  *  @return TInt

  *          Value representing played samples.

  */

 EXPORT_C TInt CMMFDevSound::SamplesPlayed()

 	{

 	return iBody->SamplesPlayed();

 	}

 /*

  *  CMMFDevSound::PlayToneL

  *

  *  Initializes audio device and starts playing a single tone according with

  *  the specified frequency and duration attributes.

  *

  *  @param  aFrequency. Frequency at with the tone will be played.

  *  @param  aDuration. The period over which the tone will be played. A zero value causes

  *          no tone to be played.

  */

 EXPORT_C void CMMFDevSound::PlayToneL(TInt aFrequency,const TTimeIntervalMicroSeconds& aDuration)

 	{

 	iBody->PlayToneL(aFrequency, aDuration);

 	}

 /*

  *  CMMFDevSound::PlayDualToneL

  *

  *  Initializes audio device and starts playing a dual tone.

  *  The tone consists of two sine waves of different frequencies summed

  *  together. Both frequencies and the duration are specified in the passed

  *  in attributes.

  *

  *  @param  aFrequencyOne. Value representing first frequency of the dual tone.

  *

  *  @param  aFrequencyTwo. Value representing second frequency of the dual tone.

  *

  *  @param  aDuration. The period over which the tone will be played. A zero value causes

  *          no tone to be played.

  */

 EXPORT_C void CMMFDevSound::PlayDualToneL(

 								TInt aFrequencyOne,

 								TInt aFrequencyTwo,

 								const TTimeIntervalMicroSeconds& aDuration)

 	{

 	iBody->PlayDualToneL(aFrequencyOne, aFrequencyTwo, aDuration);

 	}

 /*

  *  CMMFDevSound::PlayDTMFStringL

  *

  *  Initializes audio device and starts playing DTMF string.

  *

  *  @param  aDTMFString. DTMF sequence in a descriptor.

  */

 EXPORT_C void CMMFDevSound::PlayDTMFStringL(const TDesC& aDTMFString)

 	{

 	iBody->PlayDTMFStringL(aDTMFString);

 	}

 /*

  *  CMMFDevSound::PlayToneSequenceL

  *

  *  Initializes audio device and starts playing tone sequence.

  *

  *  @param  aData. Tone sequence in a descriptor.

  */

 EXPORT_C void CMMFDevSound::PlayToneSequenceL(const TDesC8& aData)

 	{

 	iBody->PlayToneSequenceL(aData);

 	}

 /*

  *  CMMFDevSound::PlayFixedSequenceL

  *

  *  Initializes audio device and starts playing the specified tone sequence.

  *

  *	Method is deprecated from OS release 9.5

  *

  *  @param  aSequenceNumber. The index identifying the specific pre-defined tone sequence. The

  *          index values are relative to zero. This can be any value between

  *          zero and the value returned by the call to

  *          CMdaAudioPlayerUtility::FixedSequenceCount() - 1. The function

  *          raises a panic if sequence number is out of range.

  */

 EXPORT_C void CMMFDevSound::PlayFixedSequenceL(TInt /*aSequenceNumber*/)

 	{

 	User::Leave(KErrNotSupported);

 	}

 /*

  *  CMMFDevSound::SetToneRepeats

  *

  *  Defines the number of times the audio is to be repeated during the tone

  *  playback operation.

  *

  *  A period of silence can follow each playing of tone. The tone playing can

  *  be repeated indefinitely.

  *

  *  @param  aRepeatCount. The number of times the tone, together with the trailing silence,

  *          is to be repeated. If this is set to KMdaRepeatForever, then the

  *          tone, together with the trailing silence, is repeated indefinitely

  *          or until Stop() is called. If this is set to zero, then the tone is

  *          not repeated.  Supported only during the tone playing.

  *  @param  aRepeatTrailingSilence. The duration of the trailing silence.

  */

 EXPORT_C void CMMFDevSound::SetToneRepeats(TInt aRepeatCount,const TTimeIntervalMicroSeconds& aRepeatTrailingSilence)

 	{

 	iBody->SetToneRepeats(aRepeatCount, aRepeatTrailingSilence);

 	}

 /*

  *  CMMFDevSound::SetDTMFLengths

  *

  *  Defines the duration of 'tone on/tone off' and 'tone pause' to be used

  *  during the DTMF playback.

  *

  *  Supported only during tone playing.

  *

  *  @param  aToneOnLength. The period over which the tone will be played. If this is set to

  *          zero, then the tone is not played.

  *

  *  @param  aToneOffLength. The period over which 'no tone' will be played.

  *

  *  @param  aPauseLength. The period over which the tone playing will be paused.

  */

 EXPORT_C void CMMFDevSound::SetDTMFLengths(

 									TTimeIntervalMicroSeconds32& aToneOnLength,

 									TTimeIntervalMicroSeconds32& aToneOffLength,

 									TTimeIntervalMicroSeconds32& aPauseLength)

 	{

 	iBody->SetDTMFLengths(aToneOnLength, aToneOffLength, aPauseLength);

 	}

 /*

  *  CMMFDevSound::SetVolumeRamp

  *

  *  Defines the period over which the volume level will rise smoothly from

  *  mute to the normal volume level.

  *

  *  @param  aRampDuration. The period over which the volume is to rise. A zero value causes

  *          the tone sample to be played at the normal level for the full duration of the 

  *          playback. A value, which is longer than the duration

  *          of the tone sample, will result in the sample never reaching its

  *          normal volume level.

  */

 EXPORT_C void CMMFDevSound::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

 	{

 	iBody->SetVolumeRamp(aRampDuration);

 	}

 /*

  *  CMMFDevSound::SetPrioritySettings

  *

  *  Defines the priority settings that should be used for this instance.

  *

  *  @param  aPrioritySettings. A structure representing client's priority, priority

  *          preference and the state.

  */

 EXPORT_C void CMMFDevSound::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)

 	{

 	iBody->SetPrioritySettings(aPrioritySettings);

 	}

 /*

  *  CMMFDevSound::CustomInterface

  *

  *  Sends request to the DevSound Server to start custom interface specified

  *  by the TUid attribute.

  *

  *  @param  aInterface. Unique ID of the custom interface

  *

  *  @return TAny*

  *          Pointer to the custom interface object.

  */

 EXPORT_C TAny* CMMFDevSound::CustomInterface(TUid aInterface)

 	{

 	return iBody->CustomInterface(aInterface);

 	}

 /*

  *  CMMFDevSound::FixedSequenceCount

  *

  *  Returns the number of available pre-defined tone sequences.

  *

  *	Method is deprecated from OS release 9.5

  *

  *  This is the number of fixed sequence supported by the DevSound by default.

  *

  *  @return TInt

  *          The fixed sequence count. This value is implementation dependent

  *          but is always greater than or equal to zero.

  */

 EXPORT_C TInt CMMFDevSound::FixedSequenceCount()

 	{

 	return 0;

 	}

 /*

  *  CMMFDevSound::FixedSequenceName

  *

  *  Returns the name assigned to a specific pre-defined tone sequence.

  *

  *	Method is deprecated from OS release 9.5

  *

  *  @param  aSequenceNumber. The index identifying the specific pre-defined tone sequence.

  *          Index values are relative to zero. This can be any value between

  *          zero and the value returned by the call to

  *          CMdaAudioPlayerUtility::FixedSequenceCount() - 1. The function

  *          raises a panic if sequence number is out of range.

  *

  *  @return TDesC&

  *          A reference to a descriptor containing fixed sequence name

  *          indexed by aSequenceNumber.

  */

 EXPORT_C const TDesC& CMMFDevSound::FixedSequenceName(TInt /*aSequenceNumber*/)

 	{

 	return KNullDesC;

 	}

 /*

  *  CMMFDevSound::GetSupportedInputDataTypesL

  *

  *  Returns a list of supported input data types that can be sent to the

  *  DevSound for playing audio.

  *

  *  @param  aSupportedDataTypes. An array of supported data types.

  *  @param  aPrioritySettings. Structure containing priority settings.

  */

 EXPORT_C void CMMFDevSound::GetSupportedInputDataTypesL(RArray<TFourCC>& aSupportedDataTypes,const TMMFPrioritySettings& aPrioritySettings) const

 	{

 	iBody->GetSupportedInputDataTypesL(aSupportedDataTypes,

 									aPrioritySettings);

 	}

 /*

  *  CMMFDevSound::GetSupportedOutputDataTypesL

  *

  *  Returns a list of supported output data types that can be received from

  *  the DevSound for recording audio.

  *

  *  @param  aSupportedDataTypes. An array of supported data types.

  *  @param aPrioritySettings. Structure containing priority settings.

  */

 EXPORT_C void CMMFDevSound::GetSupportedOutputDataTypesL(RArray<TFourCC>& aSupportedDataTypes,const TMMFPrioritySettings& aPrioritySettings) const

 	{

 	iBody->GetSupportedOutputDataTypesL(aSupportedDataTypes,aPrioritySettings);

 	}

 /********************************************************************************

  *				Non Exported public functions ends here		*					

  ********************************************************************************/

 /******************************************************************************

  *	Function Name:	E32Dll

  *	

  *	Description:	Entry point for applications.

  *

  ******************************************************************************/

 enum TDllReason {};

 EXPORT_C TInt E32Dll(TDllReason /*aReason*/)

 	{

 	return KErrNone;

 	}

 // CMMFDevSoundEventHandler::NewL() has been declared in export table

 // but since it is the only class method to be so, and .h is in source

 // it is not actually usable. Just declare the following to keep linker happy

 // Need dummy abstract type - this is not the real class

 class RMMFAudioPolicyProxy;

 class CMMFDevSoundEventHandler : public CActive

 	{

 public:

 	IMPORT_C static CMMFDevSoundEventHandler* NewL(RMMFAudioPolicyProxy*);

 private:

 	CMMFDevSoundEventHandler();

 	};

 EXPORT_C CMMFDevSoundEventHandler* CMMFDevSoundEventHandler::NewL(RMMFAudioPolicyProxy*)

 	{

 	_LIT(KModule, "DevSound");

 	User::Panic(KModule, 1000);

 	return NULL;

 	}

 // default constructor - keep compilers happy

 CMMFDevSoundEventHandler::CMMFDevSoundEventHandler():

 	CActive(EPriorityStandard)

 	{

 	}

 // End of File