// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifndef __SOUNDDEVICE_H__

#define __SOUNDDEVICE_H__

#include <e32base.h>

#include <f32file.h>

#include <mmf/common/mmfbase.h>

#include <mmf/common/mmfutilities.h>

#include <mmf/common/mmfcontroller.h>

//Debugging info

/*

Notes: 

This file defines the DevSound class which acts as an interface to

the hardware and is intended to invoke VCR functionality via the plug-ins.

The DevSound also contains a product specific policy.

*/

//UIDs for buffers: According to Symbian: Not used

// Public Media Server includes

/**

@publishedAll

@released

Sampling rates available.

When queried from DevSound by calling the function Capabilities(), iRate indicates

the sampling rates supported by the audio device.

DevSound by default is configured to 8KHz sampling rate.

So to configure DevSound to play/record audio at 16 KHz sampling rate:

The mode should not be OR'ed with each other, only single values are accepted. 

*/

enum TMMFSampleRate

	{

  	/** 8000 Hz Sampling Rate

	*/

	EMMFSampleRate8000Hz  = 0x00000001,

  	/** 11025 Hz Sampling Rate

	*/

	EMMFSampleRate11025Hz = 0x00000002,

  	/** 16000 Hz Sampling Rate

	*/

	EMMFSampleRate16000Hz = 0x00000004,

  	/** 22050 Hz Sampling Rate

	*/

	EMMFSampleRate22050Hz = 0x00000008,

  	/** 32000 Hz Sampling Rate

	*/

	EMMFSampleRate32000Hz = 0x00000010,

  	/** 44100 Hz Sampling Rate

	*/

	EMMFSampleRate44100Hz = 0x00000020,

  	/** 48000 Hz Sampling Rate

	*/

	EMMFSampleRate48000Hz = 0x00000040,

  	/** 88200 Hz Sampling Rate

	*/

	EMMFSampleRate88200Hz = 0x00000080,

  	/** 96000 Hz Sampling Rate

	*/

	EMMFSampleRate96000Hz = 0x00000100,

  	/** 12000 Hz Sampling Rate

	*/

	EMMFSampleRate12000Hz = 0x00000200,

  	/** 24000 Hz Sampling Rate

	*/

	EMMFSampleRate24000Hz = 0x00000400,

  	/** 64000 Hz Sampling Rate

	*/

	EMMFSampleRate64000Hz = 0x00000800

	};

/**

@publishedAll

@released

Mono Stereo playback and record modes available.

When queried from DevSound by calling the function Capabilities(), iChannels

indicates whether the underlying audio device supports playing back stereo

audio samples and recording audio samples in stereo mode or not.

DevSound by default is configured to Mono mode.

So to configure DevSound to play/record audio sample in stereo mode:

The mode should not be OR'ed with each other, only single values are accepted. 

*/

enum TMMFMonoStereo

	{

	/** Mono mode

	*/

	EMMFMono	= 0x00000001,

	/** Stereo mode

	*/

	EMMFStereo	= 0x00000002

	};

/**

@publishedAll

@released

Encoding modes available.

When queried from DevSound by calling the function Capabilities(), iEncoding

provides information about different encoding supported by audio device.

DevSound by default is configured to play PCM16 Bit audio data.

Setting encoding mode is not supported yet:

*/

enum TMMFSoundEncoding

	{

  	/** Signed 8 Bit PCM

	*/

	EMMFSoundEncoding8BitPCM		= 0x00000001,

  	/** Signed 16 Bit PCM

	*/

	EMMFSoundEncoding16BitPCM		= 0x00000002,

  	/** Signed 8 Bit ALaw

	*/

	EMMFSoundEncoding8BitALaw		= 0x00000004,

  	/** Signed 8 Bit MuLaw

	*/

	EMMFSoundEncoding8BitMuLaw		= 0x00000008,

	};

/**

@publishedAll

@released

Stereo support enum.

*/

enum TMMFStereoSupport

	{

	/** No stereo support

	*/

	EMMFNone						= 0x00000000,

	/** Interleaved stereo support

	*/

	EMMFInterleavedOnly				= 0x00000001,

	/** Non Interleaved stereo support

	*/

	EMMFNonInterleavedOnly			= 0x00000002,

	/** Interleaved and Non Interleaved stereo support

	*/

	EMMFBothNonAndInterleaved		= 0x00000003,

 	/** Joint stereo support

 	*/

 	EMMFJoint						= 0x00000004

	};

