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

// Bearer manager.

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCON_SERVER);

#endif

#include <remcon/remconbearerplugin.h>

#include <remcon/remconbearerinterface.h>

#include <remcon/remconbearerbulkinterface.h>

#include <remcon/bearerparams.h>

#include <remcon/bearersecurity.h>

#include <remcon/remconconverterinterface.h>

#include "bearermanager.h"

#include "utils.h"

#include "server.h"

#include "session.h"

#include "remconmessage.h"

#include "connections.h"

PANICCATEGORY("bearerman");

#ifdef __FLOG_ACTIVE

#define LOGBEARERS	LogBearers()

#else

#define LOGBEARERS

#endif

static TBool RemConAddrsMatch(const TRemConAddress& aFirstAddr, const TRemConAddress& aSecondAddr)

	{

	return aFirstAddr == aSecondAddr;

	}

CBearerManager* CBearerManager::NewL(CRemConServer& aServer)

	{

	LOG_STATIC_FUNC

	CBearerManager* self = new(ELeave) CBearerManager(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CLEANUPSTACK_POP1(self);

	return self;

	}

CBearerManager::~CBearerManager()

	{

	LOG_FUNC;

	// We do not check these are empty before cleaning them up. There are no 

	// cancel methods for connect/disconnect in the bearer API.

	iCurrentlyBeingConnected.Close();

	iCurrentlyBeingDisconnected.Close();

	LOGBEARERS;

	// Destroy all bearer instances.

	iBearers.ResetAndDestroy();

	LOGBEARERS;

	iBearerIfs.Close();

	// Clean up the security policy collection.

	TSglQueIter<TBearerSecurity> iter(iBearerSecurityPolicies);

	TBearerSecurity* sec;

	while ( ( sec = iter++ ) != NULL )

		{

		iBearerSecurityPolicies.Remove(*sec);

		delete sec;

		}

	}

CBearerManager::CBearerManager(CRemConServer& aServer)

:	iBearerSecurityPolicies(_FOFF(TBearerSecurity, iLink)),

	iServer(aServer)

	{

	LOG_FUNC

	}

void CBearerManager::ConstructL()

	{

	LOG_FUNC;

	// Instantiate all bearers at construction time.

	LoadAllBearersL();

	LOGBEARERS;

	}

MRemConBearerInterface* CBearerManager::BearerIf(TUid aBearerUid) const

	{

	LOG_FUNC;

	LOG1(_L("\taBearerUid = 0x%08x"), aBearerUid);

	MRemConBearerInterface* bearerIf = NULL;

	const TUint numBearerIfs = iBearerIfs.Count();

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

		{

		if ( iBearerIfs[ii].iBearerUid == aBearerUid )

			{

			// In the current implementation we only have three bearer interface 

			// UIDs. This UID is tied to the version of MRemConBearerInterface.

			ASSERT_DEBUG(iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface1) || 

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface2) ||

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface3));

			bearerIf = iBearerIfs[ii].iIf;

			break;

			}

		}

	LOG1(_L("\tbearerIf = 0x%08x"), bearerIf);

	return bearerIf;

	}

MRemConBearerInterfaceV2* CBearerManager::BearerIfV2(TUid aBearerUid) const

	{

	LOG_FUNC;

	LOG1(_L("\taBearerUid = 0x%08x"), aBearerUid);

	MRemConBearerInterfaceV2* bearerIfV2 = NULL;

	const TUint numBearerIfs = iBearerIfs.Count();

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

		{

		if ( iBearerIfs[ii].iBearerUid == aBearerUid )

			{

			// In the current implementation we only have two bearer interface 

			// UIDs. This UID is tied to the version of MRemConBearerInterface.

			ASSERT_DEBUG(iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface1) || 

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface2) ||

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface3));

			if((iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface2)) ||

			   (iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface3)))

				{

				bearerIfV2 = iBearerIfs[ii].iIfV2;

				}

			break;

			}

		}

	LOG1(_L("\tbearerIfV2 = 0x%08x"), bearerIfV2);

	return bearerIfV2;

	}

MRemConBearerInterfaceV3* CBearerManager::BearerIfV3(TUid aBearerUid) const

	{

	LOG_FUNC;

	LOG1(_L("\taBearerUid = 0x%08x"), aBearerUid);

	MRemConBearerInterfaceV3* bearerIfV3 = NULL;

	const TUint numBearerIfs = iBearerIfs.Count();

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

		{

		if ( iBearerIfs[ii].iBearerUid == aBearerUid )

			{

			// In the current implementation we only have three bearer interface 

			// UIDs. This UID is tied to the version of MRemConBearerInterfaceV3.

			ASSERT_DEBUG(iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface1) || 

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface2) ||

						 iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface3));

			if(iBearerIfs[ii].iIfUid == TUid::Uid(KRemConBearerInterface3))

				{

				bearerIfV3 = iBearerIfs[ii].iIfV3;

				}

			break;

			}

		}

	LOG1(_L("\tbearerIfV3 = 0x%08x"), bearerIfV3);

	return bearerIfV3;

	}

