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

// avrcpincomingcommandhandler.cpp

//

/**

 @file

 @internalComponent

 @released

*/

#include <e32base.h>

#include <remcon/remconbearerbulkobserver.h>

#include <remconaddress.h>

#include "browsecommand.h"

#include "avrcpbrowsingcommandhandler.h"

#include "avrcpinternalinterface.h"

#include "avrcplog.h"

#include "avrcprouter.h"

#include "avrcputils.h"

#include "browsingframe.h"

#include "bulkbearer.h"

#include "mediabrowse.h"

#include "remconcommandinterface.h"

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

// Construction/Destruction

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

/** Factory function.

@param aCommandInterface	The interface for providing commands that have been handled.

@param aRouter	A CRcpRouter to use for communication with remote devices.

@param aPlayerInfoManager	The central manager for player information.

@param aAddr	The Bluetooth device address for the remote device handled by this handler.

@return A fully constructed CRcpBrowsingCommandHandler.

@leave System wide error codes.

*/

CRcpBrowsingCommandHandler* CRcpBrowsingCommandHandler::NewL(MRemConBulkCommandInterface& aCommandInterface,

	CBulkRouter& aRouter,

	CAvrcpPlayerInfoManager& aPlayerInfoManager,

	const TBTDevAddr& aAddr)

	{

	LOG_STATIC_FUNC

	CRcpBrowsingCommandHandler* handler = new(ELeave) CRcpBrowsingCommandHandler(aCommandInterface, aRouter, aPlayerInfoManager, aAddr);

	return handler;

	}

/**

@param aCommandInterface	The interface for providing commands that have been handled.

@param aRouter	A CRcpRouter to use for communication with remote devices.

@param aPlayerInfoManager	The central manager for player information.

@param aAddr	The Bluetooth device address for the remote device handled by this handler.

@return A partially constructed CRcpBrowsingCommandHandler.

*/	

CRcpBrowsingCommandHandler::CRcpBrowsingCommandHandler(MRemConBulkCommandInterface& aCommandInterface,

	CBulkRouter& aRouter,

	CAvrcpPlayerInfoManager& aPlayerInfoManager,

	const TBTDevAddr& aAddr) 

	: iCommandQueue(_FOFF(CBrowseCommand, iHandlingLink))

	, iInternalCommandQueue(_FOFF(CBrowseCommand, iHandlingLink))

	, iCommandInterface(aCommandInterface)

	, iRouter(aRouter)

	, iMtu(335) // initialise to min for browse channel

	, iPlayerInfoManager(aPlayerInfoManager)

	, iAddr(aAddr)

	{

	LOG_FUNC

	}

CRcpBrowsingCommandHandler::~CRcpBrowsingCommandHandler()

	{

	LOG_FUNC

	while (!iCommandQueue.IsEmpty())

		{

		CBrowseCommand *command = iCommandQueue.First();

		HandledCommand(*command);

		}

	TRemConAddress remConAddr;

	AvrcpUtils::BTToRemConAddr(iAddr, remConAddr);

	iCommandInterface.MrcbciRemoveAddressing(remConAddr);

	}

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

// Called from the bearer

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

/** Tell the handler to gracefully shutdown.

*/

void CRcpBrowsingCommandHandler::Disconnect()

	{

	LOG_FUNC

	while (!iCommandQueue.IsEmpty())

		{

		CBrowseCommand* command = iCommandQueue.First();

		iRouter.RemoveFromSendQueue(*command);

		HandledCommand(*command);

		}

	}

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

// Called by router

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

/** Receive an incoming AVRCP browse command.

@param aMessageInformation	The command data from the AVCTP message.

@param aTransactionLabel	AVCTP transaction label for this command.

@param aAddr	The bluetooth device from which this command originated.

@leave System Wide Error code

*/

void CRcpBrowsingCommandHandler::ReceiveCommandL(const TDesC8& aMessageInformation, 

	SymbianAvctp::TTransactionLabel aTransactionLabel, 

	const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	// If there's nothing beyond a header this is bobs.  Dump it now.

	AvrcpBrowsing::BrowsingFrame::VerifyFrameL(aMessageInformation);

	TUint id = iCommandInterface.MrcciNewTransactionId();

	CBrowseCommand* command = CBrowseCommand::NewL(aMessageInformation, id, aTransactionLabel, aAddr, &iPlayerInfoManager);

	CleanupStack::PushL(command);

	TInt result = command->ProcessIncomingCommandL(iMtu);

	CleanupStack::Pop(command);

	command->IncrementUsers();

	switch(result)

		{

	case KErrAvrcpFurtherProcessingRequired: 

		{

		// The only command that we need to check out before sending on is

		// SetBrowsedPlayer.  Although it's been parsed to verify that it's 

		// a syntactically valid command we need to ensure that the selected

		// player is available before sending it on.

		__ASSERT_DEBUG(command->RemConInterfaceUid() == TUid::Uid(KRemConMediaBrowseApiUid) && command->RemConOperationId() == ESetBrowsedPlayerOperationId, AVRCP_PANIC(EFurtherProcessingRequiredForNonSetBrowsedPlayer));

		TBool valid = HandleSetBrowsedPlayer(*command);

		if(!valid)

			{

			Respond(*command, result);

			command->DecrementUsers();

			break;

			}

		else

			{

			result = KErrNone;

			}

		// valid case fallsthrough to be handled as normal

		}

	case KErrAvrcpHandledInternallyInformRemCon:  // this case falls through

	case KErrNone:

		{

		iCommandQueue.AddLast(*command);

		iCommandInterface.MrcciNewCommand(*command);

		if (result == KErrNone)

			{

			break;

			}

		// KErrAvrcpHandledInternallyInformRemCon fallsthrough here

		}

	case KErrAvrcpHandledInternallyRespondNow:

		{

		// If the command has already set payload, just sent the command

		iRouter.AddToSendQueue(*command);

		command->DecrementUsers();

		break;

		}

	case KErrAvrcpInternalCommand:

		{

		iInternalCommandQueue.AddLast(*command);

		HandleInternalCommand(*command);

		break;

		}

	default:

		{

		Respond(*command, result);

		command->DecrementUsers();

		break;

		}

		};

	}

