// 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);
	}