// Copyright (c) 2005-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:

// BT Host Resolver test code

// 

//

#include "teir.h"

#include <utf.h>

#include <btsdp.h>

#include <e32math.h>

#define USE_SMALL_CONSOLE 0

typedef TBuf<20> TBTDevAddrBuf;

const TUint8 KEIRDataOffset = 1;

//_LIT(KManufacturerData, "This is a very very very very very very very very very very very very very very very very very very very very very very very very very very long data from phone manufacturer!");

_LIT(KManufacturerData, "This is a very very long data from phone manufacturer!");

_LIT(KManufacturerData1, "");

GLDEF_D RTest test(_L("Extended Inquiry Response tests"));

GLDEF_D TBTDevAddr gDevAddr(MAKE_TINT64(0x0002, 0x5b019a39)); // csr

//GLDEF_D TBTDevAddr gDevAddr(MAKE_TINT64(0x001b, 0xdc0f5cae)); // EIR windows

GLDEF_D TSize gSmallConsole(75,50);

//TInt CActiveHostResolver::iHRNumber = 0;

/** 

 Appends a TDesC string to a TDes string. 

 @param aDes String, which aOrg appends to

 @param aDesC String to be appended to aDest

 @return EFalse, if there not enough space in the TDes sting to contain the TDesC string. Otherwise, ETrue.

 */

TBool AppendDes(TDes& aDest, const TDesC& aOrg)

	{

	if((aDest.MaxLength() - aDest.Length()) < aOrg.Length())

		return EFalse;

	aDest.Append(aOrg);

	return ETrue;

	}

// ----------------------------------------------------------------------------

//							EIR App

// ----------------------------------------------------------------------------

CEirApp::CEirApp(CConsoleBase& aConsole)

: iConsole(aConsole)

	{

	}

CEirApp::~CEirApp()

	{

	iResolvers.ResetAndDestroy();

	iResolvers.Close();

	iDevicesFound.Close();

	StopProtocols();

	delete iActiveConsole;

	delete iNameRequester;

	if(iEirPublisherTestManuSpecific)

		{

		delete iManuNotifier;

		delete iEirPublisherTestManuSpecific;

		iManuNotifier = NULL;

		iEirPublisherTestManuSpecific = NULL;

		}

	iSdpDB.Close();

	}

CEirApp* CEirApp::NewL(CConsoleBase& aConsole)

	{

	CEirApp* thisapp = new (ELeave) CEirApp(aConsole);

	CleanupStack::PushL(thisapp);

	thisapp->ConstructL(aConsole);

	CleanupStack::Pop(thisapp);

	return thisapp;

	}

void CEirApp::ConstructL(CConsoleBase& aConsole)

	{

	iConsole.Printf(_L("Using HCI_V2\n"));

	iConsole.Printf(_L("Bluetooth Protocols Loading...\n"));

    InitialiseL();

    iConsole.Printf(_L("Bluetooth Protocols Loaded.\n"));

	ShowAddress();

	iActiveConsole = CActiveConsole::NewL(aConsole, *this);

	iManuNotifier = CManufacturerDataNotifier::NewL(*this);

	iEirPublisherTestManuSpecific = CEirPublisherManufacturerSpecificData::NewL(*iManuNotifier);

	}

void CEirApp::StartL()

	{

	// go ....

	CActiveScheduler::Start();

	}

void CEirApp::Stop()

	{

	CActiveScheduler::Stop();

	}

void CEirApp::SetPublishManuData(TUint aAvailableDataSize)

	{

	// TODO: some logic can be added here to cope with the given aAvailableDataSize

	// maybe truncating the intended data 

	HBufC8* buf = HBufC8::NewL(240);// LocalName-granular truncation

	buf->Des().Append(KManufacturerData);

	if(buf->Des().Length() > aAvailableDataSize)

		{

		TPtrC8 ptr(buf->Left(aAvailableDataSize));

		iEirPublisherTestManuSpecific->SetManufacturerSpecificData(ptr);

		}

	else

		{

		iEirPublisherTestManuSpecific->SetManufacturerSpecificData(*buf);

		}

	delete buf;

	}

