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

#include "avcpanel.h"

#include "controlcommand.h"

#include "avrcpoutgoingcommandhandler.h"

#include "avrcplog.h"

#include "avrcprouter.h"

#include "avrcptimer.h"

#include "avrcputils.h"

#include "controlbearer.h"

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

// Construction/Destruction

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

/** Factory function.

@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 fully constructed CRcpOutgoingCommandHandler.

@leave System wide error codes.

*/

CRcpOutgoingCommandHandler* CRcpOutgoingCommandHandler::NewL(MRemConControlCommandInterface& aCommandInterface, 

	MRemConBearerObserver& aObserver,

	CRcpRouter& aRouter,

	CDeltaTimer& aTimer)

	{

	LOG_STATIC_FUNC

	CRcpOutgoingCommandHandler* handler = new(ELeave)CRcpOutgoingCommandHandler(aCommandInterface, aObserver, aRouter, aTimer);

	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.

*/		

CRcpOutgoingCommandHandler::CRcpOutgoingCommandHandler(MRemConControlCommandInterface& aCommandInterface, 

	MRemConBearerObserver& aObserver,

	CRcpRouter& aRouter,

	CDeltaTimer& aTimer) : iCommandQueue(_FOFF(CControlCommand, iHandlingLink)),

	iNotifyCommandQueue(_FOFF(CControlCommand, iHandlingLink)),

	iCommandInterface(aCommandInterface), iObserver(aObserver), iRouter(aRouter), iTimer(aTimer)

	{

	LOG_FUNC

	}

/** Destructor.

*/

CRcpOutgoingCommandHandler::~CRcpOutgoingCommandHandler()

	{

	LOG_FUNC

	ClearQueue(iCommandQueue);

	ClearQueue(iNotifyCommandQueue);

	}	

void CRcpOutgoingCommandHandler::ClearQueue(TDblQue<CControlCommand>& aQue)

	{

	while(!aQue.IsEmpty())

		{

		CControlCommand* command = aQue.First();

		command->CancelTimer(iTimer);

		command->iHandlingLink.Deque();

		command->DecrementUsers();

		}

	}

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

// Called from the bearer

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

/** Tell the handler to gracefully shutdown.

@param aClearQueue Whether to clear the queue without handling the things 

					on it.  If this is true the commands will be deleted.

					If this is false then pending commands will have responses

					generated to RemCon.

*/

void CRcpOutgoingCommandHandler::Disconnect(TBool aClearQueue)

	{

	LOG_FUNC	

	ProcessDisconnect(iCommandQueue, aClearQueue);

	ProcessDisconnect(iNotifyCommandQueue, aClearQueue);

	}

void CRcpOutgoingCommandHandler::ProcessDisconnect(TDblQue<CControlCommand>& aQue, TBool aClearQueue)

	{

	while(!aQue.IsEmpty())

		{

		CControlCommand* command = aQue.First();

		iRouter.RemoveFromSendQueue(*command);

		command->CancelTimer(iTimer);

		if(aClearQueue)

			{

			GenerateFailureResult(*command, KErrDisconnected);

			}

		command->iHandlingLink.Deque();

		command->DecrementUsers();

		}

	}

/** Sends a new command.

@param aInterfaceUid	The RemCon client interface this command is from.

@param aCommand			The operation id within aInterfaceUid.

@param aId				A unique identifier provided by RemCon.

@param aCommandData		Data associated with this command.

@param aAddr			Bluetooth address of device to send this command to.

@leave KErrNoMemory or system wide error code.

@leave Command parsing error.

*/

void CRcpOutgoingCommandHandler::SendCommandL(TUid aInterfaceUid, 

		TUint aCommand, 

		TUint aId,  

		RBuf8& aCommandData, 

		const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	if(aInterfaceUid.iUid == KRemConCoreApiUid)

		{

		// Passthrough commands are stateful, so we need to examine the

		// history - we can't just blindly wham it on the queue.

		HandleCoreApiCommandL(aCommand, aId, aCommandData, aAddr);

		}

	else

		{

		SendCommandL(aInterfaceUid, aCommand, aId, aCommandData, EFalse, aAddr, ETrue, EFalse);

		}

	}

/** Sends a new notify command.

@param aInterfaceUid	The RemCon client interface this command is from.

@param aCommand			The operation id within aInterfaceUid.

@param aId				A unique identifier provided by RemCon, the transaction ID.

@param aCommandData		Data associated with this command.

@param aAddr			Bluetooth address of device to send this command to.

@leave KErrNoMemory or system wide error code.

@leave Command parsing error.

*/

void CRcpOutgoingCommandHandler::SendNotifyCommandL(TUid aInterfaceUid, 

		TUint aCommand, 

		TUint aId,  

		RBuf8& aCommandData, 

		const TBTDevAddr& aAddr)

	{

	LOG_FUNC

	SendCommandL(aInterfaceUid, aCommand, aId, aCommandData, EFalse, aAddr, ETrue, ETrue);

	}

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

// Data notifications from the router

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

/** Called by the router to provide a new response.

@param aFrame The AV/C frame for this response. Ownership is taken.

@param aTransLabel The AVCTP transaction id of this response. This is used

				to match it with its command.

@param aAddr The remote from which this response originated

*/

void CRcpOutgoingCommandHandler::ReceiveResponse(const TDesC8& aMessageInformation, 

	SymbianAvctp::TTransactionLabel aTransLabel, 

	TBool aIpidBitSet)

	{

	LOG_FUNC

	CAVCFrame* frame = NULL;

	TInt err = KErrNone;

	if(!aIpidBitSet)

		{

		TRAP(err, frame = CAVCFrame::NewL(aMessageInformation, AVC::EResponse));

		}

	if(!err)

		{

		CControlCommand* command = NULL;

		command = FindInQueue(iCommandQueue, aTransLabel);

		if ( command != NULL )

			{

			//Found, so it is a normal command response.

			ProcessReceiveResponse(frame, aIpidBitSet, command, EFalse);

			}

		else

			{

			//Try to find in the notify command queue.

			command = FindInQueue(iNotifyCommandQueue, aTransLabel);

			if( command != NULL )

			    {

			    //Found, so it is a notify command response.

			    ProcessReceiveResponse(frame, aIpidBitSet, command, ETrue);

			    }

			}

		delete frame;

		}

	}

CControlCommand* CRcpOutgoingCommandHandler::FindInQueue(TDblQue<CControlCommand>& aQue, 

		SymbianAvctp::TTransactionLabel aTransLabel)

	{	

	CControlCommand* command = NULL;

	TDblQueIter<CControlCommand> iter(aQue);

	while (iter)

		{

		command = iter++;

		if(command->TransactionLabel() == aTransLabel)

			{

			return command;

			}

		}

	return NULL;

	}

void CRcpOutgoingCommandHandler::ProcessReceiveResponse(CAVCFrame* aFrame, 

		TBool aIpidBitSet,

		CControlCommand* aCommand, 

		TBool aNotify)

	{

	aCommand->CancelTimer(iTimer);

	TInt err = KErrNone;

	// Inform the bearer if this is something it knows about

	// ie not a click release

	if(aCommand->KnownToBearer())

		{

		if(!aIpidBitSet)

			{

			if(aFrame->Data().Length() < KAVCFrameHeaderLength)

				{

				// Drop corrupt frames

				return;

				}

			err = aCommand->ParseIncomingResponse(iObserver, *aFrame);

			}

		else

			{

			// If aIpidBitSet is true that means AVRCP is not supported

			// by the remote end.  We handle this in the same way as not

			// supported commands, passing them up to RemCon as not 

			// supported, so just map the ctype here, rather than setting

			// up another path for ipid handling, but we need pass as the

			// frame the original because we don't get one from AVCTP if

			// ipid is set.

			aCommand->SetResponseType(KErrNotSupported);

			err = aCommand->ParseIncomingResponse(iObserver, aCommand->Frame());

			}

		if ( aNotify )

		    {//This is a notify command

		    iCommandInterface.MrccciNewNotifyResponse(*aCommand);

		    }

		else

			{

			iCommandInterface.MrccciNewResponse(*aCommand);

			}

		}

	TBool doDeque = ETrue;

	if ( (!aIpidBitSet) && (err == KErrNone) && (aNotify) && (aFrame->Type() == AVC::EInterim))

		{

		doDeque = EFalse;

		}

	// If this a passthrough press that hasn't yet been released, we need 

	// to wait for a release before getting rid of this, otherwise we're done.

	if(aCommand == iUnreleasedCommand)

		{

		iUnreleasedHasResponse = ETrue;

		StartReleaseTimer(*iUnreleasedCommand);

		doDeque = EFalse;

		}

	if ( doDeque )

		{

		aCommand->iHandlingLink.Deque();

		aCommand->DecrementUsers();

		}

	}

/** Called by the router to complete a send.

@param aCommand The command which has been sent.

@param aSendResult The result of the send. KErrNone if successful.

*/	

void CRcpOutgoingCommandHandler::MessageSent(CAvrcpCommand& aCommand, TInt aSendResult)

	{

	LOG_FUNC

	if(aSendResult == KErrNone)

		{

		// Set off response timer

		StartResponseTimer(static_cast<CControlCommand&>(aCommand));

		}

	else

		{

		CControlCommand* command = FindInQueue(iNotifyCommandQueue, aCommand.TransactionLabel());

		if(command)

			{

			command->SetNotifyVolumeChangeResult(command->Frame());

			iCommandInterface.MrccciNewNotifyResponse(*command);

			}

		else

			{

			command = FindInQueue(iCommandQueue, aCommand.TransactionLabel());

			// Generate error response up to RemCon

			// if this is a core command we can set the result, 

			// otherwise we just return it as we got it.

			if(command->Frame().Opcode() == AVC::EPassThrough)

				{

				// Need to insert before setting the button action so we have

				// long enough data

				if (!command->InsertCoreResult(aSendResult))

					{

					if(command->Click())

						{

						command->SetCoreButtonAction(ERemConCoreApiButtonClick, ETrue);

						}

					}

				}

			iCommandInterface.MrccciNewResponse(*command);

			}

		command->iHandlingLink.Deque();

		command->DecrementUsers();

		}

	}

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

// Internal Utility functions

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

void CRcpOutgoingCommandHandler::CleanupUnreleased()

	{

	iUnreleasedCommand->CancelTimer(iTimer);

	iUnreleasedCommand->iHandlingLink.Deque();

	iUnreleasedCommand->DecrementUsers();

	iUnreleasedHasResponse = EFalse;

	}

/** Handle a command that is part of the Core API.

@param aCommand			The operation id within aInterfaceUid.

@param aId				A unique identifier provided by RemCon.

@param aCommandData		Data associated with this command.

@param aAddr			Bluetooth address of device to send this command to.

@leave KErrNoMemory or system wide error code.

@leave Command parsing error.

*/

void CRcpOutgoingCommandHandler::HandleCoreApiCommandL(TUint aCommand, 

		TUint aId,  

		RBuf8& aCommandData, 

		const TBTDevAddr& aAddr)

	{

	if(aCommandData.Length() < KRemConCoreApiButtonDataLength)

   		{

   		User::Leave(KErrCorrupt);

   		}

	TInt buttonData;

	AvrcpUtils::ReadCommandDataToInt(aCommandData, 

   		KRemConCoreApiButtonDataOffset, KRemConCoreApiButtonDataLength, buttonData);

 	// First check if there's anything we need to do before sending this command,

 	// mainly releasing a previous press.  	

	if(iUnreleasedCommand)

		{

		TUint prevOpId = iUnreleasedCommand->RemConOperationId();

		if(aCommand == prevOpId)

			{

			// Either we've received a release, or we've refreshed the press.

			// If the unreleased press has already been responded too we can

			// dispose of it now.  

			// If the unreleased press has not been responded too we can 

			// treat it like a normal command on reception of response, so just

			// set iUnreleased to NULL.

			if(iUnreleasedHasResponse)

				{

				CleanupUnreleased();

				}

			iUnreleasedCommand = NULL;

			}

		else

			{

			// A new operation!

			if(buttonData != ERemConCoreApiButtonRelease)

				{

				// Try and generate the release for the previous command, if

				// if fails then the remote will just have to assume it.

				// There's no point leaving this to the release timer, because

				// we want to send another command now, so even if we send the

				// release later the remote should ignore it.

				TRAP_IGNORE(GenerateCommandL(*iUnreleasedCommand, ERemConCoreApiButtonRelease));

				if(iUnreleasedHasResponse)

					{

					CleanupUnreleased();

					}

				iUnreleasedCommand = NULL;

				}

			else

				{

				// A release for a command other than iUnreleased.  We can't 

				// send this now.

				User::Leave(KErrNotReady);

				}

			}

		}

	else if(buttonData == ERemConCoreApiButtonRelease)

		{

		// We don't have an unreleased command.  We must have already 

		// released this, either via the timer, or because we've sent

		// another command in the meantime.  We can't send this now.

		// Leaving synchronously means we don't need to worry about generating

		// a fake response, which may mislead the application.

		User::Leave(KErrNotReady);

		}

   	if(buttonData == ERemConCoreApiButtonClick)

   		{	

		// aCommandData is still owned by RemCon until we return successfully.

		// If we try the operations with the new data first we won't end up 

		// in a situation where the new CControlCommand thinks that it owns 

		// aCommandData, then the release operation leaves, so RemCon also

		// thinks it owns aCommandData.

		RBuf8 pressBuf;

		pressBuf.CreateL(aCommandData);

		CleanupClosePushL(pressBuf);

		AvrcpUtils::SetCommandDataFromInt(pressBuf, 

			KRemConCoreApiButtonDataOffset, KRemConCoreApiButtonDataLength, ERemConCoreApiButtonPress);

		SendCommandL(TUid::Uid(KRemConCoreApiUid), aCommand, aId, pressBuf, ETrue, aAddr, ETrue, EFalse);

		// Data has been taken ownership of by SendCommandL, so can just let 

		// pressbuf go out of scope.

		CleanupStack::Pop(&pressBuf);

		AvrcpUtils::SetCommandDataFromInt(aCommandData, 

			KRemConCoreApiButtonDataOffset, KRemConCoreApiButtonDataLength, ERemConCoreApiButtonRelease);

		SendCommandL(TUid::Uid(KRemConCoreApiUid), aCommand, aId, aCommandData, ETrue, aAddr, EFalse, EFalse);

		}

	else if(buttonData == ERemConCoreApiButtonPress)

		{

		iUnreleasedCommand = &SendCommandL(TUid::Uid(KRemConCoreApiUid), aCommand, aId, aCommandData, EFalse, aAddr, ETrue, EFalse);

		iReleaseTimerExpiryCount = 0;

		}

	else

		{

		// Must be release

		__ASSERT_DEBUG(buttonData == ERemConCoreApiButtonRelease, AvrcpUtils::Panic(EAvrcpUnknownButtonAction));

		SendCommandL(TUid::Uid(KRemConCoreApiUid), aCommand, aId, aCommandData, EFalse, aAddr, ETrue, EFalse);

		}

	}

/** Creates a command from the RemCon data.

This is an internal utility function.

A CControlCommand will be created.  Calling ProcessOutgoingCommandL on

this creates a CAVCFrame from the provided data.  If an AV/C frame

can be created the command will be added to the outgoing queue to

wait a response from the remote.  Otherwise this function will

leave.

@param aInterfaceUid	The RemCon client interface this command is from.

@param aCommand			The operation id within aInterfaceUid.

@param aId				A unique identifier provided by RemCon.

@param aCommandData		Data associated with this command.

@param aIsClick			Whether this is a button click.

@param aAddr			Bluetooth address of device to send this command to.

@return The generated command.

@leave KErrNoMemory or system wide error code.

@leave Command parsing error.

*/

CControlCommand& CRcpOutgoingCommandHandler::SendCommandL(TUid aInterfaceUid,

	TUint aCommand, 

	TUint aId, 

	RBuf8& aCommandData, 

	TBool aIsClick, 

	const TBTDevAddr& aAddr,

	TBool aKnownToBearer,

	TBool aNotify)

	{

	LOG_FUNC

	// Create a command and wham it on our queue, so we can match it up with its response

	// CControlCommand::NewL takes ownership of the data in aCommandData then NULLs aCommandData

	// so a leave later in the function won't cause double deletion.

	CControlCommand* command = CControlCommand::NewL(aInterfaceUid, aCommand, aId, iCurrentTrans, 

			aCommandData, aIsClick, aAddr, aKnownToBearer);

	CleanupStack::PushL(command);