void CBearerManager::LoadAllBearersL()

	{

	LOG_FUNC;

	// Use ECOM to instantiate each implementation of the bearer plugin 

	// interface.

	const TUid KUidRemoteControlBearerPluginInterface = TUid::Uid(KRemConBearerInterfaceUid);

	RImplInfoPtrArray implementations;

	const TEComResolverParams noResolverParams;

	REComSession::ListImplementationsL(KUidRemoteControlBearerPluginInterface, 

		noResolverParams, 

		KRomOnlyResolverUid, 

		implementations);

	CleanupResetAndDestroyPushL(implementations);

	const TUint count = implementations.Count();

	LOG1(_L("\tnumber of implementations of bearer plugin interface: %d"), count);

	// There should be at least one bearer present. If there are no bearers in 

	// the ROM, then there shouldn't be RemCon server present either due to 

	// the waste of ROM. This is why the client-side is a separate DLL, so it 

	// can be included to satisfy any static linkages, without bringing the 

	// unnecessary bulk of the server with it.

	ASSERT_ALWAYS(count != 0);

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

		{

		CImplementationInformation* impl = implementations[ii];

		ASSERT_DEBUG(impl);

		LOG(_L("\tloading bearer with:"));

		LOG1(_L("\t\timplementation uid 0x%08x"), impl->ImplementationUid());

		LOG1(_L("\t\tversion number %d"), impl->Version());

		TBuf8<KMaxName> buf8;

		buf8.Copy(impl->DisplayName());

		LOG1(_L8("\t\tdisplay name \"%S\""), &buf8);

		LOG1(_L("\t\tROM only %d"), impl->RomOnly());

		LOG1(_L("\t\tROM based %d"), impl->RomBased());

		TBearerParams params(impl->ImplementationUid(), *this);

		CRemConBearerPlugin* bearer = CRemConBearerPlugin::NewL(params);

		CleanupStack::PushL(bearer);

		LEAVEIFERRORL(iBearers.Append(bearer));

		CLEANUPSTACK_POP1(bearer);

		// Also get information about the interface the bearer presents.

		// Look for latest interface first

		TInterfaceInfo ifInfo;

		ifInfo.iIfUid = TUid::Uid(0);

		// Control interfaces

		ifInfo.iIfV3 = reinterpret_cast<MRemConBearerInterfaceV3*>(bearer->GetInterface(TUid::Uid(KRemConBearerInterface3)));

		ifInfo.iIfV2 = reinterpret_cast<MRemConBearerInterfaceV2*>(bearer->GetInterface(TUid::Uid(KRemConBearerInterface2)));

		ifInfo.iIf = reinterpret_cast<MRemConBearerInterface*>(bearer->GetInterface(TUid::Uid(KRemConBearerInterface1)));

		if(ifInfo.iIfV3)

			{

			ifInfo.iIfUid = TUid::Uid(KRemConBearerInterface3);

			}

		else if(ifInfo.iIfV2)

			{

			ifInfo.iIfUid = TUid::Uid(KRemConBearerInterface2);

			}

		else if(ifInfo.iIf)

			{

			ifInfo.iIfUid = TUid::Uid(KRemConBearerInterface1);

			}

		LOG1(_L8("\t\tcontrol interface (V1) = [0x%08x]"), ifInfo.iIf);

		LOG1(_L8("\t\tcontrol interface (V2) = [0x%08x]"), ifInfo.iIfV2);

		LOG1(_L8("\t\tcontrol interface (V3) = [0x%08x]"), ifInfo.iIfV3);

		// If the bearer doesn't support the basic bearer API, panic server 

		// startup.

		ASSERT_ALWAYS(ifInfo.iIf);

		ifInfo.iBearerUid = impl->ImplementationUid();

		ifInfo.iControllerCount = 0;

		ifInfo.iTargetCount = 0;

		LEAVEIFERRORL(iBearerIfs.Append(ifInfo));

		TBearerSecurity* sec = new(ELeave) TBearerSecurity(bearer->Uid(), ifInfo.iIf->SecurityPolicy());

		iBearerSecurityPolicies.AddLast(*sec);

		}

	CleanupStack::PopAndDestroy(&implementations);

	}

