// 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 events part of the PlayerInformation API.
// 
//

/**
 @file
 @publishedAll
 @released
*/

#include <bluetooth/logger.h>
#include <remconinterfaceselector.h>
#include <remconbeareravrcp.h>
#include <playerinformationtarget.h>
#include <playerinformationtargetobserver.h>

#include "playerapplicationsetting.h"
#include "eventsmask.h"
#include "playereventsutils.h"
#include "playerinformation.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_AVRCP_PLAYER_INFO);
#endif

EXPORT_C void MPlayerEventsObserver::PlaybackStatusChanged(TPlaybackStatus aStatus)
	{
	DoPlaybackStatusChanged(aStatus);
	}

EXPORT_C void MPlayerEventsObserver::TrackChanged(TUint64 aTrackId, TUint32 aLengthInMilliseconds) 
	{
	DoTrackChanged(aTrackId, aLengthInMilliseconds); 
	}

EXPORT_C void MPlayerEventsObserver::TrackReachedEnd() 
	{
	DoTrackReachedEnd();
	}

EXPORT_C void MPlayerEventsObserver::TrackReachedStart()
	{
	DoTrackReachedStart();
	}

EXPORT_C void MPlayerEventsObserver::SetPlaybackPosition(TUint32 aMilliseconds) 
	{
	DoSetPlaybackPosition(aMilliseconds); 
	}
	
EXPORT_C void MPlayerEventsObserver::SetBatteryStatus(TTargetBatteryStatus aBatteryStatus) 
	{
	DoSetBatteryStatus(aBatteryStatus); 
	}

void CPlayerInfoTarget::ProcessGetStatusAndBeginObserving( const TUint aOperationId, TRegisterNotificationEvent aEventId, const TDesC8& aData)
	{
	// check the event is in the supported list
	if (!iSupportedNotificationEventList->Find(aEventId))
		{
		// Not supported so return error
		SendError(KErrAvrcpMetadataInvalidParameter, aOperationId, ERemConNotifyResponseInterim);
		return;
		}
		
	// if the event is EPlaybackPosChanged then the timeinterval is included in the RegisterNofication
	if (aEventId == ERegisterNotificationPlaybackPosChanged)
		{
		// decode the playback interval from aData
		TInt error = 0;
		RRemConPlayerInformation32BitResponse request;
		TRAP(error, request.ReadL(aData));
		
		if (error != KErrNone)
			{
			// Not supported so return error
			SendError(KErrAvrcpMetadataParameterNotFound, aOperationId, ERemConNotifyResponseInterim);
			return;
			}
		
		// save the playback interval
		iPlayBackIntervalInMilliseconds = request.iValue * 1000;
		
		// and the current position
		iLastNotifiedPlaybackPositionInMilliseconds = iPlaybackPositionInMilliseconds;
		}
		
	// and request another notification (if there is not one already pending)
	// on the next state change  
	if (KErrNotFound ==iPendingNotificationEventList.Find(aEventId))
		{
		if (iPendingNotificationEventList.Append(aEventId) != KErrNone)
			{
			return SendError(KErrAvrcpMetadataInternalError, aOperationId);   // Try to send internal error if OOM
			}
		}
		
	// send the current status
	SendNotificationResponse(aEventId, ERemConNotifyResponseInterim );
	}

void CPlayerInfoTarget::ProcessGetStatus( const TUint aOperationId, TRegisterNotificationEvent aEventId)
	{
	// send the current value
	if (iSupportedNotificationEventList->Find(aEventId))
		{
		SendNotificationResponse(aEventId, ERemConNotifyResponseChanged );
		}
	else
		{
		// Not found so return error
		SendError(KErrAvrcpMetadataInvalidParameter, aOperationId, ERemConNotifyResponseChanged);
		}
	}
		
/* ProcessGetPlayStatus This returns the current values of SongLength, 
   SongPosition and PlayStatus.
   Note if SongLength and SongPosition are not supported KPlaybackPositionUnknown is returned
 */
void CPlayerInfoTarget::ProcessGetPlayStatus()
	{
	LOG_FUNC

	TInt error =0;

	// format the response in a RRemConPlayerInformationGetPlayStatusResponse
	RRemConPlayerInformationGetPlayStatusResponse response;
	response.iTrackLength = iLengthInMilliseconds;
	response.iPlayPos = iPlaybackPositionInMilliseconds;
	response.iStatus = iPlayBackStatus;
	
	TRAP(error, response.WriteL(iOutBuf));
	if (error == KErrNone)
		{
		// send the response back to the CT
		error = InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),
												EGetPlayStatus, ERemConResponse, iOutBuf );
		}
	}

/* ProcessGetPlayStatusUpdate returns the current play status if it has changed
 * relative to the provided play status, otherwise the request is queued until
 * the play status changes.
 */
