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

// Client utility functions

// 

//

#ifndef __MMF_CLIENT_UTILITY_H__

#define __MMF_CLIENT_UTILITY_H__

#include <mda/common/audio.h>

#include <mda/common/gsmaudio.h>

#include <mda/client/utility.h>

#include <mmf/common/mmffourcc.h>

#include <mmfformatimplementationuids.hrh>

#include "mmf/common/mmfcontrollerpluginresolver.h"

#include <mmf/server/mmffile.h>

#include <mmf/server/mmfdes.h>

#include "mmf/common/mmfcontroller.h"

#include <f32file.h>

#include <caf/content.h>

#include <caf/data.h>

#include <mmf/common/mmfstandardcustomcommands.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfstandardcustomcommandsenums.h>

#include <mmf/common/mmfstandardcustomcommandsimpl.h>

#endif

#ifdef SYMBIAN_BUILD_GCE

#include <mmf/common/mmfvideosurfacecustomcommands.h>

#endif

class CMMSourceSink; // declared here.

NONSHARABLE_CLASS( CMMSourceSink ): public CBase

	{

public:

	IMPORT_C static CMMSourceSink* NewL(TUid aUid, const TDesC8& aDescriptor);

	IMPORT_C static CMMSourceSink* NewLC(TUid aUid, const TDesC8& aDescriptor);

	virtual ~CMMSourceSink();

	virtual TUid SourceSinkUid() const;

	virtual const TDesC8& SourceSinkData() const;

	virtual TBool CarryingFileHandle() const;

	virtual void EvaluateIntentL();

protected:

	CMMSourceSink(TUid aUid);	

private:

	void ConstructL(const TDesC8& aDescriptor);

	const TUid iUid;

	HBufC8* iBuf;

	};

class CMMFileSourceSink; // declared here.	

NONSHARABLE_CLASS( CMMFileSourceSink ): public CMMSourceSink

	{

public:

	IMPORT_C static CMMFileSourceSink* NewL(TUid aUid, const RFile& aFile);

	IMPORT_C static CMMFileSourceSink* NewLC(TUid aUid, const RFile& aFile);

	IMPORT_C static CMMFileSourceSink* NewL(TUid aUid, const TMMSource& aMMSource);			

	IMPORT_C static CMMFileSourceSink* NewLC(TUid aUid, const TMMSource& aMMSource);

	const TDesC& UniqueId() const {return *iUniqueId;}

	virtual ~CMMFileSourceSink();

	const TDesC& FileName() const {return *iFileName;}

	const TDesC8& SourceSinkData() const;

	IMPORT_C void EvaluateIntentL(ContentAccess::TIntent aIntent);

	virtual void EvaluateIntentL();

	TBool CarryingFileHandle() const;

	TBool UsingFileHandle() const {return iUsingFileHandle;};

	const RFile& FileHandle() const {return iHandle;};

protected:

	CMMFileSourceSink(TUid aUid);

private:

	void ConstructL(const TMMSource& aSource);

	void DoCreateFileSourceConfigDataL();

	void ConstructL(const RFile& aFile);

	void DoCreateFileHandleSourceConfigDataL();

	TBool iUsingFileHandle;

	RFile iHandle;

	HBufC* iFileName;

	HBufC8* iSourceSinkData;

	HBufC* iUniqueId;

	ContentAccess::TIntent iIntent;

	TBool	iEnableUI;

	};

class CMMFMdaObjectStateChangeObserverCallback; // declared here.

/**

Active object utility class to allow the callback to be called asynchronously.

This should help prevent re-entrant code in clients of the mediaframework.

*/

NONSHARABLE_CLASS( CMMFMdaObjectStateChangeObserverCallback ): public CActive

	{

public:

	IMPORT_C static CMMFMdaObjectStateChangeObserverCallback* NewL(MMdaObjectStateChangeObserver& aCallback);

	virtual ~CMMFMdaObjectStateChangeObserverCallback();

	IMPORT_C void CallBack(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

private:

	CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback);

	void RunL();

	void DoCancel();

private:

	MMdaObjectStateChangeObserver& iCallback;

	CBase* iObject;

	TInt iPreviousState;

	TInt iCurrentState;

	TInt iErrorCode;

	};

class CMMFClientUtility; // declared here.

