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

//

#include "BTTextNotifiers.h"

#include <btdevice.h>

#include <e32cons.h>

#include <es_sock.h>

#include <bt_sock.h>

#include <btextnotifiers.h>

#include <bluetooth/logger.h>

#include <e32keys.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "TextNotifiers");

#endif

void CBTManDeviceScanner::NotifyErrorL(TRefByValue<const TDesC> aErrorNotification)

	{

	LOG_FUNC

	CConsoleBase* console = BTTextNotifiersConsole::AutoSizeNewL(_L("Device Selector"), TSize(50,2));

	CleanupStack::PushL(console);

	console->Printf(aErrorNotification);

	console->Printf(_L("\nPress any key to continue"));

	console->Getch();

	CleanupStack::PopAndDestroy();

	}

void CBTManDeviceScanner::ResetDeviceLists()

	{

	LOG_FUNC

	iDevices.ResetAndDestroy();

	iDevices.Close();

	iNoNameDevices.ResetAndDestroy();

	iNoNameDevices.Close();

	}

void CBTManDeviceScanner::EnsureConsoleExistsL()

	{

	LOG_FUNC

	if(!iConsole)

		{

		StopWaitMessage();

		iConsole = BTTextNotifiersConsole::AutoSizeNewL(_L("Device Selector"), TSize(70, 6+KMaxDeviceRows));

		iConsole->Printf(iWaitMessage);

		}

	}

void CBTManDeviceScanner::StartWaitMessageL()

	{

	LOG_FUNC

	delete iWaitConsole;

	iWaitConsole = 0;

	iWaitConsole = BTTextNotifiersConsole::AutoSizeNewL(_L("Device Selector"), TSize(20,1));

	iWaitConsole->Printf(iWaitMessage);

	}

void CBTManDeviceScanner::StopWaitMessage()

	{

	LOG_FUNC

	delete iWaitConsole;

	iWaitConsole = 0;

	}

void CBTManDeviceScanner::AddDiscoveredDeviceL(RBTDevices& aDeviceArray, const TNameEntry& aNameEntry)

	{

	LOG_FUNC

	TInquirySockAddr& sa = TInquirySockAddr::Cast(aNameEntry().iAddr);

	const TBTDevAddr& bdaddr = sa.BTAddr();

	CBTDevice* device = CBTDevice::NewL(bdaddr);

	CleanupStack::PushL(device);

	HBufC8* temp = HBufC8::NewLC(aNameEntry().iName.Length());	 // to convert iName to narrow

	TPtr8 ptr=temp->Des();

	ptr.Copy(aNameEntry().iName);

	device->SetDeviceNameL(*temp);

	TBTDeviceClass devClass(sa.MajorServiceClass(), 

							sa.MajorClassOfDevice(), 

							sa.MinorClassOfDevice());

	device->SetDeviceClass(devClass);

	User::LeaveIfError(aDeviceArray.Append(device));

	CleanupStack::PopAndDestroy(1, temp);

	CleanupStack::Pop(device);

	}

void CBTManDeviceScanner::SetupDeviceParams(RHostResolver aHr, TBTNamelessDevice& aDevInfo)

	{

	LOG_FUNC

	SetupDeviceParams(_L(""), aDevInfo);

	//iDevPms.SetDeviceAddress(aDevInfo.Addr());

	//iDevPms.SetDeviceClass(aDevInfo.Class());

	TInquirySockAddr addr;

	addr.SetIAC(KGIAC);

	TRequestStatus stat;

	addr.SetAction(KHostResName);

	addr.SetBTAddr(aDevInfo.Address());

	TNameEntry entry;

	aHr.GetByAddress(addr, entry, stat);

	User::WaitForRequest(stat);

	if (stat == KErrNone)

		{

		iDevPms.SetDeviceName(entry().iName);

		}

	}

void CBTManDeviceScanner::SetupDeviceParams(const THostName& aName, TBTNamelessDevice& aDevInfo)

	{

	LOG_FUNC

	iDevPms.SetDeviceAddress(aDevInfo.Address());

	iDevPms.SetDeviceClass(aDevInfo.DeviceClass());

	iDevPms.SetDeviceName(aName);

	}

void CBTManDeviceScanner::RubOutWaitMessage()

	{

	LOG_FUNC

	TBuf<1> character;

	if(iConsole->WhereX()||iConsole->WhereY())

		{

		TInt len = iWaitMessage.Length();

		for(TInt i=0;i<len;++i)

			{

			character.SetLength(0);

			character.Append(0x08);

			iConsole->Printf(_L("%S"),&character);

			}

		}

	}

