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