/**

@publishedAll

@released

Type class for DevSound implementation device capabilities.

CMMFDevSound will return Sampling Rates, Encoding and Stereo feature

supported in this structure when queried for capabilities. DevSound can

also be configured by setting parameters in this structure and passing the

structure to it.

*/

class TMMFCapabilities

	{

public:

	/** Sampling Rates supported

	*/

	TUint	iRate;

	/** Encodings supported

	*/

	TUint	iEncoding;

	/** Mono/Stereo support

	*/

	TUint	iChannels;

	/** Buffer size supported

	*/

	TInt	iBufferSize;

	};

/**

@publishedAll

@released

An interface to a set of DevSound 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 MDevSoundObserver

	{

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 or convert.

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

	playing or converting. 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 or converting.

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

	while recording or converting. 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 or converted) 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 conversion completion or cancel event.

	A derived class must provide an implementation to handle the conversion

	completion or cancel request.

	CMMFDevSound object calls this function when an attempt to convert data from

	source format to destination format has completed, successfully or otherwise.

	@param  aError

	        Error code. KErrCancel conversion operation is cancelled. KErrNone

	        conversion is complete. Other values are possible indicating a

	        problem converting data.

	*/

	virtual void ConvertError(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;

	/**

	Handles policy request completion event.

	A derived class must provide an implementation to handle the policy request

	completion event.

	CMMFDevSound object calls this function when an attempt to acquire sound

	device is rejected by audio policy server.

	@param	aEvent

			Not used

	*/

	inline virtual void SendEventToClient(const TMMFEvent& aEvent);

	};

/**

@publishedAll

@released

This is the interface from Symbian OS to the raw audio functions on the

device hardware.

DevSound is currently loaded as a DLL, and implements the VCR-type

functions to be expected for such an interface.

The audio functions include the following functionality:

- Initialisation and configuration of hardware devices, for example, setting microphone gain, 

setting setero balance and so on.

- The playing and recording of raw audio data.

- The playing and dynamic control of tones with user specified frequencies.

- The playing of DTMF strings.

*/

