// Copyright (c) 2003-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:

// Generic functions associated with all Bluetooth socket addresses

// 

//

#include "bt_sock.h"

#include "internaltypes.h"

#include "btsocketpanic.h"

#include "btsynclinkhelpers.h"

#include <bluetooth/logger.h>

EXPORT_C TBTSyncPackets::TBTSyncPackets(TBTSyncPacketTypes aPacketTypes)

	: iPacketTypes(aPacketTypes)

	{}

EXPORT_C TBTSyncPacketTypes TBTSyncPackets::operator()() const

	{

	return iPacketTypes;

	}

EXPORT_C TBTSyncBandwidth::TBTSyncBandwidth()

	{}

EXPORT_C TBTSyncBandwidth::TBTSyncBandwidth(TUint aBandwidth)

	: iTransmit(aBandwidth), iReceive(aBandwidth)

	{}

TBTeSCOLinkParams::TBTeSCOLinkParams(TUint aBandwidth, TUint16 aCoding, TUint16 aLatency, TUint8 aRetransmission)

	: iBandwidth(aBandwidth), iCoding(aCoding), iLatency(aLatency), iRetransmissionEffort(aRetransmission)

	{}

/** Allocate and open a socket sub-session for Bluetooth SCO

@param aNotifier Notifier object which will receive callbacks after asynchronous requests

@param aServer Handle to a currently connected session on the socket server

@return Newly allocated CBluetoothSynchronousLink object

@capability LocalServices

*/

EXPORT_C CBluetoothSynchronousLink* CBluetoothSynchronousLink::NewL(MBluetoothSynchronousLinkNotifier& aNotifier,

														RSocketServ& aServer)

	{

	CBluetoothSynchronousLink* self = NewLC(aNotifier, aServer);

	CleanupStack::Pop();

	return self;

	}

/**  Allocate and open a socket sub-session for Bluetooth SCO

@param aNotifier Notifier object which will receive callbacks after asynchronous requests

@param aServer Handle to a currently connected session on the socket server

@return Newly allocated CBluetoothSynchronousLink object

@capability LocalServices

*/

