// 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 <remcon/avrcpspec.h>

#include <remcon/remconbearerobserver.h>

#include <remconcoreapi.h>

#include "controlcommand.h"

#include "avrcpcommandframer.h"

#include "avrcpincomingcommandhandler.h"

#include "avrcpinternalinterface.h"

#include "avrcplog.h"

#include "avrcprouter.h"

#include "avrcptimer.h"

#include "avrcputils.h"

#include "controlbearer.h"

#include "passthroughhelper.h"

#include "mediainformation.h"

#include "nowplaying.h"

#include "playerinformation.h"

#include "remconbattery.h"

#include "remcongroupnavigation.h"

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

// Construction/Destruction

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

/** Factory function.

@param aBearer	The CRemConBearerAvrcp this is to handle commands for.

@param aObserver The observer of the bearer. Used to acquire converters.

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

@param aTimer	CDeltaTimer to use for queuing timed events.

@return A fully constructed CRcpIncomingCommandHandler.

@leave System wide error codes.

*/

CRcpIncomingCommandHandler* CRcpIncomingCommandHandler::NewL(CRemConBearerAvrcp& aBearer,

	MRemConBearerObserver& aObserver,

	CRcpRouter& aRouter,

	CDeltaTimer& aTimer,

	CAvrcpPlayerInfoManager& aPlayerInfoManager,

	TBTDevAddr& aDevice) 

	{

	LOG_STATIC_FUNC

	CRcpIncomingCommandHandler* handler = new(ELeave)CRcpIncomingCommandHandler(aBearer, aObserver, aRouter, aTimer, aPlayerInfoManager, aDevice);

	CleanupStack::PushL(handler);

	handler->ConstructL();

	CleanupStack::Pop(handler);

	return handler;

	}

/** Constructor.

@param aBearer	The CRemConBearerAvrcp this is to handle commands for.

@param aObserver The observer of the bearer. Used to aquire converters.

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

@param aTimer	CDeltaTimer to use for queuing timed events.

@return A partially constructed CRcpIncomingCommandHandler.

@leave System wide error codes.

*/	

CRcpIncomingCommandHandler::CRcpIncomingCommandHandler(CRemConBearerAvrcp& aBearer, 

	MRemConBearerObserver& aObserver,

	CRcpRouter& aRouter,

	CDeltaTimer& aTimer,

	CAvrcpPlayerInfoManager& aPlayerInfoManager,

	TBTDevAddr& aDevice) 

	: iCommandQueue(_FOFF(CControlCommand, iHandlingLink))

	, iInternalCommandQueue(_FOFF(CControlCommand, iHandlingLink))

	, iFragmenter(NULL)

	, iBearer(aBearer)

	, iObserver(aObserver)

	, iRouter(aRouter)

	, iTimer(aTimer)

	, iAddressedMode(EFalse)

	, iPlayerInfoManager(aPlayerInfoManager)

	, iDevice(aDevice)

	{

	LOG_FUNC

	}

void CRcpIncomingCommandHandler::ConstructL()

	{

	LOG_FUNC

	iFragmenter = CAVRCPFragmenter::NewL();

	iPlayerInfoManager.AddObserverL(*this);

	RArray<TUint> players;

	iPlayerInfoManager.PlayerListing(players);

	CleanupClosePushL(players);

	if(players.Count())

		{

		// Start out with the first player as default.  TSP will need to update

		// us if it wants to set a different one.  Note that this wont be used 

		// unless we enter addressed mode anyway.

		iClientId = iPlayerInfoManager.ClientL(0);

		}

	// if no player have yet been registered we'll set the default when the

	// first one is

	CleanupStack::PopAndDestroy(&players);

	iPassthroughHelper = CPassthroughHelper::NewL(iRouter, iBearer, iTimer);

	}

/** Destructor.

*/	

CRcpIncomingCommandHandler::~CRcpIncomingCommandHandler()

	{

	LOG_FUNC

	iPlayerInfoManager.RemoveObserver( *this );

	delete iFragmenter;

	delete iPassthroughHelper;

	// All commands should have been handled by the time we reach here.

	__ASSERT_ALWAYS(iCommandQueue.IsEmpty(), AvrcpUtils::Panic(EAvrcpIncomingCommandsNotHandled));

	__ASSERT_ALWAYS(iInternalCommandQueue.IsEmpty(), AvrcpUtils::Panic(EAvrcpIncomingCommandsNotHandled));

	}

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

// Called from the bearer

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

/** Tell the handler to gracefully shutdown.

*/

