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

// Example UI for Registry

// 

//

#include "regui.h"

GLDEF_D TSize gSmallConsole(75,15);

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

//							Registry UI App

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

CRegUIApp::CRegUIApp()

	{

	}

CRegUIApp::~CRegUIApp()

	{

	delete iLocalDeviceUser;

	iUsers.ResetAndDestroy();

	iUsers.Close();

	iRegServ.Close();

	delete iActiveConsole;

	}

CRegUIApp* CRegUIApp::NewL()

	{

	CRegUIApp* thisapp = new (ELeave) CRegUIApp();

	CleanupStack::PushL(thisapp);

	thisapp->ConstructL();

	CleanupStack::Pop();

	return thisapp;

	}

void CRegUIApp::ConstructL()

	{

	iActiveConsole = CActiveConsole::NewL(*this);

	StartRegistryServerL();

	}

void CRegUIApp::StartRegistryServerL()

	{

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

	}

void CRegUIApp::StartL()

	{

	// go ....

	TestMenu();

	CActiveScheduler::Start();

	}

void CRegUIApp::Stop()

	{

	CActiveScheduler::Stop();

	}

void CRegUIApp::Error(TInt aError)

	{

	if (aError==KErrServerTerminated)

		{

		// try to restart server

		TRAP(aError, StartRegistryServerL());

		if (aError)

			{

			iActiveConsole->Console().Printf(_L("Failed to restart server. Error: %d\n"), aError);

			iActiveConsole->Console().Printf(_L("Stopping App\n"));			

			Stop();

			}

		}

	}

void CRegUIApp::CreateLocalDeviceL()

	{

	iLocalDeviceUser = CLocalDeviceUser::NewL(*this, iRegServ);

	}

void CRegUIApp::CreateViewL(const TBTRegistrySearch& aSearch)

	{

	CActiveRegistryUser* u = NewRegUserPleaseL();

	u->Search(aSearch);

	}

CActiveRegistryUser* CRegUIApp::NewRegUserPleaseL()

	{

	CActiveRegistryUser* u = CActiveRegistryUser::NewL(*this, iRegServ);

	CleanupStack::PushL(u);

	User::LeaveIfError(iUsers.Append(u));

	CleanupStack::Pop(u);

	return u;	

	}

void CRegUIApp::KindlyRemoveRegUserPleaseL(CActiveRegistryUser* aUser)

	{

	for (TInt i=0; i<iUsers.Count(); i++)

		{

		if (iUsers[i]==aUser)

			{

			delete aUser;

			iUsers.Remove(i);

			}

		}

	}

void CRegUIApp::KindlyRemoveLocalDeviceUserPlease()

	{

	delete iLocalDeviceUser;

	iLocalDeviceUser = NULL;

	}

void CRegUIApp::TestMenu()

	{

	CConsoleBase& con = iActiveConsole->Console();

	con.Printf(_L("Choose action...\n\n"));

	con.Printf(_L("a.\t\tList all devices\n"));

	con.Printf(_L("b.\t\tList all bonded devices\n"));

	con.Printf(_L("t.\t\tList all trusted devices\n"));	

	con.Printf(_L("p.\t\tList all Phones\n"));

	con.Printf(_L("c.\t\tList all Computers\n"));

	con.Printf(_L("l.\t\tList all Laptops\n"));

	con.Printf(_L("v.\t\tList all least sig. cookied devices\n"));

	con.Printf(_L("o.\t\tList all added devices\n"));

	con.Printf(_L("s.\t\tFind specific device\n"));

	con.Printf(_L("0.\t\tClear up completed tasks\n"));

	con.Printf(_L("L.\t\tExamine local device info\n"));

	con.Printf(_L("\n"));

	con.Printf(_L("A.\t\tAdd test device\n"));

	con.Printf(_L("Esc.\tStop\n"));

	iActiveConsole->RequestKey();

	}