NONSHARABLE_CLASS( CMMFClientUtility )

	{

public:

	IMPORT_C static TUid ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid); 

	IMPORT_C static TUid ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid); 

	IMPORT_C static TFourCC ConvertMdaCodecToFourCC(TMdaPackage& aCodec);

	IMPORT_C static TInt GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength);

	IMPORT_C static HBufC8* GetFileExtensionL(const TDesC& aFileName);

	static void PrioritiseControllersL(

		const RMMFControllerImplInfoArray& aControllers, 

		const TDesC8& aHeaderDataPlayback, 

		const TDesC8& aFileExtensionPlayback, 

		const TDesC8& aHeaderDataRecord, 

		const TDesC8& aFileExtensionRecord, 

		RMMFControllerImplInfoArray& aPrioritisedControllers);

	static TInt GetBestMatchL(const CMMFFormatImplementationInformation* format, const TDesC8& aHeaderData, const TDesC8& aFileExtension);

private:

	CMMFClientUtility();

	};

class CMMFUtilityFileInfo; // declared here.

class RMMFDRMPluginServerProxy;

NONSHARABLE_CLASS( CMMFUtilityFileInfo ): public CBase

	{

public:

	static CMMFUtilityFileInfo* NewL(TMMSource& aSource, TBool aSecureDRMMode = EFalse);

	static CMMFUtilityFileInfo* NewLC(TMMSource& aSource, TBool aSecureDRMMode = EFalse);

	~CMMFUtilityFileInfo();

	TBool GetFileMimeTypeL(TDes8& aMimeType);

	void  GetFileHeaderDataL(TDes8& aHeaderData, TInt aMaxLength);

	TInt EvaluateIntent(ContentAccess::TIntent aIntent);

private:

	CMMFUtilityFileInfo();

	void ConstructL(const TMMSource& aSource, TBool aSecureDRMMode);

private:

	ContentAccess::CData* iData;

	RMMFDRMPluginServerProxy* iDrmPluginServer;

	};

inline CMMFUtilityFileInfo::CMMFUtilityFileInfo()

	{

	};

/**

 * Mixin class that the user of the class CMMFFindAndOpenController must derive from.

 * @internalComponent

 */

class MMMFFindAndOpenControllerObserver

	{

public:

	/**

	 * Callback function to indicate the success or failure

	 * of an attempt to find and open a suitable controller and 

	 * to add a source and sink.

	 * @see CMMFFindAndOpenController

	 * 

	 * @param aError 

	 *        Indicates whether a controller has been opened sucessfully

	 *        This is passed by reference, mainly for the audio recorder utility 

	 *        which opens two controllers: if the secondary controller (which is

	 *        always opened first) fails to open, then the audio recorder utility

	 *        may choose to set aError = KErrNone in the MfaocComplete() callback 

	 *        to indicate to CFindAndOpenControler() that it should continue 

	 *        to open the primary controller, even though opening the secondary failed.

	 * @param aController

	 *        A pointer to the controller that has been opened or has failed to open

	 *        This is mainly for the audio recorder utility to indicate  

	 *        which controller (primary or secondary) has been opened.

	 * @param aControllerUid

	 *        the UID of the controller that has been opened

	 * @param aSourceHandle

	 *        a pointer to the source handle

	 * @internalComponent

	 *        a pointer to the sink handle

	 */

	virtual void MfaocComplete(

		TInt& aError, 

		RMMFController* aController, 

		TUid aControllerUid = KNullUid, 

		TMMFMessageDestination* aSourceHandle = NULL, 

		TMMFMessageDestination* aSinkHandle = NULL) = 0;

	};

class CMMFFindAndOpenController; // declared here.

/**

 * Utility class used by the MMF client API classes.

 * Finds and opens a suitable controller and adds a source and a sink 

 * asynchronously. Completion is indicated asynchronously 

 * using the MMMFFindAndOpenControllerObserver mixin class.

 *

 * @internalComponent

 */

