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

// This file contains the capabilites part of playerinformation.

// 

//

/**

 @file

 @publishedAll

 @released

*/

#include <bluetooth/logger.h>

#include <remconinterfaceselector.h>

#include <remcon/avrcpspec.h>

#include <playerinformationtarget.h>

#include "eventsmask.h"

#include "playerinformation.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVRCP_PLAYER_INFO);

#endif

class TRemConMetadataTransferGetCapabilities 

	{

public:

	TUint8	 				iCapabilityID;

	};

EXPORT_C void MPlayerCapabilitiesObserver::ClearEvents()

	{

	DoClearEvents();

	}

EXPORT_C TInt MPlayerCapabilitiesObserver::AddEvent(TRegisterNotificationEvent aEvent)

	{

	return DoAddEvent(aEvent);

	}

EXPORT_C TInt MPlayerCapabilitiesObserver::RemoveEvent(TRegisterNotificationEvent aEvent)

	{

	return DoRemoveEvent(aEvent);

	}

EXPORT_C void MPlayerCapabilitiesObserver::ClearCompanyIds()

	{

	DoClearCompanyIds();

	}

EXPORT_C TInt MPlayerCapabilitiesObserver::AddCompanyId(TInt aID)

	{

	return DoAddCompanyId( aID );

	}

EXPORT_C TInt MPlayerCapabilitiesObserver::RemoveCompanyID(TInt aID)

	{

	return DoRemoveCompanyID( aID );

	}

// from MPlayerCapabilitiesObserver

void CPlayerInfoTarget::DoClearEvents()

	{

	// AVRCP 1.3 specification, Appendix H says that PlaybackStatusChanged

	// and TrackChanged event notification support is mandatory, so add these

	iSupportedNotificationEventList->Reset();

	iSupportedNotificationEventList->Append(ERegisterNotificationPlaybackStatusChanged);

	iSupportedNotificationEventList->Append(ERegisterNotificationTrackChanged);

	}

TInt CPlayerInfoTarget::DoAddEvent( TRegisterNotificationEvent aEvent )

	{

	// check the event is supported (note system status is NOT supported)

	if (   aEvent >= ERegisterNotificationReservedLast

		|| aEvent == ERegisterNotificationSystemStatusChanged_NotSupported)

		{

		return KErrNotSupported;

		}

	// check if aEvent is already in the list of supported events

	if (!iSupportedNotificationEventList->Find(aEvent))

		{

		// not found so add it to the list

		iSupportedNotificationEventList->Append(aEvent);

		return KErrNone;

		}

	// else return already in the list

	return KErrAlreadyExists;

	}

TInt CPlayerInfoTarget::DoRemoveEvent( TRegisterNotificationEvent aEvent )

	{

	// AVRCP 1.3 specification, Appendix H says that PlaybackStatusChanged

	// and TrackChanged event notification support is mandatory, so add these

	TInt err = KErrNone;

	if (   aEvent == ERegisterNotificationPlaybackStatusChanged

		|| aEvent == ERegisterNotificationTrackChanged)

		{

		return KErrNotSupported;

		}

	// Find aEvent in the list of supported events

	if (iSupportedNotificationEventList->Find(aEvent))

		{

		// and then remove it

		iSupportedNotificationEventList->Remove(aEvent);

		TInt pendingPos = iPendingNotificationEventList.Find(aEvent);

		if (pendingPos != KErrNotFound)

			{

			iPendingNotificationEventList.Remove( pendingPos );

			// Tell anyone waiting for a notification that an event has been

			// removed. Alas, we can't specify _WHICH_ event has been removed

			// since there's no way to indicate this in an INTERNAL_ERROR response

			SendError(KErrAvrcpMetadataInternalError, 

					  RAvrcpIPC::SetIPCOperationIdFromEventId(aEvent), 

					  ERemConNotifyResponseChanged);

			}

		}

	else

		{

		err = KErrNotFound;

		}

	return err;

	}