void CRcpIncomingCommandHandler::Disconnect()

	{

	LOG_FUNC

	iPassthroughHelper->Disconnect();

	if(!iCommandQueue.IsEmpty())

		{

		// Cleanup remaining commands

		while(!iCommandQueue.IsEmpty())

			{

			CControlCommand* command = iCommandQueue.First();

			// Tell RemCon the command is finished with

			iObserver.CommandExpired(command->RemConCommandId());

			// And now remove the command from the bearer

			iRouter.RemoveFromSendQueue(*command);

			HandledCommand(*command);

			}

		}

	if(!iInternalCommandQueue.IsEmpty())

		{

		// Cleanup remaining commands

		while(!iInternalCommandQueue.IsEmpty())

			{

			CControlCommand* command = iInternalCommandQueue.First();

			// Tell RemCon the command is finished with

			iObserver.CommandExpired(command->RemConCommandId());

			// And now remove the command from the bearer

			iRouter.RemoveFromSendQueue(*command);

			HandledCommand(*command);

			}

		}

	}

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

// Called by router

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

void CRcpIncomingCommandHandler::MaxPacketSize(TInt /*aMtu*/)

	{

	// ignore - we don't care if we use AVCTP fragmentation on the

	// control channel

	}

/** Receive an incoming AVRCP command.

The command is parsed from a CAVCFrame into a CControlCommand owned by the

command handler.

@param aFrame	The AVC frame contained within 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 CRcpIncomingCommandHandler::ReceiveCommandL(const TDesC8& aMessageInformation, 

	SymbianAvctp::TTransactionLabel aTransactionLabel, 

	const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	TUint id = iBearer.MrcciNewTransactionId();

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

	if(aMessageInformation.Length() <= KAVCFrameHeaderLength)

		{

		User::Leave(KErrCorrupt);

		}

	// Parse it out into an AV/C frame

	CAVCFrame* frame = CAVCFrame::NewL(aMessageInformation, AVC::ECommand);

	CControlCommand* command = CControlCommand::NewL(frame, id, aTransactionLabel, aAddr, iAddressedMode ? iClientId : KNullClientId, &AvrcpPlayerInfoManager());

	CleanupStack::PushL(command);

	TInt result = command->ParseIncomingCommandL(iObserver, *iFragmenter);

	CleanupStack::Pop(command);

	command->IncrementUsers();

	switch(result)

		{

		case KErrAvrcpHandledInternallyInformRemCon:

			{

			HandleRemConCommand(*command);

			iRouter.AddToSendQueue(*command);

			command->DecrementUsers();

			break;

			}

		case KErrNone:

			{

			if(! command->IsPassthrough())

				{

				// add to iCommandQueue for non-passthrough commands

				iCommandQueue.AddLast(*command);

				}

			HandleRemConCommand(*command);

			break;

			}

		case KErrAvrcpInternalCommand:

			{

			iInternalCommandQueue.AddLast(*command);

			HandleInternalCommand(*command);

			break;

			}

		case KErrAvrcpInvalidCType:

			{

			// We should ignore commands with invalid ctype (AV/C v4.0 8.3.1).

			command->DecrementUsers();

			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 CRcpIncomingCommandHandler::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.

	}

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

// 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 KErrNone.

*/

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

	{

	LOG_FUNC

	// We always take ownership of the response data in SendResponse, so we 

	// always return KErrNone.

	SendResponse(iCommandQueue, aId, aData);

	return KErrNone;

	}

void CRcpIncomingCommandHandler::SendReject(TUid aInterfaceUid, TUint aId)

	{

	LOG_FUNC

	TDblQueIter<CControlCommand> iter(iCommandQueue);

	CControlCommand* command = NULL;

	while (iter)

		{

		command = iter++;

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

			{

			TInt err = KErrGeneral;

			if (aInterfaceUid.iUid == KRemConMediaInformationApiUid || aInterfaceUid.iUid == KRemConPlayerInformationUid)

				{

				err = KErrAvrcpMetadataInternalError;

				}

			Respond(*command, err);

			HandledCommand(*command);

			}		

		}

	}

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

// MPlayerChangeObserver functions

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