void CEirApp::NewEirPublisherTestL(TTestEirTag aTag)

	{

	switch(aTag)

		{

	case ETestDeviceName:

		iNameRequester->SetLocalNameL();

		break;

	case ETestUuid16:

		Register16BitSDPRecordL();

		break;

	case ETestUuid128:

		Register128BitSDPRecordL();

		break;

	case ETestSetMSD:		

		if(!iManuNotifier && !iEirPublisherTestManuSpecific)

			{

			iManuNotifier = CManufacturerDataNotifier::NewL(*this);

			iEirPublisherTestManuSpecific = CEirPublisherManufacturerSpecificData::NewL(*iManuNotifier);

			}

		iEirPublisherTestManuSpecific->RequestPublishDataSize(55);

		break;

	case ETestRemoveMSD:

		if(iEirPublisherTestManuSpecific)

			{

			delete iEirPublisherTestManuSpecific;

			}

		break;

	default:

        iConsole.Printf(_L("INVALID EIR TAG!\n"));

		//User::Panic();

		break;	

		}

	}

void CEirApp::Register16BitSDPRecordL()

	{

	CreateSdpRecordL(0x1116);

	CreateSdpRecordL(0x1234, EFalse);

	CreateSdpRecordL(0xAABB);

	CreateSdpRecordL(0xF00D);

	CreateSdpRecordL(0x0E0D);

	}

void CEirApp::Register128BitSDPRecordL()

	{

	// Set Attr 1 (service class list) to list with UUID = 0x0123456789abcdef

	TUUID uuid1280 = TUUID(0x00000000, 0x00000000, 0x00000000, 0x00000000);

	TUUID uuid1281 = TUUID(0x11111111, 0x11111111, 0x11111111, 0x11111111);

	TUUID uuid1282 = TUUID(0x22222222, 0x22222222, 0x22222222, 0x22222222);

	TUUID uuid1283 = TUUID(0x33333333, 0x33333333, 0x33333333, 0x33333333);

	TUUID uuid1284 = TUUID(0x44444444, 0x44444444, 0x44444444, 0x44444444);

	TUUID uuid1285 = TUUID(0x55555555, 0x55555555, 0x55555555, 0x55555555);

	TUUID uuid1286 = TUUID(0x66666666, 0x66666666, 0x66666666, 0x66666666);

	TUUID uuid1287 = TUUID(0x77777777, 0x77777777, 0x77777777, 0x77777777);

	TUUID uuid1288 = TUUID(0x88888888, 0x88888888, 0x88888888, 0x88888888);

	TUUID uuid1289 = TUUID(0x99999999, 0x99999999, 0x99999999, 0x99999999);

	CreateSdpRecordL(uuid1280);

	CreateSdpRecordL(uuid1281, EFalse, EFalse);

	CreateSdpRecordL(uuid1282);

	CreateSdpRecordL(uuid1283);

	CreateSdpRecordL(uuid1284);

	CreateSdpRecordL(uuid1285);

	CreateSdpRecordL(uuid1286);

	CreateSdpRecordL(uuid1287);

	CreateSdpRecordL(uuid1288);

	CreateSdpRecordL(uuid1289);

	}

void CEirApp::CreateSdpRecordL(const TUUID& aUUID,

							  TBool aIsPublicBrowseGroup,

							  TBool aIsL2cap)

	{

	TSdpServRecordHandle recHandle;

	CSdpAttrValueDES* attrValDES = NULL;

	iSdpDB.CreateServiceRecordL(aUUID, recHandle);

	if(aIsPublicBrowseGroup)

		{

		// Browse Group List

		attrValDES = CSdpAttrValueDES::NewDESL(NULL);

		CleanupStack::PushL(attrValDES);

		attrValDES

			->StartListL()

			->BuildUUIDL(TUUID(TUint16(KPublicBrowseGroupUUID))) // Public Browse Group

			->EndListL();

		iSdpDB.UpdateAttributeL(recHandle, KSdpAttrIdBrowseGroupList, *attrValDES);

		CleanupStack::PopAndDestroy(attrValDES);

		}

	if(aIsL2cap)

		{

		// protocol Descriptor List

		attrValDES = CSdpAttrValueDES::NewDESL(NULL);

		CleanupStack::PushL(attrValDES);		

		attrValDES

			->StartListL()

			->BuildUUIDL(TUUID(KL2CAPUUID))

			->EndListL();

		iSdpDB.UpdateAttributeL(recHandle, KSdpAttrIdProtocolDescriptorList, *attrValDES);

		CleanupStack::PopAndDestroy(attrValDES);

		}

	}

