// 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
 @publishedAll
 @released
*/

#ifndef REMCONMEDIABROWSETARGETBASE_H
#define REMCONMEDIABROWSETARGETBASE_H

#include <remcondatabaseawaremedialibrarybrowseobserver.h>
#include <remcondatabaseawarenowplayingbrowseobserver.h>
#include <remcondatabaseunawaremedialibrarybrowseobserver.h>
#include <remcondatabaseunawarenowplayingbrowseobserver.h>
#include <remconmediabrowsetypes.h>
#include <remcon/remconinterfacebase.h>
#include <remcon/remconinterfaceif.h>

class RRemConGetFolderItemsResponse;
class RRemConGetItemAttributesResponse;
class RRemConGetPathResponse;
class TRemConMessageQueue;
/**
This interface enables the client to present a heirarchical view
of the local media library for browsing by a remote entity.

The view is a virtual filesystem and does not need to correspond
directly to any structure on local storage.  It could for example
map onto a database of media content.

Each item in the media library is identified by a UID.  At a 
minimum this must uniquely identify an element within a folder.
For clients that support it the UID can be persistant accross
the entire virtual filesystem.  In this case a media library
state cookie is used to ensure that that state is consistent
between the client and the remote device. 

This interface does not have NewL()/NewLC, so the client should 
use the object CRemConDatabaseAwareMediaBrowseTarget or 
CRemConDatabaseUnawareMediaBrowseTarget to use its exported functions.

This class is only to be used by classes currently derived from it.

@see CRemConDatabaseAwareMediaBrowseTarget
@see CRemConDatabaseUnawareMediaBrowseTarget
*/
NONSHARABLE_CLASS(CRemConMediaBrowseTargetBase) : public CRemConInterfaceBase, public MRemConInterfaceIf
	{
protected:
	CRemConMediaBrowseTargetBase(CRemConInterfaceSelector& aInterfaceSelector, 
			MRemConDatabaseAwareMediaLibraryBrowseObserver& aMlObserver, 
			MRemConDatabaseAwareNowPlayingBrowseObserver& aNpObserver,
			TUint16 aMediaLibraryStateCookie);

	CRemConMediaBrowseTargetBase(CRemConInterfaceSelector& aInterfaceSelector, 
			MRemConDatabaseUnawareMediaLibraryBrowseObserver& aMlObserver, 
			MRemConDatabaseUnawareNowPlayingBrowseObserver& aNpObserver);
	
	virtual ~CRemConMediaBrowseTargetBase();
	
	virtual void BaseConstructL(TBool aSearchSupported);
	
	void DoFolderListing(const TArray<TRemConItem>& aFolderListing, 
			TUint16 aMediaLibraryStateCookie, 
			TInt aResult);
	
	void DoFolderUpResult(TUint aItemCount, TInt aResult);
	void DoFolderDownResult(TUint aItemCount, TInt aResult);
	
	void DoGetPathResult(TUint aItemCount, 
			TUint16 aMediaLibraryStateCookie, 
			TInt aResult);
	
	void DoSearchResult(TUint aNumberItemsFound,
			TUint16 aMediaLibraryStateCookie, 
			TInt aResult);
	
	void DoMediaLibraryStateChange(TUint16 aMediaLibraryStateCookie);
	
	void DoFolderItemResult(const TRemConItemUid& aFolderID,
			const TDesC8& aFolderName, 
			TFolderItemType aFolderType, 
			TFolderItemPlayable aPlayable,
			const TArray<TMediaElementAttribute>& aAttributes,
			TInt aResult);
	
	void DoMediaElementItemResult(const TRemConItemUid& aMediaID, 
			const TDesC8& aMediaName, 
			TMediaItemType aMediaType, 
			const TArray<TMediaElementAttribute>& aAttributes,
			TInt aResult);
	
private: // From CRemConInterfaceBase
	TAny* GetInterfaceIf(TUid aUid);

private: // From MRemConInterfaceIf
	void MrcibNewMessage(TUint aOperationId,
			const TDesC8& aData);
	
private: // Utility
	void ProcessGetFolderItems(const TDesC8& aData);
	void ProcessChangePath(const TDesC8& aData);
	void ProcessGetItemAttributes(const TDesC8& aData);
	void ProcessSearch(const TDesC8& aData);
	void ProcessGetPath(const TDesC8& aData);
	void ProcessMediaLibraryStateCookieUpdate(const TDesC8& aData);
	
	void SendGetItemAttributesResponse(TInt aResult, const TDesC8& aData);
	void SendGetFolderItemsResponse(TInt aResult, const TDesC8& aData);
	void SendChangePathResponse(TUint aItemCount, TInt aResult);
	void SendInternalNotificationResponse(TRemConMessageSubType aMsgSubType);
	void SendNotificationResponse(TRemConMessageSubType aMsgSubType);
	void SendSearchResponse(TInt aResult, TUint aNumberItemsFound, TUint16 aMediaLibraryStateCookie);
	void SendMediaLibraryStateCookieUpdateResponse(TUint16 aMediaLibraryStateCookie);
	
	static TInt NextMessageCb(TAny* aThis);
	void DoNextMessage();
	
	static TInt NextItemCallBack(TAny* aThis);
	void RequestNextItem();
	void DoItemComplete(TInt aResult);
	
	void SendError(TUint8 aPduId, 
			TUint aOperationId, 
			TInt aError);
	
	// Used for Gia
	TInt ItemAttributesResult(const TArray<TMediaElementAttribute>& aAttributes);
	TInt DoAttributeValue(TMediaAttributeId aAttributeId, const TDesC8& aAttributeData);
	void DoAllAttributesCompleted(TInt aResult);
	
	void AddToOperationQueue(TUint8 aPduId, 
			TInt aOperationId, 
			const TDesC8& aData);
	TInt ParseGetItemAttributesRequest(const TDesC8& aData,
			TRemConFolderScope& aScope,
			TRemConItemUid& aItemUid,
			TUint16& aMediaLibraryStateCookie);
	void ProcessMediaElementItemResult(const TRemConItemUid& aMediaID,
			const TDesC8& aMediaName, 
			TMediaItemType aMediaType, 
			const TArray<TMediaElementAttribute>& aAttributes,
			TInt aResult);
	void ProcessFolderItemResult(const TRemConItemUid& aFolderID,
			const TDesC8& aFolderName, 
			TFolderItemType aFolderType, 
			TFolderItemPlayable aPlayable,
			TInt aResult);
	void ProcessGetItemAttributesResult(
			const TArray<TMediaElementAttribute>& aAttributes,
			TInt aResult);

	inline TBool DatabaseAware() const;

private:
	// Unowned
	CRemConInterfaceSelector& 							iInterfaceSelector;
	
	MRemConDatabaseAwareMediaLibraryBrowseObserver*		iRcdamlbo;
	MRemConDatabaseUnawareMediaLibraryBrowseObserver*	iRcdumlbo;
	
	MRemConDatabaseAwareNowPlayingBrowseObserver*		iRcdanpbo;
	MRemConDatabaseUnawareNowPlayingBrowseObserver*		iRcdunpbo;
	
	// Owned
	CAsyncCallBack*										iNextMessageCallBack;
	CAsyncCallBack*										iNextItemCallBack;
	
	RBuf8												iOutBuf;
	
	TUint16												iMediaLibraryStateCookie;
	
	TBool												iInProgress; // used internally to see if any operation is in progress
	TRemConMessageQueue*                     			iMsgQueue; // used to queue messages if another operation is in progress
	
	RArray<TMediaAttributeId>							iMediaAttributeIds; // used for Gfl and Gia to store requested attributes
	TMediaAttributeIter									iAttributeIterator; // provided to the client on requesting item attributes for Gfl and Gia
	
	RArray<TMediaAttributeId>							iNullArray; 
	TMediaAttributeIter									iNullIterator; // Used for getting a folder item to perform a folder listing
	
	TBool												iGetFolderListing; // used to check Gfl is in progress 
	RRemConGetFolderItemsResponse*						iGflResponse; // used to build up Gfl response from client
	TRemConFolderScope									iScope; // stored for use in async callbacks to get folder items

	TBool												iGetItemAttributes;	// used to check Gia is in progress
	TBool												iSetAttributeValue; // used to check that client has set response if it returns KErrNone
	RRemConGetItemAttributesResponse*					iGiaResponse; // used to build up Gia response from client
	
	TBool												iSearchSupported;
	TBool												iSearchInProgress; // used to check Search is in progress
	RBuf8												iSearchString; // used to store search string until request is complete
	
	RRemConGetPathResponse*      						iGetPathResponse; // used to build up get path response 
	
	TBool												iMlscUpdatePending;
	TUint16												iLastMlscUpdate;
	};

#endif // REMCONMEDIABROWSETARGETBASE_H