// 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 <remcon/remconmediabrowsetargetbase.h>

#include <remconmediainformationtargetobserver.h>

#include <remconinterfaceselector.h>

#include <remconmediabrowsepanic.h>

#include <bluetooth/logger.h>

#include "mediabrowse.h"

#include "remconmediabrowsefault.h"

#include "remconqueuemessage.h"

const TInt KDatabaseUnawareUidCounter = 0;

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_REMCONMEDIABROWSEAPI);

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

#endif

//=========================================================================================

// Construction/Destruction

//=========================================================================================

CRemConMediaBrowseTargetBase::CRemConMediaBrowseTargetBase(CRemConInterfaceSelector& aInterfaceSelector, 

		MRemConDatabaseAwareMediaLibraryBrowseObserver& aMlObserver, 

		MRemConDatabaseAwareNowPlayingBrowseObserver& aNpObserver,

		TUint16 aMediaLibraryStateCookie)

	: CRemConInterfaceBase(TUid::Uid(KRemConMediaBrowseApiUid),

			KMaxLengthMediaBrowseMsg,

			aInterfaceSelector,

			ERemConClientTypeTarget),

	iInterfaceSelector(aInterfaceSelector),

	iRcdamlbo(&aMlObserver),

	iRcdanpbo(&aNpObserver),

	iMediaLibraryStateCookie(aMediaLibraryStateCookie),

	iAttributeIterator(iMediaAttributeIds),

	iNullIterator(iNullArray),

	iSearchInProgress(EFalse),

	iLastMlscUpdate(aMediaLibraryStateCookie)

	{

	}

CRemConMediaBrowseTargetBase::CRemConMediaBrowseTargetBase(CRemConInterfaceSelector& aInterfaceSelector, 

		MRemConDatabaseUnawareMediaLibraryBrowseObserver& aMlObserver, 

		MRemConDatabaseUnawareNowPlayingBrowseObserver& aNpObserver)

	: CRemConInterfaceBase(TUid::Uid(KRemConMediaBrowseApiUid),

			KMaxLengthMediaBrowseMsg,

			aInterfaceSelector,

			ERemConClientTypeTarget),

	iInterfaceSelector(aInterfaceSelector),

	iRcdumlbo(&aMlObserver),

	iRcdunpbo(&aNpObserver),

	iAttributeIterator(iMediaAttributeIds),

	iNullIterator(iNullArray),

	iSearchInProgress(EFalse)

	{

	}

CRemConMediaBrowseTargetBase::~CRemConMediaBrowseTargetBase()

	{

	iMediaAttributeIds.Close();

	iNullArray.Close();

	iOutBuf.Close();

	iSearchString.Close();

	iGetPathResponse->Close();

	iGiaResponse->Close();

	iGflResponse->Close();

	delete iGetPathResponse;

	delete iGiaResponse;

	delete iGflResponse;

	if (iNextMessageCallBack)

		{

		iNextMessageCallBack->Cancel();

		delete iNextMessageCallBack;

		}

	if (iNextItemCallBack)

		{

		iNextItemCallBack->Cancel();

		delete iNextItemCallBack;

		}

	iMsgQueue->Reset();

	delete iMsgQueue;

	}

void CRemConMediaBrowseTargetBase::BaseConstructL(TBool aSearchSupported)

	{

	iMsgQueue = new(ELeave)TRemConMessageQueue();

	iGetPathResponse = new(ELeave)RRemConGetPathResponse();

	iGiaResponse = new(ELeave)RRemConGetItemAttributesResponse();

	iGflResponse = new(ELeave)RRemConGetFolderItemsResponse();

	TCallBack cb(&NextMessageCb, this);

	iNextMessageCallBack = new(ELeave)CAsyncCallBack(cb, CActive::EPriorityStandard);

	TCallBack itemCallBack(&NextItemCallBack, this);

	iNextItemCallBack = new(ELeave)CAsyncCallBack(itemCallBack, CActive::EPriorityStandard);

	RRemConInterfaceFeatures features;

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

	CleanupClosePushL(features);

	if(aSearchSupported)

		{

		features.AddOperationL(ESearchOperationId);

		iSearchSupported = ETrue;

		}

	if(DatabaseAware())

		{

		features.AddOperationL(EUIDPersistency);

		}

	//Mandate the following operationIds to be supported in the client

	features.AddOperationL(EGetFolderItemsOperationId);

	features.AddOperationL(EChangePathOperationId);

	features.AddOperationL(EGetItemAttributesOperationId);

	features.AddOperationL(ESetBrowsedPlayerOperationId);

	iOutBuf.CreateL(KMediaBrowseOutBufMaxLength);

	CRemConInterfaceBase::BaseConstructL(features, ETrue); // it's true, this interface is a bulk interface

	CleanupStack::PopAndDestroy(&features);

	}

