// 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:

//

/**

 @file

 @internalComponent

 @released

*/

#include <remconmediabrowsetypes.h>

#include <remcondatabaseawarenowplayingtargetobserver.h>

#include <remcondatabaseunawarenowplayingtargetobserver.h>

#include <remcon/remconnowplayingtargetbase.h>

#include <remcon/avrcpspec.h>

#include <remconinterfaceselector.h>

#include <bluetooth/logger.h>

#include "mediabrowse.h"

#include "nowplaying.h"

#include "remconnowplayingfault.h"

#include "remconqueuemessage.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCONNOWPLAYINGAPI);

_LIT8(KLogFormat, "Operation Id = 0x%x, Data Lengh = %d");

#endif

CRemConNowPlayingTargetBase::CRemConNowPlayingTargetBase(

	CRemConInterfaceSelector& aInterfaceSelector,

	MRemConDatabaseAwareNowPlayingTargetObserver& aObserver)

	: CRemConInterfaceBase(

	TUid::Uid(KRemConNowPlayingApiUid),

	KMaxLengthNowPlayingMsg,

	aInterfaceSelector,

	ERemConClientTypeTarget), 

	iDaObserver(&aObserver),

	iInterfaceSelector(aInterfaceSelector),

	iInProgress(EFalse)

	{

	}

CRemConNowPlayingTargetBase::CRemConNowPlayingTargetBase(

	CRemConInterfaceSelector& aInterfaceSelector,

	MRemConDatabaseUnawareNowPlayingTargetObserver& aObserver)

	: CRemConInterfaceBase(

	TUid::Uid(KRemConNowPlayingApiUid),

	KMaxLengthNowPlayingMsg,

	aInterfaceSelector,

	ERemConClientTypeTarget), 

	iDuObserver(&aObserver),

	iInterfaceSelector(aInterfaceSelector),

	iInProgress(EFalse)

	{

	}

void CRemConNowPlayingTargetBase::BaseConstructL()

	{

	iMsgQueue = new(ELeave)TRemConMessageQueue;

	TCallBack cb(&NextMessageCb, this);

	iNextMessageCallBack = new (ELeave) CAsyncCallBack(cb,

			CActive::EPriorityStandard);

	iOutBuf.CreateL(KMaxLengthNowPlayingMsg);

    // Mandate the following features supported.

	RRemConInterfaceFeatures features;

	User::LeaveIfError(features.Open());

	CleanupClosePushL(features);

	features.AddOperationL(EPlayItem);

	features.AddOperationL(EAddToNowPlaying);

	features.AddOperationL(ERegisterNotification);

    CRemConInterfaceBase::BaseConstructL(features);

    CleanupStack::PopAndDestroy(&features);

	}

EXPORT_C CRemConNowPlayingTargetBase::~CRemConNowPlayingTargetBase()

	{

	iOutBuf.Close();

	iNextMessageCallBack->Cancel();

	delete iNextMessageCallBack;

	iMsgQueue->Reset();

	delete iMsgQueue;

	}

/** 

@internalComponent

@released

Gets a pointer to a specific interface version.

@return A pointer to the interface, NULL if not supported.

*/

TAny* CRemConNowPlayingTargetBase::GetInterfaceIf(TUid aUid)

	{

	TAny* ret = NULL;

	if ( aUid == TUid::Uid(KRemConInterfaceIf2) )

		{

		ret = reinterpret_cast<TAny*>(

			static_cast<MRemConInterfaceIf2*>(this)

			);

		}

	return ret;

	}

/**

Provide a response to the play item command. For database aware clients this 

would have been called via MrcdanptoPlayItem(). For database unaware client

this would have been called via MrcdunptoPlayItem()

The client must call NowPlayingContentChanged() if the content of the now 

playing list has been changed after the client successfully plays the item

and provides the response with KErrNone through this function.

@param aErr The result of play item operation.

     - KErrNone if the operation was successful.

     - KErrInvalidMediaLibraryStateCookie if the client is able to maintain 

       unique UIDs accross the entire virtual filesystem, but the media 

       library state cookie provided does not match the client's state cookie.

     - KErrInvalidUid if the uid of the item provided does not refer to any 

       valid item.

     - KErrNowPlayingUidIsADirectory if the uid of the item provided refers to

       a directory which can not be handled by this media player.

     - KErrNowPlayingMediaInUse if the item is in use and can not be played.

     - System wide error code otherwise.

@see NowPlayingContentChanged()

*/

EXPORT_C void CRemConNowPlayingTargetBase::PlayItemResponse(TInt aErr)

	{

	TUint8 status = RAvrcpIPC::SymbianErrToStatus(aErr);

	SendResponse(status, EPlayItem);

	iInProgress = EFalse;		

	if (!iMsgQueue->IsEmpty())

		{

		iNextMessageCallBack->CallBack();

		}

	}

