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

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <remconinterfaceselector.h>

#include <remcon/remconinterfacebase.h>

#include <remconerrorobserver.h>

#include <remcon/remconinterfacefeatures.h>

#include <remcon/remconifdetails.h>

#include <s32mem.h>

#include "bulkreceiver.h"

#include "receiver.h"

#include "remconclient.h"

#include "remconbulkclient.h"

#include "utils.h"

const TInt KMaxSharedThreadHeapSize = 0x0400;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_IF_SEL);

#endif

#ifdef _DEBUG

PANICCATEGORY("ifsel");

#endif

#define RCIS_VERBOSE_PANIC(code) \

	{ \

	LOG1(_L("Panicking with RemConIfSel / %d"), code); \

	User::Panic(KRemConIfSelPanicCat, code); \

	}

#define RCIS_VERBOSE_ASSERT(cond, code) \

	{ \

	if ( !(cond) ) \

		{ \

		RCIS_VERBOSE_PANIC(code); \

		} \

	}

void CloseDeleteAndNull(TAny* aPtr)

	{

	RRemCon** sessionPtrPtr = static_cast<RRemCon**>(aPtr);

	RRemCon* session = *sessionPtrPtr;

	session->Close();

	delete session;

	*sessionPtrPtr = NULL;

	}

void CleanupCloseDeleteAndNullPushL(RRemCon** aSession)

	{

	TCleanupItem item(CloseDeleteAndNull, aSession);

	CleanupStack::PushL(item);	

	}

EXPORT_C CRemConInterfaceSelector* CRemConInterfaceSelector::NewL()

	{

	CONNECT_LOGGER

	LOG_STATIC_FUNC

	CRemConInterfaceSelector* ifSel = new(ELeave) CRemConInterfaceSelector;

	CleanupStack::PushL(ifSel);

	ifSel->ConstructL();

	CleanupStack::Pop(ifSel);

	return ifSel;

	}

void CRemConInterfaceSelector::ConstructL()

	{

	iSharedThreadHeap = UserHeap::ChunkHeap(NULL, 0, KMaxSharedThreadHeapSize);

	if(!iSharedThreadHeap)

		{

		LEAVEL(KErrNoMemory);

		}

	iBulkCleanupCall = new(ELeave) RSpecificThreadCallBack;

	TCallBack bulkCleanupCb(StaticBulkCleanup, this);

	LEAVEIFERRORL(iBulkCleanupCall->Create(bulkCleanupCb, CActive::EPriorityStandard));

	// allocate in the shared objects heap.

	RHeap* currentHeap = User::SwitchHeap(iSharedThreadHeap);

	CleanupSwitchHeapPushL(*currentHeap);

		{

		iInterfaces = CRemConInterfaceDetailsArray::NewL();

		}

	CleanupStack::PopAndDestroy(currentHeap);

	}

CRemConInterfaceSelector::CRemConInterfaceSelector()

	{

	LOG_FUNC

	iTargetReceiver = NULL;

	}

EXPORT_C CRemConInterfaceSelector::~CRemConInterfaceSelector()

	{

	LOG_FUNC

	// The easy one... (i.e. non-bulk interfaces)

	for(TInt ix = 0; ix < iInterfaces->Array().Count(); ++ix)

		{

		CRemConInterfaceDetails* const details = iInterfaces->Array()[ix];

		ASSERT_DEBUG(details);

		if(!details->IsBulk())

			{

			CRemConInterfaceBase* interface = details->Interface();

			details->Interface() = NULL;

			delete interface;

			}

		}

	// The tricky one...

	// we have to use the thread specific cleanup because they have to 

	// cancel some objects...

	TInt err = iBulkCleanupCall->CallBack();

	if(err == KErrDied)

		{

		// If the other thread is dead then we cannot cleanly cleanup

		// but if the heap is shared then we should be ok.

		if(iBulkHeap == &User::Heap())

			{

			BulkCleanup();

			}

		}

	// Finally tidy-up shared thread objects.

	RHeap* currentHeap = User::SwitchHeap(iSharedThreadHeap);

		{

		delete iInterfaces;

		}

	User::SwitchHeap(currentHeap);

	delete iTargetReceiver;

	delete iControllerReceiver;

	// delete iBulkReceiver; // This is done in the bulk thread cleanup.

	if(iControllerSession)

		{

		iControllerSession->Close();

		delete iControllerSession;

		}

	if(iTargetSession)

		{

		iTargetSession->Close();

		delete iTargetSession;

		}

	// iBulkSession.Close(); // This is done in the bulk thread cleanup.

	iBulkCleanupCall->Close();

	delete iBulkCleanupCall;

	iSharedThreadHeap->Close();

	iBulkThread.Close();

	iLock->Wait();

	iLock->Close();

	delete iLock;

	CLOSE_LOGGER

	}

