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

 //

 #include <mmf/plugin/mmfhwdeviceimplementationuids.hrh>

 #include "SoundDeviceBody.h"

 #include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh> // KUidRefDevSoundTaskConfig

 const TInt KMaxMessageQueueItems = 8;

 /*

  *

  *	Default Constructor.

  *

  *	No default implementation. CMMFDevSound implements 2-phase construction.

  *

  */

 CMMFDevSoundClientImp::CMMFDevSoundClientImp()

 	{

 	}

 /*

  *

  *	Destructor.

  *

  *	Deletes all objects and releases all resource owned by this

  *	instance.

  *

  */

 CMMFDevSoundClientImp::~CMMFDevSoundClientImp()

 	{

 	// clear the array of custom interfaces

 	for (TInt i = 0; i < iCustomInterfaceArray.Count(); i++)

 		{

 		iCustomInterfaceArray[i].iInterface->Release();

 		}

 	iCustomInterfaceArray.Reset();

 	iCustomInterfaceArray.Close();

 	// delete the MUX utility

 	delete iMuxUtility;

 	if (iMsgQueueHandler && iMsgQueueHandler->IsActive())

 		{

 		iMsgQueueHandler->Cancel();

 		}

 	delete iMsgQueueHandler;

 	iMsgQueue.Close();	

 	if( iDevSoundProxy != NULL)

 		{

 		iDevSoundProxy->Close();

 		delete iDevSoundProxy;

 		}

 	}

 /*

  *

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

  *

  *	Leaves on failure.

  *

  */

 CMMFDevSoundClientImp* CMMFDevSoundClientImp::NewL()

 	{

 	CMMFDevSoundClientImp* self = new (ELeave) CMMFDevSoundClientImp();

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /*

  *

  *	2nd phase constructor - assumes that iParent has already been set up properly.

  *

  */

 void CMMFDevSoundClientImp::ConstructL()

 	{

 	// all these data properties should be NULL, but add ASSERTs to verify

 	ASSERT(iDevSoundProxy==NULL);

 	iDevSoundProxy = new (ELeave) RMMFDevSoundProxy();

 	TInt err = iMsgQueue.CreateGlobal(KNullDesC, KMaxMessageQueueItems);	// global, accessible to all that have its handle

 	User::LeaveIfError(err);

 	err = iDevSoundProxy->Open(iMsgQueue);

 	if(err)

 		{

 		delete iDevSoundProxy;

 		iDevSoundProxy = NULL;

 		}

 	User::LeaveIfError(err);

 	// create MUX utility

 	iMuxUtility = CMMFDevSoundCIMuxUtility::NewL(this);

 	}

 /*

  *

  *	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	"MDevSoundObserver& aDevSoundObserver"

  *			A reference to DevSound Observer instance.

  *

  *	@param	"TMMFState aMode"

  *			Mode for which this object will be used.

  *

  */

 void CMMFDevSoundClientImp::InitializeL(MDevSoundObserver& aDevSoundObserver, TMMFState aMode)

 	{

 	TInt initError = KErrNone;

 	iDevSoundObserver = &aDevSoundObserver;

 	initError = iDevSoundProxy->InitializeL(aMode);

 	if (initError)

 		{

 		User::Leave(initError);

 		}

 	if (iMsgQueueHandler)

 		{

 		iMsgQueueHandler->Cancel();

 		iMsgQueueHandler->SetObserver(*iDevSoundObserver);

 		}

 	else

 		{

 		iMsgQueueHandler = CMsgQueueHandler::NewL(iDevSoundProxy, *iDevSoundObserver, &iMsgQueue, *this);

 		}

 	iMsgQueueHandler->ReceiveEvents();

 	}

 /*

  *

  *	Configure CMMFDevSound object for the settings in aConfig.

  *

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

  *

  *	@param	"TMMFCapabilities& aConfig"

  *			Attribute values to which CMMFDevSound object will be configured to.

  *

  *  As part of defect 20796, the iRecordFormat has been set under the iPlayFormat, 

  *  before it was not set at all.

  *

  */

 void CMMFDevSoundClientImp::SetConfigL(const TMMFCapabilities& aConfig)

 	{

 	iDevSoundProxy->SetConfigL(aConfig);

 	}

 /*

  *

  *	Changes the current playback volume to a specified value.

  *

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

  *	immediately.

  *

  *	@param	"TInt aVolume"

  *			The volume setting. This can be any value from zero to the value

  *			returned by a call to CMdaAudioPlayerUtility::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.

  *

  */

 void CMMFDevSoundClientImp::SetVolume(TInt aVolume)

 	{

 	iDevSoundProxy->SetVolume(aVolume);

 	}

 /*

  *

  *	Changes the current recording gain to a specified value.

  *

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

  *	immediately.

  *

  *	@param	"TInt aGain"

  *			The volume setting. This can be any value from zero to the value

  *			returned by a call to CMdaAudioPlayerUtility::MaxVolume(). 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.

  *

  */

 void CMMFDevSoundClientImp::SetGain(TInt aGain)

 	{

 	iDevSoundProxy->SetGain(aGain);

 	}

 /*

  *

  *	Sets the speaker balance for playing.

  *

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

  *	effective immediately.

  *

  *	@param	"TInt& 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	"TInt& 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.

  *

  */

 void CMMFDevSoundClientImp::SetPlayBalanceL(TInt aLeftPercentage, TInt aRightPercentage)

 	{

 	iDevSoundProxy->SetPlayBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *

  *	Sets the microphone gain balance for recording.

  *

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

  *	is effective immediately.

  *

  *	@param	"TInt aLeftPercentage"

  *			Left microphone gain precentage. This can be any value from zero to

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

  *

  *	@param	"TInt aRightPercentage"

  *			Right microphone gain precentage. This can be any value from zero to

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

  *

  */

 void CMMFDevSoundClientImp::SetRecordBalanceL(TInt aLeftPercentage, TInt aRightPercentage)

 	{

 	iDevSoundProxy->SetRecordBalanceL(aLeftPercentage, aRightPercentage);

 	}

 /*

  *

  *	Initializes audio device and start play process. This method queries and

  *	acquires the audio policy before initializing audio device. If there was an

  *	error during policy initialization, PlayError() method will be called on

  *	the observer with error code KErrAccessDenied, otherwise BufferToBeFilled()

  *	method 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.

  *

  */

 void CMMFDevSoundClientImp::PlayInitL()

 	{

 	if (!iDevSoundObserver)

 		User::Leave(KErrNotReady);

 	iDevSoundProxy->PlayInitL();

 	}

 /*

  *

  *	Initializes audio device and start record process. This method queries and

  *	acquires the audio policy before initializing audio device. If there was an

  *	error during policy initialization, RecordError() method will be called on

  *	the observer with error code KErrAccessDenied, otherwise BufferToBeEmptied()

  *	method 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.

  *

  */

 void CMMFDevSoundClientImp::RecordInitL()

 	{

 	if (!iDevSoundObserver)

 		User::Leave(KErrNotReady);

 	iDevSoundProxy->RecordInitL();

 	}

 /*

  *

  *	Plays data in the buffer at the current volume. The client should fill

  *	the buffer with audio data before calling this method. The Observer gets

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

  *	the audio sample is complete, successfully or otherwise, the method

  *	PlayError() on observer is called.

  *

  */

 void CMMFDevSoundClientImp::PlayData()

 	{

 	ASSERT(iDevSoundObserver);

 	iDevSoundProxy->PlayData();

 	}

 /*

  *

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

  *

  */

 void CMMFDevSoundClientImp::Stop()

 	{

 	iDevSoundProxy->Stop();

 	}

 /*

  *

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

  *

  */

 void CMMFDevSoundClientImp::Pause()

 	{

 	iDevSoundProxy->Pause();

 	}

 /*

  *

  *	Returns the sample recorded so far.

  *

  *	@return "TInt"

  *			Returns the samples recorded.

  *

  */

 TInt CMMFDevSoundClientImp::SamplesRecorded()

 	{

 	return iDevSoundProxy->SamplesRecorded();

 	}

 /*

  *

  *	Returns the sample played so far.

  *

  *	@return "TInt"

  *			Returns the samples recorded.

  *

  */

 TInt CMMFDevSoundClientImp::SamplesPlayed()

 	{

 	return iDevSoundProxy->SamplesPlayed();

 	}

 /*

  *

  *	Initializes audio device and start playing tone. Tone is played with

  *	frequency and for duration specified.

  *

  *	Leaves on failure.

  *

  *	@param	"TInt aFrequency"

  *			Frequency at with the tone will be played.

  *

  *	@param	"TTimeIntervalMicroSeconds& 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).

  *

  */

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

 	{

 	iDevSoundProxy->PlayToneL(aFrequency, aDuration);

 	}

 /*

  *	Initializes audio device and start playing a dual tone. 

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

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

  *

  *	@param	"aFrequencyOne"

  *			First frequency of dual tone

  *

  *	@param	"aFrequencyTwo"

  *			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).

  */

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

 	{

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

 	}

 /*

  *

  *	Initializes audio device and start playing DTMF string aDTMFString.

  *

  *	Leaves on failure.

  *

  *	@param	"TDesC& aDTMFString"

  *			DTMF sequence in a descriptor.

  *

  */

 void CMMFDevSoundClientImp::PlayDTMFStringL(const TDesC& aDTMFString)

 	{

 	if (!iDevSoundObserver)

 		User::Leave(KErrNotReady);

 	iDevSoundProxy->PlayDTMFStringL(aDTMFString);

 	}

 /*

  *

  *	Initializes audio device and start playing tone sequence.

  *

  *	Leaves on failure.

  *

  *	@param	"TDesC8& aData"

  *			Tone sequence in a descriptor.

  *

  */

 void CMMFDevSoundClientImp::PlayToneSequenceL(const TDesC8& aData)

 	{

 	if (!iDevSoundObserver)

 		User::Leave(KErrNotReady);

 	iDevSoundProxy->PlayToneSequenceL(aData);

 	}

 /*

  *

  *	Initializes audio device and start playing the specified pre-defined tone

  *	sequence.

  *

  *	Leaves on failure.

  *

  *	@param	"TInt 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

  *			CMdaAudioPlayerUtility::FixedSequenceCount() - 1.

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

  *			range.

  *

  */

 void CMMFDevSoundClientImp::PlayFixedSequenceL(TInt aSequenceNumber)

 	{

 	if (!iDevSoundObserver)

 		User::Leave(KErrNotReady);

 	iDevSoundProxy->PlayFixedSequenceL(aSequenceNumber);

 	}

 /*

  *

  *	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	"TTimeIntervalMicroSeconds32& aToneOnLength"

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

  *			zero, then the tone is not played.

  *

  *	@param	"TTimeIntervalMicroSeconds32& aToneOffLength"

  *			The period over which the no tone will be played.

  *

  *	@param	"TTimeIntervalMicroSeconds32& aPauseLength"

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

  *

  */

 void CMMFDevSoundClientImp::SetDTMFLengths(TTimeIntervalMicroSeconds32& aToneOnLength,

 								TTimeIntervalMicroSeconds32& aToneOffLength,

 								TTimeIntervalMicroSeconds32& aPauseLength) 

 	{

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

 	}

 /*

  *

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

  *	nothing to the normal volume level.

  *

  *	@param	"TTimeIntervalMicroSeconds& 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, that the sample never reaches its normal

  *			volume level.

  *

  *

  */

 void CMMFDevSoundClientImp::SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration)

 	{

 	iDevSoundProxy->SetVolumeRamp(aRampDuration);

 	}

 /**

  *	@see sounddevice.h

  */

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

 	{

 	iDevSoundProxy->GetSupportedInputDataTypesL(aSupportedDataTypes, aPrioritySettings);

 	}

 /**

  *	@see sounddevice.h

  */

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

 	{

 	iDevSoundProxy->GetSupportedOutputDataTypesL(aSupportedDataTypes, aPrioritySettings);

 	}

 /**

  *	@see sounddevice.h

  */

 TInt CMMFDevSoundClientImp::SetClientThreadInfo(TThreadId aTid)

 	{

 	return iDevSoundProxy->SetClientThreadInfo(aTid);

 	}

 TInt CMMFDevSoundClientImp::RegisterAsClient(TUid aEventType, const TDesC8& aNotificationRegistrationData)

 	{

 	return iDevSoundProxy->RegisterAsClient(aEventType,aNotificationRegistrationData);

 	}

 TInt CMMFDevSoundClientImp::CancelRegisterAsClient(TUid aEventType)

 	{

 	return iDevSoundProxy->CancelRegisterAsClient(aEventType);

 	}

 TInt CMMFDevSoundClientImp::GetResourceNotificationData(TUid aEventType,TDes8& aNotificationData)

 	{

 	return iDevSoundProxy->GetResourceNotificationData(aEventType,aNotificationData);

 	}

 TInt CMMFDevSoundClientImp::WillResumePlay()

 	{

 	return iDevSoundProxy->WillResumePlay();

 	}

 TInt CMMFDevSoundClientImp::EmptyBuffers()

 	{

 	return iDevSoundProxy->EmptyBuffers();

 	}

 TInt CMMFDevSoundClientImp::GetTimePlayed(TTimeIntervalMicroSeconds& aTime)

 	{

 	return iDevSoundProxy->GetTimePlayed(aTime);

 	}

 /*

  *

  *	Returns a given Custom Interface on the DevSound based on the UID

  *  If this is not recognised then the custominterface is created by

  *  a pair of ECOM plugins.

  *

  *  @released

  *  @param	"TUid aInterfaceId"

  *			The UID of the required Custom Interface

  *  @return a pointer to the custom interface

  *

  */

 TAny* CMMFDevSoundClientImp::CustomInterface(TUid aInterfaceId)

 	{

 	// check if this UID refers to auto/pause/resume

 	if (aInterfaceId == KMmfUidDevSoundAudioResourceCustomInterface)

 		{

 		MAutoPauseResumeSupport* result = this; 

 		return result;

 		}

 	if (aInterfaceId == KMmfUidDevSoundEmptyBuffersCustomInterface)

 		{

 		MMMFDevSoundEmptyBuffers* result = this; 

 		return result;

 		}		

 	if (aInterfaceId == KMmfUidDevSoundAudioClientThreadInfoCustomInterface)

 		{

 		MAudioClientThreadInfo* result = this;

 		return result;

 		}

 	if (aInterfaceId == KMmfUidDevSoundTimePlayedCustomInterface)

 		{

 		MMMFDevSoundTimePlayed* result = this;

 		return result;

 		}	

 	// we are being asked for a Custom Interface not natively supported 

 	// by the DevSound plugin.  

 	// first check if we already have resolved a custom interface of this type

 	TInt index = FindCustomInterface(aInterfaceId);

 	MMMFDevSoundCustomInterfaceMuxPlugin* ptr = NULL;

 	// if we found the interface, take a copy of this instead

 	if (index != KNullHandle)

 		{

 		// check our index is valid

 		ptr = iCustomInterfaceArray[index-1].iInterface;

 		if (ptr)		

 			{

 			return ptr->CustomInterface(aInterfaceId);

 			}

 		else

 			{

 			// we may not need this code because this 

 			// *should* be impossible to reach

 			return NULL;

 			}

 		}

 	else

 		{

 		// else try and instantiate a plugin tunnelling

 		// pair to support this Custom Interface

 		TRAPD(err, ptr = iMuxUtility->CreateCustomInterfaceMuxL(aInterfaceId));

 		if (ptr && (err == KErrNone))

 			{

 			TMMFDevSoundCustomInterfaceData data;

 			data.iInterface = ptr;

 			data.iId = aInterfaceId;

 			// attempt to open remote demux

 			// this will store a handle in the mux plugin if successful

 			// and also return it here - invalid handle = -1

 			data.iHandle = ptr->OpenInterface(aInterfaceId);

 			// if the handle is greater than zero then we know we have

 			// successfully opened the interface

 			if (data.iHandle > KNullHandle)

 				{	

 				// append this to the current interface list

 				TInt err = KErrNone;

 				err = iCustomInterfaceArray.Append(data);

 				if (err == KErrNone)

 					{

 					// return the custom interface on the ptr

 					return ptr->CustomInterface(aInterfaceId);

 					}

 				}

 				// no memory or other problem so shut down interface

 				ptr->Release();

 				ptr = NULL;

 			}

 		}

 		// if code gets here then we don't support the interface

 		// so we can pass it onto the DevSound proxy so that we 

 		// can attempt to resolve the interface externally

 		return iDevSoundProxy->CustomInterface(aInterfaceId);	

 	}

 TInt CMMFDevSoundClientImp::FindCustomInterface(TUid aInterfaceId)

 	{

 	TInt index = KNullHandle;

 	for (TInt i = 0; i < iCustomInterfaceArray.Count(); i++)

 		{

 		if (iCustomInterfaceArray[i].iId == aInterfaceId)

 			{

 			index = i+1; // use index+1 as the handle, so 0 is undefined/not-found

 			break;

 			}

 		}

 	return index;

 	}

 void CMMFDevSoundClientImp::CloseCustomInterface(TInt aIndex)

 	{

 	for (TInt i = 0; i < iCustomInterfaceArray.Count(); i++)

 		{

 		if(iCustomInterfaceArray[i].iHandle == aIndex)

 			{

 			iCustomInterfaceArray[i].iInterface->Release();	

 			iCustomInterfaceArray.Remove(i);

 			break;

 			}

 		}

 	}