EXPORT_C CBluetoothSynchronousLink* CBluetoothSynchronousLink::NewLC(MBluetoothSynchronousLinkNotifier& aNotifier,

														 RSocketServ& aServer)

	{

	CBluetoothSynchronousLink* self=new (ELeave) CBluetoothSynchronousLink(aNotifier, aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

Destructor

*/

EXPORT_C CBluetoothSynchronousLink::~CBluetoothSynchronousLink()

	{

	FTRACE(FPrint(_L("Destroying CBTSyncLink 0x%08x"), this));

	delete iBTSynchronousLinkSenderSCO;

	delete iBTSynchronousLinkSenderESCO;

	delete iBTSynchronousLinkReceiverSCO;

	delete iBTSynchronousLinkReceiverESCO;

	delete iBTSynchronousLinkAccepterSCO;

	delete iBTSynchronousLinkAccepterESCO;

	delete iBTSynchronousLinkAttacherSCO;

	delete iBTSynchronousLinkAttacherESCO;

	delete iBTSynchronousLinkDetacherSCO;

	delete iBTSynchronousLinkDetacherESCO;

	delete iBTSynchronousLinkBaseband;

	FLOG(_L("Closing sockets"));

	ListeningSCOSocket().Close();

	ListeningESCOSocket().Close();	

	SCOSocket().Close();

	ESCOSocket().Close();

	}

void CBluetoothSynchronousLink::ConstructL()

	{

	iBTSynchronousLinkSenderSCO = CBTSynchronousLinkSender::NewL(*this,ESCO);

	iBTSynchronousLinkSenderESCO = CBTSynchronousLinkSender::NewL(*this,EeSCO);

	iBTSynchronousLinkReceiverSCO = CBTSynchronousLinkReceiver::NewL(*this,ESCO);

	iBTSynchronousLinkReceiverESCO = CBTSynchronousLinkReceiver::NewL(*this,EeSCO);

	iBTSynchronousLinkAccepterSCO = CBTSynchronousLinkAccepter::NewL(*this,ESCO);

	iBTSynchronousLinkAccepterESCO = CBTSynchronousLinkAccepter::NewL(*this,EeSCO);

	iBTSynchronousLinkAttacherSCO = CBTSynchronousLinkAttacher::NewL(*this,ESCO);

	iBTSynchronousLinkAttacherESCO = CBTSynchronousLinkAttacher::NewL(*this,EeSCO);

	iBTSynchronousLinkDetacherSCO = CBTSynchronousLinkDetacher::NewL(*this,ESCO);

	iBTSynchronousLinkDetacherESCO = CBTSynchronousLinkDetacher::NewL(*this,EeSCO);

	iBTSynchronousLinkBaseband = CBTSynchronousLinkBaseband::NewL(*this);

	}

CBluetoothSynchronousLink::CBluetoothSynchronousLink(MBluetoothSynchronousLinkNotifier& aNotifier, 

										             RSocketServ& aServer)

	: iNotifier(&aNotifier), iSockServer(aServer),

	  iRequestedLink(KBTSync64KBit, 0, 25, EeSCORetransmitDontCare),

	  iNegotiatedLink(0, 0, 0, 0)

	{

	FTRACE(FPrint(_L("Constructing CBTSyncLink 0x%08x"), this));

	}

/**

Create a synchronous link (e.g. voice) on an EXISTING physical link.

@param aBDAddr Bluetooth address of remote device (specifying existing physical link)

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::SetupConnection(const TBTDevAddr& aBDAddr)

	{

	return SetupConnection(aBDAddr, TBTSyncPackets(TBTSyncPackets::ESyncAnySCOPacket));

	}

/**

Create a synchronous link (e.g. voice) on an EXISTING physical link.

@see TBTPacketType

@param aBDAddr Bluetooth address of remote device (specifying existing physical link)

@param aPacketTypes Bitmask of the SCO packet types required on this connection

Use only the three SCO specific packet type enums

E.g. EPacketsHV1|EPacketsHV2|EPacketsHV3 (EAnySCOPacket) specifies all the three packet

types are allowed.

OR if ESCO is supported

three ESCO specific packet type enums

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::SetupConnection(const TBTDevAddr& aBDAddr, const TUint16 aPacketTypes)

	{

	return SetupConnection(aBDAddr, TBTSyncPackets((aPacketTypes & EAnySCOPacket) >> KSCOvsSyncHVOffset));

	}

// This needs to be a macro or the 'return' won't return properly

#define CLOSE_RETURN_IF_ERROR(error) if (error) { LinkDown(); SCOSocket().Close(); ESCOSocket().Close(); return error; }

#define CLOSE_LISTENER_RETURN_IF_ERROR(error) if (error) { ListeningSCOSocket().Close(); ListeningESCOSocket().Close(); return error; }

EXPORT_C TInt CBluetoothSynchronousLink::SetupConnection(const TBTDevAddr& aBDAddr, const TBTSyncPackets& aPacketTypes)

	{

	TBool openSCO = EFalse;

	TBool openESCO = EFalse;

	FTRACE(FPrint(_L("SetupConnection on CBTSyncLink 0x%08x"), this));

	TBTSyncPacketTypes packets = aPacketTypes();

	__ASSERT_ALWAYS(packets, Panic(EBadSyncPacketTypes));

	packets &= (TBTSyncPackets::ESyncAnySCOPacket | TBTSyncPackets::ESyncAnyESCOPacket);

	if (!packets)

		{

		FLOG(_L("Bad packets specified at initial mask"));

		return KErrNotSupported;

		}

	TBTSyncPacketTypes packetsSCO = packets & TBTSyncPackets::ESyncAnySCOPacket;

    if (packetsSCO)

        {

        iSCOTypes |= ESCO;

        openSCO = ETrue;

        }

	TBTSyncPacketTypes packetsESCO = packets & TBTSyncPackets::ESyncAnyESCOPacket;

	if (packetsESCO) 

		{

		iSCOTypes |= EeSCO;

		openESCO = ETrue;	

		}

	// but must be one		

	__ASSERT_ALWAYS(packetsSCO || packetsESCO, Panic(EBadSyncPacketTypes));

	if (iBTSynchronousLinkAttacherSCO->IsActive())

		{

		FLOG(_L("Link attacher already active"));

		return KErrInUse;

		}

	if (iBTSynchronousLinkAttacherESCO->IsActive())

		{

		FLOG(_L("Link attacher already active"));

		return KErrInUse;

		}	

	TInt linkState = LinkUp(aBDAddr);

	if (linkState != KErrNone)

		{

		FLOG(_L("Baseband link not available"));

		return KErrDisconnected;

		}

	TInt err = KErrNone;			   

	if (openSCO && openESCO)

		{

		/* open both socket types */

		/* first try ESCO */

		err = ESCOSocket().Open(iSockServer, 

						        KBTAddrFamily,

						        KSockBluetoothTypeESCO,

						        KBTLinkManager);							        

		if(!err)

			{

			err = ESCOSocket().SetOpt(ESyncUserPacketTypes, KSolBtSCO, packets);

			if (!err)

				{

				TPckgBuf<TBTeSCOLinkParams> options;

				options() = iRequestedLink;

				err = ESCOSocket().SetOpt(EeSCOExtOptions, KSolBtESCO, options);

				}

			}

		if (err)

			{	// ESCO failed so try only SCO

			ESCOSocket().Close();

			openESCO = EFalse;

			}

    	err = SCOSocket().Open(iSockServer, 

								   KBTAddrFamily,

							       KSockBluetoothTypeSCO,

							       KBTLinkManager);						       							    

		if(!err)

			{

	        err = SCOSocket().SetOpt(ESyncUserPacketTypes, KSolBtSCO, packetsSCO);

			}

		else

			{// SCO failed

			openSCO = EFalse;

			}		

		CLOSE_RETURN_IF_ERROR(err);	// this will sort out if both have failed

		}							    

	else if (openSCO)

        {

    	err = SCOSocket().Open(iSockServer, 

							   KBTAddrFamily,

						       KSockBluetoothTypeSCO,

						       KBTLinkManager);						       							    

		if(err)

			{

			return err;

			}

        err = SCOSocket().SetOpt(ESyncUserPacketTypes, KSolBtSCO, packetsSCO);

        CLOSE_RETURN_IF_ERROR(err);	

        }      

	else if (openESCO) 

		{

		err = ESCOSocket().Open(iSockServer, 

						        KBTAddrFamily,

						        KSockBluetoothTypeESCO,

						        KBTLinkManager);							        

		if(err)

			{

			SCOSocket().Close();

			return err;

			}					

		err = ESCOSocket().SetOpt(ESyncUserPacketTypes, KSolBtSCO, packetsESCO);

		TPckgBuf<TBTeSCOLinkParams> options;

		options() = iRequestedLink;

		err = ESCOSocket().SetOpt(EeSCOExtOptions, KSolBtESCO, options);

		CLOSE_RETURN_IF_ERROR(err);	

		}							    

	iSockAddr.SetBTAddr(aBDAddr);

	iBTSynchronousLinkBaseband->PreventPark();

	if(openESCO)

		{

		iOpeningESCO = ETrue;

		iBTSynchronousLinkAttacherESCO->AttachSCOLink(iSockAddr);

		iBTSynchronousLinkBaseband->CatchEvents();

		}

	if(openSCO)

		{

		iOpeningSCO = ETrue;

		iBTSynchronousLinkAttacherSCO->AttachSCOLink(iSockAddr);

		iBTSynchronousLinkBaseband->CatchEvents();

		}

	return KErrNone;							     

	}