TInt CRemConInterfaceSelector::StaticBulkCleanup(TAny* aSelf)

	{

	LOG_STATIC_FUNC

	reinterpret_cast<CRemConInterfaceSelector*>(aSelf)->BulkCleanup();

	return KErrNone;

	}

void CRemConInterfaceSelector::BulkCleanup()

	{

	LOG_FUNC

	CBulkReceiver* recv = iBulkReceiver;

	iBulkReceiver = NULL;

	delete recv;

	if(RThread().Id() == iBulkThread.Id() && iBulkSession)

		{

		iBulkSession->Close();

		delete iBulkSession;

		iBulkSession = NULL;

		}

	for(TInt ix = 0; ix < iInterfaces->Array().Count(); ++ix)

		{

		CRemConInterfaceDetails* const details = iInterfaces->Array()[ix];

		ASSERT_DEBUG(details);

		if(details->IsBulk())

			{

			CRemConInterfaceBase* interface = details->Interface();

			details->Interface() = NULL;

			delete interface;

			}

		}

	}

void CRemConInterfaceSelector::EstablishBulkThreadBindingL()

	{

	LOG_FUNC

	if(iBulkHeap)

		{

		// Already bound

		RCIS_VERBOSE_ASSERT(RThread().Id() == iBulkThread.Id(), ERemConIfSelMultipleBulkInterfaceThreads);

		}

	else

		{

		// Create Binding.

		LEAVEIFERRORL(iBulkThread.Duplicate(RThread()));

		CleanupClosePushL(iBulkThread);

		LEAVEIFERRORL(iBulkCleanupCall->Start());

		iBulkReceiver = CBulkReceiver::NewL(*this);	

		iBulkHeap = &User::Heap();

		CleanupStack::Pop(&iBulkThread);

		}

	}

void CRemConInterfaceSelector::RegisterInterfaceCommonL(CRemConInterfaceBase& aInterface, const TDesC8& aFeatures)

	{

	LOG_FUNC

	const TBool bulkIf = aInterface.Bulk();

	if(bulkIf)

		{

		EstablishBulkThreadBindingL();

		}

	// Check an instance of the same interface (same interface UID and type) 

	// has not already been added.

	const TUint count = iInterfaces->Array().Count();

	for(TUint ii=0; ii<count; ++ii)

		{

		CRemConInterfaceBase* const iface = iInterfaces->Array()[ii]->Interface();

		RCIS_VERBOSE_ASSERT(iface, ERemConIfSelInternalError);

		RCIS_VERBOSE_ASSERT( (iface->InterfaceUid() != aInterface.InterfaceUid()) || (iface->Type() != aInterface.Type()), 

			ERemConIfSelInterfaceOfThatTypeAlreadyRegistered);

		}

	// Registration of interfaces should occur before we try to use any of 

	// them.

	RCIS_VERBOSE_ASSERT(!TargetOpened() && !ControllerOpened(), ERemConIfSelTardyInterfaceRegistration);

	iLock->Wait();	// critical session

	RHeap* currentHeap = User::SwitchHeap(iSharedThreadHeap);

	CleanupSwitchHeapPushL(*currentHeap);

		{

		CRemConInterfaceDetails* details = CRemConInterfaceDetails::NewLC(aInterface.InterfaceUid(), aInterface.Type(), bulkIf, &aInterface, aFeatures);

		iInterfaces->AppendL(details);

		CleanupStack::Pop(details);

		}

	CleanupStack::PopAndDestroy(currentHeap);

	iLock->Signal(); // end of critical session

	// The interface has been appended OK, so adjust iMaxDataLength.

	const TUint interfaceMaxLength = aInterface.MaxLength();

	if(!bulkIf && interfaceMaxLength > iControlMaxDataLength)

		{

		iControlMaxDataLength = interfaceMaxLength;

		}

	else if(bulkIf && interfaceMaxLength > iBulkMaxDataLength)

		{

		iBulkMaxDataLength = interfaceMaxLength;

		}

	}

