// 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 <bluetooth/hci/hcierrors.h>

#include <bluetooth/aclsockaddr.h>

#include "btsocketpanic.h"

//.................................

//

//Actual raw client

//

RBTBaseband::RBTBaseband()

	{

	}

void RBTBaseband::Close()

	{

	if (SubSessionHandle())

		{

		iSocket.Close();

		}

	}

/**

  API useful for Bluetooth as seen from a single physical link perspective

*/

// for 'getting' a RBTBaseband from a connected socket

TInt RBTBaseband::Open(RSocketServ& aSocketServ, RSocket& aConnectedSocket)

	{

	if (!aConnectedSocket.SubSessionHandle())

		{

		return KErrNotReady;

		}

	THCIConnHandle bbHandle;

	TPckg<THCIConnHandle> bbHandleBuf(bbHandle);

	TInt err = aConnectedSocket.GetOpt(KLMGetACLHandle, KSolBtACL, bbHandleBuf);

	if (err)

		{

		return err;

		}

	err = iSocket.Open(aSocketServ, KBTAddrFamily, bbHandle, KBTLinkManager);

	return err;

	}

TInt RBTBaseband::Open(RSocketServ& aSocketServ, const TBTDevAddr& aBDAddr)

	{

	//open unsubscribed socket (currently use KSockBluetoothTypeRawBroadcast)

	TInt err = iSocket.Open(aSocketServ, 

							KBTAddrFamily, 

							KSockBluetoothTypeRawBroadcast, 

							KBTLinkManager);

	if (err)

		{

		return err;

		}

	//attempt to subscribe socket to supplied address

	TPckg<TBTDevAddr> pckg(aBDAddr);

	err = iSocket.SetOpt(EBBSubscribePhysicalLink, KSolBtLMProxy, pckg);

	if(err)

		//only leave open if there is an EXISTING connection

		{

		iSocket.Close();

		}

	return err;

	}

TInt RBTBaseband::PhysicalLinkState(TUint32& aState)

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		TBTBasebandEvent pckgEvent;

		err = iSocket.GetOpt(EBBGetPhysicalLinkState, KSolBtLMProxy, pckgEvent);

		if (err == KErrNone)

			{

			aState = pckgEvent().EventType();

			}

		}

	return err;

	}

/**Role change methods*/

TInt RBTBaseband::PreventRoleSwitch()

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		err = iSocket.SetOpt(EBBRequestPreventRoleChange, KSolBtLMProxy, 0);

		}

	return err;

	}

TInt RBTBaseband::AllowRoleSwitch()

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		err = iSocket.SetOpt(EBBRequestAllowRoleChange, KSolBtLMProxy, 0);

		}

	return err;

	}

TInt RBTBaseband::RequestMasterRole()

	{

	return RequestRole(EBBRequestRoleMaster);

	}

TInt RBTBaseband::RequestSlaveRole()

	{

	return RequestRole(EBBRequestRoleSlave);

	}

/**Low power mode methods*/

TInt RBTBaseband::PreventLowPowerModes(TUint32 aLowPowerModes)

	{

	if (!SubSessionHandle())

		{

		return KErrNotReady;

		}

	//if caller has used silly bits

	if(aLowPowerModes & ~(EAnyLowPowerMode))

		{

		return KErrArgument;

		}

	TUint32 mask = 0;

	if(aLowPowerModes & EHoldMode)

		{

		mask |= EBBRequestPreventHold;

		}

	if(aLowPowerModes & ESniffMode)

		{

		mask |= EBBRequestPreventSniff;

		}

	if(aLowPowerModes & EParkMode)

		{

		mask |= EBBRequestPreventPark;

		}

	return iSocket.SetOpt(mask, KSolBtLMProxy);

	}

