// 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 <avctpservices.h>

#include <bttypes.h>

#include <e32base.h>

#include <remconaddress.h>

#include <remconbeareravrcp.h>

#include <remcon/remconbearerobserver.h>

#include "controlcommand.h"

#include "browsecommand.h"

#include "avrcpbrowsingcommandhandler.h"

#include "avrcpincomingcommandhandler.h"

#include "avrcpoutgoingcommandhandler.h"

#include "avrcpremotedevice.h"

#include "avrcprouter.h"

#include "avrcputils.h"

#include "avrcpplayerinfomanager.h"

#include "bulkbearer.h"

#include "controlbearer.h"

#include "mediabrowse.h"

#include "nowplaying.h"

#include "avrcplog.h"

/** Allocates and constructs a new CRemConBearerAvrcp object.

@param aParams Bearer construction params used for base class construction.

@return A new CRemConBearerAvrcp object.

@leave System wide error code

*/

CRemConBearerAvrcp* CRemConBearerAvrcp::NewL(TBearerParams& aParams)

	{

	LOG_STATIC_FUNC

	CRemConBearerAvrcp* bearer = new(ELeave) CRemConBearerAvrcp(aParams);

	CleanupStack::PushL(bearer);

	TRAPD(err, bearer->ConstructL());

	if(err == KErrNoMemory)

		{

		User::Leave(err);

		}

	// else KErrNone or some other error -- swallow it.

	CleanupStack::Pop(bearer);

	return bearer;

	}

/** Constructor.

@param aParams Bearer construction params used for base class construction.

*/

CRemConBearerAvrcp::CRemConBearerAvrcp(TBearerParams& aParams) : 

	CRemConBearerPlugin(aParams), iRemotes(_FOFF(CRcpRemoteDevice, iLink)),

	iReadyCommands(_FOFF(CAvrcpCommand, iReadyLink)), iReadyResponses(_FOFF(CAvrcpCommand, iReadyLink)),

	iReadyNotifyResponses(_FOFF(CControlCommand, iReadyLink)), 

	iReadyNotifyCommands(_FOFF(CAvrcpCommand, iReadyLink))

	{

	LOG_FUNC

	}

/** Second phase construction.

@leave System wide error code

*/	

void CRemConBearerAvrcp::ConstructL()

	{

	LOG_FUNC

	// Set-up TLS

	LEAVEIFERRORL(Dll::SetTls(reinterpret_cast<TAny*>(EControlThread)));

	// New up a router.  This opens and uses the RAvctp.

	// On initialisation it should begin listening.

	iRouter = CControlRouter::NewL(iAvctp, *this);

	iTimer = CDeltaTimer::NewL(CActive::EPriorityStandard);

	iPlayerInfoManager = CAvrcpPlayerInfoManager::NewL(Observer(), *this);

	iInternalHandler = &iPlayerInfoManager->InternalCommandHandler();

	// Create the bulk bearer - actual usage occurs in the bulk thread.

	iBulkBearer = CAvrcpBulkBearer::NewL(iAvctp, *iPlayerInfoManager);

	iConstructionComplete = ETrue;

	}

/** Destructor.

*/

CRemConBearerAvrcp::~CRemConBearerAvrcp()

	{

	LOG_FUNC

	while (!iRemotes.IsEmpty())

		{

		CRcpRemoteDevice* remote = iRemotes.First();

		remote->iLink.Deque();

		remote->Disconnect(EFalse);

		delete remote;

		}

	delete iRouter;

	delete iBulkBearer;

	// Delete the timer last as pending events

	// are cancelled in remote->Disconnect

	delete iTimer;

	delete iPlayerInfoManager;

	Dll::FreeTls();

	}

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

// RemConBearer control functions

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

/** Called by RemCon to retrieve a response on a connection. 

This must only be called as a result of a NewResponse upcall.

@param aInterfaceUid The UID of the outer-layer client API specifying the response.

@param aId The command identifier used as a cookie for command/response matching.

@param aOperationId The ID of the response operation in the outer-layer client API.

@param aData API-specific message data. On success, ownership is returned.

@param aAddr The connection.

*/	