EXPORT_C void CRemConInterfaceSelector::RegisterInterfaceL(CRemConInterfaceBase& aInterface)

	{

	LOG_FUNC

	RegisterInterfaceCommonL(aInterface, KNullDesC8);

	}

void CRemConInterfaceSelector::RegisterInterfaceL(CRemConInterfaceBase& aInterface, RRemConInterfaceFeatures& aRemConInterfaceFeatures)

	{

	LOG_FUNC

	RegisterInterfaceCommonL(aInterface, aRemConInterfaceFeatures.SupportedOperations());

	}

EXPORT_C void CRemConInterfaceSelector::RegisterErrorObserver(MRemConErrorObserver* aObserver)

	{

	LOG_FUNC

	LOG1(_L("\taObserver = 0x%08x"), aObserver);

	iErrorObserver = aObserver;

	}

EXPORT_C void CRemConInterfaceSelector::OpenControllerL()

	{

	LOG_FUNC

	// An attempt to open a controller session when one is already open 

	// is an exceptional condition.

	if (ControllerOpened())

		{

		LEAVEL(KErrInUse);

		}

	// NB We don't enforce that there are some interfaces registered here 

	// because the client might be connecting just to watch connection 

	// statuses.

	iControllerSession = new(ELeave)RRemConController();

	LEAVEIFERRORL(iControllerSession->Connect());

	CleanupCloseDeleteAndNullPushL(reinterpret_cast<RRemCon**>(&iControllerSession));

	RegisterInterestedApisL(ERemConClientTypeController);

	// Now there's a session to receive on, start the receiver.

	RCIS_VERBOSE_ASSERT(!iControllerReceiver, ERemConIfSelInternalError);

	iControllerReceiver = CReceiver::NewL(*iControllerSession, *this, iControlMaxDataLength, ERemConClientTypeController);

	CleanupStack::Pop(&iControllerSession);

	}

void CRemConInterfaceSelector::RegisterInterestedApisL(TRemConClientType aType)

	{

	LOG_FUNC

	TBool target = CRemConInterfaceBase::Target(aType);

	// First get the size of the data we are going to pass to the server.

	RCountSizeWriteStream counter;

	iInterfaces->ExternalizeL(counter, aType);

	TInt size = counter.Size();

	counter.Close();

	// Create a suitable size buffer.

	RBuf8 ipcBuf;

	ipcBuf.CreateL(size);

	ipcBuf.CleanupClosePushL();

	// Encode the interface details into the buffer.

	RDesWriteStream ipcStream(ipcBuf);

	iInterfaces->ExternalizeL(ipcStream, aType);

	ipcStream.CommitL();

	ipcStream.Close();

	// Inform the correct session about the interfaces

	if(!target)

		{

		LEAVEIFERRORL(iControllerSession->RegisterInterestedAPIs(ipcBuf));

		}

	else

		{	

		LEAVEIFERRORL(iTargetSession->RegisterInterestedAPIs(ipcBuf));

		}

	CleanupStack::PopAndDestroy(&ipcBuf);

	}

