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

#include <e32base.h>

#include <remcon/remconbearerobserver.h>

#include <remcon/remconconverterplugin.h>

#include <remcon/messagetype.h>

#include <remconbeareravrcp.h>

#include <absolutevolumeapi.h>

#include <absolutevolumeutils.h>

#include <remcon/avrcpspec.h>

#include "controlcommand.h"

#include "avrcpcommandframer.h"

#include "avrcpfragmenter.h"

#include "avrcpinternalinterface.h"

#include "avrcpipc.h"

#include "avrcplog.h"

#include "avrcputils.h"

#include "avrcpincomingcommandhandler.h"

#include "avrcp.h"

#include "mediabrowse.h"

#include "mediainformation.h"

#include "nowplaying.h"

#include "playerinformation.h"

#include "remconbattery.h"

#include "remcongroupnavigation.h"

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

// Outgoing command construction

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

/** Factory function.

@param aInterfaceUid The RemCon interface uid of this command.

@param aCommand The operation id of this command within the interface defined

				by aInterface Uid.

@param aRemConId The RemCon transaction label.

@param aTransactionLabel The AVCTP transaction label.

@param aCommandData The RemCon command data associated with this command.

@param aIsClick Whether this command is a button click (ie RemCon believes

				that this and the other part of the click constitute one

				command.

@param aAddr The bluetooth address to send this command to.

@return A fully constructed CControlCommand.

@leave System wide error codes.

*/

CControlCommand* CControlCommand::NewL(TUid aInterfaceUid,

	TUint aCommand, 

	TUint aRemConId, 

	SymbianAvctp::TTransactionLabel aTransactionLabel, 

	RBuf8& aCommandData, 

	TBool aIsClick, 

	const TBTDevAddr& aAddr,

	TBool aKnownToBearer)

	{

	LOG_STATIC_FUNC

	CControlCommand* command = new (ELeave) CControlCommand(aInterfaceUid, aCommand, 

			aRemConId, aTransactionLabel, aCommandData, aIsClick, aAddr, aKnownToBearer);

	CleanupStack::PushL(command);

	command->ConstructL();

	CleanupStack::Pop(command);

	return command;

	}

/** Constructor.

@param aInterfaceUid The RemCon interface uid of this command.

@param aCommand The operation id of this command within the interface defined

				by aInterface Uid.

@param aRemConId The RemCon transaction label.

@param aTransactionLabel The AVCTP transaction label.

@param aCommandData The RemCon command data associated with this command.

@param aIsClick Whether this command is a button click (ie RemCon believes

				that this and the other part of the click constitute one

				command.

@param aAddr The bluetooth address to send this command to.

@return A constructed CControlCommand.

@leave System wide error codes.

*/

CControlCommand::CControlCommand(TUid aInterfaceUid,

	TUint aCommand,

	TUint aRemConId, 

	SymbianAvctp::TTransactionLabel aTransactionLabel, 

	RBuf8& aCommandData,

	TBool aIsClick,

	const TBTDevAddr& aAddr,

	TBool aKnownToBearer) 

	: CAvrcpCommand(aRemConId, aTransactionLabel, aAddr)

	{

	LOG_FUNC

	iIsClick = aIsClick;

	iInterfaceUid = aInterfaceUid;

	iOperationId = aCommand;

	iKnownToBearer = aKnownToBearer;

	iCommandData.Assign(aCommandData);

	aCommandData.Assign(NULL);

	iPlayerInfoManager = NULL;

	}

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

// Incoming command construction

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

/** Factory function.

@param aMessageInformation A buffer containing AV/C frame this command is to represent.

@param aRemConId The RemCon transaction label.

@param aTransLabel The AVCTP transaction label.

@param aAddr The bluetooth address to send the response to.

@param aClientId The RemCon client that should receive this command

@return A fully constructed CControlCommand.

@leave System wide error codes.

*/

CControlCommand* CControlCommand::NewL(CAVCFrame* aFrame, 

	TUint aRemConId, 

	SymbianAvctp::TTransactionLabel aTransLabel, 

	const TBTDevAddr& aAddr,

	const TRemConClientId& aClientId,

	CAvrcpPlayerInfoManager* aPlayerInfoManager)

	{

	LOG_STATIC_FUNC

	CControlCommand* command = new(ELeave)CControlCommand(aFrame, aRemConId, aTransLabel, aAddr, aClientId, aPlayerInfoManager);

	CleanupStack::PushL(command);

	command->ConstructL();

	CleanupStack::Pop(command);

	return command;

	}