void CRegUIApp::KeyPressedL(TChar aKey)	

	{

	TBTRegistrySearch searchCriteria;

	switch (aKey)

		{

	case 'a':

		{	

		iActiveConsole->Console().Printf(_L("Listing all devices...\n"));

		searchCriteria.FindAll();

		CreateViewL(searchCriteria); 

		break;

		}

	case 'b':

		{	

		iActiveConsole->Console().Printf(_L("Listing bonded devices...\n"));

		searchCriteria.FindBonded();

		CreateViewL(searchCriteria); 

		break;

		}

	case 't':

		{	

		iActiveConsole->Console().Printf(_L("Listing trusted devices...\n"));

		searchCriteria.FindTrusted();

		CreateViewL(searchCriteria); 

		break;

		}

	case 'p':

		{

		iActiveConsole->Console().Printf(_L("Listing phones...\n"));

		TBTDeviceClass phone(0, EMajorDevicePhone, 0);

		searchCriteria.FindCoD(phone.DeviceClass(), EMajorDevice);

		CreateViewL(searchCriteria);

		break;

		}

	case 'c':

		{

		iActiveConsole->Console().Printf(_L("Listing computers...\n"));

		TBTDeviceClass computer(0, EMajorDeviceComputer, 0);

		searchCriteria.FindCoD(computer.DeviceClass(), EMajorDevice);

		CreateViewL(searchCriteria);

		break;

		}

	case 'l':

		{

		iActiveConsole->Console().Printf(_L("Listing laptops...\n"));

		TBTDeviceClass laptop(0, EMajorDeviceComputer, EMinorDeviceComputerLaptop);

		searchCriteria.FindCoD(laptop.DeviceClass(), static_cast<TBTDeviceClassSearch>(EMajorDevice | EMinorDevice));

		CreateViewL(searchCriteria);

		break;

		}

	case 'v':

		{

		iActiveConsole->Console().Printf(_L("Listing least sig. cookied devices...\n"));

		searchCriteria.FindUiCookie(0x00000001, 0x000000001);

		CreateViewL(searchCriteria);

		break;

		}

	case 'o':

		{

		iActiveConsole->Console().Printf(_L("Listing owned devices...\n"));

		searchCriteria.FindBonded();

		searchCriteria.FindCurrentProcessOwned();

		CreateViewL(searchCriteria);

		break;

		}

	case '0':

		{

		for (TInt i = 0; i<iUsers.Count(); i++)

			{

			iUsers[i]->DestroyIfDone();

			}

		break;

		}

	case 'L':

		{

		if(!iLocalDeviceUser)

			{

			iActiveConsole->Console().Printf(_L("Creating local device window...\n"));

			CreateLocalDeviceL();

			}

		else

			{

			iActiveConsole->Console().Printf(_L("Already have local device window...\n"));

			}

		break;

		}

	case 'A':

		{

		iActiveConsole->Console().Printf(_L("Adding test device...\n"));

		_LIT8(KTestDeviceAddr, "\x00\x01\x02\x03\x04\x05");

		TBTDevAddr addr(KTestDeviceAddr);

		CBTDevice* device = CBTDevice::NewLC(addr);

		device->SetFriendlyNameL(_L("RegUI Test Device"));

		RBTRegistry reg;

		User::LeaveIfError(reg.Open(iRegServ));

		CleanupClosePushL(reg);

		TRequestStatus status;

		reg.AddDeviceL(*device, status);

		User::WaitForRequest(status);

		iActiveConsole->Console().Printf(_L("Result = %d\n"), status.Int());

		User::LeaveIfError(status.Int());

		CleanupStack::PopAndDestroy(2); // reg, device

		break;

		}

	case 's':

		break;

	case EKeyEscape:

		{

		Stop();

		return;

		}

	default:

		iActiveConsole->Console().Printf(_L("Unknown command\r\n"));

		}

	TestMenu();

	}

TBTDeviceName CRegUIApp::GetName()

	{

	// do it sync for now

	RTest nameConsole(_L("Get name"));

	TBTDeviceName name;

	TChar ch;

	do

		{

		ch = nameConsole.Getch();

		if (ch==0x8)

			{

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

			}

		else if (ch!=0xd) 

			{

			name.Append(ch);

			}

		nameConsole.Console()->SetPos(0);

		nameConsole.Console()->Printf(name);

		} while (ch!=0xd);

	nameConsole.Close();

	return name;

	}

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

//							Active RegUser

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

CActiveRegistryUser::CActiveRegistryUser(CRegUIApp& aApp, RBTRegServ& aRegServ)

: CActive(EPriorityStandard), iRegistryServer(aRegServ), iApp(aApp)

	{

	CActiveScheduler::Add(this);

	}

CActiveRegistryUser::~CActiveRegistryUser()

	{

	Cancel();

	delete iActiveConsole;

	delete iResponseHandler;

	delete iViewObserver;

	//iChildUser is NOT owned by us

	iView.Close();

	}

CActiveRegistryUser* CActiveRegistryUser::NewL(CRegUIApp& aApp, RBTRegServ& aRegServ)

	{

	CActiveRegistryUser* u = new (ELeave) CActiveRegistryUser(aApp, aRegServ);

	CleanupStack::PushL(u);

	u->ConstructL();

	CleanupStack::Pop(u);

	return u;

	}

void CActiveRegistryUser::ConstructL()

	{

	iActiveConsole = CActiveConsole::NewL(*this);

	User::LeaveIfError(iView.Open(iRegistryServer));

	}

void CActiveRegistryUser::DestroyIfDone()

	{

	if (iState == EDone)

		{

		iApp.KindlyRemoveRegUserPleaseL(this); //Qualified

		}

	}