TInt CRemConBearerAvrcp::GetResponse(TUid& aInterfaceUid, 

		TUint& aId, 

		TUint& aOperationId, 

		RBuf8& aCommandData, 

		TRemConAddress& aAddr)

	{

	LOG_FUNC

	// If object only partially constructed, swallow the request

	__ASSERT_DEBUG(iConstructionComplete, AVRCP_PANIC(EAvrcpNoResponsesAvailable));	

	TInt result = KErrNotFound;

	if(!iReadyResponses.IsEmpty())

		{

		CAvrcpCommand* command = iReadyResponses.First();

		TBTDevAddr btAddr;

		command->GetCommandInfo(aInterfaceUid, aId, aOperationId, aCommandData, btAddr);

		AvrcpUtils::BTToRemConAddr(btAddr, aAddr);

		// Remove command from queue first because calling

		// DecrementUsers() may delete command

		command->iReadyLink.Deque();

		command->DecrementUsers();

		result = KErrNone;

		}

	else

		{

		// RemCon is trying to pick up a response we don't think we have

		__ASSERT_DEBUG(EFalse, AVRCP_PANIC(EAvrcpNoResponsesAvailable));	

		}

	return result;

	}

/** Called by RemCon to retrieve a response on a connection. 

This must only be called as a result of a NewResponse upcall.

@param aInterfaceUid The UID of the outer-layer client API specifying the response.

@param aId The command identifier used as a cookie for command/response matching.

@param aOperationId The ID of the response operation in the outer-layer client API.

@param aData API-specific message data. On success, ownership is returned.

@param aAddr The connection.

*/	

TInt CRemConBearerAvrcp::GetNotifyResponse(TUid& aInterfaceUid, 

		TUint& aId, 

		TUint& aOperationId, 

		RBuf8& aCommandData, 

		TRemConAddress& aAddr,

		TRemConMessageSubType& aSubMessageType)

	{

	LOG_FUNC

	// If object only partially constructed, swallow the request

	__ASSERT_DEBUG(iConstructionComplete, AVRCP_PANIC(EAvrcpNoResponsesAvailable));	

	TInt result = KErrNotFound;

	if(!iReadyNotifyResponses.IsEmpty())

		{

		CControlCommand* command = iReadyNotifyResponses.First();

		TBTDevAddr btAddr;

		command->GetCommandInfo(aInterfaceUid, aId, aOperationId, aCommandData, btAddr);

		AvrcpUtils::BTToRemConAddr(btAddr, aAddr);

		switch ( command->Frame().Type() )

	        {

	        case AVC::EInterim:

			    aSubMessageType = ERemConNotifyResponseInterim;

	            break;

		    case AVC::EChanged: 

	            aSubMessageType = ERemConNotifyResponseChanged;

		        break;

		    case AVC::ERejected: // fall into default

		    case AVC::ENotImplemented:// fall into default

		    default:

		        aSubMessageType = ERemConMessageDefault;

		        break;

		    }

		// Remove command from queue first because calling

		// DecrementUsers() may delete command

		command->iReadyLink.Deque();

		command->DecrementUsers();

		result = KErrNone;

		}

	else

		{

		// RemCon is trying to pick up a response we don't think we have

		__ASSERT_DEBUG(EFalse, AVRCP_PANIC(EAvrcpNoResponsesAvailable));	

		}

	return result;

	}

/** Called by RemCon to send a command on a connection. 

@param aInterfaceUid The UID of the outer-layer client API specifying the command.

@param aOperationId The ID of the command operation in the outer-layer client API.

@param aId The command identifier used as a cookie for command/response matching.

@param aData API-specific message data. On success, ownership is passed. 

@param aAddr The connection.

@return Error. This request is synchronous. It returns KErrNone when AVRCP has

taken responsibility for sending the message. This involves checking that the message

is well-formed and adding it to the send queue.

*/

TInt CRemConBearerAvrcp::SendCommand(TUid aInterfaceUid, 

		TUint aOperationId, 

		TUint aId,  

		RBuf8& aData, 

		const TRemConAddress& aAddr)

	{

	LOG_FUNC

	// RemCon retains ownership of the data in aData until

	// this function returns KErrNone.

	if (!iConstructionComplete)

		{

		// Object only partially constructed, swallow the request

		return KErrNotSupported;

		}

	TBTDevAddr btAddr;

	TInt err = AvrcpUtils::RemConToBTAddr(aAddr, btAddr);

	if(err == KErrNone)

		{

		CRcpRemoteDevice* remote = RemoteDevice(btAddr);

		__ASSERT_ALWAYS(remote, AVRCP_PANIC(EAvrcpNotConnected));

		TRAP(err, remote->OutgoingHandler().SendCommandL(aInterfaceUid, 

				aOperationId,

				aId, 

				aData, 

				btAddr));

		}

	return err;

	}

