/*

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

*

*/

#ifndef MMFDEVSOUNDADAPTATION_H

#define MMFDEVSOUNDADAPTATION_H

//  INCLUDES

#include <mmf/server/sounddevice.h>

#include <a3f/a3f_trace_utils.h>

// CLASS FORWARD

class MGlobalProperties;

const TInt KCallbackNone 				= 0;

const TInt KCallbackProcessingFinished	= 1;

const TInt KCallbackProcessingUnitError	= 2;

const TInt KCallbackRecordPauseComplete	= 3;

const TInt KCallbackAutoPauseResume 	= 4; 

const TInt KCallbackFlushComplete		= 5;

// CLASS DECLARATION

/**

@publishedAll

@released

An interface to a set of DevSound adaptation observer callback functions.

This serves as the method of communication between the client and the

DevSound.

The class is a mixin and is intended to be inherited by the client class

that is interested in observing the DevSound operation. The functions

encapsulated by this class are called when specific events occur in the

process of initializing and playing/recording an audio sample or playing

tones.

*/

class MDevSoundAdaptationObserver

	{

	public:

	/**

	Handles initialization completion event.

	A derived class must provide an implementation to handle the initialization

	request.

	CMMFDevSound object calls this function when its InitializeL() function

	completes.

	@param  aError

			Error code. KErrNone if successful. Other values are possible

			indicating a problem initializing CMMFDevSound object.

	*/

	virtual void InitializeComplete(TInt aError)=0;

	/**

	Handles tone play completion event.

	A derived class must provide an implementation to handle the tone play

	completion request.

	CMMFDevSound object calls this function when an attempt to play tone has

	completed, successfully or otherwise.

	The following are the play tone functions; PlayToneL(), PlayDMTFStringL(),

	PlayToneSequenceL(), and PlayFixedSequenceL().

	@param  aError

			Error code. The status of tone playback. KErrUnderflow playing of

			the tone is complete. KErrAccessDenied the sound device is in use by

			another higher priority client. KErrCancel playing of the audio

			sample is stopped by DevSound client another higher priority client.

	*/

	virtual void ToneFinished(TInt aError)=0;

	/**

	Handles CMMFDevSound object's data request event.

	A derived class must provide an implementation to supply CMMFDevSound

	object the data that it needs to play.

	CMMFDevSound object calls this function when and where it needs data for

	playing. The observer should notify CMMFDevSound object as

	quickly as possible after the data is read into buffer, aBuffer by calling

	PlayData(), otherwise the implementation might callback function PlayError()

	on derived class object with error code KErrUnderflow.

	This does not apply to the very first call to PlayData(), however.

	It is possible for a user of DevSound to hold the first buffer sent in

	BufferToBeFilled() until ready to play.

	The use case for this is if a low latency audio response

	is required, as at this point all the resources used to play audio are open.

	If used in this way then it is important to be aware that when when the

	resources for audio are ready at the BufferToBeFilled() callback, a Devsound

	on a real device will be running at increased power consumption as the audio

	hw and any required DSPs will be powered up etc.

	@param  aBuffer

			Buffer into which data should be read. The amount of data that is

			needed is specified in CMMFBuffer::RequestSize().

	*/

	virtual void BufferToBeFilled(CMMFBuffer* aBuffer)=0;

	/**

	Handles play completion or cancel event.

	A derived class must provide an implementation to handle the play

	completion or cancel request.

	CMMFDevSound object calls this function when an attempt to play audio sample

	has completed, successfully or otherwise.

	@param  aError

			Error code. The status of playback. KErrUnderflow playing of the

			audio sample is complete. KErrAccessDenied the sound device is in

			use by another higher priority client.

	*/

	virtual void PlayError(TInt aError)=0;

	/**

	Handles CMMFDevSound object's data request event.

	A derived class must provide an implementation to process the data

	supplied by CMMFDevSound object while recording.

	CMMFDevSound object calls this function when the buffer, aBuffer gets filled

	while recording. The observer should notify CMMFDevSound

	object as quickly as possible after data in the buffer is processed by

	calling RecordData(), otherwise the implementation might callback

	the function RecordError() on derived class object with error code KErrOverflow.

	@param  aBuffer

			Buffer containing processed (recorded) data. The amount

			of data that is available is specified in CMMFBuffer::RequestSize().

	*/

	virtual void BufferToBeEmptied(CMMFBuffer* aBuffer)=0;

	/**

	Handles record completion or cancel event.

	A derived class must provide an implementation to handle the record

	completion or cancel request.

	CMMFDevSound object calls this function when an attempt to record audio sample

	has completed, successfully or otherwise.

	@param  aError

			Error code. The status of recording. KErrOverflow audio devices

			runs out of internal buffer. KErrAccessDenied the sound device is

			in use by another higher priority client.

	*/

	virtual void RecordError(TInt aError)=0;

	/**

	Handles device event.

	A derived class must provide an implementtion to handle the messages from

	audio hardware device.

	CMMFDevSound object calls this function when a message is received from the

	audio hardware device.

	@param  aMessageType

			Defines the type of message. Used to determine how to

			interpret the contents of aMsg.

	@param  aMsg

			Message that is packed in the Descriptor format.

	*/

	virtual void DeviceMessage(TUid aMessageType, const TDesC8& aMsg)=0;

	/**

	A derived class must provide an implementation to handle the low layer operation completion

	@param	aError	The status of operation in progress

	@param	aCanStartNewOperation	If EFalse indicates that the operation has more than a cycle

	*/

	virtual void AsynchronousOperationComplete(TInt aError, TBool aCanStartNewOperation) = 0;

	/**

	Underlying interface has been (or is about to be) deleted.

	Implementations will generally cancel outstanding messages

	@param	aInterfaceId	Uid of the Interface which has been deleted

	*/

	virtual void InterfaceDeleted(TUid aInterfaceId) = 0;

	/*

	Underlying physical adaptation has sent a callback that will result either on a commit

	and need to scheduled or in the case of RecordPauseComplete, completes the message.

	@param aType the callback type

	@param aError KErrNone if successful, else corresponding error

		code

	*/

	virtual void CallbackFromAdaptorReceived(TInt aType, TInt aError) = 0;

	/*

	Underlying physical adaptation has sent a callback indicating that a preemption process 

 	has started, any incomming commands will be queued during the preemption.  

	*/

	virtual void PreemptionStartedCallbackReceived() = 0;

	/*

	Underlying physical adaptation has sent a callback indicating that a preemption process

	has finished. Queued commands during preemption can now be processed. 

	@param	aCanStartNewOperation	If EFalse indicates that the operation has more than a cycle

	*/

	virtual void PreemptionFinishedCallbackReceived(TBool aCanStartNewOperation) = 0;

	/*

	 * The adaptor has control of the context.

	 * @return returns True if the adaptor is the entity responsible for calling Commit()

	 */

	virtual TBool AdaptorControlsContext() const = 0;

	/*

	 * Callback indicating that a clash with pre-emption has occurred during the commit cycle

	 * and to push the current request that was being processed onto front of queue.

	 */

	virtual void PreemptionClash() = 0;

	/*

	 * Callback indicating the clash with pre-emption during the commit cycle was with state change,

	 * so the current request that was previously pushed onto the front of queue should be removed

	 * without processing.

	 */

	virtual void PreemptionClashWithStateChange() = 0;

	/*

	 * Callback to indicate an error has been noticed. This is to be cached until subsequent

	 * AsynchronousOperationComplete(), and handled then if needs.

	 */

	virtual void NotifyError(TInt aError) = 0;

	};

