// 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 "btsocketpanic.h"

#include "btsockethelpers.h"

#include "e32cmn.h" 

#include <bluetooth/logger.h>

void Panic(TBTSocketPanics aCode)

	{

	_LIT(KPanicName, "BTSocket");

	User::Panic(KPanicName, aCode);

	}

//*****************//

//----

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewL(MBluetoothSocketNotifier& aNotifier, 

												  RSocketServ& aServer, 

												  TUint aSockType,

												  TUint aProtocol)

/** Standard Bluetooth socket NewL constructor.

Opens a Bluetooth socket. The constructor identifies the server, socket type, and bluetooth 

protocol to be used for the socket, as well as an asynchronous notifier.

@pre A session on the socket server has been started.

@leave No memory, or error on opening socket.

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock).

@param aSockType One of a set of values defined in es_sock.h, for example KSockStream.

@param aProtocol An entry point into the Bluetooth stack, for example KL2CAP.

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

	CBluetoothSocket* self = NewLC(aNotifier, aServer, aSockType,aProtocol);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewLC(MBluetoothSocketNotifier& aNotifier, 

												   RSocketServ& aServer,

												   TUint aSockType,

												   TUint aProtocol)

/** Standard Bluetooth socket NewLC constructor.

Opens a Bluetooth socket as with the NewL() above, but leaves the returned CBluetoothSocket

object on the cleanup stack.

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aSockType One of a set of values defined in es_sock.h, for example KSockStream

@param aProtocol An entry point into the Bluetooth stack, for example KL2CAP

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aSockType, aProtocol);

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewL(MBluetoothSocketNotifier& aNotifier, 

												  RSocketServ& aServer, 

												  TUint aSockType,

												  TUint aProtocol,

												  RConnection& aConnection)

/** Opens a Bluetooth socket on a specified connection.

@pre A session on the socket server has been started.

@leave No memory, or error on opening socket

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aSockType One of a set of values defined in es_sock.h, for example KSockStream

@param aProtocol An entry point into the Bluetooth stack, for example KL2CAP

@param aConnection A socket server management interface for a connection

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

	CBluetoothSocket* self = NewLC(aNotifier, aServer, aSockType, aProtocol, aConnection);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewLC(MBluetoothSocketNotifier& aNotifier, 

												   RSocketServ& aServer,

												   TUint aSockType,

												   TUint aProtocol,

												   RConnection& aConnection)

/** This constructor opens a Bluetooth socket on a specified connection.

Leaves the socket on the cleanup stack.

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aSockType One of a set of values defined in es_sock.h, for example KSockStream

@param aProtocol An entry point into the Bluetooth stack, for example KL2CAP

@param aConnection A socket server management interface for a connection

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aSockType, aProtocol, aConnection);

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewL(MBluetoothSocketNotifier& aNotifier, 

												  RSocketServ& aServer,

												  const TDesC& aName)

/** Bluetooth socket named protocol NewL() constructor.

Opens a Bluetooth socket over a specified named protocol, such as "L2CAP".

@pre A session on the socket server has been started.

@leave No memory, or error on opening socket

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aName A descriptor containing the name of the protocol wanted for

making a Bluetooth connection, for example _L("L2CAP")

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

	CBluetoothSocket* self = NewLC(aNotifier, aServer, aName);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewLC(MBluetoothSocketNotifier& aNotifier, 

												   RSocketServ& aServer,

												   const TDesC& aName)

/** Bluetooth socket named protocol NewLC() constructor.

Opens a Bluetooth socket over a specified named protocol, such as "L2CAP".

Leaves returned CBluetoothSocket object on the cleanup stack.

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aName A descriptor containing the name of the protocol wanted for

making a Bluetooth connection, for example _L("L2CAP")

@return The Bluetooth socket created with the constructor.

@capability LocalServices

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aName);

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewL(MBluetoothSocketNotifier& aNotifier, RSocketServ& aServer)

/** Bluetooth blank socket NewL() constructor.

Opens a blank socket to be used when accepting an incoming connection.

This socket should be used as the parameter when a listening socket

calls CBluetoothSocket::Accept(CBluetoothSocket& aBlankSocket). When 

that connection completes this blank socket becomes the Bluetooth 

socket for that connection.

@pre A session on the socket server has been started.

@leave No memory, or error on opening socket

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@return The Bluetooth socket created with the constructor.

*/

	{

	CBluetoothSocket* self = NewLC(aNotifier, aServer);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewLC(MBluetoothSocketNotifier& aNotifier, RSocketServ& aServer)

/** Bluetooth blank socket NewLC() constructor

Opens a blank socket to be used when accepting an incoming connection.

This socket should be used as the parameter when a listening socket

calls CBluetoothSocket::Accept(CBluetoothSocket& aBlankSocket). When 

that connection completes this blank socket becomes the Bluetooth 

socket for that connection.

Leaves returned CBluetoothSocket object on the cleanup stack.

@pre A session on the socket server has been started.

@leave No memory, or error on opening socket

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@return The Bluetooth socket created with the constructor.

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewL(MBluetoothSocketNotifier& aNotifier,

												  RSocketServ& aServer,

												  RSocket& aSocket)

/** Bluetooth socket using an existing RSocket instance constructor.

Takes ownership of an existing socket to be used as the underlying

connection for this Socket wrapper.  This should be used where an

existing API returned a RSocket representing a Bluetooth connection.

@pre A session on the socket server has been started, and aSocket is open and is

set as "Transferable" through the KSOEnableTransfer SetOpt. 

@leave No memory

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aSocket A handle to an existing socket.

@return The Bluetooth socket created with the constructor.

*/

	{

	CBluetoothSocket* self = NewLC(aNotifier, aServer, aSocket);

	CleanupStack::Pop();

	return self;

	}

EXPORT_C CBluetoothSocket* CBluetoothSocket::NewLC(MBluetoothSocketNotifier& aNotifier, 

												   RSocketServ& aServer,

												   RSocket& aSocket)

/** Bluetooth socket using an existing RSocket instance constructor.

Takes ownership of an existing socket to be used as the underlying

connection for this Socket wrapper.  This should be used where an

existing API returned a RSocket representing a Bluetooth connection.

Leaves returned CBluetoothSocket object on the cleanup stack.

@pre A session on the socket server has been started, and aSocket is open and is

set as "Transferable" through the KSOEnableTransfer SetOpt.

@leave No memory

@param aNotifier The object which will receive asynchronous events.

@param aServer A handle to an existing session on the socket server (ESock)

@param aSocket A handle to an existing socket.

@return The Bluetooth socket created with the constructor.

*/

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aSocket);

	return self;

	}