//=========================================================================================

// RemCon interface stuff, called from interface selector

//=========================================================================================

/** 

@internalComponent

@released

Gets a pointer to a specific interface version.

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

*/

TAny* CRemConMediaBrowseTargetBase::GetInterfaceIf(TUid aUid)

	{

	TAny* ret = NULL;

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

		{

		ret = reinterpret_cast<TAny*>(

			static_cast<MRemConInterfaceIf*>(this)

			);

		}

	return ret;

	}

void CRemConMediaBrowseTargetBase::MrcibNewMessage(TUint aOperationId,

			const TDesC8& aData)

	{

	LOG_FUNC

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

	TMetadataTransferPDU currentOp = RAvrcpIPC::GetPDUIdFromIPCOperationId(aOperationId);

	switch(currentOp)

		{

	case EGetFolderItemsOperationId:

		AddToOperationQueue(EMbGetFolderItems, 

							EGetFolderItemsOperationId, aData);

		if (!iMsgQueue->IsEmpty() && !iInProgress && !iMsgQueue->Find(

			      TUid::Uid(KRemConMediaBrowseApiUid)

				 ,EGetFolderItemsOperationId))

			{

			iNextMessageCallBack->CallBack();

			}

		break;

	case EChangePathOperationId:

		ProcessChangePath(aData);

		break;

	case EGetItemAttributesOperationId:

		{

		AddToOperationQueue(EMbGetItemAttributes, 

							EGetItemAttributesOperationId, aData);

		if (!iMsgQueue->IsEmpty() && !iInProgress && !iMsgQueue->Find(

					      TUid::Uid(KRemConMediaBrowseApiUid)

						 ,EGetItemAttributesOperationId))

					{

					iNextMessageCallBack->CallBack();

					}

		break;

		}

	case ESearchOperationId:

		ProcessSearch(aData);

		break;

	case ESetBrowsedPlayerOperationId:

		ProcessGetPath(aData);

		break;	

	case EMediaLibraryStateCookieUpdateOperationId:

		ProcessMediaLibraryStateCookieUpdate(aData);

		break;

	default:

		__ASSERT_DEBUG(EFalse, MediaBrowseFault::Fault(EUnexpectedOperationId));

		break; 

		};

	}

//=========================================================================================

// Browse Interface functions, called from derived classes

//=========================================================================================

void CRemConMediaBrowseTargetBase::DoFolderListing(const TArray<TRemConItem>& aFolderListing, 

		TUint16 aMediaLibraryStateCookie, 

		TInt aResult)

	{

	if (aResult != KErrNone)

		{

		SendGetFolderItemsResponse(aResult, KNullDesC8);

		return;

		}	

	// If asserted here, means the client calls the interface FolderListing() 

	// more than once corresponding to the only once call 

	// MrcmbtoGetFolderListing()

	__ASSERT_DEBUG(iGflResponse->iItems.Count() == 0, MediaBrowsePanic::Panic(EFolderListingProvidedTwice));

	// Store clients state cookie to pass it back when requesting each item. 

	// This will ensure that we don't miss state change during the course of 

	// the non-atomic GetFolderListing operation

	iGflResponse->iUidCounter = aMediaLibraryStateCookie;

	// Store these UIDs, then ask for info about them

	if (iGflResponse->CopyItems(aFolderListing) != KErrNone)

		{

		SendGetFolderItemsResponse(KErrAvrcpAirInternalError, KNullDesC8);

		return;

		}

	iGflResponse->iCurrentListingSize = KGetFolderItemsResponseBaseSize;

	iGflResponse->iCurrentItem = -1;

	RequestNextItem();

	}

void CRemConMediaBrowseTargetBase::DoFolderUpResult(TUint aItemCount, TInt aResult)

	{

	SendChangePathResponse(aItemCount, aResult);

	}

void CRemConMediaBrowseTargetBase::DoFolderDownResult(TUint aItemCount, TInt aResult)

	{

	SendChangePathResponse(aItemCount, aResult);

	}

