// Copyright (c) 2004-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:
// Name     : CBtClient.cpp
// Part of  : ex_btsocket
// Created  : 17/11/2004 by Shane Kearns
// Client "smart connector" class
// Version  :
// 
//

#include <e32std.h>
#include <bt_sock.h>
#include <btsdp.h>
#include <btextnotifiers.h>
#include "cbtclient.h"

/**
Standard Symbian style 2 phase construction
@param aServiceUUID a universally unique identifier for this application.
@param aSocketServer a constructed socket server session owned by the application
@param aOwner the owning class which should receive notification of new connections
@param aSecurityRequirements optional security settings to use on the socket instead of defaults.  The default is Authorisation only ("Accept connection from xxx" dialog but no pairing)
*/
EXPORT_C CBtClient* CBtClient::NewL(const TUUID& aServiceUUID, RSocketServ& aSocketServer, MConnectionObserver& aOwner, TBTServiceSecurity* aSecurityRequirements)
	{
	LOG_FN_TRACE((_L("+CBtClient::NewL")));
	CBtClient* self = new(ELeave) CBtClient(aServiceUUID, aSocketServer, aOwner);
	CleanupStack::PushL(self);
	self->ConstructL(aSecurityRequirements);
	CleanupStack::Pop(self);
	LOG_FN_TRACE((_L("-CBtClient::NewL")));
	return self;
	}

/**
First phase constructor
initialise member data
*/
CBtClient::CBtClient(const TUUID& aServiceUUID, RSocketServ& aSocketServer, MConnectionObserver& aOwner) :
	CActive(CActive::EPriorityStandard),
	iSocketServer(aSocketServer),
	iServiceUUID(aServiceUUID),
	iOwner(aOwner)
	{
	}

/**
Second phase constructor
Leaving initialisation
*/
void CBtClient::ConstructL(TBTServiceSecurity* aSecurityRequirements)
	{
	LOG_FN_TRACE((_L("+CBtClient::ConstructL")));
	CActiveScheduler::Add(this);
	if(aSecurityRequirements)
		{
		iSecurityRequirements = *aSecurityRequirements;
		}
	else
		{
		//default security settings - authorisation only
		iSecurityRequirements.SetDenied(EFalse);
		iSecurityRequirements.SetAuthorisation(ETrue);
		iSecurityRequirements.SetAuthentication(EMitmNotRequired);
		iSecurityRequirements.SetEncryption(EFalse);
		}
	LOG_FN_TRACE((_L("-CBtClient::ConstructL")));
	}

/**
Destructor
free all resources
*/
EXPORT_C CBtClient::~CBtClient()
	{
	LOG_FN_TRACE((_L("+CBtClient::~CBtClient")));
	Deque();
	delete iConnectionSocket;
	delete iSdpAgent;
	LOG_FN_TRACE((_L("-CBtClient::~CBtClient")));
	}

/**
This function attempts to connect to a remote device
First it does a device discovery using the UI notifier
Second it does an SDP search
Third it will make the socket connection using AttemptConnection()
Failure at any stage is reported via the HandleConnectFailed() callback
Success is reported with the HandleNewConnection() callback
@param aSocketOwner the object which will take ownership of allocated socket.
*/
EXPORT_C void CBtClient::ConnectToRemoteDeviceL(MBluetoothSocketNotifier& aSocketOwner)
	{
	LOG_FN_TRACE((_L("+CBtClient::ConnectToRemoteDeviceL")));
	TBTDevAddr addr;
	TBTDeviceSelectionParamsPckg params;
	TBTDeviceResponseParamsPckg result;
	params().SetUUID(iServiceUUID); //As far as I know, no UI currently implements this yet.

	//use the notifier server to select a device.
	RNotifier notif;
	User::LeaveIfError(notif.Connect());

	TRequestStatus stat;
    notif.StartNotifierAndGetResponse(stat, KDeviceSelectionNotifierUid, params, result);

	User::WaitForRequest(stat);
	notif.Close();
	User::LeaveIfError(stat.Int());

	addr = result().BDAddr();

	ConnectToRemoteDeviceL(addr, aSocketOwner);

	LOG_FN_TRACE((_L("-CBtClient::ConnectToRemoteDeviceL")));
	}

