// RegistryHelpers.CPP

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

// Small classes to assist stack in using Registry

// 

//

#include "RegistryHelpers.h"

#include "hostresolver.h"

#include "linkmgr.h"

#include "linkutil.h"

#include "debug.h"

#include <comms-infras/commsdebugutility.h>

__FLOG_STMT(_LIT8(KSubsys, "btstack");)

__FLOG_STMT(_LIT8(KComponent, "btregistryhelpers");)

//

// Classes apertaining to MBTRegistryTaskNotifier //

//

CBTRegistryHelperBase::CBTRegistryHelperBase(MBTRegistryTaskNotifier& aParent, CRegistrySession& aRegSess)

	: CActive(EPriorityHigh)

	, iRegSess(aRegSess)

	, iParent(&aParent)

	{

	// high for servicing the protocol quickly

	CActiveScheduler::Add(this);

	}

CBTRegistryHelperBase::~CBTRegistryHelperBase()

	{

	__FLOG_STATIC(KSubsys, KComponent, _L8("sec\tRegistryHelper destructing"));

	Cancel();

	iRegistry.Close();

	iRegSess.Close();

	}

void CBTRegistryHelperBase::ConstructL()

	{

	iRegSess.Open(); // Open the resource (as we will close on delete).

	User::LeaveIfError(iRegistry.Open(iRegSess.RegServ()));

	}

void CBTRegistryHelperBase::DoCancel()

	{

	iRegistry.CancelRequest(iStatus);

	}

void CBTRegistryHelperBase::RunL()

	{

	// Store the value from iStatus in case another active request is started. 

	TInt rValue = iStatus.Int();

	// Check that the registry access is complete.

	if(IsRegistryTaskCompleteL())

		{

		// Is the parent of this object still available to be notified

		// of completion.

		if(iParent)

			{

			Notify(rValue);

			}

		else

			{

			delete this;

			}

		}

	}

TInt CBTRegistryHelperBase::RunError(TInt aError)

	{

	if(iParent)

		{

		Notify(aError);

		}

	else

		{

		delete this;

		}

	return KErrNone;

	}

TBool CBTRegistryHelperBase::IsRegistryTaskCompleteL()

	{

	// Default implementation.

	return ETrue;

	}

void CBTRegistryHelperBase::Notify(TInt aError)

	{

	// Default implementation.

	__FLOG_STATIC2(KSubsys, KComponent, _L8("CBTRegistryHelperBase::Notify(%d), this 0x%08x"), aError, this);

	iParent->RegistryTaskComplete(this, aError);

	}

void CBTRegistryHelperBase::DetachParent()

	{

	__FLOG_STATIC3(KSubsys, KComponent, _L8("CBTRegistryHelperBase::DetachParent(), this 0x%08x, Current Parent 0x%08x, IsActive() %d")

			       ,this, iParent, IsActive());

	// If the helper is not currently active then this object must be deleted.

	if(!IsActive())

		{

		delete this;

		}

	else

		{

		iParent = NULL;

		}

	}

CBTDeviceGetter::CBTDeviceGetter(MBTRegistryTaskNotifier& aParent, CRegistrySession& aRegSess)

: CBTRegistryHelperBase(aParent, aRegSess)

	{

	}