void CRemConMediaBrowseTargetBase::DoGetPathResult(TUint aItemCount, 

		TUint16 aMediaLibraryStateCookie, 

		TInt aResult)

	{

	if (aResult != KErrNone)

		{

		iGetPathResponse->Close();

		return SendError(EMbSetBrowsedPlayer,

				ESetBrowsedPlayerOperationId, aResult);

		}

	// Store the current UIDs counter.

	iMediaLibraryStateCookie = aMediaLibraryStateCookie;

	TInt status = KErrAvrcpAirBase - KErrAvrcpAirSuccess;

	iGetPathResponse->iStatus = status;

	iGetPathResponse->iUidCounter = aMediaLibraryStateCookie;

	iGetPathResponse->iNumberItems = aItemCount;

	RBuf8 responseBuf;

	TInt error = responseBuf.Create(iGetPathResponse->Size());

	if (error != KErrNone)

		{

		iGetPathResponse->Close();

		return SendError(EMbSetBrowsedPlayer, 

				ESetBrowsedPlayerOperationId, KErrAvrcpAirInternalError);

		}

	iGetPathResponse->iPduId = AvrcpBrowsing::ESetBrowsedPlayer;

	TRAP(error, iGetPathResponse->WriteL(responseBuf));

	if (error == KErrNone)

		{

		// Send the response back to the CT

		error = InterfaceSelector().SendBulkUnreliable(

				TUid::Uid(KRemConMediaBrowseApiUid),

				ESetBrowsedPlayerOperationId, responseBuf );

		}

	iGetPathResponse->Close();

	responseBuf.Close();

	}

void CRemConMediaBrowseTargetBase::DoSearchResult(TUint aNumberItemsFound,

		TUint16 aMediaLibraryStateCookie, 

		TInt aResult)

	{

	// GetFoldItems should in progress When this interface is called.

	__ASSERT_DEBUG(iSearchInProgress, MediaBrowsePanic::Panic(ESearchResultWithoutRequest));

	SendSearchResponse(aResult, aNumberItemsFound, aMediaLibraryStateCookie);

	}

void CRemConMediaBrowseTargetBase::DoMediaLibraryStateChange(TUint16 aMediaLibraryStateCookie)

	{

	if(DatabaseAware())

		{

		__ASSERT_DEBUG(aMediaLibraryStateCookie != KDatabaseUnawareUidCounter, MediaBrowsePanic::Panic(EZeroMediaLibraryStateCookie));

		// For database aware players we need to update if we have a pending update and

		// the new value is different to what we last 

		if(iMlscUpdatePending && (aMediaLibraryStateCookie != iLastMlscUpdate))

			{

			// Send update with new value

			SendMediaLibraryStateCookieUpdateResponse(aMediaLibraryStateCookie);

			}	

		// Always store the last value here.  When we are asked for an update

		// we will be provided with the value the update should be relative 

		// to, so we will compare to this. 

		iLastMlscUpdate = aMediaLibraryStateCookie;

		}

	else

		{

		__ASSERT_DEBUG(aMediaLibraryStateCookie == KDatabaseUnawareUidCounter, MediaBrowseFault::Fault(ENonZeroMediaLibraryStateCookie));

		if(iMlscUpdatePending)

			{

			SendMediaLibraryStateCookieUpdateResponse(aMediaLibraryStateCookie);

			}

		else

			{

			// For database aware clients the value can never change.  Indicate that

			// the client has informed us of the state change by incrementing our

			// update value so that we know there's been a change.  The value doesn't

			// matter, we just have to make it something other than zero.

			iLastMlscUpdate = 1;

			}

		}

	}

void CRemConMediaBrowseTargetBase::DoFolderItemResult(const TRemConItemUid& aFolderID,

		const TDesC8& aFolderName, 

		TFolderItemType aFolderType, 

		TFolderItemPlayable aPlayable,

		const TArray<TMediaElementAttribute>& aAttributes,

		TInt aResult)

	{

	// GetFolderItems should in progress When this interface is called.

	__ASSERT_DEBUG(iGetFolderListing || iGetItemAttributes, MediaBrowsePanic::Panic(EFolderItemResultWithoutRequest));

	if(iGetFolderListing)

		{

		ProcessFolderItemResult(aFolderID, aFolderName, aFolderType, aPlayable, aResult);

		}

	if (iGetItemAttributes)

		{

		ProcessGetItemAttributesResult(aAttributes, aResult);

		}

	}

void CRemConMediaBrowseTargetBase::DoMediaElementItemResult(const TRemConItemUid& aMediaID, 

		const TDesC8& aMediaName, 

		TMediaItemType aMediaType, 

		const TArray<TMediaElementAttribute>& aAttributes,

		TInt aResult)

	{

	__ASSERT_DEBUG((iGetFolderListing || iGetItemAttributes), MediaBrowsePanic::Panic(EMediaElementItemResultWithoutRequest));

	if (iGetFolderListing)

		{

		ProcessMediaElementItemResult(aMediaID, aMediaName, aMediaType, aAttributes, aResult);

		}

	if (iGetItemAttributes)

		{

		ProcessGetItemAttributesResult(aAttributes, aResult);

		}		

	}