/**

Cancel creating a synchronous link.

This cancels the asynchronous request to prevent the callback reaching the client.

It makes no claims about the resultant state of the CBluetoothSynchronousLink.  If

a client wishes to continue using the CBluetoothSynchronousLink it is strongly 

recommended to follow a call to CancelSetup with a call to Disconnect, which will

ensure that any established connection is tidied up.

@see CBluetoothSynchronousLink::Disconnect

*/

EXPORT_C void CBluetoothSynchronousLink::CancelSetup()

	{

	iBTSynchronousLinkAttacherSCO->Cancel();

	iBTSynchronousLinkAttacherESCO->Cancel();

	iBTSynchronousLinkBaseband->StopAll();

	}

/**

Disconnect a synchronous link.

The physical link will remain unless no other services are running on it.

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::Disconnect()

	{

	if (!SCOSocket().SubSessionHandle())

		{

		if(!ESCOSocket().SubSessionHandle())

			{

			return KErrDisconnected;

			}

		}

	if (iBTSynchronousLinkDetacherSCO->IsActive() ||

	    iBTSynchronousLinkDetacherESCO->IsActive())

		{

		return KErrInUse;

		}

	__ASSERT_ALWAYS(iSCOTypes, Panic(EBadSyncPacketTypes));

	if (iSCOTypes & ESCO)

		{

		iBTSynchronousLinkDetacherSCO->DetachSCOLink(iDummySCOShutdownDescriptor, iDummySCOShutdownDescriptor);

		}

	if (iSCOTypes & EeSCO)

		{

		iBTSynchronousLinkDetacherESCO->DetachSCOLink(iDummySCOShutdownDescriptor, iDummySCOShutdownDescriptor);

		}

	return KErrNone;

	}

/**

Send data over synchronous link.  It is worth noting that Bluetooth hardware

may have dedicated pins to supply synchronous data, and the RSocket interface

cannot provide the synchronous requirements of the SCO link.  As a result of

this, the CBluetoothSynchronousLink class may only provide the control plane of

a SCO connection.  In this situation, Receive returns KErrNotSupported via the

MBluetoothSynchronousLinkNotifier::HandleSendCompleteL callback.

@param const aData Data to be sent.

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::Send(const TDesC8& aData)

	{

	__ASSERT_ALWAYS(SCOSocket().SubSessionHandle() || ESCOSocket().SubSessionHandle(), Panic(EInvalidSubSession));

	if (!SCOSocket().SubSessionHandle())

		{

		if(!ESCOSocket().SubSessionHandle())

			{

			return KErrDisconnected;

			}

		}

	if (iBTSynchronousLinkSenderSCO->IsActive() ||

	    iBTSynchronousLinkSenderESCO->IsActive())

		{

		return KErrInUse;

		}

	__ASSERT_ALWAYS(iSCOTypes, Panic(EBadSyncPacketTypes));

	if (iSCOTypes & ESCO)

		{

		iBTSynchronousLinkSenderSCO->SendSCOData(aData);

		}

	if (iSCOTypes & EeSCO)

		{

		iBTSynchronousLinkSenderESCO->SendSCOData(aData);

		}

	return KErrNone;

	}

/**

Cancel sending data.

*/