#ifdef __FLOG_ACTIVE

void CBearerManager::LogBearers() const

	{

	const TUint count = iBearers.Count();

	LOG1(_L("\tNumber of bearers = %d"), count);

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

		{

		const CRemConBearerPlugin* const bearer = iBearers[ii];

		ASSERT_DEBUG(bearer);

		LOG3(_L("\t\tbearer %d [0x%08x], Uid = 0x%08x"), 

			ii, 

			bearer,

			bearer->Uid()

			);

		}

	}

#endif // __FLOG_ACTIVE

TInt CBearerManager::Send(CRemConMessage& aMsg)

	{

	LOG_FUNC;

	LOG4(_L("\taMsg.Addr.BearerUid = 0x%08x, aMsg.InterfaceUid = 0x%08x, aMsg.MsgType = %d, aMsg.OperationId = 0x%02x"), 

		aMsg.Addr().BearerUid(), aMsg.InterfaceUid(), aMsg.MsgType(), aMsg.OperationId());

	MRemConBearerInterface* const bearerIf = BearerIf(aMsg.Addr().BearerUid());

	MRemConBearerInterfaceV2* const bearerIfV2 = BearerIfV2(aMsg.Addr().BearerUid());

	MRemConBearerInterfaceV3* const bearerIfV3 = BearerIfV3(aMsg.Addr().BearerUid());

	// For connection-oriented sends, the session protects against trying to 

	// connect to a non-existent bearer. For connectionless sends, the TSP can 

	// indicate whatever connections it like, but if it indicates one 

	// belonging to a non-existent bearer, that's panicked.

	ASSERT_DEBUG(bearerIf); 

	TInt ret = KErrNone;

	switch ( aMsg.MsgType() )

		{

	case ERemConNotifyCommand:

	    // We originate a transaction identifier as it's a new outgoing 

	    // notify message.

		aMsg.TransactionId() = MrcboDoNewTransactionId();

		ASSERT_DEBUG(bearerIfV3);

		ret = bearerIfV3->SendNotifyCommand(aMsg.InterfaceUid(), 

			aMsg.OperationId(), 

			aMsg.TransactionId(),

			aMsg.OperationData(),

			aMsg.Addr());

		if ( ret == KErrNone )

			{

			// On success, the bearer takes ownership of the message data.

			aMsg.OperationData().Assign(NULL);

			}

	    break;

	case ERemConCommand:

		// We originate a transaction identifier as it's a new outgoing 

		// message.

		aMsg.TransactionId() = MrcboDoNewTransactionId();

		ret = bearerIf->SendCommand(aMsg.InterfaceUid(), 

			aMsg.OperationId(), 

			aMsg.TransactionId(),

			aMsg.OperationData(),

			aMsg.Addr());

		if ( ret == KErrNone )

			{

			// On success, the bearer takes ownership of the message data.

			aMsg.OperationData().Assign(NULL);

			}

		break;

	case ERemConResponse:

		ret = bearerIf->SendResponse(aMsg.InterfaceUid(), 

			aMsg.OperationId(), 

			aMsg.TransactionId(),

			aMsg.OperationData(), 

			aMsg.Addr());

		if ( ret == KErrNone )

			{

			// On success, the bearer takes ownership of the message data.

			aMsg.OperationData().Assign(NULL);

			}

		break;

	case ERemConReject:

		{

		ASSERT_DEBUG(aMsg.OperationData().Length() == 0);

		if (bearerIfV2)

			{

			bearerIfV2->SendReject(aMsg.InterfaceUid(), 

					aMsg.OperationId(), 

					aMsg.TransactionId(),

					aMsg.Addr());

			}

		break;

		}

	default:

		DEBUG_PANIC_LINENUM; // the session protects us against this

		break;

		}

	LOG1(_L("\tret = %d"), ret);

	return ret;

	}

TInt CBearerManager::Connect(const TRemConAddress& aAddr)

	{

	LOG_FUNC;

	LOG1(_L("\taAddr.BearerUid = 0x%08x"), aAddr.BearerUid());

	TInt ret = KErrNone;

	if ( iCurrentlyBeingConnected.Find(aAddr, RemConAddrsMatch) == KErrNotFound )

		{

		MRemConBearerInterface* const bearerIf = BearerIf(aAddr.BearerUid());

		// The caller should have checked that the interface existed before 

		// calling this.

		ASSERT_DEBUG(bearerIf);

		// Make a note of the address. If we can't do this then fail the connect.

		ret = iCurrentlyBeingConnected.Append(aAddr);

		if ( ret == KErrNone )

			{

			bearerIf->ConnectRequest(aAddr);

			}

		}

	LOG1(_L("\tret = %d"), ret);

	return ret;

	}