//=========================================================================================

// Utility functions, called internally

//=========================================================================================

void CRemConMediaBrowseTargetBase::ProcessMediaLibraryStateCookieUpdate(const TDesC8& aData)

	{

	// Try to read the incoming request

	RRemConUidsChangedRequest request;

	TRAPD(error, request.ReadL(aData));

	__ASSERT_DEBUG(error == KErrNone, MediaBrowseFault::Fault(EBadlyFormattedMediaLibraryStateCookieUpdate));

	static_cast<void>(error == error); // stops compiler warnings (assert above indicates design contract).

	if(request.iInitialUidCounter != iLastMlscUpdate)

		{

		// The client has updated the uid counter since the bearer

		// last asked.  Tell it the new value.  The Send..Response 

		// function deals with all the state management necessary,

		// including whether we are database aware or unaware

		SendMediaLibraryStateCookieUpdateResponse(iLastMlscUpdate);

		}

	else

		{

		// Bearer still up to date.  Remember that it's waiting for

		// an update.

		iMlscUpdatePending = ETrue;

		}

	}

void CRemConMediaBrowseTargetBase::ProcessGetItemAttributes(const TDesC8& aData)

	{

	TRemConFolderScope scope;

	TRemConItemUid item;

	TUint16 uidCounter;

	TInt err = ParseGetItemAttributesRequest(aData, scope, item, uidCounter);

	if (err != KErrNone)

	    {

	    SendGetItemAttributesResponse(err, KNullDesC8);

	    return;

	    }

	iAttributeIterator.Start();	

	iInProgress = ETrue;

	iGetItemAttributes = ETrue;	

	TInt result = KErrNone;

	if(scope == ENowPlayingFolder)

		{

		if (!DatabaseAware() && (0 == uidCounter))//Database UnAware

			{

			result = iRcdunpbo->MrcdunpboGetItem(item, iAttributeIterator);

			}

		else if (DatabaseAware() && (uidCounter > 0))

			{

			result = iRcdanpbo->MrcdanpboGetItem(item, iAttributeIterator, uidCounter);

			}

		else

			{

			result = KErrAvrcpAirInvalidParameter;

			}

		}

	else

		{

		if (!DatabaseAware() && (0 == uidCounter))//Database UnAware

			{

			result = iRcdumlbo->MrcdumlboGetItem(scope, item, iAttributeIterator);

			}

		else if (DatabaseAware() && (uidCounter > 0))

			{

			result = iRcdamlbo->MrcdamlboGetItem(scope, item, iAttributeIterator, 

					                     uidCounter);

			}

		else

			{

			result = KErrAvrcpAirInvalidParameter;

			}

		}

	// The call back function returns error.

	if (result != KErrNone)

		{

		SendGetItemAttributesResponse(result, KNullDesC8);

		}

	}

void CRemConMediaBrowseTargetBase::SendGetItemAttributesResponse(TInt aResult, const TDesC8& aData)

	{

	if(aResult != KErrNone)

		{

		SendError(EMbGetItemAttributes, EGetItemAttributesOperationId, aResult);

		}

	else

		{

		InterfaceSelector().SendBulkUnreliable(

				TUid::Uid(KRemConMediaBrowseApiUid),

				EGetItemAttributesOperationId, aData);

		}

	iInProgress = EFalse;

	iGetItemAttributes = EFalse;

	iMediaAttributeIds.Reset();

	iGiaResponse->Close();

	if (!iMsgQueue->IsEmpty())

		{

		iNextMessageCallBack->CallBack();

		}

	}

void CRemConMediaBrowseTargetBase::ProcessChangePath(const TDesC8& aData)

	{

	// Try to read the incoming request

	TInt error = KErrNone;

	RRemConChangePathRequest request;

	TRAP(error, request.ReadL(aData));

	// Couldn't parse the request; tell them it was invalid

	if (error != KErrNone)

		{

	    SendError(EMbChangePath, EChangePathOperationId, KErrAvrcpAirInvalidParameter);

	    return;

		}

	if(request.iDirection == AvrcpBrowsing::KUp)

		{

		if (DatabaseAware() && (request.iUidCounter > 0))

			{

			iRcdamlbo->MrcdamlboFolderUp(request.iUidCounter);

			}

		else if (!DatabaseAware() && (0 == request.iUidCounter))

			{

			iRcdumlbo->MrcdumlboFolderUp();

			}

		else

			{

			SendError(EMbChangePath, EChangePathOperationId, KErrAvrcpAirInvalidParameter);

			}