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

//

#include <btmanclient.h>

#include <e32math.h>

#include <utf.h>

#include "btmanclientserver.h"

#include "s32strm.h"

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_MANAGER_CLIENT);

#endif

const TInt KServerRetries = 2;

const TUint8 KDummyDevicePointer = 0xff;

/**

Start the btmanserver

@return Systemwide error code

@internalComponent

@released

*/

static TInt StartServer()

	{

	LOG_STATIC_FUNC

	const TUidType serverUid(KNullUid,KNullUid,KBTManServerUid3);

#ifdef __BTMANSERVER_NO_PROCESSES__

	//

	// In EKA1 WINS the server is a DLL, the exported entrypoint returns a TInt

	// which represents the real entry-point for the server thread

	//

	RLibrary lib;

	TInt r=lib.Load(KBTManServerImg,serverUid);

	if (r!=KErrNone)

		return r;

	TLibraryFunction ordinal1=lib.Lookup(1);

	TThreadFunction serverFunc=reinterpret_cast<TThreadFunction>(ordinal1());

	//

	// To deal with the unique thread (+semaphore!) naming in EPOC, and that we may

	// be trying to restart a server that has just exited we attempt to create a

	// unique thread name for the server.

	// This uses Math::Random() to generate a 32-bit random number for the name

	//

	TName name(KBTManServerName);

	_LIT(KHexString, "0x");

 	name.Append(KHexString());

	name.AppendNum(Math::Random(),EHex);

	RThread server;

	r=server.Create(name,serverFunc,

					KBTManServerStackSize,

					NULL,&lib,NULL,

					KBTManServerInitHeapSize,KBTManServerMaxHeapSize,EOwnerProcess);

	lib.Close();	// if successful, server thread has handle to library now

#else

	//

	// EPOC and EKA2 is easy, we just create a new server process. Simultaneous

	// launching of two such processes should be detected when the second one

	// attempts to create the server object, failing with KErrAlreadyExists.

	//

	RProcess server;

	TInt r=server.Create(KBTManServerImg,KNullDesC,serverUid);

#endif

	LOG1(_L("BTMan Server created, code %d"), r);

	if (r!=KErrNone)

		return r;

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat!=KRequestPending)

		{

		server.Kill(0);		// abort startup

		}

	else

		{

		server.Resume();	// logon OK - start the server

		LOG(_L("BTMan Server Resumed"));

		}

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	LOG1(_L("BTMan Server started, code %d (0=>success)"), stat.Int());

	r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

    server.Close(); 

 	LOG(_L("BTMan Server Closed"));

	return r;

	}

/**

Default Constructor.

@publishedAll

@released

*/

EXPORT_C RBTMan::RBTMan()

	{

	LOG_FUNC

	}

/**

Connects to the btman server.

@return systemwide error code

@publishedAll

@released

*/

EXPORT_C TInt RBTMan::Connect()

	{

	LOG_FUNC

	TInt retry=KServerRetries;

	for (;;)

		{

		TInt r=CreateSession(KBTManServerName,Version());	//gives MessageSlots of -1

																//this uses global pool rather

																//than local pool

		if (r!=KErrNotFound && r!=KErrServerTerminated)

			return r;

		if (--retry==0)

			return r;

		r=StartServer();

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

			return r;

		}

	}

/**

Returns the version of the server.

@return version of btmanserver

*/

EXPORT_C TVersion RBTMan::Version() const

/**

**/

	{

	LOG_FUNC

	return TVersion(KBTManServerMajorVersionNumber, 

					KBTManServerMinorVersionNumber, 

					KBTManServerBuildVersionNumber);

	}

/**

Default constructor of base class for subsessions

@publishedAll

@released

*/

EXPORT_C RBTManSubSession::RBTManSubSession()

: iClientServerMsg()

	{

	LOG_FUNC

	iClientServerMsg().iClientBusy = EFalse;

	iClientServerMsg().iClientStatusToCancel = NULL;

	}

/**

Cancel an outstanding request on btmanserver

@param aStatus the status of active object that made the original request

@publishedAll

@released

*/

EXPORT_C void RBTManSubSession::CancelRequest(TRequestStatus& aStatus)

	{

	LOG_FUNC

	if (SubSessionHandle())

		{

		SendReceive(EBTManCancelRequest, TIpcArgs(&aStatus));

		}

	else

		{

		//Client has a bad handle therefore complete the call from here

		LocalComplete(aStatus, KErrBadHandle);

		}

	}

/**

Completes a request locally without involving the server.

Called when a client-side error occurs.

@param	aStatus:	The TRequestStatus of the active object that made the request that needs to be completed.

@param	aErr:		The reason for completion. aErr will be written into the TRequestStatus of the active object.

@internalComponent

@released

**/