CBTDeviceGetter* CBTDeviceGetter::NewL(CRegistrySession& aRegSess,

									  MBTRegistryTaskNotifier& aParent)

	{

	CBTDeviceGetter* self = new(ELeave) CBTDeviceGetter(aParent, aRegSess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CBTDeviceGetter::Start(const TBTDevAddr& aAddr)

	{

	__FLOG_STATIC1(KSubsys, KComponent, _L8("Registry helper (Getter 0x%08x) started..."), this);

	iDevice.SetAddress(aAddr);

	iRegistry.GetDevice(iDevice, iStatus);

	SetActive();

	}

void CBTDeviceGetter::Notify(TInt aError)

	{

	iParent->RegistryTaskComplete(this, iDevice, aError);

	}

CBTDeviceModifier* CBTDeviceModifier::NewL(CRegistrySession& aRegSess, MBTRegistryTaskNotifier& aParent, CBTInquiryMgr& aInquiryMgr)

	{

	CBTDeviceModifier* self = new(ELeave) CBTDeviceModifier(aParent, aInquiryMgr, aRegSess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CBTDeviceModifier::CBTDeviceModifier(MBTRegistryTaskNotifier& aParent, CBTInquiryMgr& aInquiryMgr, CRegistrySession& aRegSess)

: CBTRegistryHelperBase(aParent, aRegSess), iInquiryMgr(aInquiryMgr), iRegistryUpdateStatus(ENoChange)

	{

	}

void CBTDeviceModifier::Start(const TBTNamelessDevice& aDevice, TBool aCanAddDevice)

	{

	__FLOG_STATIC1(KSubsys, KComponent, _L8("Registry helper (Modifier 0x%08x) started..."), this);

	// Store the arguments and check if the device specified by the

	// aDevice argument is currently present in the registry.

	iCanAddDevice = aCanAddDevice;

	iDevice = aDevice;

	iRegistrySearch.Reset();

	iRegistrySearch.FindAddress(iDevice.Address());

	// Check the registry for this address.  If a record exists the iStatus

	// in the RunL will be 1.

	iRegistry.CreateView(iRegistrySearch, iStatus);

	iState = EFindingDevice;

	SetActive();

	}

CBTDeviceModifier::~CBTDeviceModifier()

	{

	Cancel();

	delete iDeviceWithName;

	}

TBool CBTDeviceModifier::IsRegistryTaskCompleteL()

	{

	switch(iState)

		{

		case EFindingDevice:

			{

			// A view has been created based on the address of the new device.

			// If the iStatus value is 1 then the device has been found.

			// Note.  The value can never be greater than 1.  The server will

			// PANIC if this condition were to occur therefore the code here does

			// not need to check this condition.

			if(iStatus.Int() > 0)

				{

				// The device is in the registry, so it can be modified

				iRegistry.ModifyDevice(iDevice, iStatus);

				iState = EModifyingDevice;

				iCanAddDevice = EFalse;		// reinforce this, as its needed in the subsequent state

				SetActive();

				}

			else if (iStatus.Int()==KErrNotFound)

				{

				// The device could not be found.  Check if its valid to

				// add the device.

				if(iCanAddDevice)

					{

					// The device should be added into the registry

					delete iDeviceWithName;

					iDeviceWithName = NULL;

					iDeviceWithName = CBTDevice::NewL(iDevice); 

					iRegistry.AddDeviceL(*iDeviceWithName, iStatus); 

					iState = EAddingDevice;

					SetActive();

					}

				// ELSE Nothing more to be done - the modification will be lost.

				}

			}

			break;				

		case EAddingDevice:

		case EModifyingDevice:

			{

  			if (iStatus.Int() == KErrNone)

	  			{

				if (iCanAddDevice)

					{

					// This informs the Phy that an a reg action has occurred

					iRegistryUpdateStatus = EAddition;

					}

				else

					{

					iRegistryUpdateStatus = EModification;

					}

	  			}

  			else

	  			{

	  			__FLOG_STATIC1(KSubsys, KComponent, _L8("CBTDeviceModifier::IsRegistryTaskCompleteL() - registry update problem (TRequestStatus %d)"), iStatus.Int());

	  			}

 			// now try to put the device name in if we have one	

 			const TDesC8* name = iInquiryMgr.DeviceNameFromCache(iDevice.Address());

 			if(name && (name->Length()>0))

				{

 				iRegistry.ModifyBluetoothDeviceNameL(iDevice.Address(), *name, iStatus); 

 				iState = EModifyingName;

 				SetActive();

				}

			}

			break;

		case EModifyingName:

		default:

			break;

		};

	// If more modifications are required to the registry this AO

	// will be active.  i.e., if this AO is active then the registry

	// task is NOT complete.

	return (!IsActive());

	}

void CBTDeviceModifier::Notify(TInt aError)

	{

	// Inform the Phy whether the registry has been modified

	iParent->RegistryTaskComplete(this, iRegistryUpdateStatus, aError);

	}

CBTDeviceNameChanger::CBTDeviceNameChanger(MBTRegistryTaskNotifier& aParent,CRegistrySession& aRegSess)

: CBTRegistryHelperBase(aParent, aRegSess)

	{

	}

CBTDeviceNameChanger* CBTDeviceNameChanger::NewL(CRegistrySession& aRegSess,

									  MBTRegistryTaskNotifier& aParent)

	{

	CBTDeviceNameChanger* self = new(ELeave) CBTDeviceNameChanger(aParent, aRegSess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CBTDeviceNameChanger::Start(const TBTDevAddr& aAddr, const TBTDeviceName8& aName)

	{

	__FLOG_STATIC1(KSubsys, KComponent, _L8("Registry helper (NameChanger 0x%08x) started..."), this);

	iAddr = aAddr;

	iName = aName;

	TRAPD(err, iRegistry.ModifyBluetoothDeviceNameL(iAddr, iName, iStatus));

	SetActive();

	if(err != KErrNone)

		{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, err);

		}

	}

CBTLinkKeyDeleter::CBTLinkKeyDeleter(MBTRegistryTaskNotifier& aParent, CRegistrySession& aRegSess)

: CBTRegistryHelperBase(aParent, aRegSess)

	{

	}

void CBTLinkKeyDeleter::Start(const TBTDevAddr& aDeviceAddr)

	{

	__FLOG_STATIC1(KSubsys, KComponent, _L8("Registry helper (Linkkey deleter 0x%08x) started..."), this);

	iRegistry.UnpairDevice(aDeviceAddr, iStatus);

	SetActive();

	}

CBTLinkKeyDeleter* CBTLinkKeyDeleter::NewL(CRegistrySession& aRegSess,

										  MBTRegistryTaskNotifier& aParent)

	{

	CBTLinkKeyDeleter* self = new(ELeave) CBTLinkKeyDeleter(aParent, aRegSess);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

//

// Classes apertaining to MBtPairedDeviceNotifier //

//

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

//	Active Paired Device Getter (from Registry)

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

CBTPairedBDAddrGetter::CBTPairedBDAddrGetter(MBTPairedDeviceNotifier& aNotifier, RBTRegServ& aRegServ)

	: CActive(EPriorityStandard)

	, iNotifier(aNotifier)

	, iRegistryServer(aRegServ)

	{

	CActiveScheduler::Add(this);

	}

CBTPairedBDAddrGetter::~CBTPairedBDAddrGetter()

	{

	Cancel();

	delete iResponseHandler;

	iView.Close();

	}

CBTPairedBDAddrGetter* CBTPairedBDAddrGetter::NewL(MBTPairedDeviceNotifier& aNotifier, RBTRegServ& aRegServ)

	{

	CBTPairedBDAddrGetter* self = new (ELeave) CBTPairedBDAddrGetter(aNotifier, aRegServ);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CBTPairedBDAddrGetter::ConstructL()

	{

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

	}

void CBTPairedBDAddrGetter::Retrieve()

	{

	if(!IsActive())

		{

		// keep copy as we go async

		iRegistrySearch.Reset();

		iRegistrySearch.FindBonded();

		iView.CreateView(iRegistrySearch, iStatus);

		iState = ECreatingView;

		SetActive();

		}

	}

void CBTPairedBDAddrGetter::RunL()

	{

	// check for error

	TInt result = iStatus.Int();

	if (result < 0)

		{

		User::Leave(result);

		}

	switch (iState)

		{

		case ECreatingView:

			{

			if (result == 0)

				{

				User::Leave(KErrNotFound); // let RunError handle this

				}

			else

				{

				delete iResponseHandler; //just in case not freed

				iResponseHandler = NULL;

				iResponseHandler = CBTRegistryResponse::NewL(iView);

				iResponseHandler->Start(iStatus);

				SetActive();

				iState = EUsingResponse;

				}

			break;

			}

		case EUsingResponse:

			{

			RBTDeviceArray& array(iResponseHandler->Results());

			iNotifier.MbpdnAddPairedDevices(array);

			iState = EReady;

			break;

			}

		case EReady:

		default:

			{

			__ASSERT_DEBUG(EFalse, Panic(EPairedBDAddrGetterUnexpectedState));

			break;

			}

		}

	}

TInt CBTPairedBDAddrGetter::RunError(TInt aError)

	{

	iNotifier.MbpdnErrorInGettingPairedDevices(aError);

	iState = EReady;

	return KErrNone;

	}

void CBTPairedBDAddrGetter::DoCancel()

	{

	// Cancelling registry search.

	iView.CancelRequest(iStatus);

	// Cancelling response retrieval.

	delete iResponseHandler;

	iResponseHandler = NULL;

	// Resetting state

	iState = EReady;

	}