// 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:

// Accenture - modified for fshell's btincomingserial.dll

//

// Description:

// Name     : CBtService.cpp

// Part of  : ex_btsocket

// Created  : 17/11/2004 by Shane Kearns

// Server "smart connector" class

// Version  :

// 

//

#include "btservice.h"

#include "btdebug.h"

#include "btincomingserial.h"

/**

Standard Symbian style 2 phase construction

@param aServiceUUID a universally unique identifier for this application.

@param aSdpSession a constructed sdp session owned by the 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 aProtocol the protocol (RFCOMM or L2CAP) to register

@param aSecurity optional security settings to use on the socket instead of system defaults

*/

CBtService* CBtService::NewL(const TUUID& aServiceUUID, 

							 RSdp& aSdpSession, 

							 RSocketServ& aSocketServer, 

							 CBluetoothIncomingSerialConnection& aOwner,

							 TUint aProtocol,

							 const TBTServiceSecurity* aSecurity)

	{

	TRACE1("+CBtService::NewL");

	__ASSERT_ALWAYS(aProtocol == KL2CAP || aProtocol == KRFCOMM, PANIC());

	CBtService* self = new(ELeave) CBtService(aSocketServer, aOwner, aProtocol);

	CleanupStack::PushL(self);

	self->ConstructL(aServiceUUID, aSdpSession, aSecurity);

	CleanupStack::Pop(self);

	TRACE1("-CBtService::NewL");

	return self;

	}

/**

Standard 1st phase constructor, inialise member variables

*/

CBtService::CBtService(RSocketServ& aSocketServer, CBluetoothIncomingSerialConnection& aOwner, TUint aProtocol) :

	iSocketServer(aSocketServer),

	iOwner(aOwner),

	iProtocol(aProtocol)

	{

	TRACE2("CBtService::CBtService@%08x", this);

	}

/**

Standard 2nd phase constructor, perform initialisation which could leave

*/

void CBtService::ConstructL(const TUUID& aServiceUUID, RSdp& aSdpSession, const TBTServiceSecurity* aSecurity)

	{

	TRACE1("+CBtService::ConstructL");

	//open handle so it is certain to be valid in the destructor

	User::LeaveIfError(iServiceRecord.Open(aSdpSession));

	//First, create a listening socket

	if(iProtocol == KL2CAP)

		{

		iAcceptorSocket = CBluetoothSocket::NewL(*this, iSocketServer, KSockSeqPacket, KL2CAP);

		//bind the socket to a port

		TL2CAPSockAddr addr;

		addr.SetPort(KL2CAPPassiveAutoBind); //allow the stack to choose a free port automatically

		if(aSecurity)

			{

			addr.SetSecurity(*aSecurity); //set security requirements, if present

			}

		User::LeaveIfError(iAcceptorSocket->Bind(addr));

		}

	else if(iProtocol == KRFCOMM)

		{

		iAcceptorSocket = CBluetoothSocket::NewL(*this, iSocketServer, KSockStream, KRFCOMM);

		//bind the socket to a port

		TRfcommSockAddr addr;

		addr.SetPort(KRfcommPassiveAutoBind); //allow the stack to choose a free port automatically

		if(aSecurity)

			{

			addr.SetSecurity(*aSecurity); //set security requirements, if present

			}

		User::LeaveIfError(iAcceptorSocket->Bind(addr));

		}

	User::LeaveIfError(iAcceptorSocket->Listen(1)); 

	//Now, register in the SDP database

	TUint port = iAcceptorSocket->LocalPort(); //get the port chosen by the stack

	TRACE2("Listening for connections on port %d", port);

	iServiceRecord.CreateServiceRecordL(aServiceUUID, iServiceRecordHandle);

	// Set attr 4 (protocol list) to L2CAP, and RFCOMM

	CSdpAttrValueDES *attrValDES;

	//This following code is doing these steps

	//1. create a DES (data element set) attribute

	//2. within that list, create a DES for each protocol, L2CAP and optionally RFCOMM

	//3. each protocol is a list of elements, the UUID of the protocol, and the port to connect to.

	//4. the service record is updated to include the new attribute

	//5. discard the attribute we built, as it has been copied to the SDP server

	attrValDES = CSdpAttrValueDES::NewDESL(NULL);

	CleanupStack::PushL(attrValDES);

	if(iProtocol == KL2CAP)

		{

		TRACE1("Registering SDP PDL for L2CAP");

		//This code will register an L2CAP (datagram) service

		attrValDES

			->StartListL()

				->BuildDESL()

					->StartListL()

						->BuildUUIDL(TUUID(TUint16(KL2CAP)))	// L2CAP

						->BuildUintL(TSdpIntBuf<TUint16>(TUint16(port)))	// The Protocol Service Multiplexor (port) for our service

					->EndListL()

			->EndListL();

		}

	else if(iProtocol == KRFCOMM)

		{

		TRACE1("Registering SDP PDL for RFCOMM");

		//This code will register an RFCOMM (stream) service

		attrValDES

			->StartListL()

				->BuildDESL()

					->StartListL()

						->BuildUUIDL(TUUID(TUint16(KL2CAP))) // L2CAP

					->EndListL()

				->BuildDESL()

					->StartListL()

						->BuildUUIDL(TUUID(TUint16(KRFCOMM))) // RFCOMM

						->BuildUintL(TSdpIntBuf<TUint8>(TUint8(port)))

					->EndListL()

			->EndListL();

		}

	iServiceRecord.UpdateAttributeL(iServiceRecordHandle, KSdpAttrIdProtocolDescriptorList, *attrValDES);

	CleanupStack::PopAndDestroy(attrValDES);

	attrValDES = NULL;

	_LIT8(KSerialPortServiceName, "Bluetooth Serial Console");

	CSdpAttrValueString* attrVal = CSdpAttrValueString::NewStringL(KSerialPortServiceName);

	CleanupStack::PushL(attrVal);

	iServiceRecord.UpdateAttributeL(iServiceRecordHandle, 

			KSdpAttrIdBasePrimaryLanguage + KSdpAttrIdOffsetServiceName, *attrVal);

	CleanupStack::PopAndDestroy(attrVal);

	attrVal = NULL;

	TRACE1("-CBtService::ConstructL");

	}