NONSHARABLE_CLASS( CMMFFindAndOpenController ): public CActive, public MMMFAddDataSourceSinkAsyncObserver

	{

public:

	enum TControllerMode

		{

		EPlayback,

		ERecord,

		EConvert

		};

	enum TControllerNumber

		{

		EPrimaryController,

		ESecondaryController

		};

	class TSourceSink

		{

	public:

		IMPORT_C TSourceSink(TUid aUid, const TDesC8& aData = KNullDesC8);

		IMPORT_C TSourceSink(TUid aUid, const RFile& aFile);

		TUid iUid;

		const TDesC8& iConfigData;

		TBool iUseFileHandle;

		RFile iFileHandle;

		};

public:

	IMPORT_C static CMMFFindAndOpenController* NewL(MMMFFindAndOpenControllerObserver& aObserver);

	virtual ~CMMFFindAndOpenController();

	// from CActive

	virtual void DoCancel();

	virtual void RunL();

	// from MMMFAddDataSourceSinkAsyncObserver

	virtual void MadssaoAddDataSourceSinkAsyncComplete(TInt aError, const TMMFMessageDestination& aHandle);

	IMPORT_C void Configure(

		TUid aMediaId, 

		TMMFPrioritySettings aPrioritySettings,

		CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType = CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

	IMPORT_C void ConfigureController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);

	IMPORT_C void ConfigureSecondaryController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);

	IMPORT_C void UseSharedHeap();

	IMPORT_C void ConfigureSourceSink(

		TSourceSink aSource,

		TSourceSink aSink);

	IMPORT_C void ConfigureSecondarySourceSink(

		TSourceSink aSource,

		TSourceSink aSink);

	IMPORT_C void ConfigureSourceSink(

		const TMMSource& aSource, 

		TSourceSink aSink);

	IMPORT_C void OpenByFileSource(const TMMSource& aFileSource, const TDesC& aFileNameSecondary = KNullDesC);	

	IMPORT_C void OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary = KNullUid);

	IMPORT_C void OpenByDescriptor(const TDesC8& aDescriptor);

	IMPORT_C void OpenByUrl(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType);

	IMPORT_C void OpenByControllerUid(TUid aControllerUid, TUid aSecondaryControllerUid = KNullUid);

	IMPORT_C void ReOpen();

	IMPORT_C void Close();

	IMPORT_C static TMMFFileConfig GetConfigFile(const TDesC& aFileName);

	IMPORT_C static TMMFDescriptorConfig GetConfigDescriptor(const TDesC8& aDescriptor);

	IMPORT_C void CloseConfig();

	IMPORT_C static void GetConfigUrlL(CBufFlat*& aUrlCfgBuffer, const TDesC& aUrl, TInt aIapId);

	/** made public to check for further selected controllers in the queue */

	inline TInt ControllerIndex() const;

	inline TInt ControllerCount() const; 

	/** made public to stop checking for further selected controllers in the queue */

	inline TBool StopTryLoadController() const;

	IMPORT_C void SetInitScreenNumber(TInt aScreenNumber, RMMFVideoSetInitScreenCustomCommands* aVideoSetInitScreenCustomCommands);

#ifdef SYMBIAN_BUILD_GCE

	inline void SetSurfaceMode(TBool aUseSurface, RMMFVideoPlaySurfaceSupportCustomCommands* aVideoPlaySurfaceSupportCustomCommands);

	inline TInt SurfaceSupported();

#endif

private:

	class CConfig: public CBase

		{

	public:

		CConfig();

		~CConfig();

		void Close();

	public:

		RMMFController* iController;				// not owned

		CMMFControllerEventMonitor* iEventMonitor;	// not owned

		/** indicates whether this controller is being used for 

		playback, recording or converting */

		TControllerMode iControllerMode;

		CMMSourceSink* iSource;

		CMMSourceSink* iSink;

		TUid iControllerUid;

		};

	CMMFFindAndOpenController(MMMFFindAndOpenControllerObserver& aObserver);

	void ConstructL();

	void Init();

	void ConfigureSourceSink(

		CConfig& config,

		TSourceSink aSource, 

		TSourceSink aSink);

	void ConfigureSourceSink(

		CConfig& config,

		const TMMSource& aSource, 

		TSourceSink aSink);

	void ConfigureController(

		CConfig& config,

		RMMFController& aController, 

		CMMFControllerEventMonitor& aEventMonitor,

		TControllerMode aControllerMode);

	void CloseController();

	void OpenPrimaryController(void);

	void KickState();

	void Process();

	void SendError(TInt aError = KErrNone, TBool aForcedError = EFalse);

	void SchedSendError(TInt aError = KErrNone);

	void BuildControllerListFileNameL();

	void BuildControllerListDescriptorL();

	void BuildControllerListUrlL();

	void BuildControllerListFormatL();

	void TryNextController();

	CMMSourceSink* CreateSourceSinkL(const TSourceSink& aParams);

	CMMSourceSink* CreateSourceSinkL(const TMMSource& aSource);

	CMMFUtilityFileInfo* CreateFileInfoL(TBool aSecureDRMMode = EFalse);

	void UseSecureDRMProcessL(TBool& aIsSecureDrmProcess);