void CActiveRegistryUser::KeyPressedL(TChar aKey)

	{

	// non supported at moment

	CConsoleBase& con = iActiveConsole->Console();

	// these valid in any state	

	if (PreProcessKey(aKey))

		return;

	if (iState == ESelecting)

		{

		if ( (aKey == 'u') || ( aKey == 'U') )

			{

			// the user typed u or U in order to unpair all devices displayed

			UnpairAllDevicesInView();

			}

		else if ( (aKey == 'd') || ( aKey == 'D') )

			{

			// the user typed d or D in order to delete all devices displayed

			Delete();

			}

		else

			{

			// the input was numerical, this is to select one device only from the list	

			// just to make this simple, and to show that synchronous can be BAD (can't cancel)

			TInt n = static_cast<TInt>(aKey)-49;

			if (n>=0 && n<=iResponseHandler->Results().Count())

				{

				// create that device as the child

				iChildUser = iApp.NewRegUserPleaseL(); //Qualified

				TBTRegistrySearch s;

				s.FindAddress(iResponseHandler->Results()[n]->BDAddr());

				iChildUser->Search(s);

				}

			else

				{

				con.Printf(_L("Invalid device!\n"));

				}

			}

		iActiveConsole->RequestKey();

		}

	else if (iState == EReady)

		{

		switch (aKey)

			{

			case 'a':

				RequireAuthorisation(ETrue);

				break;

			case 'b':

				RequireAuthorisation(EFalse);

				break;			

			case 'u':

				Unpair();

				break;

			case 'd':

				Delete();

				break;

			case 'c':

					{

					TRAPD(err, SetCookieL())

					if(err != KErrNone)

						{

						iActiveConsole->Console().Printf(_L("Error %d\n"),err);

						}

					}

				break;

			case 'n':

				con.Printf(_L("Finished with this device\n"));

				iState = EDone;

				break;

			case 'f':

				TRAPD(err,ChangeFriendlyNameL());

				if (err)

					{

					iActiveConsole->Console().Printf(_L("Error %d\n"),err);

					}

				break;

			}

		}

	else

		{

		con.Printf(_L("Not ready\n"));

		}

	}

TBool CActiveRegistryUser::PreProcessKey(TChar aKey)

	{

	TBool processed = EFalse;

	switch (aKey)

		{

		case 'x':

		case EKeyEscape:

			// ok in any state

//			delete this;	// actually should tell app!

			processed = ETrue;

			break;

		default:

			break;

		}

	return processed;

	}

void CActiveRegistryUser::Search(const TBTRegistrySearch& aSearch)

	{

	// keep copy as we go async

	iSearch = aSearch;

	iView.CreateView(iSearch, iStatus);

	iState = ECreatingView;

	SetActive();

	}

void CActiveRegistryUser::Unpair()

	{

	// unpair the single device in this view

	if (!iResponseHandler->Results().Count())

		{

		iActiveConsole->Console().Printf(_L("whoops!\n"));

		}

	else

		{

		iView.UnpairDevice(iResponseHandler->Results()[0]->BDAddr(), iStatus);

		iState = EUnpairing;

		SetActive();

		}

	}

void CActiveRegistryUser::UnpairAllDevicesInView()

	{

	// unpair all the devices in this view

	if (!iResponseHandler->Results().Count())

		{

		iActiveConsole->Console().Printf(_L("whoops!\n"));

		}

	else

		{

		iView.UnpairAllInView(iStatus);

		iState = EUnpairing;

		SetActive();

		}

	}	

void CActiveRegistryUser::ChangeFriendlyNameL()

	{

	if (!iResponseHandler->Results().Count())

		{

		iActiveConsole->Console().Printf(_L("whoops!\n"));

		}

	else

		{

		// havent got around to a full text entry box :o)

		TBTDeviceName friendly = iApp.GetName();

		iView.ModifyFriendlyDeviceNameL(iResponseHandler->Results()[0]->BDAddr(), friendly, iStatus);

		iState = EChangingFriendlyName;

		SetActive();

		}

	}

void CActiveRegistryUser::SetCookieL()

	{

	if (!iResponseHandler->Results().Count())

		{

		iActiveConsole->Console().Printf(_L("whoops!\n"));

		}

	else

		{

		iDevice = iResponseHandler->Results()[0]->AsNamelessDevice();

		iDevice.SetUiCookie(0x00800001); // hardcoded for the moment :)

		iState = ESettingCookie;

		iView.ModifyDevice(iDevice, iStatus);

		SetActive();

		}

	}

void CActiveRegistryUser::RequireAuthorisation(const TBool aAuthorisationRequired)

	{

	if (!iResponseHandler->Results().Count())

		{

		// there is no device listed..