/**
This function attempts to connect to a remote device
First it does an SDP search
Second it will make the socket connection using AttemptConnection()
Failure at any stage is reported via the HandleConnectFailed() callback
Success is reported with the HandleNewConnection() callback
@param aAddr the bluetooth address of remote device
@param aSocketOwner the object which will take ownership of allocated socket.
@note use this version if you already know the device to connect to, e.g. you made your own discovery UI using RHostResolver
*/
EXPORT_C void CBtClient::ConnectToRemoteDeviceL(TBTDevAddr& aAddr, MBluetoothSocketNotifier& aSocketOwner)
	{
	LOG_FN_TRACE((_L("+CBtClient::ConnectToRemoteDeviceL")));
	iConnectingToDevice = aAddr;
	//First, we need to perform an SDP search to discover what port the service is running on
	__ASSERT_ALWAYS(iSdpAgent == NULL && iConnectionSocket == NULL && iSocketOwner == NULL, ExBtSocket::Panic(ExBtSocket::EReEntrant));
	iSocketOwner = &aSocketOwner;
	iSdpAgent = CSdpAgent::NewL(*this, aAddr);

	//Create a search pattern so we only see SDP records for our application
	CSdpSearchPattern *pattern = CSdpSearchPattern::NewL();
	CleanupStack::PushL(pattern);
	pattern->AddL(iServiceUUID);
	iSdpAgent->SetRecordFilterL(*pattern);
	CleanupStack::PopAndDestroy(pattern);

	//Create a search pattern for the SDP attributes we are interested in - only protocol descriptor in this case
	CSdpAttrIdMatchList* attribs = CSdpAttrIdMatchList::NewL();
	CleanupStack::PushL(attribs);
	attribs->AddL(TAttrRange(KSdpAttrIdProtocolDescriptorList));
	iSdpAgent->SetAttributePredictorListL(*attribs);
	CleanupStack::PopAndDestroy(attribs);
	
	//Start the search...
	iSdpAgent->NextRecordRequestL();
	//Results will be in NextRecordRequestComplete()
	LOG_FN_TRACE((_L("-CBtClient::ConnectToRemoteDeviceL")));
	}

/**
This function is called after SDP search is completed.
It is used to allocate an appropriate socket and start the connection procedure
*/
void CBtClient::AttemptConnection(TUUID aProtocol, TUint16 aPort)
	{
	LOG_FN_TRACE((_L("+CBtClient::AttemptConnection")));
	//Convert protocol from a UUID (SDP format) to a TUint (ESOCK format)
	TUint protocol;
	TUint socktype;
	TBTSockAddr* addrCommon;
	//protocol specific initialisation
	if(aProtocol == TUUID(KL2CAP))
		{
		protocol = KL2CAP;
		socktype = KSockSeqPacket;
		LOG_INFO((_L("Creating an L2CAP socket")));
		iAddrL2CAP.SetPort(aPort);
		addrCommon = &iAddrL2CAP;
		}
	else if(aProtocol == TUUID(KRFCOMM))
		{
		protocol = KRFCOMM;
		socktype = KSockStream;
		LOG_INFO((_L("Creating an RFCOMM socket")));
		iAddrRFCOMM.SetPort(aPort);
		addrCommon = &iAddrRFCOMM;
		}
	else
		{
		CallOut(KErrNotSupported);
		return;
		}
	//Common initialisation
	addrCommon->SetBTAddr(iConnectingToDevice);
	addrCommon->SetSecurity(iSecurityRequirements);

	//Create the socket and make an outgoing connection
	TRAPD(err, iConnectionSocket = CBluetoothSocket::NewL(*iSocketOwner, iSocketServer, socktype, protocol));
	if(err != KErrNone)
		{
		CallOut(err);
		return;
		}
	iConnectionSocket->Connect(*addrCommon);

	//The current API doesnt allow the MBluetoothSocketNotifier to be changed after construction.
	//Therefore, the client must deal with connection success or failure
	NewConnection();
	LOG_FN_TRACE((_L("-CBtClient::AttemptConnection")));
	}