/** Called by RemCon to retrieve a command on a connection. 

This must only be called as a result of a NewCommand upcall.

@param aInterfaceUid The UID of the outer-layer client API specifying the command.

@param aId The command identifier used as a cookie for command/response matching.

@param aOperationId The ID of the command operation in the outer-layer client API.

@param aData API-specific message data. On success, ownership is returned.

@param aAddr The connection.

*/	

TInt CRemConBearerAvrcp::GetCommand(TUid& aInterfaceUid, 

		TUint& aId, 

		TUint& aOperationId, 

		RBuf8& aCommandData, 

		TRemConAddress& aAddr)

	{

	TInt result = KErrNotFound;

	if(!iReadyCommands.IsEmpty())

		{

		CAvrcpCommand* command = GetFirstCommand(iReadyCommands, aInterfaceUid, aId, aOperationId, aCommandData, aAddr);

		if(command)

			{

			// Remove command from queue first because calling

			// DecrementUsers() may delete command

			command->iReadyLink.Deque();

			command->DecrementUsers();

			result = KErrNone;

			}

		}

	else

		{

		__DEBUGGER();

		}

	return result;

	}

/** Called by RemCon to retrieve a notify command on a connection. 

This must only be called as a result of a NewNotifyCommand upcall.

@param aInterfaceUid The UID of the outer-layer client API specifying the command.

@param aId The command identifier used as a cookie for command/response matching.

@param aOperationId The ID of the command operation in the outer-layer client API.

@param aData API-specific message data. On success, ownership is returned.

@param aAddr The connection.

*/	

TInt CRemConBearerAvrcp::GetNotifyCommand(TUid& aInterfaceUid, 

		TUint& aId, 

		TUint& aOperationId, 

		RBuf8& aCommandData, 

		TRemConAddress& aAddr)

	{

	TInt result = KErrNotFound;

	CAvrcpCommand* command = GetFirstCommand(iReadyNotifyCommands, aInterfaceUid, aId, aOperationId, aCommandData, aAddr);

	if(command)

		{		

		// Remove command from queue first because calling

		// DecrementUsers() may delete command

		command->iReadyLink.Deque();

		command->DecrementUsers();

		result = KErrNone;

		}

	return result;

	}

/**

Internal method, called by GetCommand() and GetNotifyCommand()

@return The first command from the Queue.  NULL if the queue is empty.  The command remains 

		on the queue.

*/

CAvrcpCommand* CRemConBearerAvrcp::GetFirstCommand(TDblQue<CAvrcpCommand>& aQue, TUid& aInterfaceUid, 

		TUint& aId, 

		TUint& aOperationId, 

		RBuf8& aCommandData, 

		TRemConAddress& aAddr)

	{

	LOG_FUNC

	// If object only partially constructed, swallow the request

	__ASSERT_DEBUG(iConstructionComplete, AVRCP_PANIC(EAvrcpNoResponsesAvailable));	

	CAvrcpCommand* command = NULL;

	if(! aQue.IsEmpty())

		{

		command = aQue.First();

		// Calling GetCommandInfo transfers the command data to RemCon.  This means

		// once we have called it we are committed to returning KErrNone.

		TBTDevAddr btAddr;

		command->GetCommandInfo(aInterfaceUid, aId, aOperationId, aCommandData, btAddr);

		AvrcpUtils::BTToRemConAddr(btAddr, aAddr);

		}

	else

		{

		// RemCon is trying to pick up a command we don't think we have

		__ASSERT_DEBUG(EFalse, AVRCP_PANIC(EAvrcpNoResponsesAvailable));

		}

	return command;

	}

