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

// Provides the implementation of the subsession that refers to remote devices

// 

//

#include "BTManServer.h"

#include "btmanserverutil.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_MANAGER_SERVER);

#endif

//=====================================================================

//	CBTRegistrySubSession

//=====================================================================

//Description:	Provides an interface to the registry for device 

//				This is needed to provide device connection information for

//				subsequent connections.

//=====================================================================

CBTRegistrySubSession* CBTRegistrySubSession::NewL(CBTManSession& aSession, CBTRegistry& aRegistry)

	{

	LOG_STATIC_FUNC

	CBTRegistrySubSession* self = new(ELeave) CBTRegistrySubSession(aSession, aRegistry);

	//Since its a CObject derived class so we should use CleanupClosePushL

	CleanupClosePushL(*self);	

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CBTRegistrySubSession::ConstructL()

	{

	LOG_FUNC

	}

CBTRegistrySubSession::CBTRegistrySubSession(CBTManSession& aSession, CBTRegistry& aRegistry)

: CBTManSubSession(aSession,aRegistry)

	{

	LOG_FUNC

	}

CBTRegistrySubSession::~CBTRegistrySubSession() 

	{

	LOG_FUNC

	DoCloseView();

	delete iResultBuffer;

	}

void CBTRegistrySubSession::OpenViewL(const TBTRegistrySearch& aSearch, const RMessage2& aMessage)

/**

	@param aSearch	The structure containing the parameters to search for

	@param aMessage	The message to complete

**/

	{

	LOG_FUNC

	if (iDBView)

		{

		// previous view hasn't been retrieved

		User::Leave(KErrInUse);

		}

	// Form the SQL query based on the search criteria

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.SearchL(aSearch);

	// execute the SQL

	iDBView = iRegistry.OpenViewL(query, iBookmark);

	iUnderlyingSearch = query.ConstraintBuf().AllocL();

	// see how many records are in the view

	iViewCount = iDBView->CountL();

	// send count back to client

	if (!iViewCount)

		{

		User::Leave(KErrNotFound);

		}

	else

		{

		// go to the first record in the view for later retrieval

		iDBView->FirstL();

		iSession.CompleteMessage(aMessage, iViewCount);

		}

	CleanupStack::Pop(1); // query

	// **leave view open for client's later requests upon it**

	}

void CBTRegistrySubSession::UnpairL(const TBTDevAddr& aAddress, const RMessage2& aMessage)

/**

	@param	aAddress	The address to unbond

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	// Form the SQL query based on the device address

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.FindDeviceL(aAddress);

	// Execute the SQL

	RDbView* localView = iRegistry.OpenViewL(query, iBookmark);

	CleanupCloseDeletePushL(localView);

	HBufC* localViewUnderlyingSearch = query.ConstraintBuf().AllocLC();

	TInt c = localView->CountL();

	if (c)

		{

		// device is there - check to see if client is allowed to change

		__ASSERT_DEBUG(c==1, PanicServer(EBTManTooManyDevicesInView));

		// Try to notify interested parties before deleting the device.

		// If we notify afterwards, then the device will fall out of someone's

		// view and a change would then not be detected on that view.

		NotifyChange(*this, *localViewUnderlyingSearch);

		// the client is allowed to change the details

		iRegistry.UnpairL(*localView);

		iSession.CompleteMessage(aMessage, KErrNone);

		}

	else

		{

		// device wasn't even there

		User::Leave(KErrNotFound);

		}

	// Cleanup localViewUnderlyingSearch, localView and query

	CleanupStack::PopAndDestroy(3, &query);

	}

void CBTRegistrySubSession::GetDeviceL(const TBTNamelessDevice& aDevice, const RMessage2& aMessage)

/**

	Get a single nameless device from registry

	@param	aDevice		The device to retrieve (only the address is used as a key at present)

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	// open the device

	TDbBookmark bookmark;

	RDbView* localView = iRegistry.OpenDeviceL(aDevice.Address(), bookmark);

	CleanupCloseDeletePushL(localView);

	TInt localCount = localView->CountL();

	if (localCount==0)

		{

		// the device wasn't there!

		User::Leave(KErrNotFound);

		}

	else

		{

		__ASSERT_DEBUG(localCount==1, PanicServer(EBTManTooManyDevicesInView));

		// Get the resulting device (we take ownership), stays on cleanupstack

		const TBTNamelessDevice* device =

			iRegistry.GetNextNamelessDeviceLC(*localView,bookmark,aMessage.HasCapability(ECapabilityReadDeviceData));

		// Write back resulting device to client

		TBTNamelessDevicePckgBuf writePckg;

		writePckg = *device;

		aMessage.WriteL(0, writePckg);

		iSession.CompleteMessage(aMessage, KErrNone);

		CleanupStack::Pop(1);	// device

		delete const_cast<TBTNamelessDevice*>(device);	//MSDev workaround

		}

	CleanupStack::PopAndDestroy(localView);

	}

void CBTRegistrySubSession::AddDeviceL(const CBTDevice& aDetails, const RMessage2& aMessage)

/**

	@note This is an insertion, which can be slower via SQL; so we stick with C++ methods

	Further, this saves us the effort of converting various binary values into the ASCII

	SQL equivalent, only for DBMS to have to retokenise it ;-)

	Slight disadvantage is that the C++ interface to DBMS is synchronous...

	..but the addition of a new row unordered should not be hard in our small database

**/

	{

	LOG_FUNC

	iRegistry.CreateDeviceL(aDetails,

							aMessage.HasCapability(ECapabilityWriteDeviceData),

							aMessage.SecureId());

	// Form the SQL query based on the device address

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.FindDeviceL(aDetails.BDAddr());

	HBufC* localViewUnderlyingSearch = query.ConstraintBuf().AllocLC();

	iSession.CompleteMessage(aMessage, KErrNone);

	// Try to notify interested parties after adding the device.

	// We need the device to be present in other views for change notification to work.

	NotifyChange(*this, *localViewUnderlyingSearch);

	// Cleanup localViewUnderlyingSearch and query

	CleanupStack::PopAndDestroy(2, &query);

	}

void CBTRegistrySubSession::ModifyL(const CBTDevice& aNewDetails, const RMessage2& aMessage)

/**

	@param	aNewDetails	The new device details; with the address to modify

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	// check that we can modify this device...

	if (!aNewDetails.IsValidBDAddr())

		{

		// the device address has not been set correctly

		User::Leave(KErrCorrupt);

		}

	if (!iRegistry.DevicePresentL(aNewDetails.BDAddr()))

		{

		// the device record that the client wants to modify is not present in the registry

		User::Leave(KErrNotFound);

		}

	else

		{

		// device is in Registry - open local device view

		TDbBookmark dummy; // ignore position for now

		// Form the SQL query based on the device address

		RBTDbQuery query;

		CleanupClosePushL(query);

		query.FindDeviceL(aNewDetails.BDAddr());

		// Execute the SQL

		RDbView* localView = iRegistry.OpenViewL(query, dummy);

		CleanupCloseDeletePushL(localView);

		HBufC* localViewUnderlyingSearch = query.ConstraintBuf().AllocLC();

		// Try to notify interested parties before making the change.

		// If we notify afterwards, then the device may fall out of someone's

		// view and a change would then not be detected on that view.		

		NotifyChange(*this, *localViewUnderlyingSearch);

		iRegistry.UpdateDeviceL(*localView, aNewDetails); 

		iSession.CompleteMessage(aMessage, KErrNone);

		// Cleanup localViewUnderlyingSearch, localView and query

		CleanupStack::PopAndDestroy(3, &query);

		}

	}

void CBTRegistrySubSession::ModifyL(const TBTNamelessDevice& aNewDetails, const RMessage2& aMessage)

/**

	@param	aNewDetails	The new device details; with the address to modify

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	// make a CBTDevice based on the T class

	CBTDevice* tempDevice = CBTDevice::NewLC(aNewDetails);

	ModifyL(*tempDevice, aMessage);

	CleanupStack::PopAndDestroy(tempDevice);

	// Notification already handled by overloaded ModifyL() implementation

	}

void CBTRegistrySubSession::ModifyNameL(const TBTDevAddr& aAddress, const RMessage2& aMessage)

/**

	Updates one of the names for a device in the Registry

	Here we decide if we can work with an address or not

	@param	aAddress	The address of the device to modify

	@param	aMessage	The message to complete, and from which we get the name

**/

	{

	LOG_FUNC

	// Form the SQL query based on the device address

	RBTDbQuery query;

	CleanupClosePushL(query);

	query.FindDeviceL(aAddress);

	// Execute the SQL

	RDbView* localView = iRegistry.OpenViewL(query, iBookmark);

	CleanupCloseDeletePushL(localView);

	HBufC* localViewUnderlyingSearch = query.ConstraintBuf().AllocLC();

	TInt c = localView->CountL();

	if (!c)

		{

		// can't modify name cos device isn't there!

		User::Leave(KErrNotFound);

		}

	// read the names

	TBuf8<KMaxBluetoothNameLen> buf;

	aMessage.ReadL(1, buf);

	// Try to notify interested parties before making the change.

	// If we notify afterwards, then the device may fall out of someone's

	// view and a change would then not be detected on that view.		

	NotifyChange(*this, *localViewUnderlyingSearch);

	// read out what's already in the database

	iRegistry.UpdateNameL(aAddress, buf, static_cast<TBTManServerRequest>(aMessage.Function()));

	// done, OK at this stage

	iSession.CompleteMessage(aMessage, KErrNone);

	// Cleanup localViewUnderlyingSearch, localView and query

	CleanupStack::PopAndDestroy(3, &query);

	}

void CBTRegistrySubSession::PreLoadL(const RMessage2& aMessage)

/**

	Load in the results from DBMS

	we'd have to load it all in at some time for giving to client, so we extend

	the lifetime a bit.  We kill the cache upon delivery to client.

	This approach allows us to compute the size of the result set, 

	so that we can tell client

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	if (!iViewCount)

		{

		// client has asked for something we dont have

		User::Leave(KErrNotFound);

		}

	// In case a previous registry response is cancelled, and then for the next request, 

	// a new registry response is created, the iResultBuffer could still be non-zero.

	// So, release memory now.

	delete iResultBuffer;

	iResultBuffer = NULL;

	// Create a buffer to hold the externalised entry

	iResultBuffer = CBufFlat::NewL(sizeof(CBTDevice)); // just a granularity for expansion

	RBufWriteStream stream;

	CleanupClosePushL(stream);

	stream.Open(*iResultBuffer);	// returns void

	TInt res = KErrNone;

	CBTDevice* device = NULL;

	iNumDevicesInBuffer=0;

	while (res == KErrNone)

		{

		// Get the entry and externalise to stream.

		TRAP(res, 

			 device= iRegistry.GetNextDeviceL(*iDBView, 

									iBookmark, 

									aMessage.HasCapability(ECapabilityReadDeviceData));

			CleanupStack::PushL(device);

			device->ExternalizeL(stream);

			CleanupStack::PopAndDestroy(device);

			device = NULL;

			iNumDevicesInBuffer++;

			);

		}

	// complete message with size of the blob or the error

	TInt code;

	if (res == KErrEof)

		{

		code = iResultBuffer->Size();

		}

	else

		{

		code = res;

		}

	iSession.CompleteMessage(aMessage, code);

	CleanupStack::PopAndDestroy(1); // stream

	// do not need to close view here

	}

void CBTRegistrySubSession::RetrieveL(const RMessage2& aMessage)

/**

	Returns the previously cached result set to the client

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	if (!iResultBuffer)

		{

		// they haven't preloaded

		User::Leave(KErrNotReady);

		}

	// write the buffer of devices back

	aMessage.WriteL(0, iResultBuffer->Ptr(0));

	iSession.CompleteMessage(aMessage, iNumDevicesInBuffer);

	// release memory now to reduce footprint

	delete iResultBuffer;

	iResultBuffer = NULL;

	}

void CBTRegistrySubSession::DeleteViewL(const RMessage2& aMessage)

/**

	Deletes all devices in the view - could be used to delete many devices in one call

	@param	aMessage The message to complete

**/

	{

	LOG_FUNC

	if (!iViewCount)

		{

		// no point calling delete on a view with no devices contained!

		User::Leave(KErrNotReady);

		}

	// Try to notify interested parties before deleting devices.

	// If we notify afterwards, then the devices will fall out of someone's

	// view and a change would then not be detected on that view.

	NotifyChange(*this, *iUnderlyingSearch);

	//	Delete all in view only if client has W.D.D capability. Otherwise delete the

	// devices whose SID value is same as the SecureId

	iRegistry.DeleteViewL(	*iDBView, 

							aMessage.HasCapability(ECapabilityWriteDeviceData),

							aMessage.SecureId());

	iSession.CompleteMessage(aMessage, KErrNone);

	// The view is not null, but probably not of much

	// use (ie. a view containing devices created by processes other than your own)

	// In addition, making the closure conditional would mean a potential SC

	// break for code moving from non-secure to secure world, so DoCloseView

	// remains non-optional at this point.

	DoCloseView();

	}

void CBTRegistrySubSession::UnpairViewL(const RMessage2& aMessage)

/**

	Unpairs all devices in the view

	@param	aMessage	The message to complete

**/

	{

	LOG_FUNC

	if (!iViewCount)

		{

		// no point calling delete on a view with no devices contained!

		User::Leave(KErrNotReady);

		}

	// Try to notify interested parties before making the change.

	// If we notify afterwards, then the device may fall out of someone's

	// view and a change would then not be detected on that view.		

	NotifyChange(*this, *iUnderlyingSearch);

	iRegistry.UnpairViewL(*iDBView);

	iSession.CompleteMessage(aMessage, KErrNone);

	}

void CBTRegistrySubSession::CloseView(const RMessage2& aMessage)

/**

	Client has finished with the view

	@param	aMessage	The message to complete

*/

	{

	LOG_FUNC

	DoCloseView();

	iSession.CompleteMessage(aMessage, KErrNone);

	// no underlying registry change, so don't notify

	}

void CBTRegistrySubSession::DoCloseView()

/**

	Close the internal view if it exists

**/

	{

	LOG_FUNC

	if (iDBView)

		{

		iDBView->Close();

		delete iDBView;

		iDBView=NULL;

		delete iUnderlyingSearch;

		iUnderlyingSearch=NULL;

		}

	// No point having notify on closed view; yet session may have already processed a cancel on it

	if (iSession.FindMessage(iViewChangeNotificationMessage))

		{

		iSession.CompleteMessage(iViewChangeNotificationMessage, KErrCompletion);

		}

	iViewCount=0;

	}

void CBTRegistrySubSession::Cleanup(TInt /*aError*/)