void CPlayerInfoTarget::ProcessGetPlayStatusUpdate(const TDesC8& aData)
	{
	LOG_FUNC

	// Bearer should never send us more than one of these in parallel
	__ASSERT_DEBUG(!iPlaybackStatusUpdatePending, PlayerEventsUtils::Panic(ETwoGetPlayStatusUpdatesQueued));
	
	TInt error =0;
	RRemConPlayerInformationGetPlayStatusUpdateRequest request;
	TRAP(error, request.ReadL(aData));
	__ASSERT_DEBUG(error == KErrNone, PlayerEventsUtils::Panic(EBadlyFormattedInternalData));

	if(request.iStatus != iPlayBackStatus)
		{
		// format the response in a RRemConPlayerInformationGetPlayStatusResponse
		RRemConPlayerInformationGetPlayStatusUpdateResponse response;
		response.iStatus = iPlayBackStatus;
		
		TRAP(error, response.WriteL(iOutBuf));
		if (error == KErrNone)
			{
			// send the response back to the CT
			error = InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),
													EGetPlayStatusUpdate, ERemConResponse, iOutBuf );
			if(error != KErrNone)
				{
				// We will try and send the response again next time we get an update
				iPlaybackStatusUpdatePending = ETrue;
				}
			}
		}
	else
		{
		iPlaybackStatusUpdatePending = ETrue;
		}
	}

// Send a Notification message for aEventID 
void CPlayerInfoTarget::SendNotificationResponse( TRegisterNotificationEvent aEventId, TRemConMessageSubType aMsgSubType )
	{
	LOG_FUNC

	TInt error = 0;
	iOutBuf.Zero();

	if (!iSupportedNotificationEventList->Find(aEventId))
		{
		return SendError(KErrAvrcpMetadataInvalidParameter, 
						 RAvrcpIPC::SetIPCOperationIdFromEventId(aEventId), aMsgSubType);
		}
		
	switch (aEventId)
		{
		case ERegisterNotificationTrackReachedEnd:
		case ERegisterNotificationTrackReachedStart:
			{
			// no extra data for reached start or end 
			RAvrcpIPCError response;
			response.iError = KErrNone;
			TRAP(error, response.WriteL(iOutBuf));
			break;
			}

		case ERegisterNotificationPlaybackStatusChanged:
			{
			// 8bit response -- current playback status 
			RRemConPlayerInformation8BitResponse response;
			response.iValue = iPlayBackStatus;
			TRAP(error, response.WriteL(iOutBuf));
			break;
			}

		case ERegisterNotificationBatteryStatusChanged:
			{
			// 8bit response -- current battery status
			RRemConPlayerInformation8BitResponse response;
			response.iValue = iBatteryStatus;
			TRAP(error, response.WriteL(iOutBuf));
			break;
			}

		case ERegisterNotificationPlaybackPosChanged:
			{
			// 32bit response -- current playback position in millisecond 
			RRemConPlayerInformation32BitResponse response;
			response.iValue = iPlaybackPositionInMilliseconds;
			TRAP(error, response.WriteL(iOutBuf));
			break;
			}

		case ERegisterNotificationTrackChanged:
			{
			// 64bit response -- index of the current track 
			RRemConPlayerInformation64BitResponse response;
			response.iValue = iTrackId;
			TRAP(error, response.WriteL(iOutBuf));
			break;
			}

		case ERegisterNotificationPlayerApplicationSettingChanged:
			{
			// Send a list of the settings that have changed followed by their value 
			// starting with the number of attributes to be sent 
			RRemConPlayerAttributeIdsAndValues response;
			response.iNumberAttributes = 0;
		
			// for every entry in the list
			THashMapIter<TInt, CPlayerApplicationSettings*> iter(iPlayerApplicationSettings);
			CPlayerApplicationSettings* const* setting = iter.NextValue();
			while ( setting != NULL )
				{
				TUint8 value = (*setting)->GetCurrentValue();
				TInt ret1 = response.iAttributeValue.Append(value);
				TInt ret2 = response.iAttributeId.Append((*setting)->GetAttributeID());
				if (ret1 != KErrNone || ret2 != KErrNone)
					{
					response.Close();
					return SendError(KErrAvrcpMetadataInternalError, 
									 RAvrcpIPC::SetIPCOperationIdFromEventId(aEventId),
									 aMsgSubType);   // Try to send internal error if OOM
					}
				response.iNumberAttributes++;
				setting = iter.NextValue();
				}
				
			TRAP(error, response.WriteL(iOutBuf));
			response.Close();
			break;
			}
		default:
			return;
		}
	
	if (error == KErrNone)
		{
		// send the response back to the CT
		TUint operationId = RAvrcpIPC::SetIPCOperationIdFromEventId(aEventId);
		error = InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),
												operationId, ERemConResponse, aMsgSubType, iOutBuf);
		}
	}
	 