/** Called by RemCon to send a response on a connection. 

@param aInterfaceUid The UID of the outer-layer client API specifying the response.

@param aOperationId The ID of the response operation in the outer-layer client API.

@param aId The command identifier used as a cookie for command/response matching

@param aData API-specific message data. On success, ownership is passed.

@param aAddr The connection.

@return Error. This request is synchronous. It is completed by AVRCP when it has 

taken responsibility for sending the message. This involves checking that the message 

is well-formed and adding it to the send queue.

*/	

TInt CRemConBearerAvrcp::SendResponse(TUid aInterfaceUid, 

		TUint /*aOperationId*/, 

		TUint aId, 

		RBuf8& aData, 

		const TRemConAddress& aAddr)

	{

	LOG_FUNC

	// RemCon retains ownership of the data in aData until

	// this function returns KErrNone.

	if (!iConstructionComplete)

		{

		// Object only partially constructed, swallow the request

		return KErrNotSupported;

		}

	TBTDevAddr btAddr;

	TInt err = AvrcpUtils::RemConToBTAddr(aAddr, btAddr);

	__ASSERT_DEBUG(err == KErrNone, AVRCP_PANIC(EInvalidBtAddrInResponse));

	if(btAddr != TBTDevAddr(0))

		{

		CRcpRemoteDevice* remote = RemoteDevice(btAddr);

		__ASSERT_ALWAYS(remote, AVRCP_PANIC(EAvrcpNotConnected));

		err = remote->IncomingHandler().SendRemConResponse(aInterfaceUid, aId, aData);

		}

	else

		{

		err = iInternalHandler->SendRemConResponse(aInterfaceUid, aId, aData);

		}

	return err;

	}

/**	Called by RemCon when either

	a) The TSP does not address a command to any clients

	b) The TSP does not permit the response from any commands

	c) All the clients disconnect from remcon before the response is sent

	to send a null response on a connection. The connection must already

	exist

	@param aInterfaceUid The UID of the outer-layer client API that the command

	was sent to

	@param aOperationId The ID of the command operation sent to remcon

	@param aId The command identifier used as a cookie for command/response 

	matching.

	@param aAddr The connection.

	*/

void CRemConBearerAvrcp::SendReject(TUid aInterfaceUid,

		TUint /* aOperationId */,

		TUint aTransactionId,

		const TRemConAddress& aAddr)

	{

	LOG_FUNC

	__ASSERT_DEBUG(iConstructionComplete, AVRCP_PANIC(EAvrcpNotFullyConstructed));

	TBTDevAddr btAddr;

	__DEBUG_ONLY(TInt err = )AvrcpUtils::RemConToBTAddr(aAddr, btAddr);

	__ASSERT_DEBUG(err == KErrNone, AVRCP_PANIC(EInvalidBtAddrInResponse));

	if(btAddr != TBTDevAddr(0))

		{

		CRcpRemoteDevice* remote = RemoteDevice(btAddr);

		__ASSERT_ALWAYS(remote, AVRCP_PANIC(EAvrcpNotConnected));

		remote->IncomingHandler().SendReject(aInterfaceUid, aTransactionId);

		}

	else

		{

		iInternalHandler->SendReject(aInterfaceUid, aTransactionId);

		}

	}

/** Called by RemCon to establish a bearer-level connection to another party.

Completion is signalled back in ConnectConfirm.

@param aAddr The RemCon address to connect to.

*/	

void CRemConBearerAvrcp::ConnectRequest(const TRemConAddress& aAddr)

	{

	LOG_FUNC

	if (!iConstructionComplete)

		{

		// Object only partially constructed, error the request

		Observer().ConnectConfirm(aAddr, KErrNotSupported);

		return;

		}

	// Get a bluetooth address from the TRemConAddr

	TBTDevAddr btAddr;

	TInt convErr = AvrcpUtils::RemConToBTAddr(aAddr, btAddr);

	if(convErr != KErrNone)

		{

		Observer().ConnectConfirm(aAddr, convErr);

		return;

		}

	// Address for internal commands

	if(btAddr == TBTDevAddr(0))

		{

		Observer().ConnectConfirm(aAddr, KErrNone);

		return;

		}

	CRcpRemoteDevice* remote = RemoteDevice(btAddr);

	if(remote)

		{

		// Already have a connection to this address

		Observer().ConnectConfirm(aAddr, KErrNone);

		return;