/** Called from the router to indicate send completion.

@param aCommand The command that has been sent.

@param aSendResult KErrNone if the command was sent successfully.  System wide

				   error code otherwise.

*/

void CRcpBrowsingCommandHandler::MessageSent(CAvrcpCommand& /*aCommand*/, TInt /*aSendResult*/)

	{

	LOG_FUNC

	// We try and send the response, but if we fail there's not a lot we can do about

	// it.  Just let the remote assume the response.

	}

void CRcpBrowsingCommandHandler::MaxPacketSize(TInt aMtu)

	{

	iMtu = aMtu-AvrcpBrowsing::KHeaderLength;

	}

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

// Called by bearer

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

/** Send a response.

@param aInterfaceUid The RemCon interface this response is from.

@param aId The RemCon transaction label of the command to respond to.

@param aData The command response data.

@return KErrNotFound if the command was not found on the queue.

		System wide error codes.

*/

TInt CRcpBrowsingCommandHandler::SendRemConResponse(TUid /*aInterfaceUid*/, TUint aId, RBuf8& aData)

	{

	LOG_FUNC

	return SendResponse(iCommandQueue, aId, aData);

	}

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

// Internal command handling functions

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

/** Sends a response to the remote device.

@param aCommand The command to respond to.

@param aErr The result of handling the command.

*/

void CRcpBrowsingCommandHandler::Respond(CBrowseCommand& aCommand, TInt aErr)

	{

	LOG_FUNC

	aCommand.SetResult(aErr);

	iRouter.AddToSendQueue(aCommand);

	}

/** To be called on completion of command handling.

This aggregates the handler's tidying up of a finished

command.

@param aCommand The command to tidy up.

*/	

void CRcpBrowsingCommandHandler::HandledCommand(CBrowseCommand& aCommand)

	{

	LOG_FUNC

	aCommand.iHandlingLink.Deque();

	aCommand.DecrementUsers();

	}

void CRcpBrowsingCommandHandler::HandleInternalCommand(CBrowseCommand& aCommand)

	{

	LOG_FUNC

	TUid interfaceUid;

	TUint id;

	TUint operationId;

	RBuf8 commandData;

	TBTDevAddr addr;

	aCommand.GetCommandInfo(interfaceUid, id, operationId, commandData, addr);

	__ASSERT_DEBUG(interfaceUid == TUid::Uid(KUidAvrcpInternalInterface), AvrcpUtils::Panic(EAvrcpInternalHandlingRequestedOnWrongInterface));

	TInt err = KErrNone;

	switch(operationId)

		{

	case EAvrcpInternalGetFolderItems:

		{

		err = HandleGetFolderItems(id, commandData);

		break;

		}

		};

	if(err)

		{

		HandledCommand(aCommand);

		}

	commandData.Close();

	}

TInt CRcpBrowsingCommandHandler::HandleGetFolderItems(TUint aId, RBuf8& aCommandData)

	{

	LOG_FUNC

	RBuf8 responseBuf;

	TRAPD(err, DoHandleGetFolderItemsL(aCommandData, responseBuf));

	if(!err)

		{

		err = SendInternalResponse(aId, responseBuf);

		}

	return err;

	}