// CLASS DECLARATION

/**

@publishedAll

@released

* This class implements DevSound behavior in a hardware independent way.

*

*  @lib MmfDevSoundAdaptation.lib

*  @since

*/

class CMMFDevSoundAdaptation : public CBase

{

public:  // Constructors and destructor

	/**

	* Constructs, and returns a pointer to, a new CMMFDevSoundAdaptation

	* object.

	* Leaves on failure..

	* @param MDevSoundAdaptationObserver& aDevSoundObserver A reference to DevSound

	*        Observer instance.

	* @param MGlobalPrpoerties a reference to Audio Server global properties

	* @return CMMFDevSoundAdaptation* A pointer to newly created object.

	*/

	IMPORT_C static CMMFDevSoundAdaptation* NewL(MDevSoundAdaptationObserver& aDevSoundObserver,

														MGlobalProperties& aGlobalProperties);

	/**

	* Destructor.

	*/

	IMPORT_C virtual ~CMMFDevSoundAdaptation();

public: // New functions

	/*

	2nd phase open.

	Async open - if returns successfully, then will result in AsynchronousOperationComplete()

	*/

	IMPORT_C void PostOpenL();

	/**

	* Initializes to raw audio data PCM16 and Sampling Rate of 8 KHz.

	* On completion of Initialization, calls InitializeComplete() on

	* aDevSoundObserver.

	* Leaves on failure.

	* @since

	* @param MDevSoundAdaptationObserver& aDevSoundObserver A reference to DevSound

	*        Observer instance.

	* @param TMMFState aMode Mode for which this object will be used.

	* @return void

	*/