/** Constructor.

@param aRemConId The RemCon transaction label.

@param aTransLabel The AVCTP transaction label.

@param aAddr The bluetooth address to send the response to.

@param aClientId The RemCon client that should receive this command

@return A partially constructed CControlCommand.

@leave System wide error codes.

*/	

CControlCommand::CControlCommand(CAVCFrame* aFrame, 

	TUint aRemConId, 

	SymbianAvctp::TTransactionLabel aTransLabel, 

	const TBTDevAddr& aAddr,

	const TRemConClientId& aClientId,

	CAvrcpPlayerInfoManager* aPlayerInfoManager) 

	: CAvrcpCommand(aRemConId, aTransLabel, aAddr)

	, iFrame(aFrame)

	, iClientId(aClientId)

	{

	LOG_FUNC

	iIsClick = ETrue; // Assume click until we know otherwise

	iPlayerInfoManager = aPlayerInfoManager;

	}

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

// Generic construction/destruction

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

/** Destructor.

*/

CControlCommand::~CControlCommand()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iUsers == 0, AvrcpUtils::Panic(EAvrcpCommandStillInUse));

	__ASSERT_ALWAYS(!iHandlingLink.IsQueued(), AvrcpUtils::Panic(EAvrcpCommandStillQueuedForHandling));

	__ASSERT_ALWAYS(!iReadyLink.IsQueued(), AvrcpUtils::Panic(EAvrcpCommandStillQueuedAsReady));

	__ASSERT_ALWAYS(!iSendLink.IsQueued(), AvrcpUtils::Panic(EAvrcpCommandStillQueuedForSending));

	delete iFrame;

	iCommandData.Close();

	delete iTimerEntry;

	delete iTimerExpiryInfo;

	}

/** Second phase construction.

@leave System wide error codes.

*/

void CControlCommand::ConstructL()

	{

	LOG_FUNC

	// Allocate these now so we know we have the memory.  Info is

	// irrelevant as we won't add to the timer's queue without 

	// setting the true info.

	TCallBack callback(DummyCallback, NULL);

	iTimerEntry = new(ELeave)TDeltaTimerEntry(callback);

	iTimerExpiryInfo = new(ELeave)TAvrcpTimerExpiryInfo(NULL, *this);

	}

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

// From MRcpTimerNotify

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

/** Get the timer entry.

@return Timer entry.

*/

TDeltaTimerEntry* CControlCommand::TimerEntry()

	{

	return iTimerEntry;

	}

/** Get the timer expiry info.

@return Timer expiry info.

*/

TAvrcpTimerExpiryInfo* CControlCommand::TimerExpiryInfo()

	{

	return iTimerExpiryInfo;

	}

/** Remove this command's timer entry from the queue.

@param aTimer The timer queue to remove this from.

*/	

void CControlCommand::CancelTimer(CDeltaTimer& aTimer)

	{

	LOG_FUNC

	aTimer.Remove(*iTimerEntry);

	}

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

// Called by bearer

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

const TRemConClientId& CControlCommand::ClientId() const

	{

	return iClientId;

	}

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

// Called by handlers

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

/** Creates iFrame.

This function must be called between creating this command and using it.

@param aInterfaceUid	The RemCon interface this command came from.

@param aCommand			The command id within the interface identified by aInterfaceUid.

@param aCommandData		Data supplied with this command by RemCon.  The format of this

						data is defined by RemCon and is dependent on aInterfaceUid and 

						aCommand.

@leave System wide error code if parsing could not complete.

*/