void RBTManSubSession::LocalComplete(TRequestStatus& aStatus, TInt aErr)

	{

	LOG_FUNC

	aStatus = KRequestPending;

	TRequestStatus* pS = &aStatus;

	User::RequestComplete(pS, aErr);

	}

TBool RBTManSubSession::IsBusy() const

	{

	LOG_FUNC

	return iClientServerMsg().iClientBusy;

	}

/**

To prevent clients using the server more than once

Business is cleared once the server has completed the job

@param aStatus the status of the client AO making a request on the server. this will can be used for cancelling later

@internalComponent

@released

**/

void RBTManSubSession::SetBusy(TRequestStatus& aStatus)

	{

	LOG_FUNC

	iClientServerMsg().iClientBusy = ETrue;

	iClientServerMsg().iClientStatusToCancel = &aStatus;

	}

/**

Default constructor of registry session

@publishedAll

@released

*/

EXPORT_C RBTRegServ::RBTRegServ()

	{

	LOG_FUNC

	}

/**

Connect to Registry Server

@return System-wide error code

@publishedAll

@released

@capability LocalServices

*/

EXPORT_C TInt RBTRegServ::Connect()

	{

	LOG_FUNC

	// we provide the standard RBTMan session for now, but the client doesnt know this!

	TInt r=RBTMan::Connect();

	return r;

	}

/**

Close session on Registry Server

@publishedAll

@released

*/

EXPORT_C void RBTRegServ::Close()

	{

	LOG_FUNC

	RBTMan::Close();

	}

/**

Return reference to the server session

@return reference to btman session

@publishedAll

@released

*/

EXPORT_C RBTMan& RBTRegServ::Session()

	{

	LOG_STATIC_FUNC

	return static_cast<RBTMan&>(*this);

	}

#ifndef _DEBUG

EXPORT_C TInt RBTRegServ::SetHeapFailure(TInt /*aType*/,TInt /*aRate*/)

#else

EXPORT_C TInt RBTRegServ::SetHeapFailure(TInt aType,TInt aRate)

#endif

/**

Send a message to the server to fail memory allocations (in debug builds)

@internalAll

@released

*/

	{

	LOG_FUNC

#ifdef _DEBUG

	return SendReceive(EBTManSetHeapFailure,TIpcArgs(static_cast<RHeap::TAllocFail>(aType), aRate));

#else

	return KErrNotSupported;

#endif

	}

/**

Returns the number of open subsessions.

This should be used by clients to do resource leakage debugging checks

@publishedAll

@released

*/

EXPORT_C TInt RBTRegServ::ResourceCount()

	{

	LOG_FUNC

	TInt count = 0;

	TPckg<TInt> pckg(count);

	SendReceive(EBTManSubSessionCount, TIpcArgs(&pckg));

	return count;

	}

/**

Default constructor for registry subsession

@publishedAll

@released

*/

EXPORT_C RBTRegistry::RBTRegistry()

: RBTManSubSession(), iDevicePckg(*reinterpret_cast<TBTNamelessDevice*>(KDummyDevicePointer))

	{

	LOG_FUNC

	} 

/**

Open a Bluetooth device subsession.

@param	aSession The BTManager session to which this subsession is to be attached.

@return An error code depicting the outcome of the "open".

@publishedAll

@released

@capability LocalServices

*/

EXPORT_C TInt RBTRegistry::Open(RBTRegServ& aSession)

	{

	LOG_FUNC

	iSendBuffer = NULL;

	return CreateSubSession(aSession.Session(), EBTManCreateRegistrySubSession, TIpcArgs(NULL));

	}

/** Create a constrained view of devices on the remote device table of the registry server.

This is in effect a registry search facility. 

It is needed if the user wishes find data in the registry of uncertain size.

For example:-

1) a list of remote devices. 

2) full details of a remote device including its name and/or friendly name.

Note 1: Some methods in the API (e.g. UnpairAllInView) require a view to have been created prior to their use.

Note 2: When a view has been generated, if details of the device(s) found are needed, these should be obtained using an instance of CBTRegistryResponse.

Note 3: A view must be closed before a new view can be created.

@see UnpairAllInView

@see DeleteAllInView

@see CloseView

@see NotifyViewChange

@see TBTRegistrySearch

@see CBTRegistryResponse

@param	aSearch A search struct with details of devices to be contained in the result set

@param	aStatus TRequestStatus supplied by caller

@return systemwide error

@publishedAll

@released

@capability LocalServices

@capability ReadDeviceData  (LocalServices only if link key is not needed)

*/