TInt RBTBaseband::AllowLowPowerModes(TUint32 aLowPowerModes)

	{

	if (!SubSessionHandle())

		{

		return KErrNotReady;

		}

	//if caller has used silly bits

	if(aLowPowerModes & ~(EAnyLowPowerMode))

		{

		return KErrArgument;

		}

	TUint32 mask = 0;

	if(aLowPowerModes & EHoldMode)

		{

		mask |= EBBRequestAllowHold;

		}

	if(aLowPowerModes & ESniffMode)

		{

		mask |= EBBRequestAllowSniff;

		}

	if(aLowPowerModes & EParkMode)

		{

		mask |= EBBRequestAllowPark;

		}

	return iSocket.SetOpt(mask, KSolBtLMProxy);

	}

TInt RBTBaseband::ActivateSniffRequester()

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else 

		{

		err = iSocket.SetOpt(EBBRequestSniff, KSolBtLMProxy, 0);

		}

	return err;

	}

TInt RBTBaseband::ActivateParkRequester()

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		err = iSocket.SetOpt(EBBRequestPark, KSolBtLMProxy);

		}

	return err;

	}

TInt RBTBaseband::CancelLowPowerModeRequester()

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else 

		{

		err = iSocket.SetOpt(EBBCancelModeRequest, KSolBtLMProxy, 0);

		}

	return err;

	}

TInt RBTBaseband::RequestExplicitActiveMode(TBool aActive)

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		TPckgBuf<TBool> active = aActive;

		err = iSocket.SetOpt(EBBRequestExplicitActiveMode, KSolBtLMProxy, active);

		}

	return err;

	}

/**Packet method*/

TInt RBTBaseband::RequestChangeSupportedPacketTypes(TUint16 aPacketTypes)

	{

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		// Only allow ACL packet types to be changed

		// Although EAnyNonEdrACLPacket is a confusing name in this context

		// it is correct. As standard ACL packet types are to be used when the

		// appropriate bit is set, for EDR packets the bit is set if they

		// are not to be used.  Thus we are correctly checking that only

		// valid bits are set when using the EAnyNonEdrACLPacket bitmask.

		if ((aPacketTypes & ~EAnyNonEdrACLPacket) != 0)

			{

			return KErrArgument;

			}

		TPckgBuf<TUint16> packetTypes = aPacketTypes;

		err = iSocket.SetOpt(EBBRequestChangeSupportedPacketTypes, KSolBtLMProxy, packetTypes);

		}

	return err;

	}

void RBTBaseband::ReadNewPhysicalLinkMetricValue(TRequestStatus& aStatus, TDes8& aPLMData, TBTLMIoctls anIoctl)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		iSocket.Ioctl(anIoctl, aStatus, &aPLMData, KSolBtLMProxy);

		}

	}

void RBTBaseband::CancelPhysicalLinkMetricUpdate()

	{

	if(SubSessionHandle())

		{

		iSocket.CancelIoctl();

		}

	}

/**Notification methods*/

void RBTBaseband::ActivateNotifierForOneShot(TBTBasebandEvent& aEventNotification, 

		                                     TRequestStatus& aStatus, 

											 TUint32 aEventMask)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		aEventNotification().SetEventType(aEventMask);

		iSocket.Ioctl(KLMBasebandEventOneShotNotificationIoctl, aStatus, &aEventNotification, KSolBtLMProxy);		

		}

	}

void RBTBaseband::ActivateNotifierForRecall(TBTBasebandEvent& aEventNotification, 

		                                    TRequestStatus& aStatus, 

											TUint32 aEventMask)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		aEventNotification().SetEventType(aEventMask);

		iSocket.Ioctl(KLMBasebandEventNotificationIoctl, aStatus, &aEventNotification, KSolBtLMProxy);		

		}

	}

void RBTBaseband::CancelNextBasebandChangeEventNotifier()

	{

	if (SubSessionHandle())

		{

		//only allowed one Ioctl at a time - only one used is the Notifications Ioctl

		iSocket.CancelIoctl();		

		}

	}

TInt RBTBaseband::Authenticate()

	{

	// First check that the socket is open etc	

	TInt err = KErrNone;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else 

		{

		// Send the request - this will return KErrAlreadyExists if the link is already authenticated.

		err = iSocket.SetOpt(EBBRequestLinkAuthentication, KSolBtLMProxy, 0);

		}

	return err;

	}