EXPORT_C CBluetoothSocket::~CBluetoothSocket()

/** Destructor

Cancels any outstanding Bluetooth socket functions and closes the socket.

Note sockets should be closed or shutdown before destructor is called.

*/

	{

	delete iAutoSniffDelayTimer;

	delete iBTConnecter;

	delete iBTAccepter;

	delete iBTShutdowner;

	delete iBTReceiver;

	delete iBTSender;

	delete iBTIoctler;

	delete iBTBasebandChangeEventNotifier;

	if(Socket().SubSessionHandle())

		{

		Socket().Close();

		}

	delete iBTBasebandManager; // Unregisters any basebands it has registered

	delete iBTBasebandChangeEventDelegate;

	delete iAsyncDestroyer;

	}

//RSocket functions

EXPORT_C TInt CBluetoothSocket::Send(const TDesC8& aDesc,TUint someFlags)

/** Sends data to a remote bluetooth device.

The Send() operation checks that another Send() operation isn't already in

progress before sending.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed.

This is done in the function MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr).

If Automatic Sniff Mode is active, using this function will not automatically put the link

into active mode. If it is required that the link be taken out of sniff mode automatically

when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function

should be used instead.

@param aDesc A descriptor for the data being sent to the remote device.

@param someFlags Bluetooth specific flags.

@return KErrNone meaning the operation was successful and data is being sent to the remote device,

        or KErrInUse meaning a previous Send() is not yet finished.

@see RSocket::Send(const TDesC8& aDesc,TUint someFlags,TRequestStatus& aStatus)

*/

	{

	TInt rerr = KErrNone;

	if(iSending)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTSender->Send(aDesc, someFlags);

		iSending = ETrue;

		}

	return rerr;

	}

EXPORT_C TInt CBluetoothSocket::Send(const TDesC8& aDesc,TUint someFlags,TSockXfrLength& aLen)

/**  Sends data to a remote bluetooth device.

The Send() operation checks that another Send() operation isn't already in

progress before sending.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed. 

This is done in the function

MBluetoothSocketNotifier::HandleSendCompleteL(TInt aErr)

If Automatic Sniff Mode is active, using this function will not automatically put the link

into active mode. If it is required that the link be taken out of sniff mode automatically

when data is to be sent then the CBluetoothSocket::Write(const TDesC8& aDesc) function

should be used instead.

@param aDesc A descriptor for the data being sent to the remote device.

@param someFlags Bluetooth specific flags.

@param aLen Amount of data being sent.

@return KErrNone meaning the operation was successful and data is being sent to the remote device,

        or KErrInUse meaning a previous Send() is not yet finished.

@see RSocket::Send(const TDesC8& aDesc,TUint someFlags,TSockXfrLength& aLen)

*/

	{

	TInt rerr = KErrNone;

	if(iSending)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTSender->Send(aDesc, someFlags, aLen);

		iSending = ETrue;

		}

	return rerr;

	}

