// 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 <bttypes.h>

 #include <s32mem.h>	// RDesReadStream

 #include "A2dpBTHeadsetAudioIfClient.h"

 #include "A2dpBTHeadsetAudioIfClientServer.h"

 #include "A2dpBTHeadsetAudioIfServerStart.h"

 #include "MMFBtRoutingSoundDevice.h"

 const TInt KBluetoothAddressBufferLength = 32;

 EXPORT_C RA2dpBTHeadsetAudioInterface::RA2dpBTHeadsetAudioInterface()

 	{

 	}

 EXPORT_C TInt RA2dpBTHeadsetAudioInterface::Connect()

 	{

 	TRAPD(err, iBufAddr = HBufC::NewL(KBluetoothAddressBufferLength));

 	if (err)

 		{

 		delete iBufAddr;

 		iBufAddr = NULL;

 		return err;

 		}

 	TRAP(err, iPckgBuf = new(ELeave)TPckgBuf<TBTDevAddr>);

 	if (err)

 		{

 		delete iPckgBuf;

 		iPckgBuf = NULL;

 		return err;

 		}

 	TVersion version(KBTAudioServerMajorVersionNumber,

 					KBTAudioServerMinorVersionNumber,

 					KBTAudioServerBuildVersionNumber);

 	// Assume the server is already running and attempt to create a session	

 	return CreateSession(KA2DPAudioServerName, version);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::Close()

 	{

 	// Call the base class

 	RMmfSessionBase::Close();

 	delete iPckgBuf;

 	iPckgBuf = NULL;

 	delete iBufAddr;

 	iBufAddr = NULL;

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::Initialize(const TBTDevAddr& aRemoteAddress,

 														TRequestStatus& aStatus)

 	{

 	if (iPckgBuf)

 		{

 		(*iPckgBuf)() = aRemoteAddress;

 		SendReceiveResult(EBTAudioServerInitialize, *iPckgBuf, aStatus);

 		}

 	else

 		{

 		// iPckgBuf not created => Connect() wasn't called or the returned error code was ignored.

 		TRequestStatus* status = &aStatus;

 		User::RequestComplete(status, KErrDisconnected);

 		}

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::CancelInitialize()

 	{

 	SendReceive(EBTAudioServerCancelInitialize);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::GetSupportedDataTypesL(RArray<TFourCC>& aSupportedDataTypes) const

 	{

 	aSupportedDataTypes.Reset();

 	TPckgBuf<TInt> numberOfElementsPckg;

 	TInt err = SendReceiveResult(EBTAudioServerGetSupportedDataTypes, numberOfElementsPckg);

 	User::LeaveIfError(err);

 	HBufC8* buf = HBufC8::NewLC(numberOfElementsPckg() * sizeof(TFourCC));

 	TPtr8 ptr = buf->Des();

 	err = SendReceiveResult(EBTAudioServerCopyFourCCArrayData, ptr);

 	User::LeaveIfError(err);

 	RDesReadStream stream(ptr);

 	CleanupClosePushL(stream);

 	for (TInt i = 0; i < numberOfElementsPckg(); i++)

 		{

 		err = aSupportedDataTypes.Append(stream.ReadInt32L());

 		if (err)

 			{//note we don't destroy array because we don't own it

 			//but we do reset it as it is incomplete

 			aSupportedDataTypes.Reset();

 			User::Leave(err);

 			}

 		}

 	CleanupStack::PopAndDestroy(2, buf);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::GetSupportedSampleRatesL(RArray<TUint>& aSupportedDiscreteRates,

 																	RArray<TRange>& aSupportedRateRanges) const

 	{

 	aSupportedDiscreteRates.Reset();

 	TPckgBuf<TRatesArrayElements> numberOfElementsPckg;

 	TInt err = SendReceiveResult(EBTAudioServerGetSupportedSampleRates, numberOfElementsPckg);

 	User::LeaveIfError(err);

 	HBufC8* buf = HBufC8::NewLC(numberOfElementsPckg().iDiscrete * sizeof(TUint));

 	TPtr8 ptr = buf->Des();

 	err = SendReceiveResult(EBTAudioServerGetSupportedSampleRatesDiscrete, ptr);

 	User::LeaveIfError(err);

 	RDesReadStream stream(ptr);

 	CleanupClosePushL(stream);

 	// Populate the discrete rates array

 	for (TInt i = 0; i < numberOfElementsPckg().iDiscrete; i++)

 		{

 		err = aSupportedDiscreteRates.Append(stream.ReadInt32L());

 		if (err)

 			{//note we don't destroy array because we don't own it

 			//but we do reset it as it is incomplete

 			aSupportedDiscreteRates.Reset();

 			User::Leave(err);

 			}

 		}

 	ptr.SetLength(0); //clear out exiting data	

 	// Get the rates range array (# of elements and the elements themselves)

 	buf = buf->ReAllocL(numberOfElementsPckg().iRange * sizeof(TRange));

 	ptr = buf->Des();

 	stream.Close();

 	stream.Open(ptr);

 	err = SendReceiveResult(EBTAudioServerGetSupportedSampleRatesRange, ptr);

 	User::LeaveIfError(err);

 	TRange range;

 	for (TInt i = 0; i < numberOfElementsPckg().iRange; i++)

 		{

 		range.iLow = stream.ReadInt32L();

 		range.iHigh = stream.ReadInt32L();					

 		err = aSupportedRateRanges.Append(range);

 		if (err)

 			{

 			aSupportedRateRanges.Reset();

 			User::Leave(err);

 			}

 		}

 	CleanupStack::PopAndDestroy(2, buf);//stream, buf		

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::GetSupportedChannelsL(RArray<TUint>& aSupportedChannels,

 																TMMFStereoSupport& aStereoSupport) const

 	{

 	aSupportedChannels.Reset();

 	TChannelsSupport channelsSupport;

 	channelsSupport.iElementCount = 0;

 	channelsSupport.iSupport = EMMFNone;

 	TPckgBuf<TChannelsSupport> channelsSupportPckg(channelsSupport);

 	TInt err = SendReceiveResult(EBTAudioServerGetSupportedChannels, channelsSupportPckg);

 	User::LeaveIfError(err);

 	aStereoSupport = channelsSupportPckg().iSupport;

 	HBufC8* buf = HBufC8::NewLC(channelsSupportPckg().iElementCount * sizeof(TUint));

 	TPtr8 ptr = buf->Des();

 	err = SendReceiveResult(EBTAudioServerCopyChannelsArrayData, ptr);

 	User::LeaveIfError(err);

 	RDesReadStream stream(ptr);

 	CleanupClosePushL(stream);

 	// Populate the stereo support array

 	for (TInt i = 0; i < channelsSupportPckg().iElementCount; i++)

 		{

 		err = aSupportedChannels.Append(stream.ReadInt32L());

 		if (err)

 			{//note we don't destroy array because we don't own it

 			//but we do reset it as it is incomplete

 			aSupportedChannels.Reset();

 			User::Leave(err);

 			}

 		}		

 	CleanupStack::PopAndDestroy(2, buf); //stream, buf

 	}

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

 	{

 	TPckgBuf<TFourCC> dataTypePckg(aDataType);

 	return SendReceiveResult(EBTAudioServerSetDataType, dataTypePckg);

 	}

 EXPORT_C TInt RA2dpBTHeadsetAudioInterface::SetSampleRate(TUint aSampleRate)

 	{

 	TPckgBuf<TUint> sampleRatePckg(aSampleRate);

 	return SendReceiveResult(EBTAudioServerSetSampleRate, sampleRatePckg);

 	}

 EXPORT_C TInt RA2dpBTHeadsetAudioInterface::SetChannels(TUint aChannels,

 														TMMFStereoSupport aStereoSupport)

 	{

 	TChannelsSupport channelsSupport;

 	channelsSupport.iElementCount = aChannels;

 	channelsSupport.iSupport = aStereoSupport;

 	TPckgBuf<TChannelsSupport> pckgBuf(channelsSupport);

 	return SendReceiveResult(EBTAudioServerSetChannels, pckgBuf);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::OpenDevice(TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	SendReceive(EBTAudioServerOpenDevice, aStatus);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::CancelOpenDevice()

 	{

 	SendReceive(EBTAudioServerCancelOpenDevice);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::CloseDevice(TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	SendReceive(EBTAudioServerCloseDevice, aStatus);

 	}

 EXPORT_C TUint RA2dpBTHeadsetAudioInterface::Volume() const

 	{

 	TUint volume = 0;

 	TPckgBuf<TUint> volumePckg(volume);

 	SendReceiveResult(EBTAudioServerVolume, volumePckg);

 	return volumePckg();

 	}

 EXPORT_C TInt RA2dpBTHeadsetAudioInterface::SetVolume(TUint aVolume)

 	{

 	TPckgBuf<TUint> volumePckg(aVolume);

 	return SendReceiveResult(EBTAudioServerSetVolume, volumePckg);

 	}

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

 	{

 	aStatus = KRequestPending;

 	SendReceive(EBTAudioServerPlayData, aData, aStatus);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::CancelPlayData()

 	{

 	SendReceive(EBTAudioServerCancelPlayData);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::FlushBuffer()

 	{

 	SendReceive(EBTAudioServerFlushBuffer);

 	}

 EXPORT_C TUint RA2dpBTHeadsetAudioInterface::BytesPlayed() const

 	{

 	TUint bytes = 0;

 	TPckgBuf<TUint> bytesPlayedPckg(bytes);

 	SendReceive(EBTAudioServerBytesPlayed, bytesPlayedPckg);

 	return bytesPlayedPckg();

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::ResetBytesPlayed()

 	{

 	SendReceive(EBTAudioServerResetBytesPlayed);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::PauseBuffer()

 	{

 	SendReceive(EBTAudioServerPauseBuffer);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::ResumePlaying()

 	{

 	SendReceive(EBTAudioServerResumePlaying);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::NotifyError(TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	SendReceive(EBTAudioServerNotifyError, aStatus);

 	}

 EXPORT_C void RA2dpBTHeadsetAudioInterface::CancelNotifyError()

 	{

 	SendReceive(EBTAudioServerCancelNotifyError);

 	}