void CRcpIncomingCommandHandler::MpcoAvailablePlayersChanged()

	{

	LOG_FUNC 

	TDblQueIter<CControlCommand> internalIter(iInternalCommandQueue);

	CControlCommand* command = NULL;

	TInt err = KErrNone;

	while(internalIter)

		{

		command = internalIter++;

		if((command->RemConInterfaceUid() == TUid::Uid(KUidAvrcpInternalInterface)) && (command->RemConOperationId() == EAvrcpInternalAvailablePlayersNotification))

			{

			// If this fails we cann't send the notification - just give up

			err = HandleRegisterAvailablePlayersNotification(*command);

			static_cast<void>(err = err); // ignore this error (i.e. give up).

			}

		}

	//register internal notification

	//still need to optimize for avoid re-registering notification

	RArray<TUint> players;

	err = iPlayerInfoManager.PlayerListing(players);

	if(err == KErrNone)

		{

		TBool currentClientAvailable = EFalse;

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

			{

			TRemConClientId clientId = 0;

			clientId = iPlayerInfoManager.Client(players[i]);

			if(clientId == iClientId)

				{

				currentClientAvailable = ETrue;

				}

			}

		if((iClientId == KNullClientId || !currentClientAvailable) && players.Count())

			{

			// If this is the first target client we set our default client id

			// to this

			iClientId = iPlayerInfoManager.Client(players[0]);

			}

		}

	players.Close();

	}

void CRcpIncomingCommandHandler::MpcoAddressedPlayerChangedLocally(TRemConClientId aClientId)

	{

	LOG_FUNC

	TRAP_IGNORE(AddressedPlayerChangedL(aClientId));

	}

void CRcpIncomingCommandHandler::MpcoUidCounterChanged(TRemConClientId aClientId)

	{

	LOG_FUNC

	CControlCommand* command;

	if(aClientId == iClientId)

		{

		command = FindNotify(iInternalCommandQueue, TUid::Uid(KUidAvrcpInternalInterface),EAvrcpInternalUidChangedNotification);

		if(command)

			{

			// if we fail to send an update it is effectively the same condition

			// as when the notification arrives after the controller uses the

			// old UID counter

			TInt err = HandleUidChangedNotification(*command);

			if(err != KErrNone)

				{

				Respond(*command, KErrAvrcpAirInternalError);

				HandledCommand(*command);

				}

			}

		}

	}

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

// Internal command handling functions

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

/** Sends a response to the remote device.

Because of the 100ms timeout for responses we send a response to

passthrough commands as soon as we receive them.  This means the real

response from RemCon is currently ignored.  A real response is

only sent if this is a vendor dependent command.

@param aCommand The command to respond to.

@param aErr The result of handling the command.  KErrNone if successful.

			KErrNotSupported if this operation is not supported.

*/		

void CRcpIncomingCommandHandler::Respond(CControlCommand& aCommand, TInt aErr)

	{

	LOG_FUNC

	aCommand.SetResponseType(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 CRcpIncomingCommandHandler::HandledCommand(CControlCommand& aCommand)

	{

	LOG_FUNC

	aCommand.CancelTimer(iTimer);

	aCommand.iHandlingLink.Deque();

	aCommand.DecrementUsers();

	}

void CRcpIncomingCommandHandler::HandleInternalCommand(CControlCommand& 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 EAvrcpInternalSetAddressedPlayer:

		{

		err = HandleSetAddressedPlayer(id, commandData);

		break;

		}

	case EAvrcpInternalAvailablePlayersNotification:

		{

		err = HandleRegisterAvailablePlayersNotification(aCommand);

		break;

		}

	case EAvrcpInternalAddressedPlayerNotification:

		{

		err = HandleRegisterAddressedPlayerNotification(aCommand);

		break;

		}

	case EAvrcpInternalUidChangedNotification:

		{

		err = HandleUidChangedNotification(aCommand);

		break;

		}

		};

	if(err != KErrNone)

		{

		Respond(aCommand, KErrAvrcpAirInternalError);

		HandledCommand(aCommand);

		}

	commandData.Close();

	}

void CRcpIncomingCommandHandler::HandleRemConCommand(CControlCommand& aCommand)

	{

	LOG_FUNC

	if(aCommand.IsPassthrough())

		{

		// This deals with button press/release stuff,

		// queues the command and responds

		iPassthroughHelper->HandlePassthrough(aCommand);

		}

	else 

		{

		// can go directly to client (unlike passthrough which may need to map 2 commands to 1 click

		if (aCommand.Frame().Type() == AVC::ENotify)

			{

			iBearer.MrccciNewNotifyCommand(aCommand, aCommand.ClientId());

			}

		else

			{

			iBearer.MrcciNewCommand(aCommand, aCommand.ClientId());

			}

		}

	}

TInt CRcpIncomingCommandHandler::HandleSetAddressedPlayer(TUint aId, RBuf8& aCommandData)

	{

	LOG_FUNC

	// Once we respond to this we've told the remote that we're using a particular player

	iAddressedMode = ETrue;

	// SetAddressedPlayer involves not just responding to this command but

	// also rejecting a bunch of notifies and completing the addressed player