// 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     : CBtService.cpp

// Part of  : ex_btsocket

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

// Server "smart connector" class

// Version  :

// 

//

#include "cbtservice.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

*/

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

							 RSdp& aSdpSession, 

							 RSocketServ& aSocketServer, 

							 MConnectionObserver& aOwner,

							 TUint aProtocol,

							 const TBTServiceSecurity* aSecurity=NULL)

	{

	LOG_FN_TRACE((_L("+CBtService::NewL")));

	__ASSERT_ALWAYS(aProtocol == KL2CAP || aProtocol == KRFCOMM, ExBtSocket::Panic(ExBtSocket::EUnsupportedProtocol));

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

	CleanupStack::PushL(self);

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

	CleanupStack::Pop(self);

	LOG_FN_TRACE((_L("-CBtService::NewL")));

	return self;

	}

/**

Standard 1st phase constructor, inialise member variables

*/

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

	iSocketServer(aSocketServer),

	iOwner(aOwner),

	iProtocol(aProtocol)

	{

	}

/**

Standard 2nd phase constructor, perform initialisation which could leave

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::ConstructL")));

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

	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

	LOG_INFO((_L("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)

		{

		LOG_INFO((_L("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)

		{

		LOG_INFO((_L("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;

	LOG_FN_TRACE((_L("-CBtService::ConstructL")));

	}

EXPORT_C CBtService::~CBtService()

	{

	LOG_FN_TRACE((_L("+CBtService::~CBtService")));

	//attempt to remove the SDP record

	TRAP_IGNORE(iServiceRecord.DeleteRecordL(iServiceRecordHandle));

	iServiceRecord.Close();

	delete iAcceptorSocket;

	LOG_FN_TRACE((_L("-CBtService::~CBtService")));

	}

/**

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. 

*/

EXPORT_C void CBtService::AcceptConnection(CBluetoothSocket& aBlankSocket)

	{

	LOG_FN_TRACE((_L("+CBtService::AcceptConnection")));

	__ASSERT_ALWAYS(iConnectionSocket == NULL, ExBtSocket::Panic(ExBtSocket::EReEntrant));

	iConnectionSocket = &aBlankSocket;

	iAcceptorSocket->Accept(*iConnectionSocket);

	LOG_FN_TRACE((_L("-CBtService::AcceptConnection")));

	}

/**

Callback from CBluetoothSocket when a new incoming connection is complete.

Inform the owner 

*/

void CBtService::HandleAcceptCompleteL(TInt aErr)

	{

	LOG_FN_TRACE((_L("+CBtService::HandleAcceptCompleteL")));

	if(aErr == KErrNone)

		{

		iOwner.HandleNewConnection(iConnectionSocket); 

		}

	else

		{

		iOwner.HandleConnectFailed(aErr);

		}

	iConnectionSocket = NULL;

	LOG_FN_TRACE((_L("-CBtService::HandleAcceptCompleteL")));

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleConnectCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleShutdownCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleSendCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleReceiveCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleIoctlCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}

/**

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

*/

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

	{

	LOG_FN_TRACE((_L("+CBtService::HandleActivateBasebandEventNotifierCompleteL")));

	ExBtSocket::Panic(ExBtSocket::EBadCallback);

	}