/*
* Copyright (c) 2004 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:  Progressive Download Utility  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/server/mmffile.h"
#include "mmf/server/mmfdes.h"
#include "mmf/common/mmfcontroller.h"

#include <f32file.h>
#include <caf/content.h>
#include <caf/data.h>


class CMMSourceSink; // declared here.

NONSHARABLE_CLASS( CMMSourceSink ): public CBase
	{
public:
	 static CMMSourceSink* NewL(TUid aUid, const TDesC8& aDescriptor);
	 static CMMSourceSink* NewLC(TUid aUid, const TDesC8& aDescriptor);

	virtual ~CMMSourceSink();
	virtual TUid SourceSinkUid() const;
	virtual const TDesC8& SourceSinkData() 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:
    static CMMFileSourceSink* NewL(TUid aUid, const RFile& aFile);
	 static CMMFileSourceSink* NewLC(TUid aUid, const RFile& aFile);

	 static CMMFileSourceSink* NewL(TUid aUid, const TMMSource& aMMSource);
	 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;

	 void EvaluateIntentL(ContentAccess::TIntent aIntent);
	virtual void EvaluateIntentL();

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:
	 static CMMFMdaObjectStateChangeObserverCallback* NewL(MMdaObjectStateChangeObserver& aCallback);
	virtual ~CMMFMdaObjectStateChangeObserverCallback();
	 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:
	 static TUid ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid);
	 static TUid ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid);
	 static TFourCC ConvertMdaCodecToFourCC(TMdaPackage& aCodec);
	 static TInt GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength);
	 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.

NONSHARABLE_CLASS( CMMFUtilityFileInfo ): public CBase
	{
public:

	static CMMFUtilityFileInfo* NewL(TMMSource& aSource);
	static CMMFUtilityFileInfo* NewLC(TMMSource& aSource);

	~CMMFUtilityFileInfo();

	TBool GetFileMimeTypeL(TDes8& aMimeType);
	void  GetFileHeaderDataL(TDes8& aHeaderData, TInt aMaxLength);
	TInt EvaluateIntent(ContentAccess::TIntent aIntent);

private:
	CMMFUtilityFileInfo();

	void ConstructL(const TMMSource& aSource);

private:
	ContentAccess::CData* iData;
	};

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:
		 TSourceSink(TUid aUid, const TDesC8& aData = KNullDesC8);
		 TSourceSink(TUid aUid, const RFile& aFile);

		TUid iUid;
		const TDesC8& iConfigData;
		TBool iUseFileHandle;
		RFile iFileHandle;
		};




public:
	 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);

	 void Configure(
		TUid aMediaId,
		TMMFPrioritySettings aPrioritySettings,
		CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType = CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

	 void ConfigureController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
	 void ConfigureSecondaryController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
	 void ConfigureSourceSink(
		TSourceSink aSource,
		TSourceSink aSink);
	 void ConfigureSecondarySourceSink(
		TSourceSink aSource,
		TSourceSink aSink);


	 void ConfigureSourceSink(
		const TMMSource& aSource,
		TSourceSink aSink);



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

	 void OpenByFilename(const TDesC& aFileName, const TDesC& aFileNameSecondary = KNullDesC);
	 void OpenByFileHandle(const RFile& aFile);


	 void OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary = KNullUid);
	 void OpenByDescriptor(const TDesC8& aDescriptor);
	 void OpenByUrl(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType);
	 void OpenByControllerUid(TUid aControllerUid, TUid aSecondaryControllerUid = KNullUid);
	 void ReOpen();
	 void Close();

	 static TMMFFileConfig GetConfigFile(const TDesC& aFileName);
	 static TMMFDescriptorConfig GetConfigDescriptor(const TDesC8& aDescriptor);
	 static TInt GetConfigUrl(CBufFlat*& aUrlCfgBuffer, const TDesC& aUrl, TInt aIapId);

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);
	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);


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 iUseFileSource;
	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;
	};

#endif