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

//

/**

 @file

 @internalComponent

 @released

*/

#include <bluetoothav.h>

#include "avrcpcommand.h"

#include "avrcplog.h"

#include "avrcprouter.h"

#include "avrcputils.h"

#include "commandhandlerinterface.h"

using namespace SymbianAvctp;

/** Constructor.

@param aRemotes The list of remote devices known to AVRCP.

@param aBearer The bearer.

@return A partially constructed CRcpRouter.

*/

CRcpRouter::CRcpRouter(MAvrcpBearer& aBearer)

	: iChannel(NULL)

	, iBearer(aBearer)

	, iSendQueue(_FOFF(CAvrcpCommand, iSendLink))

	, iState(EAvrcpRouterCanSend)

	{

	LOG_FUNC

	}

/** Destructor.

*/	

CRcpRouter::~CRcpRouter()

	{

	LOG_FUNC

	// The lifetime of the Router is the same as that of the bearer plugin.

	// This means that there is no point worrying about the stuff on our

	// send queue as we won't be around to pass the results up to RemCon.

	while (!iSendQueue.IsEmpty())

		{

		CAvrcpCommand *command = iSendQueue.First();

		command->iSendLink.Deque();

		command->DecrementUsers();

		}

	}

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

// Data functions called from command handlers

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

/** Adds command to send queue.

This message will be sent as soon as the iAvcp becomes

free for sending, unless the command is removed before

then.

@param aCommand The command to send.

@see CRcpRouter::RemoveFromSendQueue

*/

void CRcpRouter::AddToSendQueue(CAvrcpCommand& aCommand)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(!aCommand.iSendLink.IsQueued(), AVRCP_PANIC(ECommandAlreadyQueuedForSending));

	iSendQueue.AddLast(aCommand);

	aCommand.IncrementUsers();

	if(iState == EAvrcpRouterCanSend)

		{

		Send();

		}	

	}

/** Remove command from send queue.

@param aCommand The command that is not to be sent.

*/	

void CRcpRouter::RemoveFromSendQueue(CAvrcpCommand& aCommand)

	{

	LOG_FUNC

	if(iSendQueue.IsFirst(&aCommand))

		{

		// If this is at the front of the queue it's currently being

		// sent.  Cancel that and start off the next thing.

		iChannel->MacCancelSend();

		aCommand.iSendLink.Deque();

		iState = EAvrcpRouterCanSend;

		if(!iSendQueue.IsEmpty())

			{

			Send();

			}

		}

	else

		{

		// Still waiting to be sent so we can just sneak it out of

		// the queue.

		aCommand.iSendLink.Deque();

		}

	}

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

// Control functions called from bearer

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

/** Try to bring up an explicit connection to a remote.

@param aAddr The address of the remote.

@return System wide error.  KErrNone if this request will be

		attempted, and generate a ConnectConfirm.

*/

TInt CRcpRouter::ConnectRequest(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	return iChannel->MacAttachRequest(aAddr);

	}

/** Try to bring down an explicit connection to a remote.

@param aAddr The address of the remote.

@return System wide error.  KErrNone if the disconnect will be

		attempted, and generate a DisconnectConfirm.

*/	

TInt CRcpRouter::DisconnectRequest(const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	return iChannel->MacDetachRequest(aAddr);

	}

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

// MAvctpEventNotify functions called from RAvctp

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

/** AVCTP Connection Indicate.

This is called when a remote device has connected 

to us. NB we don't return the configuration status as 

in Appendix A - AVCTP Upper Interface of [R2]. If aAccept 

is not changed the connection will be refused however 

this may not result in the actual disconnection of the 

device if another RAvctp client did accept the connection.

@param aBTDevice the address of the device connected to

@param aAccept this parameter is provided so that the client 

	of RAvctp can indicate whether they want to accept the 

	connection.  The meaning of a refusal is that you don't 

	care whether or not the connection is there or not.	

@see RAvctp			   

*/

void CRcpRouter::MaenAttachIndicate(const TBTDevAddr& aBTDevice, TInt aMtu, TBool& aAccept)

	{

	LOG_FUNC

	aAccept = ETrue;

	// if we have already received data from this device we will have 

	// informed RemCon about it already, so don't pass up the connection

	// now

	if(!iBearer.IncomingHandler(aBTDevice))

		{

		iBearer.ConnectIndicate(aBTDevice);

		}

	MIncomingCommandHandler* handler = iBearer.IncomingHandler(aBTDevice);

	if(handler)

		{

		handler->MaxPacketSize(aMtu);

		aAccept = ETrue;

		}

	else

		{

		aAccept = EFalse;

		}

	}