EXPORT_C void CBluetoothSocket::CancelSend()

/** Cancels an outstanding Bluetooth Send() operation.

Calling the function will cause an outstanding Bluetooth Send() 

operation to complete prematurely.

@see RSocket::CancelSend()

*/

	{

	if(iSending)

		{

		iBTSender->Cancel(); //cancels 'Write' or 'Send' as appropriate

		iSending = EFalse;

		}

	}

EXPORT_C TInt CBluetoothSocket::Recv(TDes8& aDesc,TUint flags)

/** Receives data from a remote Bluetooth device.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed. 

This is done in the function 

MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)

@param aDesc A descriptor for the information being sent to the remote Bluetooth device.

@param flags Bluetooth information flags.

@return KErrNone meaning the operation was successful and data is being received from the remote device,

        or KErrInUse meaning a previous Recv() is not yet finished.

@see RSocket::Recv(TDes8& aDesc,TUint flags)

*/

	{

	TInt rerr = KErrNone;

	if(iReceiving)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTReceiver->Recv(aDesc, flags);

		iReceiving = ETrue;

		}

	return rerr;

	}

EXPORT_C TInt CBluetoothSocket::Recv(TDes8& aDesc,TUint flags, TSockXfrLength& aLen)

/** Receives data from a remote Bluetooth device.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed. 

This is done in the function 

MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)

@param aDesc A descriptor for the information being sent to the remote Bluetooth device.

@param flags Bluetooth information flags.

@param aLen A length indicating how much data was read. This is the same as length of the returned aDesc.

@return KErrNone meaning the operation was successful and data is being received from the remote device,

        or KErrInUse meaning a previous Recv() is not yet finished.

@see RSocket::Recv(TDes8& aDesc,TUint flags, TSockXfrLength& aLen)

*/

	{

	TInt rerr = KErrNone;

	if(iReceiving)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTReceiver->Recv(aDesc, flags, aLen);

		iReceiving = ETrue;	

		}

	return rerr;

	}

EXPORT_C TInt CBluetoothSocket::RecvOneOrMore(TDes8& aDesc,TUint flags,TSockXfrLength& aLen)

/** Receives data from a remote Bluetooth device, completing when data is available.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed. 

This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr).

@param aDesc A descriptor for the information being sent to the remote Bluetooth device.

@param flags Bluetooth information flags.

@param aLen A length indicating how much data was read. This is the same as length of the returned aDesc.

@return KErrNone meaning the operation was successful and data is being received from the remote device,

        or KErrInUse meaning a previous Recv() is not yet finished.

@see RSocket::RecvOneOrMore(TDes8& aDesc,TUint flags,TSockXfrLength& aLen)

*/

	{

	TInt rerr = KErrNone;

	if(iReceiving)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTReceiver->RecvOneOrMore(aDesc, flags, aLen);

		iReceiving = ETrue;

		}

	return rerr;

	}

EXPORT_C void CBluetoothSocket::CancelRecv()

/** Cancels an outstanding Recv() operation. 

Calling this function will cause any outstanding receive operation to cancel.

@see RSocket::CancelRecv()

*/

	{

	if(iReceiving)

		{

		iBTReceiver->Cancel(); //cancels 'Read' or 'Recv' as appropriate

		iReceiving = EFalse;

		}

	}

EXPORT_C TInt CBluetoothSocket::Read(TDes8& aDesc)

/** Receives data from a remote Bluetooth host.

Read() is only used with a connected Bluetooth host.

When this request completes, notification is sent to the MBluetoothSocketNotifier

object	supplied when this CBluetoothSocket was constructed. 

This is done in the function MBluetoothSocketNotifier::HandleReceiveCompleteL(TInt aErr)

@param aDesc A descriptor for the data being read.

@return KErrNone meaning the operation was successful and data is being received from the remote device,

        or KErrInUse meaning a previous Recv() is not yet finished.

@see RSocket::Read(TDes8& aDesc)

*/

	{

	TInt rerr = KErrNone;

	if(iReceiving)

		{

		rerr = KErrInUse;

		}

	else

		{

		iBTReceiver->Read(aDesc);

		iReceiving = ETrue;

		}

	return rerr;

	}

EXPORT_C void CBluetoothSocket::CancelRead()

/** Cancels an outstanding Read() operation. 

Calling this function will cause any outstanding Read() operation to cancel.

@see RSocket::CancelRead()

*/

	{

	if(iReceiving)

		{

		iBTReceiver->Cancel(); //cancels 'Read' or 'Recv' as appropriate

		iReceiving = EFalse;

		}

	}

EXPORT_C TInt CBluetoothSocket::Write(const TDesC8& aDesc)

/** Writes to a remote Bluetooth device

@see RSocket::Write(const TDesC8& aDesc)