/**

Sends the response for the request MrcnptoAddToNowPlaying()

The client must call NowPlayingContentChanged() if the content of the now 

playing list has been changed after the client successfully adds the item

to the now playing list and provides the response with KErrNone through 

this function.

param aErr The result of add to now playing operation.

    - KErrNone if the operation was successful.

    - KErrInvalidMediaLibraryStateCookie if the client is able to maintain 

      unique UIDs accross the entire virtual filesystem, but the media 

      library state cookie provided does not match the client's state cookie.

    - KErrInvalidUid if the uid of the item provided does not 

      refer to any valid item.

    - KErrNowPlayingUidIsADirectory if the uid of the item provided refers to

      a directory which can not be handled by this media player.

    - KErrNowPlayingMediaInUse if the item is in use and can not be added to 

      now playing list.

    - KErrNowPlayingListFull if the now playing list if full and no more items

      can be added.

    - System wide error code otherwise.

@see NowPlayingContentChanged()

*/

EXPORT_C void CRemConNowPlayingTargetBase::AddToNowPlayingResponse(TInt aErr)

	{

	TUint8 status = RAvrcpIPC::SymbianErrToStatus(aErr);

	SendResponse(status, EAddToNowPlaying);

	iInProgress = EFalse;		

	if (!iMsgQueue->IsEmpty())

		{

		iNextMessageCallBack->CallBack();

		}

	}

/**

Called by the client in the case that the now playing content changed.

@see PlayItemResponse()

@see AddToNowPlayingResponse()

*/

EXPORT_C void CRemConNowPlayingTargetBase::NowPlayingContentChanged()

	{

	if(iNotificationPending)

		{

		iNotificationPending = EFalse;

		SendNotificationResponse(ERemConNotifyResponseChanged);

		}

	}

void CRemConNowPlayingTargetBase::SendResponse(TUint8 aStatus, TUint aOperationId)

	{

	TInt error = KErrNone;

	// Formats the response in a RRemConNowPlayingResponse

	RRemConNowPlayingResponse response;

	response.iStatus = aStatus;

	TRAP(error, response.WriteL(iOutBuf));

	if (error == KErrNone)

		{

		// Send the response back to the CT

		error = InterfaceSelector().SendUnreliable(

				TUid::Uid(KRemConNowPlayingApiUid),

				aOperationId, ERemConResponse, iOutBuf );

		}

	}

void CRemConNowPlayingTargetBase::SendError(TInt aError, TUint aOperationId)

	{

	TInt error = KErrNone;	

	RAvrcpIPCError response;

	response.iError = RAvrcpIPC::SymbianErrorCheck(aError);

	TRAP(error, response.WriteL(iOutBuf));

	if (error == KErrNone)

		{

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

				aOperationId, ERemConResponse, iOutBuf);

		}

	}

// From MRemConInterfaceIf2

void CRemConNowPlayingTargetBase::MrcibNewMessage(

		TUint aOperationId, 

		const TDesC8& aData, 

		TRemConMessageSubType aMsgSubType)

	{

	LOG_FUNC

	LOG2(KLogFormat, aOperationId, aData.Length());

	TMetadataTransferPDU currentOp =

	RAvrcpIPC::GetPDUIdFromIPCOperationId(aOperationId);

	switch(currentOp)

		{

	case EPlayItem:

		if ( !iInProgress && 

			 !iMsgQueue->Find(TUid::Uid(KRemConNowPlayingApiUid), EPlayItem))

			{

			ProcessPlayItem(aData);

			}

		else

			{

			AddToOperationQueue(EPlayItem, aData);

			}

		break;

	case EAddToNowPlaying:

		if ( !iInProgress && 

			 !iMsgQueue->Find(TUid::Uid(KRemConNowPlayingApiUid), EAddToNowPlaying))

			{

			ProcessAddToNowPlaying(aData);

			}

		else

			{

			AddToOperationQueue(EAddToNowPlaying, aData);

			}

		break;

	case ERegisterNotification:

		{

		// obtain eventId from aOperationId

		TRegisterNotificationEvent eventId = 

		RAvrcpIPC::GetEventIdFromIPCOperationId(aOperationId);

		// If asserted here, must something wrong occured in the 

		// remconbearer handling

		__ASSERT_DEBUG(eventId == ERegisterNotificationNowPlayingContentChanged

				, NowPlayingFault::Fault(EInvalidEventId));

		// register for Notifications

		if (aMsgSubType == ERemConNotifyCommandAwaitingInterim)

			{

			ProcessGetStatusAndBeginObserving();

			}

		else if (aMsgSubType == ERemConNotifyCommandAwaitingChanged)

			{

			ProcessGetStatus();

			}

	 	break;

		}

	default:

		break;

		};

	}