// from MPlayerEventsObserver
 void CPlayerInfoTarget::DoPlaybackStatusChanged(TPlaybackStatus  aStatus)
	{
	LOG_FUNC

	iPlayBackStatus = aStatus;
	
	// if the playback status is in the current event list
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackStatusChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		SendNotificationResponse( ERegisterNotificationPlaybackStatusChanged, ERemConNotifyResponseChanged);
		}
	
	pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackPosChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		SendNotificationResponse(ERegisterNotificationPlaybackPosChanged, ERemConNotifyResponseChanged);
		}
	
	if(iPlaybackStatusUpdatePending)
		{
		// format the response in a RRemConPlayerInformationGetPlayStatusResponse
		RRemConPlayerInformationGetPlayStatusUpdateResponse response;
		response.iStatus = iPlayBackStatus;
		
		TRAPD(error, response.WriteL(iOutBuf));
		if (error == KErrNone)
			{
			// send the response back to the CT
			error = InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),
													EGetPlayStatusUpdate, ERemConResponse, iOutBuf );
			if(error == KErrNone)
				{
				iPlaybackStatusUpdatePending = EFalse;
				}
			// if we did error we will try and respond again next time the client's play status
			// changes
			}
		}
	}
	
void CPlayerInfoTarget::DoTrackChanged(TUint64 aTrackId, TUint32 aLengthInMilliseconds)
	{
	LOG_FUNC

	iTrackId = aTrackId;
	iLengthInMilliseconds = aLengthInMilliseconds;

	// if the playback status is in the current event list 
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationTrackChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		SendNotificationResponse(ERegisterNotificationTrackChanged, ERemConNotifyResponseChanged);
		}

	pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackPosChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		iPlaybackPositionInMilliseconds = 0;	//set 0 to current position for new track
		SendNotificationResponse(ERegisterNotificationPlaybackPosChanged, ERemConNotifyResponseChanged);
		}
	}

void CPlayerInfoTarget::DoTrackReachedEnd()
	{
	LOG_FUNC
	
	iTrackPosition = EEnd;

	// if the ETrackReachedEnd status is in the current event list 
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationTrackReachedEnd );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		SendNotificationResponse(ERegisterNotificationTrackReachedEnd, ERemConNotifyResponseChanged);
		}
	
	pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackPosChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		iPlaybackPositionInMilliseconds = iLengthInMilliseconds;
		SendNotificationResponse(ERegisterNotificationPlaybackPosChanged, ERemConNotifyResponseChanged);
		}
	}

void CPlayerInfoTarget::DoTrackReachedStart()
	{
	LOG_FUNC

	iTrackPosition = EStart;

	// if the ETrackReachedStart status is in the current event list 
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationTrackReachedStart );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		SendNotificationResponse(ERegisterNotificationTrackReachedStart, ERemConNotifyResponseChanged);
		}
	
	pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackPosChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		iPlaybackPositionInMilliseconds = 0;
		SendNotificationResponse(ERegisterNotificationPlaybackPosChanged, ERemConNotifyResponseChanged);
		}
	}

void CPlayerInfoTarget::DoSetPlaybackPosition(TUint32 aMilliseconds)		
	{
	LOG_FUNC
	
	iPlaybackPositionInMilliseconds = aMilliseconds;

	// if the playback position is in the current Notification event list 
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationPlaybackPosChanged );
	if (pos != KErrNotFound)
		{
		// a notification has been requested, now check if it is due

		TUint32 difference = (iPlaybackPositionInMilliseconds > iLastNotifiedPlaybackPositionInMilliseconds) ?
        	iPlaybackPositionInMilliseconds - iLastNotifiedPlaybackPositionInMilliseconds:
        	iLastNotifiedPlaybackPositionInMilliseconds - iPlaybackPositionInMilliseconds;

		if (difference >= iPlayBackIntervalInMilliseconds)
			{
			// Due now so send
			iPendingNotificationEventList.Remove( pos );
			SendNotificationResponse(ERegisterNotificationPlaybackPosChanged, ERemConNotifyResponseChanged);			
			}	
		}
	}

void CPlayerInfoTarget::DoSetBatteryStatus(TTargetBatteryStatus aBatteryStatus)
	{
	LOG_FUNC

	TBool validStatus = ETrue;
	if (aBatteryStatus < MPlayerEventsObserver::ENormal || 
		aBatteryStatus > MPlayerEventsObserver::EFullCharge)
		{
		LOG1(_L("Invalid battery status: %d"),aBatteryStatus);
		validStatus = EFalse;
		}
	else
		{
		iBatteryStatus = aBatteryStatus;
		}

	// if the battery status is in the current event list
	TInt pos = iPendingNotificationEventList.Find( ERegisterNotificationBatteryStatusChanged );
	if (pos != KErrNotFound)
		{
		iPendingNotificationEventList.Remove( pos );
		if (validStatus)
			{
			SendNotificationResponse(ERegisterNotificationBatteryStatusChanged, ERemConNotifyResponseChanged);
			}
		}
	}
	
void CPlayerInfoTarget::SendError(TInt aError, TInt aOperationId, TRemConMessageSubType aSubType)
	{
	TInt error = 0;
	RAvrcpIPCError response;
	response.iError = aError;
	TRAP(error, response.WriteL(iOutBuf));   // Don't send error if OOM
	if (error == KErrNone)
		InterfaceSelector().SendUnreliable(TUid::Uid(KRemConPlayerInformationUid),
										aOperationId, ERemConResponse, aSubType, iOutBuf);
	}