/** AVCTP Connection Confirm.

This is a response to RAvctp::ConnectRequest and passes on the 

result of the Connection attempt. NB we don't return the 

configuration status as in Appendix A - AVCTP Upper 

Interface of [R2]. If the aConnectResult is KErrNone 

then iAvctp is now connected.

@param aBTDevice the address of the device connected to

@param aConnectResult connection result - one of the 

					  system-wide error codes. 

@see RAvctp					  

*/	

void CRcpRouter::MaenAttachConfirm(const TBTDevAddr& aBTDevice, TInt aMtu, TInt aConnectResult)

	{

	LOG_FUNC

	iBearer.ConnectConfirm(aBTDevice, aConnectResult);

	MIncomingCommandHandler* handler = iBearer.IncomingHandler(aBTDevice);

	if(handler)

		{

		handler->MaxPacketSize(aMtu);

		}

	}

/** AVCTP Disconnection Indication.

Indicates that a remote device has disconnected from us.

It is only called if the device had been explicitly Connected to.

@param aBTDevice the address of the disconnecting device

@see RAvctp

*/	

void CRcpRouter::MaenDetachIndicate(const TBTDevAddr& aBTDevice)

	{

	LOG_FUNC

	iBearer.DisconnectIndicate(aBTDevice);

	}

/** AVCTP Disconnection Confirm.

@param aBTDevice the address of the disconnected device

@param aDisconnectResult will be one of the system-wide 

						 error codes. If KErrTimedOut is 

						 returned then the RAvctp will be 

						 disconnected.

@see RAvctp	

*/	

void CRcpRouter::MaenDetachConfirm(const TBTDevAddr& aBTDevice, TInt aDisconnectResult)

	{

	LOG_FUNC

	iBearer.DisconnectConfirm(aBTDevice, aDisconnectResult);

	}

/** AVCTP Message received indication.

This method is called when a message has been received from 

the given device on the RAvctp's PID. 

Note that because AVCTP is a connectionless protocol, it is 

perfectly possible to get a MaenMessageReceivedIndicate event 

from a device that you have not either explicitly connected to.

For instance even if you don't accept a MaenConnectIndicate 

you may still receive messages from that remote device.

@param aBTDevice address of the device sending us an AVCTP message

@param aTransactionLabel message transaction label

@param aType type of message 

@param aIpidBitSet this will be set to true only if a message has been received indicating 

				   that the profile corresponding to the originally sent message is not valid.

				   If RAvctp was used to send the message then this response will have come from

				   the remote device aBTDevice.

@param aMessageInformation contains only the AVCTP Command / Response Message Information and not the whole packet.

                           Ownership transferred to client.

@see RAvctp

*/	

void CRcpRouter::MaenMessageReceivedIndicate(const TBTDevAddr& aBTDevice,

		SymbianAvctp::TTransactionLabel aTransactionLabel,

		SymbianAvctp::TMessageType aType,

		TBool aIpidBitSet,

		const TDesC8& aMessageInformation)

	{

	LOG_FUNC

	AVRCPLOG(aMessageInformation)

	// Find the right handler

	if(aType == ECommand)

		{

		MIncomingCommandHandler* handler = iBearer.IncomingHandler(aBTDevice);

		if(!handler)

			{

			iBearer.ConnectIndicate(aBTDevice);

			handler = iBearer.IncomingHandler(aBTDevice);

			}

		if(handler)

			{

			// If this leaves the handler is rejecting handling this command, just

			// ignore it.

			TRAP_IGNORE(handler->ReceiveCommandL(aMessageInformation, aTransactionLabel, aBTDevice));

			}

		}

	else

		{

		MOutgoingCommandHandler* handler = iBearer.OutgoingHandler(aBTDevice);

		if(handler)

			{

			handler->ReceiveResponse(aMessageInformation, aTransactionLabel, aIpidBitSet);

			}

		}

	}

/** AVCTP Message send complete.

This method is called when a RAvctp has attempted to send 

the message defined by aTransactionLabel and aBTDevice. 

@param aTransactionLabel The transaction label of the message 

						 that has been sent

@param aBTDevice the device to which the send has completed

@param aSendResult KErrNone if the send was successful or one 

				   of the system-wide error codes

@see RAvctp

*/	