void CRemConNowPlayingTargetBase::ProcessPlayItem(const TDesC8& aData)

	{

	TUint64 item;

	TRemConFolderScope scope;

	TUint16 uidCounter;

	if (!ProcessNowPlaying(aData, EPlayItem, item, scope, uidCounter))

		{

		return;

		}

	iInProgress = ETrue;

	if (iDaObserver && (uidCounter > 0))	

		{

		iDaObserver->MrcdanptoPlayItem(item, scope, uidCounter);

		}

	else if (!iDaObserver && (0 == uidCounter))

		{

		iDuObserver->MrcdunptoPlayItem(item, scope);

		}

	else

		{

		PlayItemResponse(KErrAvrcpAirInvalidParameter);

		}

	}

void CRemConNowPlayingTargetBase::ProcessAddToNowPlaying(const TDesC8& aData)

	{

	TUint64 item;

	TRemConFolderScope scope;

	TUint16 uidCounter;

	if (!ProcessNowPlaying(aData, EAddToNowPlaying, item, scope, uidCounter))

		{

		return;

		}

	iInProgress = ETrue;

	if (iDaObserver && (uidCounter > 0))

		{

		iDaObserver->MrcdanptoAddToNowPlaying(item, scope, uidCounter);

		}

	else if (!iDaObserver && (0 == uidCounter))

		{

		iDuObserver->MrcdunptoAddToNowPlaying(item, scope);

		}

	else

		{

		AddToNowPlayingResponse(KErrAvrcpAirInvalidParameter);

		}

	}

TBool CRemConNowPlayingTargetBase::ProcessNowPlaying(

		const TDesC8& aData, 

		TUint aOperationId,

		TUint64& aItem, 

		TRemConFolderScope& aScope, 

		TUint16& aMediaLibraryStateCookie)

	{

	RRemConNowPlayingRequest request;

	TRAPD(error, request.ReadL(aData))

	if (error != KErrNone)

		{

		// Nothing in packet

		SendError(KErrAvrcpMetadataParameterNotFound, aOperationId);

		return EFalse;

		}

	aItem = request.iElement;

	aScope = request.iScope;

	aMediaLibraryStateCookie = request.iUidCounter;

	//Does not allow invalid scope

	if (   aScope != EBrowseFolder 

		&& aScope != ESearchResultFolder

		&& aScope != ENowPlayingFolder )

		{

		SendError(KErrAvrcpAirInvalidScope, aOperationId);

		return EFalse;

		}

	return ETrue;

	}

void CRemConNowPlayingTargetBase::ProcessGetStatusAndBeginObserving()

	{

	// and request another notification (if there is not one already pending)

	// on the next state change  

	iNotificationPending = ETrue;

	// send the current status

	SendNotificationResponse(ERemConNotifyResponseInterim);

	}

void CRemConNowPlayingTargetBase::ProcessGetStatus()

	{

	// send the current value

	SendNotificationResponse(ERemConNotifyResponseChanged);

	}

void CRemConNowPlayingTargetBase::SendNotificationResponse(

		TRemConMessageSubType aMsgSubType)

	{

	LOG_FUNC

	TInt error = KErrNone;

	// No extra data needed

	RAvrcpIPCError response;

	response.iError = KErrNone;

	TRAP(error, response.WriteL(iOutBuf));

	if (error == KErrNone)

		{

		// send the response back to the CT

		TUint operationId = 

		RAvrcpIPC::SetIPCOperationIdFromEventId(

				ERegisterNotificationNowPlayingContentChanged);

		error = InterfaceSelector().SendUnreliable(

				TUid::Uid(KRemConNowPlayingApiUid),

				operationId, ERemConResponse, aMsgSubType, iOutBuf);

		}

	}

TInt CRemConNowPlayingTargetBase::NextMessageCb(TAny* aThis)

	{

	static_cast<CRemConNowPlayingTargetBase*>(aThis)->DoNextMessage();

	return KErrNone;

	}

void CRemConNowPlayingTargetBase::DoNextMessage()

	{

	CRemConQueuedMessage* msg = iMsgQueue->First();

	iMsgQueue->Remove(*msg);

	switch (msg->iOperationId)

		{

		case EPlayItem:

			ProcessPlayItem(msg->Data());

			break;

		case EAddToNowPlaying:

			ProcessAddToNowPlaying(msg->Data());

			break;

		default:

			// Never come here.

			ASSERT(NULL);

			break;

		}

	delete msg;

	}

void CRemConNowPlayingTargetBase::AddToOperationQueue(TInt aOperationId, 

		const TDesC8& aData)

	{

	CRemConQueuedMessage* msg = NULL;

	TRAPD(err, msg = CRemConQueuedMessage::NewL(

			TUid::Uid(KRemConNowPlayingApiUid), aData, aOperationId));			

	if (err == KErrNone)

		{

		iMsgQueue->AddLast(*msg);

		}

	else

		{

		SendError(KErrAvrcpMetadataInternalError, aOperationId);

		}

	}