EXPORT_C void RBTRegistry::CreateView(const TBTRegistrySearch& aSearch, TRequestStatus& aStatus)

	{

	LOG_FUNC

	if (IsBusy())

		{

		LocalComplete(aStatus, KErrInUse);

		}

	else

		{

		if (SubSessionHandle())

			{

			SetBusy(aStatus);

			iSearchPckg = aSearch;

			SendReceive(EBTManRegistrySearch, TIpcArgs(&iSearchPckg, NULL, &iClientServerMsg), aStatus);

			}

		else

			{

			//Client has a bad handle therefore complete the call from here

			LocalComplete(aStatus, KErrBadHandle);

			}

		}

	}

/**

Close the subsession.  Removes all server side resources pertaining to this subsession

@publishedAll

@released

*/

EXPORT_C void RBTRegistry::Close()

	{

	LOG_FUNC

	delete iSendBuffer;

	iSendBuffer = NULL;

	RSubSessionBase::CloseSubSession(EBTManCloseSubSession);

	}

/**

Close a previously created view on the registry.

Allows an app to use this subsession for other view or non-view operations

@return Systemwide error

@post Subsession is left open for further use - eg to create another view, or perform a viewless operation

@publishedAll

@released

*/

EXPORT_C TInt RBTRegistry::CloseView()

	{

	LOG_FUNC

	if (SubSessionHandle())

		{

		return SendReceive(EBTRegistryCloseView, TIpcArgs(NULL, NULL, NULL));	// synchronous

		}

	else

		{

		return KErrBadHandle;

		}

	}

/**

Unpair a device in the registry

@param aAddress The device to unpair

@param aStatus reference to client AO's TRequestStatus

@publishedPartner

@released

@capability LocalServices

@capability WriteDeviceData

*/

EXPORT_C void RBTRegistry::UnpairDevice(const TBTDevAddr& aAddress, TRequestStatus& aStatus)

	{

	LOG_FUNC

	if (IsBusy())

		{

		LocalComplete(aStatus, KErrInUse);

		}

	else

		{

		if (SubSessionHandle())

			{

			SetBusy(aStatus);

			iAddrBuf = aAddress;

			SendReceive(EBTRegistryDeleteLinkKey, TIpcArgs(&iAddrBuf, NULL,  &iClientServerMsg), aStatus);

			}

		else

			{

			//Client has a bad handle therefore complete the call from here

			LocalComplete(aStatus, KErrBadHandle);

			}

		}

	}

/**

Unpair all the devices in the view - useful to unbond eg all devices (create a View with search All), or eg unbond all headsets

@param aStatus reference to client AO's TRequestStatus

@publishedPartner

@released

@capability LocalServices

@capability WriteDeviceData

*/

EXPORT_C void RBTRegistry::UnpairAllInView(TRequestStatus& aStatus)

	{

	LOG_FUNC

	if (SubSessionHandle())

		{

		iClientServerMsg().iClientStatusToCancel = &aStatus;

		SendReceive(EBTRegistryUnpairView, TIpcArgs(NULL, NULL, &iClientServerMsg), aStatus);

		}

	else

		{

		//Client has a bad handle therefore complete the call from here

		LocalComplete(aStatus, KErrBadHandle);

		}

	}

/**

Add device to the registry

@leave OOM

@param aDevice reference to CBTDevice of details of device to add

@param aStatus reference to client AO's TRequestStatus

@publishedAll

@released

@capability LocalServices

*/

EXPORT_C void RBTRegistry::AddDeviceL(const CBTDevice& aDevice, TRequestStatus& aStatus)

	{

	LOG_FUNC

	if (IsBusy())

		{

		LocalComplete(aStatus, KErrInUse);

		}

	else

		{

		if (SubSessionHandle())

			{

			if (iSendBuffer)

				{

				delete iSendBuffer;

				iSendBuffer = NULL;

				}

			// need to contiguate CBTDevice into a buffer

			SetBusy(aStatus);

			iSendBuffer = CBufFlat::NewL(sizeof(CBTDevice)); //granularity

			RBufWriteStream stream;

			stream.Open(*iSendBuffer);

			CleanupClosePushL(stream);

			aDevice.ExternalizeL(stream);

			const TPtr8 ptr=iSendBuffer->Ptr(0);

			iSendBufferPtr.Set(ptr);

			// now we can give the buffer to BTMan

			SendReceive(EBTRegistryAddDevice, TIpcArgs(&iSendBufferPtr, NULL,  &iClientServerMsg), aStatus);

			CleanupStack::PopAndDestroy(1);	// stream

			}

		else

			{

			//Client has a bad handle therefore complete the call from here

			LocalComplete(aStatus, KErrBadHandle);

			}

		}

	}