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

 @internalTechnology

 @released

*/

#include <e32debug.h>

#include <remconmediaerror.h>

#include "avrcpipcutils.h"

#include "avrcpinternalinterface.h"

#include "mediabrowse.h"

#include "mediainformation.h"

#include "nowplaying.h"

#include "playerinformation.h"

/*

 * These methods are intended to provide structured IPC communication between

 * the AVRCP bearer, and the client API DLLs. They are intended to be 'simple'

 * classes, in which the basic operation are as follows:

 *

 *   reading: call ReadL(request) and pull information out of member variables

 *   writing: put information into member variables, then call WriteL(request)

 *

 * The ReadL() and WriteL() methods effectively just serialize the information

 * already stored in the member varables. However, they serialize in Big-Endian

 * format, so that after calling WriteL() and then sending the response back to

 * the AVRCP bearer via IPC, the bearer can just append the response straight

 * into an AVC frame; no bit-twiddling is necessary.

 *

 * Therefore it is important that these classes _ALWAYS_ write in Big-Endian

 * format, and write out responses that conform to the AVRCP specification for

 * PDUs listed in sections 5.1 - 5.4 of the AVRCP 1.3 specification. The ReadL()

 * operation is the inverse of the WriteL() operation and reads an AVRCP request

 * in the format listed in the AVRCP specification.

 *

 * There's also a Size() method, which will return the size of the response

 * before WriteL() is called. This is required particularly for responses with

 * text strings so that the correct-sized buffer can be allocated, as these

 * could be very large responses (theoretically up to 16 megabytes!) sent via

 * IPC (just once) and then kept and fragmented in the AVRCP bearer. The Close()

 * method frees up any memory allocated with these classes.

 */

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

// Used for constructing PDU 0x30 responses

EXPORT_C void RRemConPlayerInformationGetPlayStatusResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iTrackLength      = Read32L();

	iPlayPos          = Read32L();

	iStatus           = (MPlayerEventsObserver::TPlaybackStatus) Read8L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformationGetPlayStatusResponse::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write32L(iTrackLength);

	Write32L(iPlayPos);

	Write8L(iStatus);

	iStream.CommitL();

	}

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

// Used for constructing PDU 0xff requests

EXPORT_C void RRemConPlayerInformationGetPlayStatusUpdateRequest::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iStatus           = (MPlayerEventsObserver::TPlaybackStatus) Read8L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformationGetPlayStatusUpdateRequest::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write8L(iStatus);

	iStream.CommitL();

	}

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

// Used for constructing PDU 0xff responses

EXPORT_C void RRemConPlayerInformationGetPlayStatusUpdateResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iStatus           = (MPlayerEventsObserver::TPlaybackStatus) Read8L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformationGetPlayStatusUpdateResponse::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iStatus);

	iStream.CommitL();

	}

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

// Used for constructing PDU 0x15 and PDU 0x16 responses

EXPORT_C void RRemConGetPlayerApplicationTextResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iNumberAttributes = Read8L();

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		RSettingWithCharset setting;

		CleanupClosePushL(setting);

		setting.iAttributeId = Read8L();

		setting.iCharset     = Read16L();

		setting.iStringLen   = Read8L();

		setting.iString      = HBufC8::NewL(setting.iStringLen);

		TPtr8 ptr            = setting.iString->Des();

		iReadStream.ReadL(ptr);

		iAttributes.AppendL(setting);

		CleanupStack::Pop(&setting);

		}

	}

EXPORT_C void RRemConGetPlayerApplicationTextResponse::WriteL(TDes8& aOutData)

	{

	// The caller should have called Size() to pre-allocate enough buffer space

	__ASSERT_DEBUG(aOutData.MaxLength() >= Size(), AvrcpIpcUtils::Panic(EAvrcpIpcCommandDataTooLong));

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iNumberAttributes);

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		Write8L(iAttributes[i].iAttributeId);

		Write16L(iAttributes[i].iCharset);

		Write8L(iAttributes[i].iStringLen);

		iStream.WriteL(iAttributes[i].iString->Des());

		}

	iStream.CommitL();

	}