TInt CBearerManager::Disconnect(const TRemConAddress& aAddr)

	{

	LOG_FUNC;

	LOG1(_L("\taAddr.BearerUid = 0x%08x"), aAddr.BearerUid());

	TInt ret = KErrNone;

	if ( iCurrentlyBeingDisconnected.Find(aAddr, RemConAddrsMatch) == KErrNotFound )

		{

		MRemConBearerInterface* const bearerIf = BearerIf(aAddr.BearerUid());

		// The caller should have checked that the interface existed before 

		// calling this.

		ASSERT_DEBUG(bearerIf);

		// Make a note of the address. If we can't do this then fail the 

		// disconnect.

		ret = iCurrentlyBeingDisconnected.Append(aAddr);

		if ( ret == KErrNone )

			{

			bearerIf->DisconnectRequest(aAddr);

			}

		}

	LOG1(_L("\tret = %d"), ret);

	return ret;

	}

TBool CBearerManager::BearerExists(TUid aBearerUid) const

	{

	LOG_FUNC;

	LOG1(_L("\taBearerUid = 0x%08x"), aBearerUid);

	TBool ret = EFalse;

	if ( BearerIf(aBearerUid) != NULL )

		{

		ret = ETrue;

		}

	LOG1(_L("\tret = %d"), ret);

	return ret;

	}

TBool CBearerManager::CheckPolicy(TUid aBearerUid, const RMessage2& aMessage)

	{

	LOG_FUNC;

	LOG1(_L("\taBearerUid = 0x%08x"), aBearerUid);

	MRemConBearerInterface* bearerIf = BearerIf(aBearerUid);

	// The caller should have checked that the interface existed before 

	// calling this.

	ASSERT_DEBUG(bearerIf);

	TBool ret = bearerIf->SecurityPolicy().CheckPolicy(aMessage);

	LOG1(_L("\tret = %d"), ret);

	return ret;

	}

void CBearerManager::ClientTypeSet(TBool aController)

	{

	LOG_FUNC;

	LOG1(_L("\taController = %x"), aController);

	/* When a client (session) has its type set (controller or target) then 

	   it will still have a bearer uid of NullUid. In this case we want to 

	   update any bearers which now have a controller or target count moving to 1 */

	const TUint count = iBearerIfs.Count();

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

		{

		MRemConBearerInterface* const bearerIf = iBearerIfs[ii].iIf;

		MRemConBearerInterfaceV3* const bearerIfV3 = iBearerIfs[ii].iIfV3;

		ASSERT_DEBUG(bearerIf);

		/* maintain the controller and target count for each bearer 

		   tell the bearer if the count has increased to 1

		   by doing this in this loop we are sure we only 

		   tell the bearer when we need to */

		if (aController)

			{

			iBearerIfs[ii].iControllerCount++;

			if (1 == iBearerIfs[ii].iControllerCount)

				{

				bearerIf->ClientStatus(TBool(iBearerIfs[ii].iControllerCount), TBool(iBearerIfs[ii].iTargetCount));

				}

			}

		else

			{

			iBearerIfs[ii].iTargetCount++;

			if (1 == iBearerIfs[ii].iTargetCount)

				{

				bearerIf->ClientStatus(TBool(iBearerIfs[ii].iControllerCount), TBool(iBearerIfs[ii].iTargetCount));

				}

			}

		}

	}

void CBearerManager::TargetClientAvailable(TRemConClientId aId, const TPlayerType& aClientType, const TPlayerSubType& aClientSubType, const TDesC8& aName)

	{

	LOG_FUNC;

	const TUint count = iBearerIfs.Count();

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

		{

		MRemConBearerInterfaceV3* const bearerIfV3 = iBearerIfs[ii].iIfV3;

		if(bearerIfV3)

			{

			bearerIfV3->ClientAvailable(aId, aClientType, aClientSubType, aName);

			}

		}

	}

void CBearerManager::ControllerClientAvailable()

	{

	LOG_FUNC;

	RArray<TUid> supportedInterfaces;

	TInt err = iServer.ControllerSupportedInterfaces(supportedInterfaces);

	LOG2(_L("\tGot %d supported interfaces with result %d"), supportedInterfaces.Count(), err);

	if(!err)

		{

		const TUint count = iBearerIfs.Count();

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

			{

			MRemConBearerInterfaceV3* const bearerIfV3 = iBearerIfs[ii].iIfV3;