void CRcpRouter::MaenMessageSendComplete(const TBTDevAddr& aBTDevice, 

		       		SymbianAvctp::TTransactionLabel aTransactionLabel,   

					TInt aSendResult)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(!iSendQueue.IsEmpty(), AvrcpUtils::Panic(EAvrcpNoOutstandingSend));

	CAvrcpCommand* command = iSendQueue.First();

	__ASSERT_ALWAYS(command->TransactionLabel() == aTransactionLabel, AvrcpUtils::Panic(EAvrcpUnknownAvctpTransId));

	MAvrcpCommandHandler* handler = NULL;

	if(command->MessageType() == ECommand)

		{

		handler = iBearer.OutgoingHandler(aBTDevice);

		}

	else 

		{

		handler = iBearer.IncomingHandler(aBTDevice);

		}

	if(handler)

		{

		handler->MessageSent(*command, aSendResult);

		}

	// Deque before calling Decrement because Decrement handling may involve

	// deleting command

	command->iSendLink.Deque();

	command->DecrementUsers();

	// Now able to do another send. Toggle our state and check if there

	// are any commands waiting.

	iState = EAvrcpRouterCanSend;

	if(!iSendQueue.IsEmpty())

		{

		Send();

		}

	}

/** AVCTP Close Complete.

This is the response to the CloseGracefully() that has been

called on a RAvctp object. It is the last event that will be 

called until the RAvctp object is Open()'d again.

@see RAvctp

*/

void CRcpRouter::MaenCloseComplete()

	{

	LOG_FUNC

	}

/** AVCTP error notification.

Note an errored device does not indicate that the device has 

been disconnected. If it has then a MaenDisconnectIndicate 

event will be used to indicate this.

@param aBTDevice the remote device associated with the error or TBTDevAddr(0) for a general error

@param aError system wide error

@see RAvctp

*/

void CRcpRouter::MaenErrorNotify(const TBTDevAddr& /*aBTDevice*/, TInt /*aError*/)

	{

	LOG_FUNC

	}

/**

Returns a null aObject if the extension is not implemented,

or a pointer to another interface if it is.

@param aInterface UID of the interface to return

@param aObject system wide error

@see RAvctp

*/	

void CRcpRouter::MaenExtensionInterfaceL(TUid /*aInterface*/, void*& aObject)

	{

	LOG_FUNC

	aObject = NULL;

	}

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

// Utility functions

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

/** Issue a send to AVCTP.

This sends the first message on the command queue.

*/

void CRcpRouter::Send()

	{

	LOG_FUNC

	__ASSERT_ALWAYS(!iSendQueue.IsEmpty(), AvrcpUtils::Panic(EAvrcpNoOutstandingSend));

	CAvrcpCommand* command = iSendQueue.First();

#ifdef _DEBUG	

	TInt err = 

#endif // _DEBUG

	iChannel->MacSendMessage(command->RemoteAddress(),

		command->TransactionLabel(),

		command->MessageType(),

		command->Data());

	__ASSERT_DEBUG(err == KErrNone, AvrcpUtils::Panic(EAvrcpSendingMessageFailed));

	iState = EAvrcpRouterSending;

	}

/** Factory funtion.

@param aAvctp An open RAvctp instance.

@param aBearer The bearer.

@return A fully constructed CRcpRouter.

@leave System wide error codes.

*/

CControlRouter* CControlRouter::NewL(RAvctp& aAvctp, MAvrcpBearer& aBearer)

	{

	LOG_STATIC_FUNC

	CControlRouter* router = new(ELeave) CControlRouter(aAvctp, aBearer);

	CleanupStack::PushL(router);

	router->ConstructL();

	CleanupStack::Pop(router);

	return router;

	}

CControlRouter::~CControlRouter()

	{

	LOG_FUNC

	iAvctp.Close(RAvctp::ENormal);

	}

CControlRouter::CControlRouter(RAvctp& aAvctp, MAvrcpBearer& aBearer)

	: CRcpRouter(aBearer)

	, iAvctp(aAvctp)

	{

	LOG_FUNC

	}

void CControlRouter::ConstructL()

	{

	LOG_FUNC

	LEAVEIFERRORL(iAvctp.Open(*this, KAvrcpPid, iChannel));

	}

/** Factory funtion.

@param aAvctp An open RAvctp instance.

@param aBearer The bearer.

@return A fully constructed CRcpRouter.

@leave System wide error codes.

*/

CBulkRouter* CBulkRouter::NewL(RAvctp& aAvctp, MAvrcpBearer& aBearer)

	{

	LOG_STATIC_FUNC

	CBulkRouter* router = new(ELeave) CBulkRouter(aAvctp, aBearer);

	CleanupStack::PushL(router);

	router->ConstructL();

	CleanupStack::Pop(router);

	return router;

	}

CBulkRouter::~CBulkRouter()

	{

	LOG_FUNC

	iAvctp.UninstallSecondaryChannel();

	}

CBulkRouter::CBulkRouter(RAvctp& aAvctp, MAvrcpBearer& aBearer)

	: CRcpRouter(aBearer)

	, iAvctp(aAvctp)

	{

	LOG_FUNC

	}

void CBulkRouter::ConstructL()

	{

	LOG_FUNC

	LEAVEIFERRORL(iAvctp.InstallSecondaryChannel(*this, iChannel));

	}