void CPlayerInfoTarget::DoClearCompanyIds()

	{

	// The Bluetooth SIG vendor id must always be present

	// See AVRCP 1.3 Specification, section 5.5.1, table 5.4

	iCompanyIdList.Reset();

	iCompanyIdList.Append(KBluetoothSIGVendorId);

	}

TInt CPlayerInfoTarget::DoAddCompanyId( TInt aID )

	{

	if ( aID > KMaxCompanyID )

		{

		return KErrNotSupported;

		}

	// check if the ID is already in the list

	TInt pos = iCompanyIdList.Find( aID );

	// add only if not present in list to avoid duplicates

	if (pos != KErrNotFound)

		{

		return KErrAlreadyExists;

		}

	// make sure the list cannot contain more than 255 items

	if (iCompanyIdList.Count() >= KMaxNrOfCompanyIDs)

		{

		return KErrOverflow;

		}

	return iCompanyIdList.Append( aID );

	}

TInt CPlayerInfoTarget::DoRemoveCompanyID( TInt aID )

	{

	// The Bluetooth SIG vendor id must always be present

	// See AVRCP 1.3 Specification, section 5.5.1, table 5.4

	if ( aID == KBluetoothSIGVendorId )

		{

		return KErrNotSupported;

		}

	// check if the ID is in the list

	TInt pos = iCompanyIdList.Find( aID );

	// if found remove else do nothing

	if (pos != KErrNotFound)

		{

		iCompanyIdList.Remove( pos );

		return KErrNone;

		}

	return pos;

	}

void CPlayerInfoTarget::ProcessGetCapabilities(const TDesC8& aData)

	{

	LOG_STATIC_FUNC

	/* Decode the get capability message */

	TRemConMetadataTransferGetCapabilities getCapability;

	// check there is at least 1 byte of data

	if (!aData.Length())

		{

		// Invalid packet

		return SendError(KErrAvrcpMetadataInvalidParameter, EGetCapabilities);

		}

	TPckgC<TRemConMetadataTransferGetCapabilities> data(*reinterpret_cast<const TRemConMetadataTransferGetCapabilities*>(aData.Ptr()));

	getCapability = data();

	TGetCapabilityValues id = (TGetCapabilityValues) getCapability.iCapabilityID;

	// format the response in a TRemConGetCapabilitiesResponse

	RRemConGetCapabilitiesResponse response;

	switch ( id )

		{

	case ECapabilityIdCompanyID:

		// respond with ECapabilityIdCompanyID

		response.iCapabilityId = ECapabilityIdCompanyID;

		// followed by number of IDs

		response.iCapabilityCount = iCompanyIdList.Count();

		// and then list of company ids,

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

			{

			TInt x = iCompanyIdList[i];

			if (response.iCapabilities.Append(x) != KErrNone)

				{

				response.Close();

				return SendError(KErrAvrcpMetadataInternalError, EGetCapabilities);   // Try to send internal error if OOM

				}

			}

		break;

	case ECapabilityIdEventsSupported:

		// respond with ECapabilityIdEventsSupported

		response.iCapabilityId = ECapabilityIdEventsSupported;

		// followed by number of supported events, and then list of events

		response.iCapabilityCount = 0;

		iSupportedNotificationEventList->Begin();

		while(iSupportedNotificationEventList->Next())

			{

			if (KErrNone != response.iCapabilities.Append(iSupportedNotificationEventList->Get()))

				{

				response.Close();

				return SendError(KErrAvrcpMetadataInternalError, EGetCapabilities);   // Try to send internal error if OOM

				}

			response.iCapabilityCount++;

			}

		break;	

	default:

		/* other IDs are reserved */

		return SendError(KErrAvrcpMetadataInvalidParameter, EGetCapabilities);  // Invalid packet

		}

	TInt error = 0;

	TRAP(error, response.WriteL(iOutBuf));   // Don't send error if OOM

	response.Close();

	if (error == KErrNone)

		// send the result back to the CT

		InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),

											EGetCapabilities, ERemConResponse, iOutBuf );

	}