EXPORT_C TInt RRemConGetPlayerApplicationTextResponse::Size()

	{

	// Return the size that a buffer needs to be allocated to

	// serialise the data encapsulated within this data structure.

	TInt size = 5; // 5 bytes: status code + number attributes

	for (TInt i = 0; i < iNumberAttributes; i++)

		{

		size += 4;   // 4 bytes: attribute id + charset + stringlen

		size += iAttributes[i].iString->Length();

		}

	return size;

	}

EXPORT_C void RRemConGetPlayerApplicationTextResponse::Close()

	{

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

		{

		iAttributes[i].Close();

		}

	iAttributes.Close();

	RAvrcpIPC::Close();

	}

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

// Used for constructing PDU 0x10 responses

EXPORT_C void RRemConGetCapabilitiesResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iCapabilityId     = Read8L();

	if (   iCapabilityId != ECapabilityIdCompanyID

	    && iCapabilityId != ECapabilityIdEventsSupported)

		{

		iReadStream.Close();

		User::Leave(KErrNotSupported);

		}

	iCapabilityCount  = Read8L();

	for (TInt i = 0; i < iCapabilityCount; i++ )

		{

		if (iCapabilityId == ECapabilityIdCompanyID)

			{

			iCapabilities.AppendL(Read24L());  // Read 3 bytes

			}

		else

			{

			iCapabilities.AppendL(Read8L());   // Read 1 byte

			}

		}

	iReadStream.Close();

	}

EXPORT_C void RRemConGetCapabilitiesResponse::WriteL(TDes8& aOutData)

	{

	if (   iCapabilityId != ECapabilityIdCompanyID

	    && iCapabilityId != ECapabilityIdEventsSupported)

		{

		User::Leave(KErrNotSupported);

		}

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iCapabilityId);

	Write8L(iCapabilityCount);

	for (TInt i = 0; i < iCapabilityCount; i++ )

		{

		if (iCapabilityId == ECapabilityIdCompanyID)

			{

			Write24L(iCapabilities[i]);  // Write 3 bytes

			}

		else

			{

			Write8L(iCapabilities[i]);   // Write 1 byte

			}

		}

	iStream.CommitL();

	}

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

// Used for constructing and parsing PDU 0x13 (response) and PDU 0x14 (request)

EXPORT_C void RRemConPlayerAttributeIdsAndValues::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iNumberAttributes = Read8L();

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		TInt attributeId     = Read8L();

		TInt attributeValue = Read8L();

		iAttributeId.AppendL(attributeId);

		iAttributeValue.AppendL(attributeValue);

		}

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerAttributeIdsAndValues::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iNumberAttributes);

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		Write8L(iAttributeId[i]);

		Write8L(iAttributeValue[i]);

		}

	iStream.CommitL();

	}

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

// Used for constructing PDU 0x11 and PDU 0x12 responses

EXPORT_C void RRemConPlayerListOfAttributes::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iNumberAttributes = Read8L();

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		TInt attribute = Read8L();

		iAttributes.AppendL(attribute);

		}

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerListOfAttributes::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	iAttributes.Sort();

	Write32L(KErrNone);   // Successful operation

	Write8L(iNumberAttributes);

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		Write8L(iAttributes[i]);

		}

	iStream.CommitL();

	}

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

// Used for parsing PDU 0x20 requests

EXPORT_C void RRemConGetElementAttributesRequest::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iElement = Read64L();

	iNumberAttributes = Read8L();

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		TInt attribute = Read32L();

		iAttributes.AppendL(attribute);

		}

	iReadStream.Close();

	}

EXPORT_C void RRemConGetElementAttributesRequest::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	iAttributes.Sort();

	Write32L(KErrNone);   // Successful operation

	// 64 bits of data

	Write64L(iElement);

	Write8L(iNumberAttributes);

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		Write32L(iAttributes[i]);

		}

	iStream.CommitL();

	}

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

// Used for PDU 0x20 responses

EXPORT_C void RRemConGetElementAttributesResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iNumberAttributes = Read8L();

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		REAResponse eattr;

		CleanupClosePushL(eattr);

		eattr.iAttributeId = Read32L();

		eattr.iCharset     = Read16L();

		eattr.iStringLen   = Read16L();

		eattr.iString      = HBufC8::NewL(eattr.iStringLen);

		TPtr8 ptr          = eattr.iString->Des();

		iReadStream.ReadL(ptr);

		iAttributes.AppendL(eattr);

		CleanupStack::Pop(&eattr);

		}

	}

EXPORT_C void RRemConGetElementAttributesResponse::WriteL(TDes8& aOutData)

	{

	__ASSERT_DEBUG(aOutData.MaxLength() >= Size(), AvrcpIpcUtils::Panic(EAvrcpIpcCommandDataTooLong));

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iNumberAttributes);

	for (TInt i = 0; i < iNumberAttributes; i++ )

		{

		Write32L(iAttributes[i].iAttributeId);

		Write16L(iAttributes[i].iCharset);

		Write16L(iAttributes[i].iStringLen);

		iStream.WriteL(iAttributes[i].iString->Des());

		}

	iStream.CommitL();

	}

EXPORT_C TInt RRemConGetElementAttributesResponse::Size()

	{

	// Return the size that a buffer needs to be allocated to

	// serialise the data encapsulated within this data structure.

	TInt size = 5; // 5 bytes: status code + number attributes

	for (TInt i = 0; i < iNumberAttributes; i++)

		{

		size += 4+2+2; // 8 bytes: attrId (4 bytes) + charset (2 bytes) + stringlen (2 bytes)

		size += iAttributes[i].iString->Length();

		}

	return size;

	}

EXPORT_C void RRemConGetElementAttributesResponse::Close()

	{

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

		{

		iAttributes[i].Close();

		}

	iAttributes.Close();

	RAvrcpIPC::Close();

	}

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

EXPORT_C void RRemConPlayerInformation8BitResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iValue = Read8L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformation8BitResponse::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write8L(iValue);

	iStream.CommitL();

	}

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

EXPORT_C void RRemConPlayerInformation32BitResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iValue = Read32L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformation32BitResponse::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write32L(iValue);

	iStream.CommitL();

	}

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

EXPORT_C void RRemConPlayerInformation64BitResponse::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iValue = Read64L();

	iReadStream.Close();

	}

EXPORT_C void RRemConPlayerInformation64BitResponse::WriteL(TDes8& aOutData)

	{

	aOutData.Zero();

	iStream.Open(aOutData);

	Write32L(KErrNone);   // Successful operation

	Write64L(iValue);

	iStream.CommitL();

	}

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

EXPORT_C void RSettingWithCharset::Close()

	{

	delete iString;

	iString = NULL;

	}

EXPORT_C void REAResponse::Close()

	{

	delete iString;

	iString = NULL;

	}

EXPORT_C void RRemConGetCapabilitiesResponse::Close()

	{

	iCapabilities.Close();

	}

EXPORT_C void RRemConPlayerListOfAttributes::Close()

	{

	iAttributes.Close();

	}

EXPORT_C void RRemConGetElementAttributesRequest::Close()

	{

	iAttributes.Close();

	}

EXPORT_C void RRemConPlayerAttributeIdsAndValues::Close()

	{

	iAttributeId.Close();

	iAttributeValue.Close();

	}

EXPORT_C void RItem::Close()

	{

	delete iName;

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

		{

		iAttributes[i].Close();

		}

	}

EXPORT_C TInt RItem::Size()

	{

	// Base size:

	// type + length field + length

	return 3 + iLength;

	}

EXPORT_C void RMediaPlayerItem::Close()

	{

	iName.Close();

	}

EXPORT_C TInt RMediaPlayerItem::Size()

	{

	// Base size:

	// type + length field + length

	return 3 + iLength;

	}

/**

Parses PDU 0x74 and 0x90 requests.

*/

EXPORT_C void RRemConNowPlayingRequest::ReadL(const TDesC8& aData)

	{

	iReadStream.Open(aData);

	iScope = static_cast<TRemConFolderScope>(Read8L());

	iElement = Read64L();