void CEirApp::NewNameRequesterL(TBool aEirInstead, TBool aIgnoreCache)

	{

	}

void CEirApp::NewInquirerL(TUint aIAC, TBool aDoNames, TBool aIgnoreCache, TBool aDoEir, TBool forever)

	{

	}

void CEirApp::CancelInquirer()

	{

	TInt numresolvers = iResolvers.Count();

	if (numresolvers)

		iResolvers[numresolvers-1]->Cancel(); //FIXME! Cancel's the newest host resolver

	else

		iConsole.Printf(_L("No resolver to cancel!\n"));

	}

void CEirApp::NewNameArrayRequesterL()

	{

	}

void CEirApp::DeviceFound(TBTDevAddr aAddress)

	{

#if USE_SMALL_CONSOLE

	iConsole.Printf(_L("App: Found device.\n"));

#endif

	}

void CEirApp::InquiryComplete()

	{

	iConsole.Printf(_L("App: No more devices.\n"));

	iActiveConsole->DrawCursor();

	}

RSocketServ& CEirApp::SocketServ() 

	{

	return iSocketServer;

	}

void CEirApp::InitialiseL()

	{

	_LIT(KLDDName, "ECOMM");

#if defined (__WINS__)

	iConsole.Printf(_L("Initialise using EMULATOR PDD\n"));

	_LIT(KPDDName, "ECDRV");

#else

	iConsole.Printf(_L("Initialise using H2 PDD\n"));

	_LIT(KPDDName, "EUART1");

#endif

	TInt rerr = KErrNone;

	rerr = User::LoadPhysicalDevice(KPDDName);

	if(rerr != KErrNone && rerr != KErrAlreadyExists)

		{

		iConsole.Printf(_L("Failed Load Physical Device %d!\n") ,rerr);

		User::Leave(rerr);

		}

	else 

		{

		iConsole.Printf(_L("Loaded LDD\n"));

		}

	rerr = User::LoadLogicalDevice(KLDDName);

	if(rerr != KErrNone && rerr != KErrAlreadyExists)

	{

		iConsole.Printf(_L("Failed Load Logical Device%d!\n") ,rerr);

		User::Leave(rerr);

		}

	else 

		{

		iConsole.Printf(_L("Loaded PDD\n"));

		}

	User::LeaveIfError(iSocketServer.Connect());

	rerr = iSdp.Connect();

	if(rerr == KErrNone)

		{

		rerr = iSdpDB.Open(iSdp);

		}

	TProtocolDesc iProtocolInfo;

	TRequestStatus status;

	User::LeaveIfError(iSocketServer.FindProtocol(_L("L2CAP"), iProtocolInfo));

	iSocketServer.StartProtocol(iProtocolInfo.iAddrFamily, iProtocolInfo.iSockType, iProtocolInfo.iProtocol, status);

	User::WaitForRequest(status);

	User::LeaveIfError(iSocketServer.FindProtocol(_L("RFCOMM"), iProtocolInfo));

	User::LeaveIfError(iSocketServer.FindProtocol(_L("BTLinkManager"), iProtocolInfo));

	}

void CEirApp::StopProtocols()

	{

	TInt err;

	TProtocolDesc iProtocolInfo;

	TRequestStatus status;

	if(!iSocketServer.Handle())

		{

		// if the socket server has not even been opened

		// then there is no point trying to unload protocols

		return;

		}

	err = iSocketServer.FindProtocol(_L("L2CAP"), iProtocolInfo);

	if(err)

		{

		iConsole.Printf(_L("Failed to find L2CAP protocol. ERROR %d\n"), err);

		}

	iSocketServer.StopProtocol(iProtocolInfo.iAddrFamily, iProtocolInfo.iSockType, iProtocolInfo.iProtocol, status);

	User::WaitForRequest(status);

	err = iSocketServer.FindProtocol(_L("RFCOMM"), iProtocolInfo);

	if(err)

		{

		iConsole.Printf(_L("Failed to find RFCOMM protocol. ERROR %d\n"), err);

		}

	iSocketServer.StopProtocol(iProtocolInfo.iAddrFamily, iProtocolInfo.iSockType, iProtocolInfo.iProtocol, status);

	User::WaitForRequest(status);

	}