/**
Called to clean up after we failed to make a connection for some reason
e.g. missing SDP record.
Reset the object to initial state, then callback the owner
*/
void CBtClient::ConnectFailed(TInt aError)
	{
	LOG_FN_TRACE((_L("+CBtClient::ConnectFailed")));
	//Connection failed, attempt to clean up.
	delete iConnectionSocket;
	iConnectionSocket = NULL;
	delete iSdpAgent;
	iSdpAgent = NULL;
	iSocketOwner = NULL;
	//and inform owner
	iOwner.HandleConnectFailed(aError);
	LOG_FN_TRACE((_L("-CBtClient::ConnectFailed")));
	}

/**
Called when we made a connection successfully.
The HandleConnectComplete() from CBluetoothSocket will be sent to the owning object.
In this function, we transfer the CBluetoothSocket pointer to our owner, and perform clean up.
*/
void CBtClient::NewConnection()
	{
	LOG_FN_TRACE((_L("+CBtClient::NewConnection")));
	delete iSdpAgent;
	iSdpAgent = NULL;
	//Connection complete
	CBluetoothSocket *socket = iConnectionSocket;
	iConnectionSocket = NULL; //ownership transferred	
	iOwner.HandleNewConnection(socket);
	iSocketOwner = NULL;
	LOG_FN_TRACE((_L("-CBtClient::NewConnection")));
	}

/**
Asynchronously call back this object.
This is done to avoid deleting the SDP agent from within one of its callbacks.

Called with KErrNone, it will schedule AttemptConnection()
Called with an error, it will schedule ConnectFailed()
*/
void CBtClient::CallOut(TInt aErr)
	{
	LOG_FN_TRACE((_L("+CBtClient::CallOut")));
	SetActive();
	TRequestStatus* stat = &iStatus;
	User::RequestComplete(stat, aErr);
	LOG_FN_TRACE((_L("-CBtClient::CallOut")));
	}

//virtual functions from CActive

/**
This is the callback from CallOut()
Called with KErrNone, it will run AttemptConnection()
Called with an error, it will run ConnectFailed()
*/
void CBtClient::RunL()
	{
	LOG_FN_TRACE((_L("+CBtClient::RunL")));
	delete iSdpAgent; // done with this
	iSdpAgent = NULL;
	if(iStatus==KErrNone)
		{
		AttemptConnection(iParser.iProtocol, static_cast<TUint16>(iParser.iPort));
		iParser.iFoundFlags = 0;
		}
	else
		{
		ConnectFailed(iStatus.Int());
		}
	LOG_FN_TRACE((_L("-CBtClient::RunL")));
	}

/**
pure virtual function of CActive
This function should cancel any outstanding asynchronous requests.
However, this class doesn't make any asynchronous requests, it only completes itself.
So there is guarunteed not to be a request outstanding when this is called.
*/
void CBtClient::DoCancel()
	{
	ASSERT(iStatus != KRequestPending);
	}

//Virtual functions from MSdpAgentNotifier

/**
This function is a callback from SDP when it has found or failed to find a matching service record
In this example, we assume there will be only one good matching record (valid for most applications)
*/
#ifdef _DEBUG
void CBtClient::NextRecordRequestComplete(TInt aError, TSdpServRecordHandle aHandle, TInt aTotalRecordsCount)
#else
void CBtClient::NextRecordRequestComplete(TInt aError, TSdpServRecordHandle aHandle, TInt /*aTotalRecordsCount*/)
#endif
	{
	LOG_FN_TRACE((_L("+CBtClient::NextRecordRequestComplete")));
#ifdef _DEBUG
	LOG_INFO((_L("SDP record found, err=%d, handle=%d, count=%d"), aError, aHandle, aTotalRecordsCount));
#endif
	if(aError == KErrNone)
		{
		//We have found a service, query its port
		TRAP(aError, iSdpAgent->AttributeRequestL(aHandle, KSdpAttrIdProtocolDescriptorList));
		}
	else if(aError == KErrEof)
		{
		if(iParser.iFoundFlags != (TBtClientSdpProtocolListParser::EFoundPort | TBtClientSdpProtocolListParser::EFoundProtocol))
			{
			aError = KErrNotFound;
			}
		else
			{
			aError = KErrNone;
			CallOut(KErrNone);
			}
		}
	if(aError != KErrNone)
		{
		CallOut(aError);
		}
	LOG_FN_TRACE((_L("-CBtClient::NextRecordRequestComplete")));
	}