private:

	/** primary controller details */

	CConfig* iPrimaryConfig;

	/** secondary controller details */

	CConfig* iSecondaryConfig;

	/** points to either iPrimaryConfig or iSecondaryConfig */

	CConfig* iCurrentConfig;	// not owned

	enum TMode

		{

		EOpenByControllerUid,

		EOpenByFileName,

		EOpenByDescriptor,

		EOpenByUrl,

		EOpenByFormatUid

		};

	TMode iMode;

	/** indicates what state the state machine is in */

	enum TState

		{

		EIdle,

		EBuildControllerList,

		EOpenController,

		EAddSource,

		EAddSink,

		EWaitingForSource,

		EWaitingForSink,

		ESendError

		};

	TState iState;

	MMMFFindAndOpenControllerObserver& iObserver;

	CMMFAddDataSourceSinkAsync* iAddDataSourceSinkAsync;

	TInt iControllerIndex;

	TInt iControllerCount; 

	TFileName iFileNameSecondary;	// for converting

	TFileName iFileName;

	TBool iUseFileHandle;

	TBool iOwnFileHandle;

	HBufC* iUniqueId; 

	RFile iFileHandle;

	ContentAccess::TIntent iIntent;

	HBufC* iUrl;

	HBufC8* iMimeType;

	TPtr8 iDescriptor;

	TInt iIapId;

	TUid iFormatUid;

	TUid iFormatUidSecondary;	// for converting

	TUid iMediaId;

	TMMFPrioritySettings iPrioritySettings;

	CMMFPluginSelectionParameters::TMediaIdMatchType iMediaIdMatchType;

	RMMFControllerImplInfoArray iControllers;

	RMMFControllerImplInfoArray iPrioritisedControllers;

	// if this is non-null, then it points to an element in

	// either iControllers or iPrioritisedControllers

	CMMFControllerImplementationInformation* iControllerImplInfo;	// not owned

	TControllerMode iControllerMode;

	TBool iSourceSinkConfigured;

	TInt iError;

	TMMFMessageDestination iSourceHandle;

	TMMFMessageDestination iSinkHandle;

	TBool iEnableUi;

	TBool iUseSharedHeap; // should new controllers use shared heaps?

	TBool iStopTryLoadController; //stop to try loading the selected conrollers from the list

	RMMFVideoSetInitScreenCustomCommands* iVideoSetInitScreenCustomCommands;

	TInt iScreenNumber;

	TBool iHasDrmCapability;

	TBool iUsingSecureDrmProcess;	

#ifdef SYMBIAN_BUILD_GCE

	RMMFVideoPlaySurfaceSupportCustomCommands* iVideoPlaySurfaceSupportCustomCommands;

	TBool iUseVPU2;

	TInt iSurfaceSupported;

#endif	

	};

inline TInt CMMFFindAndOpenController::ControllerIndex() const

	{

	return iControllerIndex;

	}

inline TInt CMMFFindAndOpenController::ControllerCount() const

	{

	return iControllerCount;

	}

inline TBool CMMFFindAndOpenController::StopTryLoadController() const

	{

	return iStopTryLoadController;

	}

#ifdef SYMBIAN_BUILD_GCE

inline void CMMFFindAndOpenController::SetSurfaceMode(TBool aUseVPU2, RMMFVideoPlaySurfaceSupportCustomCommands* aVideoPlaySurfaceSupportCustomCommands)

	{

	iUseVPU2 = aUseVPU2;

	iSurfaceSupported = KErrNone;

	iVideoPlaySurfaceSupportCustomCommands = aVideoPlaySurfaceSupportCustomCommands;

	}

inline TInt CMMFFindAndOpenController::SurfaceSupported()

	{

	return iSurfaceSupported;

	}

#endif	// SYMBIAN_BUILD_GCE

#endif // __MMF_CLIENT_UTILITY_H__