	IMPORT_C void InitializeL(TMMFState aMode);

	/**

	* Initializes DevSound object for the mode aMode for processing audio

	* data with hardware device aHWDev.

	* On completion of Initialization, calls InitializeComplete() on

	* aDevSoundObserver.

	* Leaves on failure.

	* @since

	* @param MDevSoundAdaptationObserver& aDevSoundObserver A reference to DevSound

	*        Observer instance.

	* @param TUid aHWDev The CMMFHwDevice implementation identifier.

	* @param TMMFState aMode The mode for which this object will be used

	* @return void

	*/

	IMPORT_C void InitializeL(TUid aHWDev,

							  TMMFState aMode);

	/**

	* Initializes DevSound object for the mode aMode for processing audio

	* data with hardware device supporting FourCC aDesiredFourCC.

	* Leaves on failure.

	* @since

	* @param MDevSoundAdaptationObserver& aDevSoundObserver A reference to DevSound

	*        Observer instance.

	* @param TFourCC aDesiredFourCC The CMMFHwDevice implementation FourCC

	*        code.

	* @param TMMFState aMode The mode for which this object will be used

	* @return KErrNone if successfull, else corresponding error code

	* @return void

	*/

	IMPORT_C void InitializeL(TFourCC aDesiredFourCC,

							  TMMFState aMode);

	/**

	* Cancels the initialization of a DevSound object.

	* @since

	* @return An error code indicating if the function call was successful.

	*   	  KErrNone on success,

	*		  KerrNotReady if this is called before InitializeL() call or after

	*		  the object has been initialized,

	*/

	IMPORT_C TInt CancelInitialize();

	/**

	* Returns the supported Audio settings ie. encoding, sample rates,

	* mono/stereo operation, buffer size etc..

	* @since

	* @return TMMFCapabilities The device settings.

	*/

	IMPORT_C TInt Capabilities(TMMFCapabilities& aCap);

	/**

	* Returns the current device configuration.

	* @since

	* @return TMMFCapabilities The device settings.

	*/

	IMPORT_C TMMFCapabilities Config() const;

	/**

	* Configure CMMFDevSound object with the settings in aConfig. Use this

	* to set sampling rate, encoding and mono/stereo.

	* Leaves on failure.

	* @since

	* @param const TMMFCapabilities& aConfig The attribute values to which

	*        CMMFDevSound object will be configured to.

	* @return void

	*/

	IMPORT_C void SetConfigL(const TMMFCapabilities& aCaps);

	/**

	* Returns an integer representing the maximum volume device supports.

	* This is the maximum value which can be passed to

	* CMMFDevSound::SetVolume.

	* @since

	* @return TInt The maximum volume. This value is platform dependent but

	*        is always greater than or equal to one.

	*/

	IMPORT_C TInt MaxVolume();

	/**

	* Returns an integer representing the current volume.

	* @since

	* @return TInt The current volume level.

	*/

	IMPORT_C TInt Volume();

	/**

	* Changes the current playback volume to a specified value. The volume

	* can be changed before or during playback and is effective immediately.

	* @since

	* @param TInt aVolume The volume setting. This can be any value from 0

	*        to the value returned by a call to

	*        CMMFDevSound::MaxVolume(). If the volume is not

	*        within this range, the volume is automatically set

	*        to minimum or maximum value based on the value

	*        that is being passed. Setting a zero value mutes

	*        the sound. Setting the maximum value results in

	*        the loudest possible sound.

	* @param aAsyncCompletion Returns ETrue to say the call is asynchronous, with result sent

	*        to AsynchronousOperationComplete()

	* @return KErrNone if successful, otherwise system-wide error code

	*/