void CBTManDeviceScanner::PrintDiscoveredDevice()

	{

	LOG_FUNC

	RubOutWaitMessage();

	const TBTDevAddr& bdaddr = iDevPms.BDAddr();

	iConsole->Printf(_L("%d.\t0x%02x%02x%02x%02x%02x%02x\t"),

						++iPrintedCounter,bdaddr[0],bdaddr[1],bdaddr[2],bdaddr[3],

						bdaddr[4],bdaddr[5]);

	if(!(iDevPms.DeviceName().Length()))

		iConsole->Printf(_L("(No name found)\t"));

	else

		{

		// need to widen it for displaying! just display 40 chars worth

		TBuf<40> dispBuf;

		dispBuf.Copy(iDevPms.DeviceName().Left(40));

		iConsole->Printf(_L("\"%S\"\t"), &dispBuf);

		}

	iConsole->Printf(_L("0x%04x-"),iDevPms.DeviceClass().MajorServiceClass());

	iConsole->Printf(_L("%02x-"),iDevPms.DeviceClass().MajorDeviceClass());

	iConsole->Printf(_L("%02x\n"),iDevPms.DeviceClass().MinorDeviceClass());

	iConsole->Printf(iWaitMessage);

	}

TBool CBTManDeviceScanner::DeviceNumberFromUserL(TBool allowMore)

	{

	LOG_FUNC

	TBuf<3> numBuf;

	TBuf<63> errStr;

	errStr.SetLength(0);

	numBuf.Zero();

	TKeyCode code;

	TBuf<1> character;

	RubOutWaitMessage();

	TBuf<0x100> prompt(_L("\nIf the device you require appears above,\n\

		\rselect the device number you require and THEN press 'Return'.\n\

		\rIf not,  "));

	if(allowMore)

		{

		prompt.SetLength(prompt.Length()-2);

		prompt.Append(_L("\npress 'Esc' to abort or 'Return' to seek more devices.\n"));

		iConsole->Printf(prompt);

		}

	else

		{

		prompt.SetLength(prompt.Length()-2);

		prompt.Append(_L(" - THERE ARE NO MORE DEVICES - so\n\

			\rpress 'Esc' to abort or 'Return' to ***REDO*** device inquiry.\n"));

		iConsole->Printf(prompt);

		}

	FOREVER

		{

		code = iConsole->Getch();

		if(!(numBuf.Length())&&code==EKeyEnter)

			{

			// No device number entered so this must be a redo device inquiry

			iScanState = EScanStateUnfinished;

			break;

			}

		if(!(numBuf.Length())&&code==EKeyBackspace)

			{

			// No device number entered so nothing to delete, just continue looking for input

			continue;

			}

		if(!(code>=0x30&&code<=0x39)&&code!=EKeyEscape&&code!=EKeyEnter&&code!=EKeyBackspace)

			{

			// Not a valid number and not escape, enter or backspace, just continue looking for input

			continue;

			}

		if(code==EKeyEscape)

			{

			// Escape is always abort regardless if a number has been entered

			iScanState = EScanStateCancelled;

			break;

			}

		character.SetLength(0);

		character.Append(code);

		if (code == EKeyEnter)

			{

			// We must have a number at this point otherwise the enter key would have forced a

			// redo inquiry above

			TLex lex(numBuf);

			TInt err = lex.Val(iChosenDeviceIndex, EDecimal);

			User::LeaveIfError(err);

			if(iChosenDeviceIndex<=iPrintedCounter&&

				iChosenDeviceIndex>=((iPrintedCounter-1)/KMaxDeviceRows)*KMaxDeviceRows+1)

				{

				iScanState = EScanStateSelected;

				break;

				}

			else

				{

				while((numBuf.Length() != 0))

					{

					character.SetLength(0);

					character.Append(EKeyBackspace);

					iConsole->Printf(_L("%S"),&character);

					numBuf.SetLength((numBuf.Length()-1));

					}

				while((errStr.Length() != 0))

					{

					character.SetLength(0);

					character.Append(EKeyBackspace);

					iConsole->Printf(_L("%S"),&character);

					errStr.SetLength((errStr.Length()-1));

					}

				errStr.Format(_L("Device %d does not exist! Please re-enter...."), iChosenDeviceIndex);

				iConsole->Printf(_L("%S"), &errStr);

				}

			}

		else if (code == EKeyBackspace)

			{

			// We must have a number at this point otherwise we would have asked for another key press

			// above

			iConsole->Printf(_L("%S"),&character);

			numBuf.SetLength((numBuf.Length()-1));

			}

		else

			{

			if (numBuf.Length() < numBuf.MaxLength())

				{

				// Store the number

				iConsole->Printf(_L("%S"),&character);

				numBuf.Append(code);

				}

			}

		}

	delete iConsole;

	iConsole = 0;

	//return FALSE if scan not terminated (by cancelation or selection)

	if(iScanState == EScanStateUnfinished)

		{

		StartWaitMessageL();

		return EFalse;

		}

	return ETrue;

	}

TBool CBTManDeviceScanner::GetByScanL(TBTDevAddr& aBDAddr, 

									  TBTDeviceName& aName, 

									  TBTDeviceClass& aClass)

	{

 	LOG_FUNC

	StartWaitMessageL();

    RSocketServ ss;

	TInt ret=ss.Connect();

	if(ret)

		{

		NotifyErrorL(_L("Internal error: unable to connect to outside socket."));

		return EFalse;

		}

	RHostResolver hr;

 	TProtocolDesc pInfo;

	// List out all the protocols

 	ret=ss.FindProtocol(_L("BTLinkManager"),pInfo);

	if(ret)

		{

		NotifyErrorL(_L("Internal error: unable to find Bluetooth."));

		ss.Close();

		return EFalse;

		}

	ret = hr.Open(ss,pInfo.iAddrFamily,pInfo.iProtocol);

	//ret = hr.Open(ss,KBTAddrFamily,KBTLinkManager);

	if(ret)

		{

		NotifyErrorL(_L("Internal error: unable to find Bluetooth."));

		ss.Close();

		return EFalse;

		}

	iScanState = EScanStateUnfinished;

	while(iScanState==EScanStateUnfinished)

		{

		iResultCountNoName = 0;

		iResultCountWithName = 0;

		iChosenDeviceIndex = 0;

		iPrintedCounter = 0;

		ResetDeviceLists();	

		TInquirySockAddr addr;

		addr.SetIAC(KGIAC);

		TRequestStatus stat;

		addr.SetAction(KHostResInquiry + KHostResName);	// Default: Both

		TNameEntry entry;

		hr.GetByAddress(addr, entry, stat);

		User::WaitForRequest(stat);

		//Collect surrounding devices in a device array

		iPrintedCounter = 0;

		while (stat == KErrNone)

			{

			if(entry().iName.Length())

				{

				EnsureConsoleExistsL();

				AddDiscoveredDeviceL(iDevices, entry);

				SetupDeviceParams(entry().iName, (*iDevices[iResultCountWithName]).AsNamelessDevice());

				PrintDiscoveredDevice();

				iResultCountWithName++;

				if(!(iPrintedCounter%KMaxDeviceRows))

					if(CBTManDeviceScanner::DeviceNumberFromUserL(ETrue))

						break;

				}

			else

				{

				// Don't add to the Devices list yet, add to a separate list for those

				// who's name needs to be host resolve-d.

				TNameEntry* copied = new(ELeave) TNameEntry();

				CleanupStack::PushL(copied);

				(*copied)().iName = entry().iName; // should be 0 length

				(*copied)().iAddr = entry().iAddr;

				(*copied)().iFlags = entry().iFlags;

				User::LeaveIfError(iNoNameDevices.Append(copied));

				CleanupStack::Pop(copied);

				iResultCountNoName++;

				}

			if(iResultCountNoName+iResultCountWithName==999)

				{

				EnsureConsoleExistsL();

				if(CBTManDeviceScanner::DeviceNumberFromUserL(EFalse))

					//=>User has requested to see more devices

					{

					iScanState = EScanStateCancelled;//ensure do not search on unnamed devices

					DisplayNoDeviceMessageL(ETrue);

					}

				break;

				}

			hr.Next(entry, stat);

			User::WaitForRequest(stat);

			}

		addr.SetAction( KHostResName );

		while(iResultCountNoName && iScanState==EScanStateUnfinished && 

			  iPrintedCounter<(iResultCountWithName+iResultCountNoName))

			{

			EnsureConsoleExistsL();

			//Should never happen....

			if(iPrintedCounter<iResultCountWithName)

				break;

			TNameEntry* noNameEntry = iNoNameDevices[iPrintedCounter-iResultCountWithName];

			AddDiscoveredDeviceL(iDevices, *noNameEntry);

			SetupDeviceParams(hr, (*iDevices[iPrintedCounter]).AsNamelessDevice());

			PrintDiscoveredDevice();

			if(!(iPrintedCounter%KMaxDeviceRows))

				if(CBTManDeviceScanner::DeviceNumberFromUserL(ETrue))

					break;

			}

		if(iConsole)

			CBTManDeviceScanner::DeviceNumberFromUserL(EFalse);

				/*NB because of parameter EFalse above will never change 

					 state to EScanStateUnfinished so will never start wait dialog.*/

		if(!iPrintedCounter)

			{

			DisplayNoDeviceMessageL(EFalse);

			iScanState = EScanStateCancelled;

			}

		CheckUnfinishedL();

		}

	//now extract the selected device number from the string...

	TBTNamelessDevice devInfo;

	if(iScanState == EScanStateSelected)

		{

		if(iChosenDeviceIndex<=iResultCountWithName)

			devInfo = (*iDevices[iChosenDeviceIndex-1]).AsNamelessDevice();

		else if(iChosenDeviceIndex<=(iResultCountWithName+iResultCountNoName))

			devInfo = (*iDevices[iChosenDeviceIndex-iResultCountWithName-1]).AsNamelessDevice();

		else

			{

			iScanState = EScanStateCancelled;

			NotifyErrorL(_L("Error taking in device selection."));

			}

		}

	if(iScanState == EScanStateSelected)

		{

		StartWaitMessageL();

		SetupDeviceParams(hr, devInfo);

		aBDAddr = iDevPms.BDAddr();

		aName.Copy(iDevPms.DeviceName());

		aClass = iDevPms.DeviceClass();

		StopWaitMessage();

		}

	//Shouldn't ever be true

	if(iScanState == EScanStateUnfinished)

		{

		DisplayNoDeviceMessageL(iPrintedCounter?ETrue:EFalse);

		}

	StopWaitMessage();

	hr.Close();

	ss.Close();

	return (iScanState == EScanStateSelected)?ETrue:EFalse;

	}

void CBTManDeviceScanner::DisplayNoDeviceMessageL(TBool isMore)

	{

	LOG_FUNC

	CConsoleBase* console = 0;

	TRAPD(err, console = BTTextNotifiersConsole::AutoSizeNewL(_L("Device Selection"), TSize(45,4)));

	if(err)

		return;

	CleanupStack::PushL(console);

	TBuf<0x40> prompt(_L("Sorry! No"));

	if(isMore)

		prompt.Append(_L(" more"));

	prompt.Append(_L(" devices could be found.\n\nPress any key."));

	console->Printf(prompt);

	console->Getch();

	CleanupStack::PopAndDestroy();//console

	}

void CBTManDeviceScanner::CheckUnfinishedL()

	{

	LOG_FUNC

	if(iScanState!=EScanStateUnfinished||

		(iResultCountWithName+iResultCountNoName)%KMaxDeviceRows)

		return;

	CConsoleBase* console = 0;

	TRAPD(err, console = BTTextNotifiersConsole::AutoSizeNewL(_L("Device Selection"), TSize(70,3)));

	if(err)

		return;

	CleanupStack::PushL(console);

	TBuf<0x100> prompt(_L("Sorry!"));

	prompt.Append(_L(" - THERE ARE NO MORE DEVICES - so\n\

		\rpress 'Esc' to abort or 'Return' to ***REDO*** device inquiry.\n"));

	console->Printf(prompt);

	TKeyCode code = console->Getch();

	while(code!=0x1b&&code!=0x0d)

		code = console->Getch();

	iScanState = code==0x0d?EScanStateUnfinished:EScanStateCancelled;

	CleanupStack::PopAndDestroy();//console

	}

CBTManDeviceScanner* CBTManDeviceScanner::NewL()

	{

	LOG_STATIC_FUNC

	CBTManDeviceScanner* self=new (ELeave) CBTManDeviceScanner();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CBTManDeviceScanner::~CBTManDeviceScanner()

	{

	LOG_FUNC

	delete iConsole;

	ResetDeviceLists();

	iDevices.Close();

	iNoNameDevices.Close();

	}

CBTManDeviceScanner::CBTManDeviceScanner()

	: iWaitMessage(_L("Please wait..."))

	{

	LOG_FUNC

	}

void CBTManDeviceScanner::ConstructL()

	{

	LOG_FUNC