// Copyright (c) 2006-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

 @prototype

*/

#include <avcframe.h>

#include <e32base.h>

#include <remcon/remconbearerobserver.h>

#include <remcon/remconconverterplugin.h>

#include <remcon/messagetype.h>

#include <remcon/avrcpspec.h>

#include <remconbeareravrcp.h>

#include <remconbatterytargetobserver.h>

#include <absolutevolumeapi.h>

#include <absolutevolumeutils.h>

#include "avrcp.h"

#include "controlcommand.h"

#include "avrcpcommandframer.h"

#include "avrcpinternalinterface.h"

#include "avrcpipc.h"

#include "avrcplog.h"

#include "avrcputils.h"

#include "avrcpincomingcommandhandler.h"

#include "mediabrowse.h"

#include "mediainformation.h"

#include "nowplaying.h"

#include "playerinformation.h"

#include "remconbattery.h"

#include "remcongroupnavigation.h"

TInt CControlCommand::ParseMetadataTransferPassthroughCommand()

	{

	// company id and frame type should already be set before here

	__ASSERT_DEBUG(iFrame->Type() == AVC::EControl,  AvrcpUtils::Panic(EAvrcpCTypeNotSet));

	__ASSERT_DEBUG(iVendorId == KBluetoothSIGVendorId,  AvrcpUtils::Panic(EAvrcpCompanyIDNotSet));

	TInt ret = KErrNotSupported;

	TUint16 operation = MetadataTransferParser::GetPassThroughOperationId(iVendorPayloadData);

	if (operation == ENextGroup)

		{

		iOperationId = ENextGroup;

		iInterfaceUid = TUid::Uid(KRemConGroupNavigationApiUid);

		ret = KErrNone;

		}

	else if (operation == EPreviousGroup)

		{

		iOperationId = EPreviousGroup;

		iInterfaceUid = TUid::Uid(KRemConGroupNavigationApiUid);

		ret = KErrNone;

		}

	return ret;

	}

/* Before calling this method, the following MUST be set:

 *  - Vendor Payload data

 *  - Opcode       == Vendor Dependent

 *  - Subunit Type == Panel

 *  - Subunit Id   == 0

 */