	IMPORT_C TInt SetVolume(TInt aVolume, TBool& aAyncCompletion);

	/**

	* Returns an integer representing the maximum gain the device supports.

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

	* @since

	* @return TInt The maximum gain. This value is platform dependent but is

	*        always greater than or equal to one.

	*/

	IMPORT_C TInt MaxGain();

	/**

	* Returns an integer representing the current gain.

	* @since

	* @return TInt The current gain level.

	*/

	IMPORT_C TInt Gain();

	/**

	* Changes the current recording gain to a specified value. The gain can

	* be changed before or during recording and is effective immediately.

	* @since

	* @param TInt aGain The gain setting. This can be any value from zero to

	*        the value returned by a call to

	*        CMMFDevSound::MaxGain(). If the volume

	*        is not within this range, the gain is automatically

	*        set to minimum or maximum value based on the value

	*        that is being passed. Setting a zero value mutes the

	*        sound. Setting the maximum value results in the

	*        loudest possible sound.

	* @param aAsyncCompletion Returns ETrue to say the call is asynchronous, with result sent

	*        to AsynchronousOperationComplete()

	* @return KErrNone if successful, otherwise system-wide error code

	*/

	IMPORT_C TInt SetGain(TInt aGain, TBool& aAyncCompletion);

	/**

	* Returns the speaker balance set for playing.

	* Leaves on failure.

	* @since

	* @param TInt &aLeftPercentage On return contains the left speaker

	*        volume percentage.

	* @param TInt &aRightPercentage On return contains the right speaker

	*        volume percentage.

	* @return void

	*/

	IMPORT_C void GetPlayBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage);

	/**

	* Sets the speaker balance for playing. The speaker balance can be

	* changed before or during playback and is effective immediately.

	* Leaves on failure.

	* @since

	* @param TInt aLeftPercentage The left speaker volume percentage. This

	*        can be any value from zero to 100. Setting

	*        a zero value mutes the sound on left

	*        speaker.

	* @param TInt aRightPercentage The right speaker volume percentage.

	*        This can be any value from zero to 100.

	*        Setting a zero value mutes the sound on

	*        right speaker.

	* @param aAsyncCompletion Returns ETrue to say the call is asynchronous, with result sent

	*        to AsynchronousOperationComplete()

	* @return void

	*/

	IMPORT_C void SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage, TBool& aAyncCompletion);

	/**

	* Returns the microphone gain balance set for recording.

	* Leaves on failure.

	* @since

	* @param TInt &aLeftPercentage On return contains the left microphone

	*        gain percentage.

	* @param TInt &aRightPercentage On return contains the right microphone

	*        gain percentage.

	* @return void

	*/

	IMPORT_C void GetRecordBalanceL(TInt& aLeftPercentage, TInt& aRightPercentage);

	/**

	* Sets the microphone balance for recording. The microphone balance can

	* be changed before or during recording and is effective immediately.

	* Leaves on failure.

	* @since

	* @param TInt aLeftPercentage The left microphone gain percentage. This

	*        can be any value from zero to 100. Setting

	*        a zero value mutes the sound from left

	*        microphone.

	* @param TInt aRightPercentage The right microphone gain percentage.

	*        This can be any value from zero to 100.

	*        Setting a zero value mutes the sound from

	*        right microphone.

	* @param aAsyncCompletion Returns ETrue to say the call is asynchronous, with result sent

	*        to AsynchronousOperationComplete()

	* @return void

	*/

	IMPORT_C void SetRecordBalanceL(TInt aLeftPercentage, TInt aRightPercentage, TBool& aAyncCompletion);

	/**

	* Initializes the audio device and starts the play process. This

	* function queries and acquires the audio policy before initializing

	* audio device. If there was an error during policy initialization,

	* PlayError() function will be called on the observer with error code

	* KErrAccessDenied, otherwise BufferToBeFilled() function will be called

	* with a buffer reference. After reading data into the buffer reference

	* passed, the client should call PlayData() to play data.

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

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

	* this size will be ignored.

	* Leaves on failure.

	* @since

	* @return void

	*/

	IMPORT_C void PlayInitL();

	/**

	* Initializes the audio device and starts the record process. This

	* function queries and acquires the audio policy before initializing