// Copyright (c) 2005-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 <mmfbase.h>

 #include <bttypes.h>

 #include "MMFBtRoutingSoundDevice.h"

 // Sound drivers

 _LIT(KPddFileName,"ESDRV.PDD");

 _LIT(KLddFileName,"ESOUND.LDD");

 EXPORT_C CRoutingSoundPlayDevice* CRoutingSoundPlayDevice::NewL()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CRoutingSoundPlayDevice::ConstructL()

 	{

 	}

 CRoutingSoundPlayDevice::CRoutingSoundPlayDevice()

 	{

 	}

 EXPORT_C CRoutingSoundPlayDevice::~CRoutingSoundPlayDevice()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (iSpeakerDevice.Handle() > 0)

 			{

 			iSpeakerDevice.Close();

 			}

 		}

 	else

 		{

 		iBTDevice.Close();

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::Initialize(	TUid aDeviceUid,

 													const TDesC8& aDeviceConfig,

 													TRequestStatus& aStatus)

 	{

 	TInt err = KErrNone;

 	iDeviceUid = aDeviceUid;

 	iInitializeStatus = &aStatus;

 	if (iDeviceUid == KDeviceUidA2dpHeadset)

 		{

 		// Connect to the Bluetooth client

 		err = iBTDevice.Connect();

 		if (!err)

 			{

 			// Get the Bluetooth device's address using the descriptor

 			iBTAddress = TBTDevAddr(aDeviceConfig);

 			// Initialize

 			iBTDevice.Initialize(iBTAddress, *iInitializeStatus);

 			}

 		else

 			{

 			// Failed to connect

 			User::RequestComplete(iInitializeStatus, err);

 			}

 		}

 	else if ((iDeviceUid == KDeviceUidSpeaker)||(iDeviceUid == KDeviceUidMic))

 		{

 		// aDeviceConfig must be NULL to reach here (see 5.1 of design doc)

 		// Load the drivers

 		// Try to load the audio physical driver

 	    err = User::LoadPhysicalDevice(KPddFileName);

 		if ((err == KErrNone) || (err == KErrAlreadyExists))

 			{

 		    // Try to load the audio logical driver

 			err = User::LoadLogicalDevice(KLddFileName);

 		    }

 		if (err == KErrAlreadyExists)

 			{

 			// It's not a problem if the drivers have already

 			// been loaded so reset the error code accordingly

 			err = KErrNone;

 			}

 		// Completed to load the drivers so signal

 		User::RequestComplete(iInitializeStatus, err);

 		}

 	else

 		{

 		// Unexpected Uid

 		User::RequestComplete(iInitializeStatus, KErrNotSupported);

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::CancelInitialize(TUid aDeviceUid)

 	{

 	if (aDeviceUid == iDeviceUid)

 		{//can only cancel bt headset initialize

 		if (aDeviceUid == KDeviceUidA2dpHeadset)

 			{

 			iBTDevice.CancelInitialize();

 			}

 		if (iInitializeStatus && *iInitializeStatus == KRequestPending)

 			{

 			User::RequestComplete(iInitializeStatus, KErrCancel);				

 			}		

 		}

 	}

 /**

  *	OpenDevice() is used when a specific client needs a handle to the sound

  *	device and is called after permission has been given by the policy server.

  *	TODO - what's the required behaviour when calling OpenDevice repeatedly

  *	(without calling CloseDevice in between) - prevent it (as now by checking the 

  *	handle) or just return the KErrInUse code?

  *	TODO:

  *	Check differences in behaviour: RMdaDevSound must be Opened before any "Set"

  *	calls can be made on it, whereas BT headset's settings can be changed

  *	after it has been initialized but before it's been opened.

  */

 EXPORT_C void CRoutingSoundPlayDevice::OpenDevice(	TUid aDeviceUid,

 													TRequestStatus& aStatus)

 	{

 	iOpenDeviceStatus = &aStatus;

 	if (aDeviceUid == KDeviceUidSpeaker)

 		{

 		TInt error = KErrNone;

 		if (!Handle())

 			{

 			error = iSpeakerDevice.Open();

 			if ((!error)||(error == KErrAlreadyExists))

 				{

 				error = KErrNone;//swallow KErrAlreadyExists

 				//update the configuration here ignore error

 				//it'll get picked up below if not opened due to error

 				RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 				iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 				soundDeviceSettings().iEncoding = RMdaDevSound::EMdaSoundEncoding16BitPCM;

 				if (iSampleRate)

 					{

 					soundDeviceSettings().iRate = iSampleRate;

 					}

 				if (iChannels)

 					{

 					soundDeviceSettings().iChannels = iChannels;

 					}

 				//tell sound driver what buffer size to expect

 				//it is up the the implementor to make use the device can support

 				//the required buffer size

 				if (iBufferSize)

 					{	

 					soundDeviceSettings().iBufferSize = iBufferSize;

 					}

 				error = iSpeakerDevice.SetPlayFormat(soundDeviceSettings);

 				if (error)

 					{

 					iSpeakerDevice.Close();

 					}

 				}

 			}

 		User::RequestComplete(iOpenDeviceStatus, error);

 		}

 	else if (aDeviceUid == KDeviceUidA2dpHeadset)

 		{

 		iBTDevice.OpenDevice(*iOpenDeviceStatus);

 		}

 	else

 		{

 		User::RequestComplete(iOpenDeviceStatus, KErrNotSupported);

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::CancelOpenDevice(TUid aDeviceUid)

 	{

 	if (aDeviceUid == iDeviceUid)

 		{

 		if (aDeviceUid != KDeviceUidA2dpHeadset)

 			{

 			if(Handle() > 0)

 			 	{

 			 	iSpeakerDevice.Close();

 			 	}

 			}

 		else

 			{

 			iBTDevice.CancelOpenDevice();

 			}

 		if (iOpenDeviceStatus && *iOpenDeviceStatus == KRequestPending)

 			{

 			User::RequestComplete(iOpenDeviceStatus, KErrCancel);				

 			}		

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::CloseDevice(TUid aDeviceUid, TRequestStatus& aStatus)

 	{

 	if (aDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		aStatus = KRequestPending;

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.Close();

 			}

 		TRequestStatus* status = &aStatus;

 		User::RequestComplete(status, KErrNone);

 		}

 	else

 		{

 		iCloseDeviceStatus = &aStatus;

 		iBTDevice.CloseDevice(*iCloseDeviceStatus);

 		}

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::GetSupportedDataTypes(RArray<TFourCC>& aSupportedDataTypes)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TSoundFormatsSupportedBuf formats;

 			iSpeakerDevice.PlayFormatsSupported(formats);

 			// Only PCM16 is supported (what about unsigned PCM16 and big-endian versions?)

 			err = aSupportedDataTypes.Append(KMMFFourCCCodePCM16);

 			if (!err)

 				{

 				aSupportedDataTypes.Reset();

 				}

 			}

 		else

 			{

 			err = KErrNotReady;

 			}

 		}

 	else

 		{

 		TRAP(err, iBTDevice.GetSupportedDataTypesL(aSupportedDataTypes));

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::GetSupportedSampleRates(RArray<TUint>& aSupportedDiscreteRates,

 																RArray<TRange>& aSupportedRateRanges)

 	{

 	TInt err = KErrNone;

 	aSupportedDiscreteRates.Reset();

 	aSupportedRateRanges.Reset();

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TSoundFormatsSupportedBuf formatsSupported;

 			iSpeakerDevice.PlayFormatsSupported(formatsSupported);

 			TRange range;

 			range.iLow = formatsSupported().iMinRate;

 			range.iHigh = formatsSupported().iMaxRate;

 			err = aSupportedRateRanges.Append(range);

 			if (err != KErrNone)

 				{

 				aSupportedRateRanges.Reset();

 				}

 			}

 		else

 			{

 			err = KErrNotReady;

 			}

 		}

 	else

 		{

 		TRAP(err, iBTDevice.GetSupportedSampleRatesL(aSupportedDiscreteRates,

 													aSupportedRateRanges);)

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::GetSupportedChannels(RArray<TUint>& aSupportedChannels,

 															TMMFStereoSupport& aStereoSupport)

 	{

 	TInt err = KErrNone;

 	aSupportedChannels.Reset();

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 			iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 			//1 = mono 2 = stereo

 			err = aSupportedChannels.Append(soundDeviceSettings().iChannels);

 			if (soundDeviceSettings().iChannels != 2)

 				{

 				// No stereo support

 				aStereoSupport = EMMFNone;

 				}

 			else

 				{

 				aStereoSupport = EMMFBothNonAndInterleaved;

 				}

 			}

 		else

 			{

 			err = KErrNotReady;

 			}

 		}

 	else

 		{

 		TRAP(err, iBTDevice.GetSupportedChannelsL(aSupportedChannels, aStereoSupport));

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::SetDataType(const TFourCC& aDataType)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			if (aDataType == KMMFFourCCCodePCM16)

 				{

 				// Section 5 of design doc => only PCM16 is supported

 				RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 				iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 				soundDeviceSettings().iEncoding = RMdaDevSound::EMdaSoundEncoding16BitPCM;

 				err = iSpeakerDevice.SetPlayFormat(soundDeviceSettings);

 				}

 			else

 				{

 				// Trying to set an unsupported data type

 				err = KErrNotSupported;

 				}

 			}

 		// else actually doesn't really matter - we always set the sound driver to pcm16 anyway

 		}

 	else

 		{

 		err = iBTDevice.SetDataType(aDataType);

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::SetSampleRate(TUint aSampleRate)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle())

 			{

 			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 			iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 			soundDeviceSettings().iRate = aSampleRate;

 			err = iSpeakerDevice.SetPlayFormat(soundDeviceSettings);

 			}

 	//should also check whether we support aSampleRate

 		}

 	else

 		{

 		err = iBTDevice.SetSampleRate(aSampleRate);

 		}

 	iSampleRate = aSampleRate;

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::SetChannels(	TUint aChannels,

 													TMMFStereoSupport aStereoSupport)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 			iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 			// 1 = mono 2 = stereo

 			soundDeviceSettings().iChannels = aChannels;			

 			err = iSpeakerDevice.SetPlayFormat(soundDeviceSettings);

 			}

 		}

 	else

 		{

 		err = iBTDevice.SetChannels(aChannels, aStereoSupport);

 		}

 	iChannels = aChannels;

 	iStereoSupport = aStereoSupport;

 	return err;	

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::SetBufferSize(TUint aBufferSize)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 			iSpeakerDevice.GetPlayFormat(soundDeviceSettings);

 			// 1 = mono 2 = stereo

 			soundDeviceSettings().iBufferSize = aBufferSize;			

 			err = iSpeakerDevice.SetPlayFormat(soundDeviceSettings);

 			}

 		}

 	iBufferSize = aBufferSize;

 	//else we don't need this for bt headset

 	return err;

 	}

 EXPORT_C void CRoutingSoundPlayDevice::FlushBuffer()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.FlushPlayBuffer();

 			}

 		}

 	else

 		{

 		iBTDevice.FlushBuffer();

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::NotifyError(TRequestStatus& aStatus)

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.NotifyPlayError(aStatus);

 			}

 		}

 	else

 		{

 		iBTDevice.NotifyError(aStatus);

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::CancelNotifyError()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		// To avoid a KE0 panic if -ve handle is returned

 		if (Handle() > 0)

 			{		

 			iSpeakerDevice.CancelNotifyPlayError();

 			}

 		}

 	else

 		{

 		iBTDevice.CancelNotifyError();

 		}	

 	}

 EXPORT_C TUint CRoutingSoundPlayDevice::Volume() const

 	{

 	TUint volume = 0;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound* mutableSpeakerDevice = const_cast<RMdaDevSound*>(&iSpeakerDevice);

 			volume = mutableSpeakerDevice->PlayVolume();

 			}

 		}

 	else

 		{

 		volume = iBTDevice.Volume();

 		}

 	return volume;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::SetVolume(TUint aVolume)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.SetPlayVolume(aVolume);

 			}

 		}

 	else

 		{

 		err = iBTDevice.SetVolume(aVolume);

 		}

 	return err;

 	}

 EXPORT_C void CRoutingSoundPlayDevice::PlayData(const TDesC8& aData, TRequestStatus& aStatus)

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.PlayData(aStatus, aData);

 			}

 		else

 			{

 			TRequestStatus* status = &aStatus;

 			User::RequestComplete(status, KErrBadHandle);

 			}

 		}

 	else

 		{

 		iBTDevice.PlayData(aData, aStatus);

 		}

 	}

 EXPORT_C void CRoutingSoundPlayDevice::CancelPlayData()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.CancelPlayData();

 			}

 		}

 	else

 		{

 		iBTDevice.CancelPlayData();

 		}

 	}

 EXPORT_C TUint CRoutingSoundPlayDevice::BytesPlayed()

 	{

 	TUint bytes = 0;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			bytes = iSpeakerDevice.BytesPlayed();

 			}

 		}

 	else

 		{

 		bytes = iBTDevice.BytesPlayed();

 		}

 	return bytes;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::ResetBytesPlayed()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{		

 			iSpeakerDevice.ResetBytesPlayed();

 			}

 		}

 	else

 		{

 		iBTDevice.ResetBytesPlayed();

 		}

 	return KErrNone;	// why are we returing a value?

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::PauseBuffer()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.PausePlayBuffer();

 			}

 		}

 	else

 		{

 		iBTDevice.PauseBuffer();

 		}

 	return KErrNone;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::ResumePlaying()

 	{

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			iSpeakerDevice.ResumePlaying();

 			}

 		}

 	else

 		{

 		iBTDevice.ResumePlaying();

 		}

 	return KErrNone;

 	}

 EXPORT_C TInt CRoutingSoundPlayDevice::Handle() const

 	{

 	TInt handle;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		handle = iSpeakerDevice.Handle();

 		}

 	else

 		{

 		handle = iBTDevice.Handle();

 		}

 	return handle;

 	}

 /**

  * Implementation of CRoutingSoundRecordDevice.

  */

 EXPORT_C CRoutingSoundRecordDevice* CRoutingSoundRecordDevice::NewL()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 void CRoutingSoundRecordDevice::ConstructL()

 	{

 	//...

 	}

 CRoutingSoundRecordDevice::CRoutingSoundRecordDevice()

 	{

 	}

 EXPORT_C CRoutingSoundRecordDevice::~CRoutingSoundRecordDevice()

 	{

 	if (iInputDevice.Handle())

 		{

 		iInputDevice.Close();

 		}

 	}

 EXPORT_C void CRoutingSoundRecordDevice::Initialize(TUid aDeviceUid,

 													const TDesC8& /*aDeviceConfig*/,

 													TRequestStatus& aStatus)

 	{

 	iDeviceUid = aDeviceUid;

 	TRequestStatus* status = &aStatus;

 	TInt ret = KErrNone;

 	if (iDeviceUid == KDeviceUidMic)

 		{

 		// Load the drivers

 		// Try to load the audio physical driver

 	    ret = User::LoadPhysicalDevice(KPddFileName);

 		if ((ret == KErrNone) || (ret == KErrAlreadyExists))

 			{

 		    // Try to load the audio logical driver

 			ret = User::LoadLogicalDevice(KLddFileName);

 		    }

 		if (ret == KErrAlreadyExists)

 			{

 			// It's not a problem if the drivers have already

 			// been loaded so reset the error code accordingly

 			ret = KErrNone;

 			}

 		}

 	else

 		{

 		ret = KErrNotSupported;

 		}

 	User::RequestComplete(status, ret);

 	}

 EXPORT_C void CRoutingSoundRecordDevice::CancelInitialize(TUid /*aDeviceUid*/)

 	{

 	// Nothing to do

 	}

 EXPORT_C void CRoutingSoundRecordDevice::OpenDevice(TUid /*aDeviceUid*/, TRequestStatus& aStatus)

 	{

 	iOpenDeviceStatus = &aStatus;

 	TInt error = KErrNone;

 	if (!iInputDevice.Handle())

 		{

 		error = iInputDevice.Open();

 		if ((!error)||(error == KErrAlreadyExists))

 			{

 			error = KErrNone;//swallow KErrAlreadyExists

 			//update the configuration here ignore error

 			//it'll get picked up below if not opened due to error

 			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 			iInputDevice.GetRecordFormat(soundDeviceSettings);

 			soundDeviceSettings().iEncoding = RMdaDevSound::EMdaSoundEncoding16BitPCM;

 			if (iSampleRate)

 				{

 				soundDeviceSettings().iRate = iSampleRate;

 				}

 			if (iChannels)

 				{

 				soundDeviceSettings().iChannels = iChannels;

 				}

 			//tell sound driver what buffer size to expect

 			//it is up the the implementor to make use the device can support

 			//the required buffer size

 			if (iBufferSize)

 				{	

 				soundDeviceSettings().iBufferSize = iBufferSize;

 				}

 			error = iInputDevice.SetRecordFormat(soundDeviceSettings);

 			if (error)

 				{

 				iInputDevice.Close();

 				}

 			}

 		}

 	User::RequestComplete(iOpenDeviceStatus, error);

 	}

 EXPORT_C void CRoutingSoundRecordDevice::CancelOpenDevice(TUid aDeviceUid)

 	{

 	if (aDeviceUid == iDeviceUid)

 		{

 		if (iDeviceUid != KDeviceUidA2dpHeadset)

 			{

 			if(Handle() > 0)

 			 	{

 			 	iInputDevice.Close();

 			 	}

 			}

 		if (iOpenDeviceStatus && *iOpenDeviceStatus == KRequestPending)

 			{

 			User::RequestComplete(iOpenDeviceStatus, KErrCancel);				

 			}		

 		}

 	}

 EXPORT_C void CRoutingSoundRecordDevice::CloseDevice(TUid /*aDeviceUid*/, TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;//async not really necessary with RMdaDevSound since close is sync

 	if (iInputDevice.Handle())

 		{

 		iInputDevice.Close();

 		}

 	TRequestStatus* status = &aStatus;

 	User::RequestComplete(status, KErrNone);

 	}	

 EXPORT_C TInt CRoutingSoundRecordDevice::GetSupportedSampleRates(RArray<TUint>& aSupportedDiscreteRates,

 																RArray<TRange>& aSupportedRateRanges)

 	{

 	aSupportedDiscreteRates.Reset();

 	aSupportedRateRanges.Reset();

 	TInt err = KErrNone;

 	if (Handle() > 0)

 		{

 		RMdaDevSound::TSoundFormatsSupportedBuf formatsSupported;

 		iInputDevice.RecordFormatsSupported(formatsSupported);

 		TRange range;

 		range.iLow = formatsSupported().iMinRate;

 		range.iHigh = formatsSupported().iMaxRate;

 		err = aSupportedRateRanges.Append(range);

 		if(!err)

 			{

 			aSupportedRateRanges.Reset();

 			}

 		}

 	else

 		{

 		err = KErrNotReady;

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::GetSupportedChannels(	RArray<TUint>& aSupportedChannels,

 																TMMFStereoSupport& aStereoSupport)

 	{

 	TInt err = KErrNone;

 	if (Handle() > 0)

 		{

 		RMdaDevSound::TSoundFormatsSupportedBuf formatsSupported;

 		iInputDevice.RecordFormatsSupported(formatsSupported);

 		aSupportedChannels.Reset();

 		err = aSupportedChannels.Append(formatsSupported().iChannels);

 		if (err == KErrNone)

 			{

 			aStereoSupport = EMMFNone;	// assume no stereo support for starters

 			if (formatsSupported().iChannels == 2)

 				{

 				aStereoSupport = EMMFBothNonAndInterleaved;		

 				}

 			}

 		}

 	else

 		{

 		err = KErrNotReady;

 		}

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::SetSampleRate(TUint aSampleRate)

 	{

 	// Assume we don't have a handle to the device

 	TInt err = KErrNone;

 	if (Handle())

 		{

 		RMdaDevSound::TCurrentSoundFormatBuf format;

 		iInputDevice.GetRecordFormat(format);

 		format().iRate = aSampleRate;

 		err = iInputDevice.SetRecordFormat(format);		

 		}

 	iSampleRate = aSampleRate;

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::SetChannels(TUint aChannels, TMMFStereoSupport aStereoSupport)

 	{

 	TInt err = KErrNone;

 	if (Handle() > 0)

 		{

 		RMdaDevSound::TCurrentSoundFormatBuf format;

 		iInputDevice.GetRecordFormat(format);

 		format().iChannels = aChannels;

 		err = iInputDevice.SetRecordFormat(format);			

 		}

 	iChannels = aChannels;

 	iStereoSupport = aStereoSupport;	

 	return err;

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::SetBufferSize(TUint aBufferSize)

 	{

 	TInt err = KErrNone;

 	if (iDeviceUid != KDeviceUidA2dpHeadset)

 		{

 		if (Handle() > 0)

 			{

 			RMdaDevSound::TCurrentSoundFormatBuf format;

 			iInputDevice.GetRecordFormat(format);

 			// 1 = mono 2 = stereo

 			format().iBufferSize = aBufferSize;			

 			err = iInputDevice.SetRecordFormat(format);

 			}

 		}

 	iBufferSize = aBufferSize;

 	//else we don't need this for bt headset

 	return err;

 	}

 EXPORT_C void CRoutingSoundRecordDevice::FlushBuffer()

 	{

 	if (Handle() > 0)

 		{

 		iInputDevice.FlushRecordBuffer();

 		}

 	}

 EXPORT_C void CRoutingSoundRecordDevice::NotifyError(TRequestStatus& aStatus)

 	{

 	if (Handle() > 0)

 		{

 		iInputDevice.NotifyRecordError(aStatus);

 		}

 	}

 EXPORT_C void CRoutingSoundRecordDevice::CancelNotifyError()

 	{

 	// To avoid a KE0 panic if -ve handle is returned

 	if (Handle() > 0)

 		{

 		iInputDevice.CancelNotifyRecordError();

 		}

 	}

 EXPORT_C TUint CRoutingSoundRecordDevice::Gain() const

 	{

 	TUint gain = 0;

 	if (Handle() > 0)

 		{

 		RMdaDevSound* mutableInputDevice = const_cast<RMdaDevSound*>(&iInputDevice);

 		gain = mutableInputDevice->RecordLevel();		

 		}

 	return gain;

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::SetGain(TUint aGain)

 	{

 	TInt err = KErrNone;

 	if (Handle() > 0)

 		{

 		iInputDevice.SetRecordLevel(aGain);

 		}

 	else

 		{

 		err = KErrNotReady;

 		}

 	return err;

 	}

 EXPORT_C void CRoutingSoundRecordDevice::RecordData(TDes8& aData, TRequestStatus& aStatus)

 	{

 	//this handle check should really be removed since it impacts performance

 	//, however there do seem to

 	//be cases where a record error occus but the client sends an ack before

 	//it has time to get the RecordError so keep it for now

 	if (Handle() > 0)

 		{

 		iInputDevice.RecordData(aStatus, aData);

 		}

 	else

 		{

 		TRequestStatus* status = &aStatus;

 		User::RequestComplete(status, KErrBadHandle);

 		}

 	}

 EXPORT_C void CRoutingSoundRecordDevice::CancelRecordData()

 	{

 	if (Handle() > 0)

 		{

 		iInputDevice.CancelRecordData();

 		}

 	}

 EXPORT_C TUint CRoutingSoundRecordDevice::BytesRecorded()

 	{

 	// Is there an equivalent call to bytes played for bytes recorded?

 	// If not, why do we have this method or what should we return?

 	TUint bytesPlayed = 0;

 	if (Handle() > 0)

 		{

 		bytesPlayed = iInputDevice.BytesPlayed();

 		}

 	return bytesPlayed; 

 	}

 EXPORT_C TInt CRoutingSoundRecordDevice::Handle() const

 	{

 	return iInputDevice.Handle();

 	}