/**

  API useful for Bluetooth as seen from a device perspective

*/

TInt RBTBaseband::Open(RSocketServ& aSocketServ)

	{

	// need to specify this is a raw socket

	TInt err = iSocket.Open(aSocketServ, 

							KBTAddrFamily, 

							KSockBluetoothTypeRawBroadcast, 

							KBTLinkManager);

	return err;

	}

void RBTBaseband::Connect(const TBTDevAddr& aAddr, TRequestStatus& aStatus)

	{

	iConnectToken().iDevice.SetAddress(aAddr);

	DoConnect(aStatus);

	}

void RBTBaseband::Connect(const TPhysicalLinkQuickConnectionToken& aToken, TRequestStatus& aStatus)

//  (Not for documentation!)

//	param	aDevice	

//	A valid nameless device - that may have been obtained from Registry

	{

	if (!iConnectToken().iDevice.IsValidAddress())

		{

		LocalComplete(aStatus, KErrArgument);

		}

	else

		{

		iConnectToken() = aToken;

		DoConnect(aStatus);

		}

	}

TInt RBTBaseband::Broadcast(const TDesC8& aData)

	{

#ifdef PROXY_COMMUNICATES

	// have to notify Proxy that we intend to write data via it

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		err = iSocket.SetOpt(EBBBeginRaw, KSolBtLMProxy, 0);

		}

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

		{

		TRequestStatus s;

		TUint8 flags = KPiconetBroadcast << 2;

		iSocket.Send(aData, flags, s);	// 'send' to allow flags

		User::WaitForRequest(s);

		err = s.Int();

		}

	return err;

#else

	return KErrNotSupported;

#endif

	}

TInt RBTBaseband::ReadRaw(TDes8& aData)

/**

	NOT PROPERLY IMPLEMENTED - JUST A PLACE HOLDER REALLY

*/

	{

#ifdef PROXY_COMMUNICATES

	// have to notify Proxy that we intend to write data via it

	TInt err;

	if (!SubSessionHandle())

		{

		err = KErrNotReady;

		}

	else

		{

		err = iSocket.SetOpt(EBBBeginRaw, KSolBtLMProxy, 0);

		}

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

		{

		TRequestStatus s;

		TUint8 flags = KPiconetBroadcast << 2;

		iSocket.Recv(aData, flags, s);	// 'send' to allow flags

		User::WaitForRequest(s);

		err = s.Int();

		}

	return err;

#else

	return KErrNotSupported;

#endif

	}

void RBTBaseband::TerminatePhysicalLink(TInt /*aReason*/)

	{

	// synchronise

	TRequestStatus stat;

	TerminatePhysicalLink(0, stat);

	User::WaitForRequest(stat);

	}

void RBTBaseband::TerminatePhysicalLink(TInt /*aReason*/, TRequestStatus& aStatus)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		// synchronise

		TBuf8<1> dummy;

		iSocket.Shutdown(RSocket::EImmediate, KDisconnectOnePhysicalLink, dummy, aStatus); // this *means* detach now

		}

	}

void RBTBaseband::TerminatePhysicalLink(TInt /*aReason*/, const TBTDevAddr& aAddr, TRequestStatus& aStatus)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		// ensure that BT address has persistence

		iSocketAddress.Zero();

		iSocketAddress.Copy(aAddr.Des());

		// the following line needs to be EImmediate when ESock has been fixed

		iSocket.Shutdown(RSocket::ENormal, iSocketAddress, iConnectInData, aStatus); // this *means* detach now

		}

	}

void RBTBaseband::ShutdownPhysicalLink(TRequestStatus& aStatus)

	{

	if (!SubSessionHandle())

		{

		LocalComplete(aStatus, KErrNotReady);

		}

	else

		{

		// synchronise

		TBuf8<1> dummy;

  		iSocket.Shutdown(RSocket::ENormal, KDisconnectOnePhysicalLink, dummy, aStatus); // this *means* detach gently