void CRemConInterfaceSelector::OpenTargetCommonL()

	{

	LOG_FUNC

	// NB We don't enforce that there are some interfaces registered here 

	// because the client might be connecting just to watch connection 

	// statuses.

	CleanupCloseDeleteAndNullPushL(reinterpret_cast<RRemCon**>(&iTargetSession));

	RegisterInterestedApisL(ERemConClientTypeTarget);

	// Now we are finished with the features, so we can release some memory.

	RHeap* currentHeap = User::SwitchHeap(iSharedThreadHeap);

		{

		for(TInt ix = 0; ix < iInterfaces->Array().Count(); ++ix)

			{

			CRemConInterfaceDetails* const details = iInterfaces->Array()[ix];

			ASSERT_DEBUG(details);

			details->DeleteFeatures();

			}

		}

	User::SwitchHeap(currentHeap);

	// Now there's a session to receive on, start the receiver.

	RCIS_VERBOSE_ASSERT(!iTargetReceiver, ERemConIfSelInternalError);

	iTargetReceiver = CReceiver::NewL(*iTargetSession, *this, iControlMaxDataLength, ERemConClientTypeTarget);

	CleanupDeleteAndNullPushL(iTargetReceiver);

	if(iBulkReceiver)

		{

		// We delegate the call to the thread the receiver is running

		// in - waiting until it has completed (with success or error).

		iBulkReceiver->WaitUntilConnectedL();

		}

	CleanupStack::Pop(2, &iTargetSession); // iTargetReceiver, iTargetSession

	}

EXPORT_C void CRemConInterfaceSelector::OpenTargetL()

	{

	LOG_FUNC

	// An attempt to open a target session when one is already open 

	// is an exceptional condition.

	if (TargetOpened())

		{

		LEAVEL(KErrInUse);

		}

	iTargetSession = new(ELeave)RRemConTarget();

	TInt err = iTargetSession->Connect();

	if(err == KErrNone)

		{

		OpenTargetCommonL();

		}

	else

		{

		delete iTargetSession;

		iTargetSession = NULL;

		LEAVEL(err);

		}

	}

/**

This should be run from the thread in which the bulk interfaces are to run.

*/

void CRemConInterfaceSelector::BulkSessionConnectL()

	{

	LOG_FUNC

	RCIS_VERBOSE_ASSERT(iBulkReceiver, ERemConIfSelInternalError);

	}

/**

Opens a target session to RemCon.

If any bulk interfaces have been registered on this interface selector the

the thread in which the first bulk interface was created must be ready to run and

not blocked waiting for the completion of this function.  Failure to do so will lead

to deadlock.

@param aPlayerType The type of player

@param aPlayerSubType The sub-type of the player

@param aPlayerName  The name of the player

@leave KErrInUse If a target session is already open.

*/

EXPORT_C void CRemConInterfaceSelector::OpenTargetL(TPlayerType aPlayerType, TPlayerSubType aPlayerSubType, const TDesC8& aPlayerName)

	{

	LOG_FUNC

	// An attempt to open a target session when one is already open 

	// is an exceptional condition.

	if (TargetOpened())

		{

		LEAVEL(KErrInUse);

		}

	iTargetSession = new(ELeave)RRemConTarget();

	TInt err = iTargetSession->Connect(aPlayerType,aPlayerSubType,aPlayerName);

	if(err == KErrNone)

		{

		OpenTargetCommonL();

		}

	else

		{

		delete iTargetSession;

		iTargetSession = NULL;

		LEAVEL(err);

		}

	}

EXPORT_C TBool CRemConInterfaceSelector::ControllerOpened() const

	{

	ASSERT_DEBUG((iControllerSession && iControllerSession->Handle()) || !iControllerSession);

	return iControllerSession ? ETrue : EFalse;

	}

EXPORT_C TBool CRemConInterfaceSelector::TargetOpened() const

	{

	ASSERT_DEBUG((iTargetSession && iTargetSession->Handle()) || !iTargetSession);

	return iTargetSession ? ETrue : EFalse;

	}

TBool CRemConInterfaceSelector::BulkOpened() const

	{

	ASSERT_DEBUG((iBulkSession && iBulkSession->Handle()) || !iBulkSession);

	return iBulkSession ? ETrue : EFalse;

	}

EXPORT_C void CRemConInterfaceSelector::GoConnectionOrientedL(const TRemConAddress& aConnection)

	{

	LOG_FUNC

	RCIS_VERBOSE_ASSERT(ControllerOpened(), ERemConIfSelNoControllerSession);

	LEAVEIFERRORL(iControllerSession->GoConnectionOriented(aConnection));

	// Store the address.  This means that if the server dies we know all

	// we need to to return the existing sessions to usability without 

	// troubling the app.

	iAddress = aConnection;

	}

EXPORT_C void CRemConInterfaceSelector::GoConnectionlessL()

	{