CBtService::~CBtService()

	{

	TRACE1("CBtService::~CBtService");

	//attempt to remove the SDP record

	TRAP_IGNORE(iServiceRecord.DeleteRecordL(iServiceRecordHandle));

	iServiceRecord.Close();

	delete iAcceptorSocket;

	}

/**

Accept a new connection.

When the incoming connection has been made, HandleAcceptCompleteL() will be called

in this class.

That function informs the owner by calling HandleNewConnection() or HandleConnectFailed()

@param aBlankSocket an empty socket to receive the incoming connection. 

*/

void CBtService::AcceptConnection(CBluetoothSocket& aBlankSocket)

	{

	TRACE1("+CBtService::AcceptConnection");

	__ASSERT_ALWAYS(iConnectionSocket == NULL, PANIC());

	iConnectionSocket = &aBlankSocket;

	iAcceptorSocket->Accept(*iConnectionSocket);

	TRACE1("-CBtService::AcceptConnection");

	}

/**

Callback from CBluetoothSocket when a new incoming connection is complete.

Inform the owner 

*/

void CBtService::HandleAcceptCompleteL(TInt aErr)

	{

	TRACE1("+CBtService::HandleAcceptCompleteL");

	if(aErr == KErrNone)

		{

		iOwner.HandleNewConnection(iConnectionSocket); 

		}

	else

		{

		iOwner.HandleConnectFailed(aErr);

		}

	iConnectionSocket = NULL;

	TRACE1("-CBtService::HandleAcceptCompleteL");

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleConnectCompleteL(TInt /*aErr*/)

	{

	TRACE1("+CBtService::HandleConnectCompleteL");

	PANIC();

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleShutdownCompleteL(TInt /*aErr*/)

	{

	TRACE1("+CBtService::HandleShutdownCompleteL");

	PANIC();

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleSendCompleteL(TInt /*aErr*/)

	{

	TRACE1("+CBtService::HandleSendCompleteL");

	PANIC();

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleReceiveCompleteL(TInt /*aErr*/)

	{

	TRACE1("+CBtService::HandleReceiveCompleteL");

	PANIC();

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleIoctlCompleteL(TInt /*aErr*/)

	{

	TRACE1("+CBtService::HandleIoctlCompleteL");

	PANIC();

	}

/**

This function is not used but must be implemented as it is pure virtual

*/

void CBtService::HandleActivateBasebandEventNotifierCompleteL(TInt /*aErr*/, TBTBasebandEventNotification& /*aEventNotification*/)

	{

	TRACE1("+CBtService::HandleActivateBasebandEventNotifierCompleteL");

	PANIC();

	}