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

		{