TInt CControlCommand::ParseMetadataTransferVendorCommand(CAVRCPFragmenter& aFragmenter)

	{

	__ASSERT_DEBUG(iFrame->Opcode() == AVC::EVendorDependent, AvrcpUtils::Panic(EAvrcpNotFullyConstructed));

	__ASSERT_DEBUG(iFrame->SubunitType() == AVC::EPanel,      AvrcpUtils::Panic(EAvrcpNotFullyConstructed));

	__ASSERT_DEBUG(iFrame->SubunitID() == 0,                  AvrcpUtils::Panic(EAvrcpNotFullyConstructed));

	TInt ret = KErrNotSupported;

	iInterfaceUid = TUid::Uid(0);

	TMetadataTransferPDUID metadataPDUID = MetadataTransferParser::GetPDUID(iVendorPayloadData);

	TPtrC8 mtPayload(iVendorPayloadData.Mid(KRemConMetadataHeaderLength));

	TUint paramLength = MetadataTransferParser::GetParamLength(iVendorPayloadData);

	if (mtPayload.Length() != paramLength)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	// If we're in a fragmented state, and we receive an un-expected

	// PDU (i.e. not CONTINUE or ABORT) then throw away the fragment

	// and just process the request. The specification (section 5.5.1)

	// isn't entirely clear as to what should happen, but Sian reckons

	// this is probably the most polite thing to do (be liberal, etc)

	if (aFragmenter.InFragmentedState())

		{

		if (   metadataPDUID != ERequestContinuingResponse

			&& metadataPDUID != EAbortContinuingResponse)

			{

			aFragmenter.Reset();

			}

		}

	switch (iFrame->Type())

		{

		case AVC::EControl:

			{

			switch (metadataPDUID)	

				{

				case ERequestContinuingResponse:

					ret = ParseContinuingResponse(mtPayload, aFragmenter);

					break;

				case EAbortContinuingResponse:

					ret = ParseAbortContinuingResponse(mtPayload, aFragmenter);

					break;

				case ESetPlayerApplicationSettingValue:

					ret = ParseSetPlayerApplicationSettingValue(mtPayload);

					break;

				case EInformBatteryStatusOfCT:

					ret = ParseInformBatteryStatusOfCT(mtPayload);

					break;

				case EInformDisplayableCharacterSet:

					ret = KErrNotSupported;

					break;

				case ESetAddressedPlayer:

					ret = ParseSetAddressedPlayer(mtPayload);

					break;

				case EPlayItem:

					ret = ParsePlayItem(mtPayload);

					break;

				case EAddToNowPlaying:

					ret = ParseAddToNowPlaying(mtPayload);

					break;

				case ESetAbsoluteVolume:

				    ret =ParseSetAbsoluteVolume(mtPayload);

				    break;

				default:

					// not allowed PDUID for Control

					ret = KErrAvrcpMetadataInvalidCommand;

				}

			break;

			}

		case AVC::EStatus:

			{

			switch (metadataPDUID)	

				{

				case EGetCapabilities:

					ret = ParseGetCapabilities( mtPayload );

					break;

				case EGetPlayStatus:

					ret = ParseGetPlayStatus( mtPayload );

					break;

				case EListPlayerApplicationSettingAttributes:

					ret = ParseListPlayerApplicationSettingAttributes( mtPayload );

					break;

				case EListPlayerApplicationSettingValues:

					ret = ParseListPlayerApplicationSettingValues( mtPayload );

					break;

				case EGetCurrentPlayerApplicationSettingValue:

					ret = ParseGetCurrentPlayerApplicationSettingValue( mtPayload );

					break;

				case EGetPlayerApplicationSettingAttributeText:

					ret = ParseGetPlayerApplicationSettingAttributeText( mtPayload );

					break;

				case EGetPlayerApplicationSettingValueText:

					ret = ParseGetPlayerApplicationSettingValueText( mtPayload );

					break;

				case EGetElementAttributes:

					ret = ParseGetElementAttributes(mtPayload );

					break;

				case ESetAddressedPlayer:

					ret = ParseSetAddressedPlayer(mtPayload );

					break;

				case EPlayItem:

					ret = ParsePlayItem(mtPayload );

					break;

				case EAddToNowPlaying:

					ret = ParseAddToNowPlaying(mtPayload );

					break;

				default:

					// not allowed PDUID for Status

					ret = KErrAvrcpMetadataInvalidCommand;

				}

			break;

			}

		case AVC::ENotify:

			{

			if (metadataPDUID==ERegisterNotification)

				{

				if (mtPayload.Length() != KLengthRegisterNotification)

					{

					ret = KErrAvrcpMetadataInvalidCommand;

					}

				else

					{

					ret = KErrNone;

					TRegisterNotificationEvent eventId = static_cast<TRegisterNotificationEvent>(mtPayload[KVendorDependentEventId]);

					switch (eventId)

						{

						case ERegisterNotificationPlaybackStatusChanged:

						case ERegisterNotificationTrackChanged:

						case ERegisterNotificationTrackReachedEnd:

						case ERegisterNotificationTrackReachedStart:

						case ERegisterNotificationBatteryStatusChanged:

						case ERegisterNotificationPlayerApplicationSettingChanged:

							{

							iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

							iOperationId = RAvrcpIPC::SetIPCOperationIdFromEventId(eventId);

							break;

							}

						// Note: ERegisterNotificationPlaybackPosChanged takes a 4 byte parameter

						case ERegisterNotificationPlaybackPosChanged:

							{

							iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

							iOperationId = RAvrcpIPC::SetIPCOperationIdFromEventId(eventId);

							iCommandData.Close();

							ret = iCommandData.Create(KLengthPlaybackPosChangedParam);

							if (ret == KErrNone)

								{

								iCommandData.Append(mtPayload.Right(KLengthPlaybackPosChangedParam));

								}

							else

								{

								ret = KErrAvrcpMetadataInternalError;

								}

							break;

							}

						// Note ERegisterNotificationSystemStatusChanged is not supported

						case ERegisterNotificationSystemStatusChanged_NotSupported:

							{

							ret = KErrNotSupported;

							break;

							}

						case ERegisterNotificationNowPlayingContentChanged:

							{

							iInterfaceUid = TUid::Uid(KRemConNowPlayingApiUid);

							iOperationId = RAvrcpIPC::SetIPCOperationIdFromEventId(eventId);

							break;

							}

						case ERegisterNotificationAvailablePlayersChanged:

						case ERegisterNotificationAddressedPlayerChanged:

						case ERegisterNotificationUidsChanged:

							{

							iInterfaceUid = TUid::Uid(KUidAvrcpInternalInterface);

							iOperationId = RAvrcpIPC::SetIPCOperationIdFromEventId(eventId);

							ret = KErrAvrcpInternalCommand;

							break;

							}

						case ERegisterNotificationVolumeChanged	:

							{

							ret = ParseVolumeChangedNotification(mtPayload);

							break;

							}

						default:

							{

							ret = KErrAvrcpMetadataInvalidParameter;

							}

						}

					}

				}

			else

				{

				ret = KErrAvrcpMetadataInvalidCommand;

				}

			break;

			}

		case AVC::EReserved1:

		case AVC::EReserved2:

		case AVC::EReserved3:

		case AVC::EReserved4:

			{

			ret = KErrAvrcpInvalidCType;

			break;

			}

		default:

			ret = KErrAvrcpMetadataInvalidCommand;

		}

	return ret;

	}