EXPORT_C void CBluetoothSynchronousLink::CancelSend()

	{

	iBTSynchronousLinkSenderSCO->Cancel();

	iBTSynchronousLinkSenderESCO->Cancel();

	}

/**

Receive data over synchronous link.  It is worth noting that Bluetooth hardware

may have dedicated pins to supply synchronous data, and the RSocket interface

cannot provide the synchronous requirements of the SCO link.  As a result of

this, the CBluetoothSynchronousLink class may only provide the control plane of

a SCO connection.  In this situation, Receive returns KErrNotSupported via the

MBluetoothSynchronousLinkNotifier::HandleReceiveCompleteL callback.

@param const aData Buffer for data to be received.

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::Receive(TDes8& aData)

	{

	__ASSERT_ALWAYS(SCOSocket().SubSessionHandle() || ESCOSocket().SubSessionHandle(), Panic(EInvalidSubSession));

	if (!SCOSocket().SubSessionHandle())

		{

		if(!ESCOSocket().SubSessionHandle())

			{

			return KErrDisconnected;

			}

		}

	if (iBTSynchronousLinkSenderSCO->IsActive() ||

	    iBTSynchronousLinkSenderESCO->IsActive())

		{

		return KErrInUse;

		}

	__ASSERT_ALWAYS(iSCOTypes, Panic(EBadSyncPacketTypes));

	if (iSCOTypes & ESCO)

		{

		iBTSynchronousLinkReceiverSCO->ReadSCOData(aData);

		}

	if (iSCOTypes & EeSCO)

		{

		iBTSynchronousLinkReceiverESCO->ReadSCOData(aData);

		}

	return KErrNone;

	}

/**

Cancel receiving data.

*/

EXPORT_C void CBluetoothSynchronousLink::CancelReceive()

	{

	iBTSynchronousLinkReceiverSCO->Cancel();

	iBTSynchronousLinkReceiverESCO->Cancel();

	}

/**

Prepare for a remote device to set up a synchronous link on the local device.

Whilst this facility is set, a response can be sent to a remote device trying to 

set up a synchronous link, allowing that synchronous link to be brought up.

This object will represent that synchronous link locally when/if it does come up.

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::AcceptConnection()

	{

	return AcceptConnection(TBTSyncPackets(TBTSyncPackets::ESyncAnySCOPacket));

	}

/**

Prepare for a remote device to set up a synchronous link on the local device.

Whilst this facility is set, a response can be sent to a remote device trying to 

set up a synchronous link, allowing that synchronous link to be brought up.

This object will represent that synchronous link locally when/if it does come up.

@see TBTPacketType

@param aPacketTypes Bitmask of supported packets.

@return Error code

*/

EXPORT_C TInt CBluetoothSynchronousLink::AcceptConnection(const TBTSyncPackets& aPacketTypes)

	{

	TBool listenForSCO = EFalse;

	TBool listenForESCO = EFalse;

	FTRACE(FPrint(_L("AcceptConnection on CBTSyncLink 0x%08x"), this));

	TBTSyncPacketTypes packets = aPacketTypes();

	__ASSERT_ALWAYS(packets, Panic(EBadSyncPacketTypes));

	packets &= (TBTSyncPackets::ESyncAnySCOPacket | TBTSyncPackets::ESyncAnyESCOPacket);

	if (!packets)

		{

		return KErrNotSupported;

		}

	if (iBTSynchronousLinkAccepterSCO->IsActive())

		{

		return KErrInUse;

		}

	if (iBTSynchronousLinkAccepterESCO->IsActive())

		{

		return KErrInUse;

		}

	TInt err = ListeningSCOSocket().Open(iSockServer, KBTAddrFamily, KSockBluetoothTypeSCO, KBTLinkManager);

	if(err)