/**
This function is a callback from SDP when it finds a matching service attribute
The attribute value is transferred to us so we must delete it when finished with it
*/
#ifdef _DEBUG
void CBtClient::AttributeRequestResult(TSdpServRecordHandle aHandle, TSdpAttributeID aAttrID, CSdpAttrValue* aAttrValue)
#else
void CBtClient::AttributeRequestResult(TSdpServRecordHandle /*aHandle*/, TSdpAttributeID aAttrID, CSdpAttrValue* aAttrValue)
#endif
	{
	LOG_FN_TRACE((_L("+CBtClient::AttributeRequestResult")));
#ifdef _DEBUG
	LOG_INFO((_L("SDP attribute found, handle=%d, id=0x%x"), aHandle, aAttrID));
#endif

	if(aAttrID == KSdpAttrIdProtocolDescriptorList)
		{
		//Decode the SDP attribute to find protocol and port
		TRAPD(err, aAttrValue->AcceptVisitorL(iParser));
		if(err != KErrNone)
			{
			CallOut(err);
			}
		}
	delete aAttrValue;
	LOG_FN_TRACE((_L("-CBtClient::AttributeRequestResult")));
	}

/**
The function is a callback from SDP after fully processing a service attribute
We schedule a search for the next matching service record.
*/
void CBtClient::AttributeRequestComplete(TSdpServRecordHandle, TInt /*aError*/)
	{
	LOG_FN_TRACE((_L("+CBtClient::AttributeRequestComplete")));
	TRAPD(err, iSdpAgent->NextRecordRequestL());
	if(err != KErrNone)
		{
		CallOut(err);
		}
	LOG_FN_TRACE((_L("-CBtClient::AttributeRequestComplete")));
	}

/**
Constructor
*/
TBtClientSdpProtocolListParser::TBtClientSdpProtocolListParser()
	{
	iFoundFlags = 0;
	}

/**
This function is a callback from SDP which is called with each element of the protocol descriptor list
we are parsing.
There will be one or more protocol UUIDs, received in lower -> higher layer order.
We are interested only in the highest layer protocol, so overwrite each time.
For the highest layer protocol, there will be connection parameters (a port number).
This implementation only supports L2CAP and RFCOMM, so other protocols will cause a KErrNotSupported exception.
*/
void TBtClientSdpProtocolListParser::VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)
	{
	LOG_FN_TRACE((_L("+TBtClientSdpProtocolListParser::VisitAttributeValueL")));
	switch(aType)
		{
		case ETypeDES:
		case ETypeDEA:
			break;
		case ETypeUUID:
			iProtocol = aValue.UUID();
			iFoundFlags |= EFoundProtocol;
			if(iProtocol == TUUID(KL2CAP))
				{
				LOG_INFO((_L("Found L2CAP protocol")));
				}
			else if(iProtocol == TUUID(KRFCOMM))
				{
				LOG_INFO((_L("Found RFCOMM protocl")));
				}
			else
				{
				LOG_ERROR((_L("Found unsupported protocol")));
				User::Leave(KErrNotSupported);
				}
			break;
		case ETypeUint:
			if(aValue.DoesIntFit())
				{
				iPort = aValue.Uint();
				iFoundFlags |= EFoundPort;
				LOG_INFO((_L("Found port %d"), iPort));
				}
			else
				{
				LOG_ERROR((_L("Port won't fit in 32 bits")));
				User::Leave(KErrNotSupported);
				}
			break;
		default:
			LOG_ERROR((_L("Found unexpected attribute type %d"), aType));
			User::Leave(KErrNotSupported);
			break;
		}
	LOG_FN_TRACE((_L("+TBtClientSdpProtocolListParser::VisitAttributeValueL")));
	}

/**
Callback from SDP at the start of each DEA or DES in the protocol descriptor list.
In this implementation we don't care about structure so it is ignored
*/
void TBtClientSdpProtocolListParser::StartListL(CSdpAttrValueList& /*aList*/)
	{
	//do nothing
	}

/**
Callback from SDP at the end of each DEA or DES in the protocol descriptor list.
In this implementation we don't care about structure so it is ignored
*/
void TBtClientSdpProtocolListParser::EndListL()
	{
	//do nothing
	}