/** Allocate correct space and append the payload to iCommandData

 */

TInt CControlCommand::AppendIncomingPayload(const TPtrC8& aPayload)

	{

	iCommandData.Close();

	if (iCommandData.Create(aPayload.Length()) != KErrNone)

		{

		return KErrAvrcpMetadataInternalError;

		}

	iCommandData.Append(aPayload);

	return KErrNone;

	}

/** Decode a InformBatteryStatusOfCT PDU ID: 0x18 and call the BatteryStatus API 

 */

TInt CControlCommand::ParseInformBatteryStatusOfCT(TPtrC8& aMtPayload)

	{

	if (aMtPayload.Length() != KLengthInformBatteryStatusOfCTPdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	TUint8 batteryStatus = aMtPayload[0];

	if (batteryStatus > EFullCharge)

		{

		return KErrAvrcpMetadataInvalidParameter;

		}

	if (AppendIncomingPayload(aMtPayload) != KErrNone)

		{

		return KErrAvrcpMetadataInvalidParameter;

		}

	iOperationId = EInformBatteryStatusOfCT;

	iInterfaceUid = TUid::Uid(KRemConBatteryApiUid);

	TInt ret = RespondToInforms(EInformBatteryStatusOfCT);

	if (ret != KErrNone)

		{

		return ret;

		}

	return KErrAvrcpHandledInternallyInformRemCon;

	}

/** Decode PDU ID 0x40 - fragmentation support

 */

TInt CControlCommand::ParseContinuingResponse(TPtrC8& aMtPayload,

										  CAVRCPFragmenter& aFragmenter)

	{

	// Check if in fragmentation state, return error if not

	if (! aFragmenter.InFragmentedState())

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	// Check if the parameter matches the fragmented response

	TMetadataTransferPDUID pduId = MetadataTransferParser::GetPDUID(aMtPayload);

	if (pduId != aFragmenter.GetPDU())

		{

		return KErrAvrcpMetadataInvalidParameter;

		}

	RBuf8 respPayload;

	CAVCFrame* frame = NULL;

	TRAPD(err, frame = CAVCVendorDependentResponse::NewL(KBluetoothSIGVendorId));

	err = respPayload.Create(KAVCMaxVendorDependentPayload); //longest resp

	if (err == KErrNone)

		{

		respPayload.Append(aFragmenter.GetNextFragmentHeader());

		respPayload.Append(aFragmenter.GetNextFragment());

		frame->SetType(AVC::EStable);

		frame->Append(respPayload);

		delete iFrame;

		iFrame = frame;

		respPayload.Close();

		}

	else

		return KErrAvrcpMetadataInternalError;

	return KErrAvrcpHandledInternallyRespondNow;

	}

/** Decode PDU ID 0x41 - fragmentation support

 */

TInt CControlCommand::ParseAbortContinuingResponse(TPtrC8& aMtPayload,

												CAVRCPFragmenter& aFragmenter)

	{

	// Check if in fragmentation state, return error if not

	if (! aFragmenter.InFragmentedState())

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	// Check if the parameter matches the fragmented response

	TMetadataTransferPDUID pduId = MetadataTransferParser::GetPDUID(aMtPayload);

	if (pduId != aFragmenter.GetPDU())

		{

		return KErrAvrcpMetadataInvalidParameter;

		}

	aFragmenter.Reset();

	CAVCFrame* frame = NULL;

	TRAPD(err, frame = CAVCVendorDependentResponse::NewL(KBluetoothSIGVendorId));

	if (err == KErrNone)

		{

		frame->Append(EAbortContinuingResponse);

		frame->Append(EUnfragmented);

		// the package length is 0

		frame->Append( 0 );

		frame->Append( 0 );

		frame->SetType(AVC::EStable);

		delete iFrame;

		iFrame = frame;

		}

	else

		{

		return KErrAvrcpMetadataInternalError;

		}

	return KErrAvrcpHandledInternallyRespondNow;

	}

/** Decode a SetPlayerApplicationSettingValue PDU ID: 0x14 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseSetPlayerApplicationSettingValue(TPtrC8& aMtPayload)

	{

	if (aMtPayload.Length() < KMinLengthSetPASValuePdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	// get the number of attributes contained 

	TUint8 numAttributes = aMtPayload[KVendorDependentNumberAttributes];

	// Each attribute is 16 bits long

	if (sizeof(numAttributes) + numAttributes*sizeof(TUint16) != aMtPayload.Length())

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	iOperationId = ESetPlayerApplicationSettingValue;

	iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

	return AppendIncomingPayload(aMtPayload);

	}

/** Decode a GetCapabilities PDU ID: 0x10 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseGetCapabilities(TPtrC8& aMtPayload)

	{

	// check enough data available

	if (aMtPayload.Length() != KLengthGetCapabilitiesPdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	// pass one byte of data to Player Information API 

	iOperationId = EGetCapabilities;

	iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

	return AppendIncomingPayload(aMtPayload);

	}

/** Decode a GetPlayStatus PDU ID: 0x30 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseGetPlayStatus(TPtrC8& aMtPayload)

	{

	// no payload in this command

	if (aMtPayload.Length()!=KLengthGetPlayStatusPdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	iOperationId = EGetPlayStatus;

	iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

	return KErrNone;

	}

/** Decode a ListPlayerApplicationSettingAttributes PDU ID: 0x11 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseListPlayerApplicationSettingAttributes(TPtrC8& aMtPayload)

	{

	// check length, there should be no parameters

	if (aMtPayload.Length()!=KLengthListPASAttributesPdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	iOperationId = EListPlayerApplicationSettingAttributes;

	iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

	return KErrNone;

	}

/** Decode a ListPlayerApplicationSettingValues PDU ID: 0x12 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseListPlayerApplicationSettingValues(TPtrC8& aMtPayload)

	{

	// check length, there should be 1 byte of data

	if (aMtPayload.Length() != KLengthListPASValuesPdu)

		{

		return KErrAvrcpMetadataInvalidCommand;

		}

	iOperationId = EListPlayerApplicationSettingValues;

	iInterfaceUid = TUid::Uid(KRemConPlayerInformationUid);

	return AppendIncomingPayload(aMtPayload);

	}

/** Decode a GetCurrentPlayerApplicationSettingValue PDU ID: 0x13 and call the PlayerInformation API 

 */

TInt CControlCommand::ParseGetCurrentPlayerApplicationSettingValue(TPtrC8& aMtPayload)

	{

	// check the length

	if (aMtPayload.Length() < KMinLengthGetCurrentPASValuePdu)

		{

		return KErrAvrcpMetadataInvalidCommand;