void CControlCommand::ProcessOutgoingCommandL(MRemConBearerObserver& aObserver)

	{

	LOG_FUNC

	switch(iInterfaceUid.iUid)

		{

		//Process the absolute volume controller api

		case KRemConAbsoluteVolumeControllerApiUid:

			{

			switch (iOperationId)

			    {

			    //Registers absolute volume changed

			    case KRemConAbsoluteVolumeNotification:

			        {

					iFrame = AvrcpCommandFramer::NotifyVolumeChangeCommandL();

			        break;

			        }

			    //Sets absolute volume.

			    case KRemConSetAbsoluteVolume:

			    	{

			    	//Gets the absolute volume to be set.

			    	RRemConAbsoluteVolumeRequest setAbsVol;

			    	CleanupClosePushL(setAbsVol);

					setAbsVol.ReadL(iCommandData);

					__ASSERT_ALWAYS(setAbsVol.iVolume <= setAbsVol.iMaxVolume, 

							AvrcpUtils::Panic(EAvrcpVolumeBeyondMaxVolume));

					TUint8 absVol = KAvrcpMaxAbsoluteVolume * setAbsVol.iVolume / setAbsVol.iMaxVolume;

					iFrame = AvrcpCommandFramer::SetAbsoluteVolumeCommandL(absVol);	

					CleanupStack::PopAndDestroy(&setAbsVol);					

			    	break;

			    	}

			    default:

			    	{

			    	User::Leave(KErrNotSupported);

			    	}

			    }			

			break;

			}

		case KRemConCoreApiUid:

			{

			// Default interface - all commands are passthrough

			AVCPanel::TOperationId avrcpOp;

			if((RemConToAvrcpOperation(iOperationId, avrcpOp) != KErrNone) ||

			   (iCommandData.Length() < KRemConCoreApiButtonDataLength))

				{

				User::Leave(KErrCorrupt);

				}

			else

				{

				TInt remConButtonAct;

				AvrcpUtils::ReadCommandDataToInt(iCommandData, 

					KRemConCoreApiCommandDataOffset + KRemConCoreApiButtonDataOffset,

					KRemConCoreApiButtonDataLength, remConButtonAct);

				AVCPanel::TButtonAction buttonAct = (remConButtonAct == ERemConCoreApiButtonPress) ? 

					AVCPanel::EButtonPress : AVCPanel::EButtonRelease;

				iFrame = AvrcpCommandFramer::PassthroughL(avrcpOp, buttonAct);

				if(iIsClick)

					{

					// restore our mangled command data

					AvrcpUtils::SetCommandDataFromInt(iCommandData, 

						KRemConCoreApiCommandDataOffset + KRemConCoreApiButtonDataOffset,

						KRemConCoreApiButtonDataLength, ERemConCoreApiButtonClick);

					}

				}

			break;

			}	

		default:

			{

			RBuf8 buf;

			buf.CreateMaxL(KAVCFrameMaxLength);

			User::LeaveIfError(aObserver.InterfaceToBearer(TUid::Uid(KRemConBearerAvrcpImplementationUid), 

				iInterfaceUid, iOperationId, iCommandData, ERemConCommand, buf));

			CleanupClosePushL(buf);

			iFrame = CAVCFrame::NewL(buf, AVC::ECommand);

			CleanupStack::PopAndDestroy(&buf);

			break;

			}

		};

	}

/** Fills in command info from iFrame.

This must be called by the command handler before handling this

command.

This functions sets iInterfaceUid, iOperationId and iCommandData

to the correct values according to iFrame.  The format of iCommandData

is defined by RemCon and is dependent on iInterfaceUid and iOperationId.

@return KErrNone				If the frame has been parsed successfully.

@return KErrNotSupported		This frame represents a command for which a

								RemCon converter or client side interface

								cannot be found.

@return KErrAvrcpInvalidCType	The CType specified in this frame is invalid.

@return KErrAvrcpMetadataInvalidCommand		The AVRCP command is invalid.

@return KErrAvrcpMetadataInvalidParameter	The AVRCP parameter is invalid.

@return KErrAvrcpMetadataParameterNotFound	The AVRCP parameter was not found.

@return KErrAvrcpMetadataInternalError		An AVRCP internal error occurred (such as out-of-memory,

											or an inter-process communication error)

@return KErrCorrupt	        	If the frame is corrupted(e.g invalid Operation Id).

@return	System wide error code.

*/