void CEirApp::ShowAddress()

/**

	Shows the example of using a synchronous Get to retrieve local BTAddr

*/

	{

	RProperty property;

	TBuf8<6> addr;

	TRequestStatus status;

	iConsole.Printf(_L("Waiting for Local BDADDR...\n"));

	// Wait for the address to be set

	TInt err = property.Attach(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothGetLocalDeviceAddress);

	if(err)

		{

		iConsole.Printf(_L("P&S: ERROR attaching to local address\n"));

		return;

		}

	RTimer addrTimer;

	err = addrTimer.CreateLocal();

	if(err != KErrNone)

		{

		iConsole.Printf(_L("Error creating P&S timer (%d)\n"), err);

		property.Close();

		return;

		}

	TRequestStatus timerStatus;

	property.Subscribe(status);

	addrTimer.After(timerStatus, 5000000); // 5 seconds.

	User::WaitForRequest(status, timerStatus);

	addrTimer.Close(); // done with timer now.

	err = property.Get(addr);

	if (err)

		{	

		iConsole.Printf(_L("P&S: ERROR getting local address\n"));

		}

	else

		{

		iConsole.Printf(_L("Local Address: %02X:%02X:%02X:%02X:%02X:%02X\n"), addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);

		}

	// Set inquiry scan

	RProperty discprop;

	err=discprop.Set(KPropertyUidBluetoothCategory, KPropertyKeyBluetoothSetScanningStatus, EInquiryAndPageScan);

	if (err)

		{	

		iConsole.Printf(_L("P&S: ERROR setting discoverability\n"));

		}

	else

		{

		iConsole.Printf(_L("Device now in discoverable mode\n"));

		}

	property.Close();

	User::WaitForRequest(status, timerStatus);

	}

// ----------------------------------------------------------------------------

//							Active Host Resolver

// ----------------------------------------------------------------------------

CActiveHostResolver::CActiveHostResolver(CConsoleBase& aConsole, CEirApp& aApp)

: CActive(EPriorityStandard), iConsole(aConsole), iApp(aApp)

	{

	//++iHRNumber;

	CActiveScheduler::Add(this);

	}

CActiveHostResolver::~CActiveHostResolver()

	{

//	if (iHostResolver.SubSessionHandle())

//		iHostResolver.Cancel();

	Cancel();

	iHostResolver.Close();

#if USE_SMALL_CONSOLE

	delete iHROutputConsole;

#endif

	}

void CActiveHostResolver::StartServerL()

/** 

  Connect to socket server and get BTLinkManager protocol info

 **/

	{

	iSocketServer = iApp.SocketServ();

	}

void CActiveHostResolver::StartHostResolverL()

/** 

	In future have a bunch of host resolvers

*/

	{

	iConsole.Printf(_L("Opening Host Resolver ..\n"));

        User::LeaveIfError(iSocketServer.FindProtocol(_L("BTLinkManager"), iProtocolInfo));

	User::LeaveIfError(iHostResolver.Open(iSocketServer,

											iProtocolInfo.iAddrFamily,

											iProtocolInfo.iProtocol));

//#if 0

	// show Localname for free

	TBTDeviceName localName;

	iHostResolver.GetHostName(localName);

	iConsole.Printf(_L("Local hostname is %S\n"), &localName);					

//#endif

	}

TInt CActiveHostResolver::RunError(TInt /*aError*/)

	{

	__DEBUGGER();

	return KErrNone;

	}

void CActiveHostResolver::SetLocalNameL()

	{

	iConsole.Printf(_L("Enter local device name (esc to finish)"));

	const TUint8 KMaxLength = 16;

	TBuf<KMaxLength> localName;

	localName.Zero();

	FOREVER

		{