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

 // DevSoundSessionBody.h

 // 

 //

 #ifndef MMFDEVSOUNDSESSIONBODY_H

 #define MMFDEVSOUNDSESSIONBODY_H

 #include <e32base.h>

 #include <mmf/server/mmfhwdevice.h>

 #include "MmfDevSoundSession.h"

 #include "MmfDevSoundSessionXtnd.h"

 #include "ToneGenerator.h"

 #include "mmfAudioPolicyProxy.h"

 #include "MmfDevSoundInfo.h"

 #include "DevSoundUtility.h"

 #ifdef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER

 	#include "mdasoundadapter.h"

 #else

 	#include <mdasound.h>

 #endif

 #include <mmf/server/devsoundstandardcustominterfaces.h>

 //controlls buffer sizes

 const TInt KDevSoundDefaultFrameSize = 0x1000;

 const TInt KDevSoundMinFrameSize = 0x800; //2K

 const TInt KDevSoundMaxFrameSize = 0x4000;  //16K

 const TInt KDevSoundDeltaFrameSize = 0x800; //2K

 const TInt KDevSoundFramesPerSecond = 4;

 //Forward references:

 class CDevSoundPlayer;

 class CDevSoundError;

 class CDevSoundRecorder;

 class CDevSoundRecordError;

 class CMMFDevSoundProxyXtnd;

 class CMMFHwDevice;

 class CMMFHwDeviceObserver;

 class MPlayCustomInterface;

 class MRecordCustomInterface;

 class MEmptyBuffersCustomInterface;

 class MTimePlayedCustomInterface;

 /*

  *

  *	Reference internals for CMMFDevSound

  *  @internalComponent

  *

  */

 class CMMFDevSoundSvrImp;

 NONSHARABLE_CLASS( CMMFDevSoundSvrImp ) : public CBase, public MMMFHwDeviceObserver, 

 										  public MMMFDevSoundCustomInterfaceTarget

 	{

 public:

 	static CMMFDevSoundSvrImp* NewL(CMMFDevSoundSessionXtnd* aParent);

 	~CMMFDevSoundSvrImp();

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

 	void InitializeL(MDevSoundObserver& aDevSoundObserver, TMMFState aMode);

 	// Initializes with hardware device and mode (play, record, convert)

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

 	// Initializes with hardware device associated with specific FourCC code 

 	// and desired mode (play, record, convert)

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

 	// Returns device capabilities

 	TMMFCapabilities Capabilities();

 	// Returns device configuration

 	TMMFCapabilities Config() const;

 	// Sets device configuration

 	void SetConfigL(const TMMFCapabilities& aCaps);

 	// Returns maximum play volume device supports

 	TInt MaxVolume();

 	// Returns play volume device is configured to

 	TInt Volume();

 	// Sets device play volume

 	void SetVolume(TInt aVolume);

 	// Returns maximum record gain device supports

 	TInt MaxGain();

 	// Returns record gain device is configured to

 	TInt Gain();

 	// Sets device record gain

 	void SetGain(TInt aGain);

 	// Returns play balance

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

 	// Sets play balance

 	void SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage);

 	// Returns record balance

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

 	// Sets record balance

 	void SetRecordBalanceL(TInt aLeftPercentage, TInt aRightPercentage);

 	// Initializes audio device and start play process

 	void PlayInitL();

 	// Initializes audio device and start record process

 	void RecordInitL(const RMmfIpcMessage& aMessage);

 	// Plays the data in the buffer

 	TBool PlayData(const RMmfIpcMessage& aMessage);

 	// Records data into buffer

 	TBool RecordData(const RMmfIpcMessage& aMessage);

 	// Stops the ongoing operation

 	void Stop();

 	// Tempororily Stops the ongoing operation

 	void Pause();

 	// Returns the Sample recorded so far

 	TInt SamplesRecorded();

 	// Returns the Sample played so far

 	TInt SamplesPlayed();

 	// Initializes device and start playing tone

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

 	// Initializes device and start playing dual tone

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

 	// Initializes device and start playing DTMF String

 	void PlayDTMFStringL(const TDesC& aDTMFString);

 	// Initializes device and start playing tone sequence

 	void PlayToneSequenceL(const TDesC8& aData);

 	// Initializes device and start playing fixed sequence

 	void PlayFixedSequenceL(TInt aSequenceNumber);

 	// Sets tone repeat attributes

 	void SetToneRepeats(TInt aRepeatCount,

 					const TTimeIntervalMicroSeconds& aRepeatTrailingSilence);

 	// Sets DTMF tone attributes

 	void SetDTMFLengths(TTimeIntervalMicroSeconds32& aToneOnLength,

 									TTimeIntervalMicroSeconds32& aToneOffLength,

 									TTimeIntervalMicroSeconds32& aPauseLength);

 	// Sets volume ramp for playing

 	void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

 	// Sets priority settings

 	void SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings);

 	// Provides interface for sending custom commands for the audio device

 	virtual TAny* CustomInterface(TUid aInterfaceId);

 	// Provides interface for querying fixed sequence count

 	TInt FixedSequenceCount();

 	// Provides interface for querying fixed sequence name

 	const TDesC& FixedSequenceName(TInt aSequenceNumber);

 	// Gets the supported input datatypes

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

 	// Gets the supported output datatypes

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

 	// Interface for Audio Policy

 	// Sets id for this DevSound instance

 	void SetDevSoundId(TInt aDevSoundId);

 	// Returns info about this DevSound instance

 	TMMFDevSoundInfo DevSoundInfo();

 	// Called by Audio Policy Server when play reqeust is granted

 	void StartPlayDataL();

 	// Called by Audio Policy Server when record reqeust is granted

 	void StartRecordDataL();

 	// Called by Audio Policy Server when play tone reqeust is granted

 	void StartPlayToneL();

 	// Called by Audio Policy Server when play dual tone request is granted

 	void StartPlayDualToneL();

 	// Called by Audio Policy Server when play DTMF reqeust is granted

 	void StartPlayDTMFStringL();

 	// Called by Audio Policy Server when play tone sequence reqeust is granted

 	void StartPlayToneSequenceL();

 	// Called by Audio Policy Server when DevSound instance looses device

 	void SendEventToClient(const TMMFEvent& aEvent);

 	// Updates the total bytes played from audio device

 	void UpdateBytesPlayed();

 	// CMMFHwDevice implementation:

 	TInt FillThisHwBuffer(CMMFBuffer& aHwBuffer);

 	TInt EmptyThisHwBuffer(CMMFBuffer& aHwBuffer);

 	TInt MsgFromHwDevice(TUid aMessageType, const TDesC8& aMsg);

 	void Stopped();

 	void Error(TInt aError);

 	// CMMFHwDevice implementation ends

 	//provides interface for register a notification event

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

 	//provides interface to cancel the registered notification

 	TInt CancelRegisterAsClient(TUid aEventType);

 	//Gets the notification data for client to resume

 	TInt GetResourceNotificationData(TUid aEventType, TDes8& aNotificationData);

 	//waits for the client to resume playback even after the timeout expires

 	TInt WillResumePlay();

 	//Empties the buffers below DevSound without causing the codec to be deleted

 	TInt EmptyBuffers();

 	TInt GetTimePlayed(TTimeIntervalMicroSeconds& aTime);

 	// CustomCommand implementation - this bit knows it is server side

 	void DoSyncCustomCommandL(const RMmfIpcMessage& aMessage);

 	void DoSyncCustomCommandResultL(const RMmfIpcMessage& aMessage);

 	void DoAsyncCustomCommandL(const RMmfIpcMessage& aMessage);

 	void DoAsyncCustomCommandResultL(const RMmfIpcMessage& aMessage);

 private:

 	// So that nobody can extend 

 	CMMFDevSoundSvrImp(CMMFDevSoundSessionXtnd* aParent);

 	// Second phase constructor

 	void Construct3L(RServer2& aPolicyServerHandle);

 	void PreInitializeL();

 	// Initializes format based on format supported

 	TInt InitializeFormat(RMdaDevSound::TSoundFormatsSupportedBuf& aSupportedFormat,

 		RMdaDevSound::TCurrentSoundFormatBuf& aFormat);

 	// Request Policy

 	void RequestPolicy();

 	// Play tone

 	void DoPlayL();

 	// Sets active tone

 	void SetActiveToneBuffer();

 	// Fills free tone buffer with tone data

 	TInt FillFreeToneBuffer();

 	// Updates the state of audio policy based on the audio policy settings

 	TInt UpdatePolicyState(TMMFAudioPolicyState aNewState);

 	// HwDevice implementation begins

 	TInt InitTask();

 	// Returns Sampling Frequency the device is currently configured to

 	TInt SamplingFrequency();

 	// Returns number of channels the device is currently configured to

 	TInt NumberOfChannels();

 	//returns the number of bytes in each audio sample

 	TInt BytesPerAudioSample();

 	// HwDevice implementation ends

 	TInt SetDeviceVolume(TInt aVolume);

 	TInt SetPlayFormat(RMdaDevSound::TCurrentSoundFormatBuf& aPlayFormat);

 	TInt SetRecordFormat(RMdaDevSound::TCurrentSoundFormatBuf& aRecordFormat);

 	TInt SetDeviceRecordLevel(TInt aGain);

 	TInt SetDeviceVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

 public:

 	enum TMMFDevSoundState

 		{

 		/** Idle state.

 		*/

 		EMMFDevSoundStateIdle,

 		/** The DevSound is currently playing.

 		*/

 		EMMFDevSoundStatePlaying,

 		/** The DevSound is playing a tone.

 		*/

 		EMMFDevSoundStateTonePlaying,

 		/** The DevSound is currently recording.

 		*/

 		EMMFDevSoundStateRecording,

 		/** The DevSound is playing and recording.

 		*/

 		EMMFDevSoundStatePlayingRecording,

 		/** The DevSound is converting data.

 		*/

 		EMMFDevSoundStateConverting

 		};                

 private:

 	CMMFDevSoundSessionXtnd& iParent;	

 	//Objects (owned or referred to):

 	RMMFAudioPolicyProxy*	iAudioPolicyProxy;

 	CMMFAudioPolicyRequest*	iAudioPolicyRequest;

 	MDevSoundObserver*		iDevSoundObserver;

 	// Handles receiving events

 	CMMFDevSoundEventHandler* iDevSoundEventHandler;

 	//WINS Sound Device Structures

 	RMdaDevSound::TSoundFormatsSupportedBuf iPlayFormatsSupported;

 	RMdaDevSound::TCurrentSoundFormatBuf	iPlayFormat;

 	RMdaDevSound::TSoundFormatsSupportedBuf iRecordFormatsSupported;

 	RMdaDevSound::TCurrentSoundFormatBuf	iRecordFormat;

 	// DevSound capabilities

 	TMMFCapabilities		iDeviceCapabilities;

 	// Current Configuration

 	TMMFCapabilities		iDeviceConfig;

 	// AudioPolicy priority used to communicate with server

 	TMMFAudioPolicyPrioritySettings	iAudioPolicyPrioritySettings;

 	MPlayCustomInterface* iPlayCustomInterface;

 	MRecordCustomInterface* iRecordCustomInterface;

 	// Bytes of audio data played in current play cycle

 	TInt					iPlayedBytesCount;

 	TInt					iGain;

 	TInt					iVolume;

 	TMMFDevSoundInfo		iDevSoundInfo;

 	//Tone Stuff:

 	MMdaToneSynthesis*			iCurrentGenerator;

 	TMdaSimpleToneGenerator		iToneGen;

 	TMdaDualToneGenerator		iDualToneGen;

 	TMdaDTMFGenerator			iDTMFGen;

 	TMdaSequenceGenerator		iSequenceGen; // Not Supported

 	TInt						iRepeatCount;

 	TTimeIntervalMicroSeconds	iRepeatTrailingSilence;

 	TTimeIntervalMicroSeconds	iRampDuration;

 	// Double buffer tone playing

 	CMMFDataBuffer*				iToneBuffer1;

 	CMMFDataBuffer*				iToneBuffer2;

 	// Reference to current tone buffer playing

 	CMMFDataBuffer*				iActiveToneBuffer;

 	// Hardware device implementation

 	CMMFHwDevice*				iCMMFHwDevice;

 	// Mode in which DevSound instance will be used for

 	TMMFDevSoundState			iMode;

 	// Reference to hardware buffer

 	CMMFDataBuffer*				iHwDeviceBuffer;

 	TBool						iLastBufferReceived;

 	// Holds true of Audio data given to DevSound needs to ramped up

 	CMMFDevSoundUtility*		iDevSoundUtil;

 	// Fixed sequence related

 	CPtrC8Array*				iFixedSequences;	// Holds the fixed sequence data

 	TPtrC8						iFixedSequence;		// Holds reference to current sequence

 	// Balance

 	TInt						iLeftPlayBalance;

 	TInt						iRightPlayBalance;

 	TInt						iLeftRecordBalance;

 	TInt						iRightRecordBalance;

 	TBool						iPaused;

 	TUid                        iHwDeviceID;

 	// Hardware device initialization parameters

 	THwDeviceInitParams			iDevInfo;

 	TBool                      iFirstCallFromHwDevice;

 	TBool 						iFourCCSet;

 	TFourCC						iSrcFourCC;

 	TFourCC						iDestFourCC;

 	TBool						iHasPolicy;

 	MTimePlayedCustomInterface* iTimePlayedCustomInterface;

 	TTimeIntervalMicroSeconds	iTimePlayed;

 	friend class CMMFDevSoundSession;

 	};

 #include "MmfDevSoundSessionBody.inl"

 #endif // MMFDEVSOUNDSESSIONBODY__H