TInt CControlCommand::ParseIncomingCommandL(MRemConBearerObserver& aObserver, CAVRCPFragmenter& aFragmenter)

	{

	LOG_FUNC

	TInt err = KErrNotSupported;

	switch(iFrame->Type())

		{

		// check it isn't a reponse

		case AVC::ENotImplemented:

		case AVC::EAccepted:

		case AVC::ERejected:

		case AVC::EInTransition:

		case AVC::EImplemented:

		case AVC::EChanged:

		case AVC::EInterim:

		case 0x0E:	// not given a enum for SC reasons; reserved response code in spec

			{

			// We were told this was a command, can't go using response

			// CTypes here matey

			err = KErrAvrcpInvalidCType;

			break;

			}

		case AVC::EGeneralEnquiry:

		case AVC::ESpecificEnquiry:

			{

			err = KErrNotSupported;

			break;

			}

		default:

			if (iFrame->Opcode() == AVC::EVendorDependent)

				{

				err = ParseIncomingVendorCommandL(aObserver, aFragmenter);

				}

			else

				{

				// give off to the regular processor

				err = ParseIncomingKnownOpcodeL(aObserver);

				}

			break;

		};

	return err;

	}

/** Processes an incoming response.

This function may not fail.  We always need to generate something

to RemCon.

@param aObserver Observer to use for retrieving converter.

@param aFrame The AV/C frame containing the response.

*/

TInt CControlCommand::ParseIncomingResponse(MRemConBearerObserver& aObserver, const CAVCFrame& aFrame)

	{

	LOG_FUNC	

	TInt error = KErrNone;

	// Compare Opcode with that of the sent frame rather than the

	// received one because we trust that more.  Should be the same

	// as this is matched by AVCTP transaction label, but who knows

	// what those illicit remote devices could be up to.

	if(iFrame->Opcode() == AVC::EPassThrough)

		{

		switch(aFrame.Type())

			{		

			case AVC::EAccepted:

				{

				InsertCoreResult(KErrNone);

				break;

				}

			case AVC::ENotImplemented:

				{

				InsertCoreResult(KErrNotSupported);

				break;

				}

			default:

				{

				InsertCoreResult(KErrGeneral);

				break;

				}

			}

		}	

	else if (iFrame->Opcode() == AVC::EVendorDependent)

		{

		TPtrC8 payloadData;

		AVC::TAVCVendorId vID;

		//Get the PDU ID with that of the sent frame rather than the received one,

		//the reason is the same to above comments.

		payloadData.Set(CAVCVendorDependentCommand::GetPayloadAndVID(*iFrame, vID));

		if (vID == KBluetoothSIGVendorId)

			{

			TMetadataTransferPDUID metadataPDUID = MetadataTransferParser::GetPDUID(payloadData);

			switch ( metadataPDUID )

			    {

			    case ESetAbsoluteVolume://Response for setting absolute volume.

			    	{

			    	error = SetSetAbsoluteVolumeResult(aFrame);

			    	break;

			    	}

			    case ERegisterNotification:

			    	{

			    	//Get notify event ID with the sent frame rather than the received one

			    	//because there is a big possibility that the received one is an error response, e.g. rejected,notimplemented.

			    	//In order to make sure this is an absolute volume response even if the response is an error response, 

			    	//we have to use the sent frame, and then we can process absolute volume specifically.

			    	TMetadataTransferNotifyEventID eventID = MetadataTransferParser::GetNotifyEventID(payloadData);

			    	__ASSERT_ALWAYS(eventID == ERegisterNotificationVolumeChanged,

			    			AvrcpUtils::Panic(EAvrcpInvalidEventId));

			    	if (eventID == ERegisterNotificationVolumeChanged)

			    		{

			    		error = SetNotifyVolumeChangeResult(aFrame);

			    		}

			    	break;

			    	}

			    default:

			    	{

			    	// Should never hit here

			    	AvrcpUtils::Panic(EAvrcpResponseToUnknownCommand);

			        break;

			    	}

			    }

			}

		else

			{

			ParseIncomingUnknownResponse(aObserver, aFrame);

			}

		}

	else

		{

		ParseIncomingUnknownResponse(aObserver, aFrame);

		}

	return error;

	}

/** Processes an outgoing response.

This should only be called for vendor dependent commands as

we respond to passthrough commands internally.

@param aObserver Observer to use for retrieving converter.

@param aFrame The command data for the response.

*/

TInt CControlCommand::ProcessOutgoingResponse(MRemConBearerObserver& aObserver,

//											TRemConMessageType aMessageType,

											RBuf8& aResponseData,

											CAVRCPFragmenter& aFragmenter)

	{