class CMMFDevSound : public CBase

	{

public:

	/**

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

	Leaves on failure.

	*/

	IMPORT_C static CMMFDevSound* NewL();

	/**

	Destructor.

	Deletes all objects and releases all resource owned by this

	instance.

	*/

	IMPORT_C ~CMMFDevSound();

	/**

	Initializes CMMFDevSound object to play and record PCM16 raw audio data

	with sampling rate of 8 KHz.

	On completion of Initialization, calls InitializeComplete() on

	aDevSoundObserver.

	Leaves on failure.

	@param  aDevSoundObserver

	        A reference to DevSound Observer instance.

	@param  aMode

	        The mode for which this object will be used. Any value other than EMMFStatePlaying, EMMFStateRecording or EMMFStateTonePlaying is unsupported. 

	*/

    IMPORT_C void InitializeL(MDevSoundObserver& aDevSoundObserver, TMMFState aMode);

	/**

	Initializes DevSound object for the mode aMode for processing audio data

	with hardware device aHWDev.

	On completion of Initialization, the observer will be notified via call back

	InitializeComplete().

	Leaves on failure.

	@param  aDevSoundObserver

	        A reference to DevSound Observer instance.

	@param  aHWDev

	        The CMMFHwDevice implementation identifier.

	@param  aMode

	        The mode for which this object will be used. Any value other than EMMFStatePlaying, EMMFStateRecording or EMMFStateTonePlaying is unsupported.

   	*/

	IMPORT_C void InitializeL(MDevSoundObserver& aDevSoundObserver, TUid aHWDev, TMMFState aMode);

	/**

	Initializes DevSound object for the mode aMode for processing audio data

	with hardware device supporting FourCC aDesiredFourCC.

	On completion of Initialization, the observer will be notified via call back

	InitializeComplete().

	Leaves on failure.

	@param  aDevSoundObserver

	        A reference to DevSound Observer instance.

	@param  aDesiredFourCC

	        The CMMFHwDevice implementation FourCC code.

	@param  aMode

	        The mode for which this object will be used. Any value other than EMMFStatePlaying, EMMFStateRecording or EMMFStateTonePlaying is unsupported.

    */

	IMPORT_C void InitializeL(MDevSoundObserver& aDevSoundObserver, TFourCC aDesiredFourCC, TMMFState aMode);

	/**

	Returns the supported Audio settings ie. encoding, sample rates, mono/stereo operation, buffer 

	size etc.

	@return	The device settings.

	*/

	IMPORT_C TMMFCapabilities Capabilities();

	/**

	Returns the current device configuration.

	@return	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.

	@param  aCaps

	        The attribute values to which CMMFDevSound object will be configured to.

	*/

	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.

	@return	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.

	@return 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.

	@param  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.

	*/

	IMPORT_C void SetVolume(TInt aVolume);

	/**

	Returns an integer representing the maximum gain the device supports.

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

	@return 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.

	@return 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.

	@param  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.

	*/

	IMPORT_C void SetGain(TInt aGain);

	/**

	Returns the speaker balance set for playing.

	Leaves on failure.

	@param  aLeftPercentage

	        On return contains the left speaker volume percentage.

	@param  aRightPercentage

	        On return contains the right speaker volume percentage.

	*/

	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.

	@param  aLeftPercentage

	        On return contains left speaker volume perecentage. This can be any

	        value from zero to 100. Setting a zero value mutes the sound on left

	        speaker.

	@param  aRightPercentage

	        On return contains right speaker volume perecentage. This can be any

	        value from zero to 100. Setting a zero value mutes the sound on

	        right speaker.

	*/

	IMPORT_C void SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage);

	/**

	Returns the microphone gain balance set for recording.

	Leaves on failure.

	@param  aLeftPercentage

	        On return contains the left microphone gain percentage.

	@param  aRightPercentage

	        On return contains the right microphone gain percentage.

	*/

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

	/**

	Sets the microphone gain balance for recording.

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

	is effective immediately.

	@param  aLeftPercentage

	        The left microphone gain precentage. This can be any value from zero to

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

	@param  aRightPercentage

	        The right microphone gain precentage. This can be any value from zero to

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

	*/

	IMPORT_C void SetRecordBalanceL(TInt aLeftPercentage, TInt aRightPercentage);

	/**

	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.

	@see    MDevSoundObserver::PlayError()

	@see    MDevSoundObserver::BufferToBeFilled()

	*/

	IMPORT_C void PlayInitL();

	/**

	Initializes audio device and starts the recording process. 

	This function queries and acquires the audio policy before initializing audio device. If there 

	was an error during policy initialization, RecordError() function will be called on the observer 

	with error code KErrAccessDenied, otherwise BufferToBeEmptied()	function will be called with a 

	buffer reference. This buffer contains recorded	or encoded data. After processing data in the 

	buffer reference passed, the client should call RecordData() to continue recording process.

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

	Leaves on failure.

	@see    MDevSoundObserver::RecordError() 

	@see    MDevSoundObserver::BufferToBeEmptied()

	@capability	UserEnvironment

			For recording - the requesting client process must have the 

			UserEnvironment capability.

	*/

	IMPORT_C void RecordInitL();

	/**

	Plays data in the buffer at the current volume. 

	The client should fill the buffer with audio data before calling this function. The observer gets

	a reference to the buffer along with the callback function BufferToBeFilled(). When playing of

	the audio sample is complete, successfully or otherwise, the function PlayError() on the

	observer is called.

	The last buffer of the audio stream being played should have the last buffer flag set using

	CMMFBuffer::SetLastBuffer(TBool). If a subsequent attempt to play the clip is made, this flag 

	will need resetting by the client.

	@see    MDevSoundObserver::PlayError()

	*/

	IMPORT_C void PlayData();

	/**

	Contine the process of recording. 

	Once the buffer is filled with recorded	data, the Observer gets a reference to the buffer along 

	with the callback function BufferToBeEmptied(). After processing the buffer (copying over to a

	different buffer or writing to file) the client should call this function to continue the 

	recording process.

	@capability	UserEnvironment

			For recording - the requesting client process must have the 

			UserEnvironment capability.

	*/

	IMPORT_C void RecordData();

	/**

	Stops the ongoing operation (Play, Record, TonePlay, Convert).

	This function should be synchronous and invoke no callbacks through MDevSoundObserver.

	*/

	IMPORT_C void Stop();

	/**

	Temporarily Stops the ongoing operation (Play, Record, TonePlay, Convert).

	The behaviour of Pause() is currently undefined when the initialisation mode

	is not EMMFStateRecording, consequently different DevSound implementations exhibit

	different behaviour for pause during play.  For this reason, it is recommended that

	when pausing of audio during playing is required, Stop() is used instead of the call

	to Pause(). To resume audio playing after Stop(), call PlayInitL(). Among other things,

	this will internally reset the SamplesPlayed() result and the calling code may need to

	remember the previous result to give the correct "samples played from start" value.

	In the case of record, Pause is taken to mean halt any further recording

	but continue to call the MDevSoundObserver::BufferToBeEmptied() passing

	already recorded buffers. The last buffer flag should be set when

	all recorded buffers have been flushed.

	@see CMMFDevSound::Stop()

	@see CMMFDevSound::PlayInitL()

	@see CMMFDevSound::SamplesPlayed()

	*/

	IMPORT_C void Pause();

	/**

	Returns the number samples recorded so far.

	@return The samples recorded.

	*/

	IMPORT_C TInt SamplesRecorded();

	/**

	Returns the number of samples played so far.

	@return The samples played.

	*/

	IMPORT_C TInt SamplesPlayed();

	/**

	Initializes the audio device and starts playing a tone. The tone is played with the

	frequency and duration specified.

	Leaves on failure.

	@param  aFrequency

	        The frequency at which the tone will be played.

	@param  aDuration

	        The period over which the tone will be played. A zero value causes

	        the no tone to be played.

	*/

	IMPORT_C void PlayToneL(TInt aFrequency, const TTimeIntervalMicroSeconds& aDuration);

	/**

	Initializes audio device and starts playing a dual tone.

	The generated tone consists of two sine waves of different frequencies

	summed together.

	Dual Tone is played with the specified frequencies and for the specified duration.

	@param  aFrequencyOne

	        The first frequency of dual tone.

	@param  aFrequencyTwo

	        The second frequency of dual tone

	@param  aDuration

	        The period over which the tone will be played. A zero value causes

	        the no tone to be played (Verify this with test app).

	*/

	IMPORT_C void PlayDualToneL(TInt aFrequencyOne, TInt aFrequencyTwo, const TTimeIntervalMicroSeconds& aDuration);

	/**

	Initializes the audio device and starts playing the DTMF string aDTMFString.

	Leaves on failure.

	@param  aDTMFString

	        The DTMF sequence in a descriptor.

	*/

	IMPORT_C void PlayDTMFStringL(const TDesC& aDTMFString);

	/**

	Initializes the audio device and starts playing a tone sequence.

	Leaves on failure.

	@param  aData

	        The tone sequence in a descriptor.

	*/

	IMPORT_C void PlayToneSequenceL(const TDesC8& aData);

	/**

	Initializes the audio device and starts playing the specified pre-defined tone

	sequence.

	Leaves on failure.

	@param  aSequenceNumber

	        The index identifying the specific pre-defined tone sequence. Index

	        values are relative to zero.

	        This can be any value from zero to the value returned by a call to

			FixedSequenceCount() - 1.

	        The function raises a panic if the sequence number is not within this

	        range.

	@see	FixedSequenceCount()

	*/

	IMPORT_C void PlayFixedSequenceL(TInt aSequenceNumber);

	/**

	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 a 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.

	@param  aRepeatTrailingSilence

	        An interval of silence which will be played after each tone.

	        Supported only during tone playing.

	*/

	IMPORT_C void SetToneRepeats(TInt aRepeatCount,

					const TTimeIntervalMicroSeconds& aRepeatTrailingSilence);

	/**

	Defines the duration of tone on, tone off and tone pause to be used during the

	DTMF tone playback operation.

	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 the no tone will be played.

	@param  aPauseLength

	        The period over which the tone playing will be paused.

	*/

	IMPORT_C void SetDTMFLengths(TTimeIntervalMicroSeconds32& aToneOnLength,

									TTimeIntervalMicroSeconds32& aToneOffLength,

									TTimeIntervalMicroSeconds32& aPauseLength);

	/**

	Defines the period over which the volume level is to rise smoothly from

	nothing to the normal volume level.

	The function is only available while the tone is playing.

	@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 means that the sample never reaches its normal

	        volume level.

	*/

	IMPORT_C void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

	/**

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

	@param  aPrioritySettings

	        A class type representing the client's priority, priority preference and state.

	*/

	IMPORT_C void SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings);

	/**

	Retrieves a custom interface to the device.

	@param  aInterfaceId

	        The interface UID, defined with the custom interface.

	@return A pointer to the interface implementation, or NULL if the device does not

	        implement the interface requested. The return value must be cast to the

	        correct type by the user.The user should be careful while caching the custom interface pointer,

	        as in some situations the lower level custom interface pointer may become NULL.

	*/

	IMPORT_C TAny* CustomInterface(TUid aInterfaceId);

	/**

	Returns the number of available pre-defined tone sequences.

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

	@return The fixed sequence count. This value is implementation dependent but is always greater 

	        than or equal to zero.

	*/

	IMPORT_C TInt FixedSequenceCount();

	/**

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

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

	The function raises a panic if sequence number specified is invalid.

	@param  aSequenceNumber

	        The index identifying the specific pre-defined tone sequence. Index values are relative 

	        to zero. This can be any value from zero to the value returned by a call to

	        FixedSequenceCount() - 1.

	        The function raises a panic if sequence number is not within this

	        range.

	@return A reference to a Descriptor containing the fixed sequence name indexed by

	        aSequenceNumber.

	@see	FixedSequenceCount()

	*/

	IMPORT_C const TDesC& FixedSequenceName(TInt aSequenceNumber);

	/**

	Returns a list of the supported input datatypes that can be sent to DevSound for playing audio.

	The datatypes returned are those that the DevSound supports given the priority settings passed

	in aPrioritySettings.

	Note that if no supported data types are found this does not constitute failure, the function will

	return normally with no entries in aSupportedDataTypes.

	@param  aSupportedDataTypes

	        The array of supported data types that will be filled in by this function.

	        The supported data types of the DevSound are in the form of an array

	        of TFourCC codes. Any existing entries in the array will be overwritten on 

	        calling this function. If no supported data types are found given the priority 

	        settings, then the aSupportedDatatypes array will have zero entries.

	@param  aPrioritySettings

	        The priority settings used to determine the supported datatypes.  Note this

	        does not set the priority settings. For input datatypes the iState member

	        of the priority settings would be expected to be either

	        EMMFStatePlaying or EMMFStatePlayingRecording. The priority settings may

	        effect the supported datatypes depending on the audio routing.

	*/

	IMPORT_C void GetSupportedInputDataTypesL(RArray<TFourCC>& aSupportedDataTypes, const TMMFPrioritySettings& aPrioritySettings) const;

	/**

	Returns a list of the supported output dataypes that can be received from DevSound for

	recording audio.  The datatypes returned are those that the DevSound supports given the priority 

	settings passed in aPrioritySettings.

	Note that if no supported data types are found this does not constitute failure, the function will 

	return normally with no entries in aSupportedDataTypes.

	@param  aSupportedDataTypes

	        The array of supported data types that will be filled in by this function.

	        The supported datatypes of the DevSound are in the form of an array

	        of TFourCC codes.

	        Any existing entries in the array will be overwritten on calling this function.

	        If no supported datatypes are found given the priority settings, then

	        the aSupportedDatatypes array will have zero entries.

	@param  aPrioritySettings

	        The priority settings used to determine the supported data types.  Note this

	        does not set the priority settings. For output data types the iState member

	        of the priority settings would expected to be either

	        EMMFStateRecording or EMMFStatePlayingRecording. The priority settings may

	        effect the supported datatypes depending on the audio routing.

	*/

	IMPORT_C void GetSupportedOutputDataTypesL(RArray<TFourCC>& aSupportedDataTypes, const TMMFPrioritySettings& aPrioritySettings) const;

	/** 

	Registers the client for notification of resource avalibility.

	@param  aEventType

	        The Notification event type for which the client needs notification.

	@param  aNotificationRegistrationData

	        The Notification Registration data has been reserved for future use and its value should be always NULL

	@return An error code indicating if the function call was successful. KErrNone on success, 

			KErrNotSupported if the event type is not supported, KErrArgument if the notification data

			is not null otherwise another of the system-wide error codes.

	*/

	inline TInt RegisterAsClient(TUid aEventType, const TDesC8& aNotificationRegistrationData = KNullDesC8);

	/**

	Cancels the Registered Notification.

	@param  aEventType

	        The Event type need to cancel

	@return An error code indicating if the function call was successful. KErrNone on success, KErrNotSupported

			if the event type is not supported otherwise another of the system-wide error codes.

	*/	

	inline TInt CancelRegisterAsClient(TUid aEventType);

	/**

	Returns the Notification data which the client needs to resume playing.

	@param aEventType

	       The Event type for which to get notification data  

	@param aNotificationData

			The reference data for which the client needs to resume the play. The actual data depends on the event type.

			Note that for the event type 'KMMFEventCategoryAudioResourceAvailable' the package buffer returned

			is TMMFTimeIntervalMicroSecondsPckg,but the contents should be converted to an integer and

			interpreted as the data returned is samples played ,but not as a microsecond value.

	@return An error code indicating if the function call was successful. KErrNone on success, otherwise

	        another of the system-wide error codes.

	*/

	inline TInt GetResourceNotificationData(TUid aEventType,TDes8& aNotificationData);