void CRcpBrowsingCommandHandler::DoHandleGetFolderItemsL(RBuf8& aCommandData, RBuf8& aResponseData)

	{

	LOG_FUNC

	__ASSERT_DEBUG( &iPlayerInfoManager != NULL, AvrcpUtils::Panic(EAvrcpNotFullyConstructed));

	RAvrcpGetFolderItemsRequest request;

	CleanupClosePushL(request);

	request.ReadL(aCommandData);

	// Use 4 bytes even though player ids are 2 bytes becuase of

	// restrictions on RArray preventing use of non-word aligned types

	RArray<TUint> players;

	TInt err = iPlayerInfoManager.PlayerListing(request.iStartItem, request.iEndItem, players);

	CleanupStack::PopAndDestroy(&request);

	RRemConMediaErrorResponse errResponse;

	if(err != KErrNone)

		{

		CleanupClosePushL(players);

		errResponse.iPduId = AvrcpBrowsing::EGetFolderItems;

		errResponse.iStatus = (err == KErrArgument) ? AvrcpStatus::ERangeOutOfBounds : AvrcpStatus::EInternalError;

		aResponseData.CreateL(KBrowseResponseBaseLength);

		CleanupClosePushL(aResponseData);

		errResponse.WriteL(aResponseData);

		CleanupStack::Pop(&aResponseData);

		CleanupStack::PopAndDestroy(&players);

		return;

		}

	RAvrcpGetFolderItemsResponse response;

	CleanupClosePushL(response);

	CleanupClosePushL(players);

	for(TInt i = 0; i < players.Count(); i++)

		{

		RMediaPlayerItem item;

		CleanupClosePushL(item);

		iPlayerInfoManager.MediaPlayerItemL(players[i], item);

		response.iItems.AppendL(item);

		CleanupStack::Pop(&item);

		}

	response.iPduId = AvrcpBrowsing::EGetFolderItems;

	response.iStatus = AvrcpStatus::ESuccess;

	response.iUidCounter = KMediaPlayerListUidCounter;

	response.iNumberItems = players.Count();

	CleanupStack::PopAndDestroy(&players);

	//check this fits within MTU, Leave if the response size is bigger than max size 

	CleanupClosePushL(aResponseData);

	if(response.Size() > iMtu)

		{

		errResponse.iPduId = AvrcpBrowsing::EGetFolderItems;

		errResponse.iStatus = AvrcpStatus::EInternalError;

		aResponseData.CreateL(KBrowseResponseBaseLength);

		errResponse.WriteL(aResponseData);

		}

	else

		{

		aResponseData.CreateL(response.Size());

		response.WriteL(aResponseData);

		}

	CleanupStack::Pop(&aResponseData);

	CleanupStack::PopAndDestroy(&response);

	}

TInt CRcpBrowsingCommandHandler::SendInternalResponse(TUint aId, RBuf8& aData)

	{

	LOG_FUNC

	return SendResponse(iInternalCommandQueue, aId, aData);

	}

TInt CRcpBrowsingCommandHandler::SendResponse(TDblQue<CBrowseCommand>& aCommandQueue, TUint aId, RBuf8& aData)

	{

	LOG_FUNC

	TInt err = KErrNotFound;

	TDblQueIter<CBrowseCommand> iter(aCommandQueue);

	CBrowseCommand* command = NULL;

	while (iter)

		{

		command = iter++;

		if(command->RemConCommandId() == aId)

			{

			err = KErrNone;

			command->ProcessOutgoingResponse(aData);

			Respond(*command, err);

			aData.Close();

			HandledCommand(*command);

			break;

			}		

		}

	return err;

	}

void CRcpBrowsingCommandHandler::SendReject(TUid /*aInterfaceUid*/, TUint aTransactionId)

	{

	LOG_FUNC;

	TDblQueIter<CBrowseCommand> iter(iCommandQueue);

	CBrowseCommand* command = NULL;

	while (iter)

		{

		command = iter++;

		if(command->RemConCommandId() == aTransactionId)

			{

			Respond(*command, KErrAvrcpAirInternalError);

			HandledCommand(*command);

			}		

		}

	}

const TBTDevAddr& CRcpBrowsingCommandHandler::BtAddr() const

	{

	return iAddr;

	}

TBool CRcpBrowsingCommandHandler::HandleSetBrowsedPlayer(CBrowseCommand& aCommand)

	{

	TInt err = KErrNone;

	RRemConSetBrowsedPlayerRequest request;

	TRAP(err, request.ReadL(aCommand.CommandData()));

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

	// Check if selected player exists

	TUint16 playerId = request.iPlayerId;

	TRemConClientId clientId;

	TRAP(err, clientId = iPlayerInfoManager.ClientL(playerId));

	if(err == KErrNone)

		{

		// Selected player exists, check with RemCon if we can use it

		TRemConAddress remConAddr;

		AvrcpUtils::BTToRemConAddr(iAddr, remConAddr);

		TInt err = iCommandInterface.MrcbciSetAddressedClient(remConAddr, clientId);

		}

	if(err != KErrNone)

		{

		// Either the player was incorrect or is already in use, form a RemCon

		// format response, then ask the command to process it for sending out

		// on the air.

		RBuf8 buf;

		TInt bufErr = buf.Create(KMediaBrowseOutBufMaxLength);

		if(bufErr == KErrNone)

			{

			RRemConMediaErrorResponse response;

			response.iPduId = 0x70;

			response.iStatus = RAvrcpIPC::SymbianErrToStatus(KErrAvrcpAirInvalidPlayerId);

			TRAP(bufErr, response.WriteL(buf));

			aCommand.ProcessOutgoingResponse(buf);

			buf.Close();

			}

		}

	// else we will continue processing this command as normal

	return err == KErrNone ? ETrue : EFalse;

	}