// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// mmf\common\mmfcontrollerpluginresolver.h
// 
//

#ifndef MMF_COMMON_MMFCONTROLLERPLUGINRESOLVER_H
#define MMF_COMMON_MMFCONTROLLERPLUGINRESOLVER_H

#include <ecom/ecom.h>
#include <e32base.h>
#include <apmstd.h>

/**
@publishedAll
@released

Default heap size for the controller thread
*/
const TUint KMMFDefaultControllerThreadHeapSize = 0x100000; //1MB


class CMMFFormatImplementationInformation;

/**
@publishedAll
@released

Array of CMMFFormatImplementationInformation 
*/
typedef RPointerArray<CMMFFormatImplementationInformation> RMMFFormatImplInfoArray;

class CMMFControllerImplementationInformation;

/**
@publishedAll
@released

Array of CMMFControllerImplementationInformation 
*/
typedef RPointerArray<CMMFControllerImplementationInformation> RMMFControllerImplInfoArray;

/**
@internalComponent

Interface to be implemented by customers of the class TaggedDataParser.
*/
class MTaggedDataParserClient
	{
public:
	virtual void ProcessTaggedDataL(const TDesC8& aTag, const TDesC8& aData) = 0;
	};

/**
@internalComponent

Utility class used to parse data separated by xml-style tags.
*/
class TaggedDataParser
	{
public:

	/**
	Splits aData into xml-style tags and values, and gets aClient to process each tag/value pair.
	*/
	static void ParseTaggedDataL(const TDesC8& aData, MTaggedDataParserClient& aClient);

	/**
	Converts a string to a uid. If the string begin with "0x" it will be parsed as Hex, else Decimal.
	*/
	static void ConvertTextToUidL(const TDesC8& aData, TUid& aUid);

	/**
	Converts a string to a TUint. The string must begin with "0x" and be 10 characters long,
	otherwise it is considered corrupt.
	*/
	static void ConvertTextToTUintL(const TDesC8& aData, TUint& aUid);

	};

class CMatchData;

class CDesC8Array;

/**
@publishedAll

Abstract class that contains basic information about ECom Multimedia plugins.

@released
@since 7.0s
*/
class CMMFPluginImplementationInformation : public CBase
	{
public:

	/**
	Returns the uid of this particular plugin implementation.
	This is the UID used to instantiate this multimedia plugin.

	@return The implementation uid.

	@since  7.0s
	*/
	IMPORT_C TUid Uid() const;

	/**
	Returns the display name of this plugin implementation.

	@return The display name.

	@since  7.0s
	*/
	IMPORT_C const TDesC& DisplayName() const;

	/**
	Returns the name of the supplier of this plugin implementation, e.g. "Symbian".

	@return The plugin supplier.

	@since  7.0s
	*/
	IMPORT_C const TDesC& Supplier() const;

	/**
	Returns the version number of this plugin.

	@return The version number.

	@since 7.0s
	*/
	IMPORT_C TInt Version() const;

	/**
	Returns the array of media IDs supported by this plugin.
	
	The media ID can be used by clients to determine whether the plugin supports audio or
	video data (or both). A UID is used for the media ID to provide future extensibility.

	@return The array of media IDs.

	@since  7.0s
	*/
	IMPORT_C const RArray<TUid>& SupportedMediaIds() const;

	/**
	Tests whether this plugin was supplied by aSupplier.

	@param  aSupplier
	        The required supplier.

	@return A boolean indicating if this plugin was supplied by aSupplier. ETrue if this plugin was supplied 
	        by aSupplier, EFalse if not.

	@since 7.0s
	*/
	IMPORT_C TBool SupportsSupplier(const TDesC& aSupplier) const;

	/**
	Tests whether this plugin supports aMediaId.

	@param  aMediaId
	        The required media id.

	@return A boolean indicating if the plugin supports aMediaId. ETrue if this plugin supports aMediaId, EFalse if not.

	@since 7.0s
	*/
	IMPORT_C TBool SupportsMediaId(TUid aMediaId) const;

	/**
	Destructor.
	*/
	virtual ~CMMFPluginImplementationInformation();

protected:

	/**
	Constructor.
	*/
	CMMFPluginImplementationInformation();

	/** 
	Sets the supplier. Takes a copy of aData.
	*/
	void SetSupplierL(const TDesC8& aData);

	/**
	Adds a media id. aData is parsed to find the uid of the media id to be added.
	*/
	void AddMediaIdL(const TDesC8& aData);
	
protected:

	/** 
	The UID of this plugin. 
	*/
	TUid iUid;

	/** 
	The display name of this plugin. 
	*/
	HBufC* iDisplayName;

	/** 
	The supplier of this plugin. 
	*/
	HBufC* iSupplier;

	/** 
	The version number of this plugin. 
	*/
	TInt iVersion;

	/**
	The media ids supported by this plugin.
	*/
	RArray<TUid> iMediaIds;
	};

/**
@publishedAll
@released

Contains format support information retrieved from the ECom registry.

An object of this type may describe either a concrete format plugin (ie a CMMFFormatEncode or a
CMMFFormatDecode implementation) or a format supported by a controller plugin.

The object is created using a CImplementationInformation object retrieved from the ECom registry.
All relevant data is copied out of the CImplementationInformation object, and its opaque data is
parsed to provide the supplier, supported media ids, supported mime types, supported file extensions,
and supported header data matches.

Notes for Format Plugin developers:
@code
The opaque data section of the ECom plugin resource file must be in the format:

opaque_data = "<?>Data 1<?>Data 2<?>Data 3<?>Data 4[...]<?>Data N";

The <?> preceding the data determines the meaning of the data.  The following are the possible tags:

	<s> - Supplier
	<i> - Media Id
	<m> - Mime Type
	<e> - File Extension
	<h> - Header Data
	<c> - Custom Interfaces

UIDs must always be in hex in the format '0x12345678', must include the '0x' and be 10 characters long
@endcode

@since 7.0s
*/
class CMMFFormatImplementationInformation : public CMMFPluginImplementationInformation, MTaggedDataParserClient
	{
public:
	/**
	Constructs a new format implementation information object.

	@param  aImplInfo
	        The ECOM implementation information

	@return The new object created.

	@since 7.0s
	*/
	static CMMFFormatImplementationInformation* NewL(const CImplementationInformation& aImplInfo);

	/**
	Constructs a new format implementation information object.

	@param  aImplInfo
	        The ECOM implementation information

	@return The new object created. Note that this will be on the cleanup stack.

	@since  7.0s
	*/
	static CMMFFormatImplementationInformation* NewLC(const CImplementationInformation& aImplInfo);

	/** 
	Destructor 
	*/
	virtual ~CMMFFormatImplementationInformation();

	/**
	Returns the array of supported file extensions.

	@return The array of file extensions.
	@since  7.0s
	*/
	IMPORT_C const CDesC8Array& SupportedFileExtensions() const;

	/**
	Returns the array of supported mime types.

	@return The array of mime types.

	@since  7.0s
	*/
	IMPORT_C const CDesC8Array& SupportedMimeTypes() const;

	/**
	Returns the array of supported header data matches.

	@return The array of header data.
	@since 7.0s
	*/
	IMPORT_C const CDesC8Array& SupportedHeaderData() const;

	/**
	Tests whether this format provides support for the specified file extension, aFileExtension.

	@param  aFileExtension
	        The requested file extension. Must be the extension only, and contain the dot '.'

	@return A boolean indicating if the specified file extension is supported. ETrue if this format provides 
	        the required support, EFalse if it does not.

	@since  7.0s
	*/
	IMPORT_C TBool SupportsFileExtension(const TDesC8& aFileExtension) const;

	/**
	Tests whether this format provides support for aMimeType.

	@param  aMimeType
	        The requested mime type.

	@return A boolean indicating if the format is supported. ETrue if this format provides the required support, EFalse if not.

	@since 7.0s
	*/
	IMPORT_C TBool SupportsMimeType(const TDesC8& aMimeType) const;

	/**
	Tests whether this format provides support for aHeaderData.
	aHeaderData is searched for each chunk supported by this format.

	@param	aHeaderData
	        The requested header data.
	        
	@return A boolean indicating if aHeaderData is supported. ETrue if this format provides the required support, EFalse if not.

	@since  7.0s
	*/
	IMPORT_C TBool SupportsHeaderDataL(const TDesC8& aHeaderData) const;

	/**
	Tests whether this format provides support for Custom Interfaces.
        
	@return A boolean indicating if Custom Interfaces are supported. ETrue if this format provides the required support, EFalse if not.
	*/
	IMPORT_C TBool SupportsCustomInterfaces() const;

protected:

	/** 
	Constructor 
	*/
	CMMFFormatImplementationInformation();

	/** 
	2nd phase constructor 
	*/
	void ConstructL(const CImplementationInformation& aImplInfo);

	/** 
	Adds a file extension to the array of extensions supported by this format. 
	*/
	void AddFileExtensionL(const TDesC8& aData);

	/**
	Adds a mime type to the array of types supported by this format.
	*/
	void AddMimeTypeL(const TDesC8& aData);

	/** 
	Adds a chunk of header data to the array of chunks supported by this format.
	*/
	void AddHeaderDataL(const TDesC8& aData);

	/** 
	from MTaggedDataParserClient 
	*/
	void ProcessTaggedDataL(const TDesC8& aTag, const TDesC8& aData);

private:
	class CBody;
	/** 
	CMMFFormatImplementationInformation body
	*/
	CBody* iBody;
	};


/**
@publishedAll
@released

Contains controller plugin information retrieved from the ECom registry.

The object is created using a CImplementationInformation object retrieved from the ECom registry.
All relevant data is copied out of the CImplementationInformation object, and its opaque data is
parsed to provide the supplier, supported media IDs.

Notes for Format Plugin developers:
The exact formats supported by the controller plugin are calculated by:

1. The formats supported by the controller plugin itself must be declared in separate entries in the
controller plugin resource file.  Two interface UIDs should be defined by the plugin writer - one
for the play formats supported, the other for the record formats supported.  The play formats are
then listed as implementations of the play format interface uid, and likewise the record formats.

2. Format plugins (CMMFFormatEncode and CMMFFormatDecode) declare which controller plugin they
extend.  ECom is search for the format plugins that extend the controller plugin, and they
are added to the list.

The opaque data section of the ECom plugin resource file must be in the format:
@code

opaque_data = "<?>Data 1<?>Data 2<?>Data 3<?>Data 4[...]<?>Data N";

The <?> preceding the data determines the meaning of the data.  The following are the possible tags:

	<s> - Supplier - must be only one
	<i> - Media Id
	<p> - UID of play format 'interface' - must be only one
	<r> - UID of record format 'interface' - must be only one

UIDs must always be in hex in the format '0x12345678', must include the '0x' and be 10 characters long.
@endcode

@since 7.0s
*/
class CMMFControllerImplementationInformation : public CMMFPluginImplementationInformation, MTaggedDataParserClient
	{
public:

	/**
	Constructs a new controller implementation information object.

	@param  aImplInfo
	        The ECOM implementation information.

	@return The new object created.
	
	@internalTechnology

	@since  7.0s
	*/
	static CMMFControllerImplementationInformation* NewL(const CImplementationInformation& aImplInfo);

	/**
	Constructs a new controller implementation information object.

	Note: 
	The new object will be on the cleanup stack.

	@param  aImplInfo
	        The ECOM implementation information

	@return The new object created.
	
	@internalTechnology

	@since  7.0s
	*/
	static CMMFControllerImplementationInformation* NewLC(const CImplementationInformation& aImplInfo);

	/**
	Constructs a new controller implementation information object.

	@param  aUid
	        The Uid of the controller to obtain controller implementation information

	@return The new object created.

	@since  7.0s
	*/
	IMPORT_C static CMMFControllerImplementationInformation* NewL(TUid aUid);

	/**
	Destructor.
	
	@internalTechnology
	*/
	~CMMFControllerImplementationInformation();

	/**
	Returns the array of play formats supported by this controller.

	@return The play formats supported.

	@since  7.0s
	*/
	IMPORT_C const RMMFFormatImplInfoArray& PlayFormats() const;

	/**
	Returns the array of record formats supported by this controller.

	@return The record formats supported.

	@since  7.0s
	*/
	IMPORT_C const RMMFFormatImplInfoArray& RecordFormats() const;

	/**
	Returns the heap space required by this controller.

	@return The heap space required.

	@since  7.0s
	*/
	IMPORT_C TUint HeapSpaceRequired() const;
	
	/**
	Queries the ECom registry for the play formats supported. 
	
	@internalTechnology
	*/
	void GetPlayFormatsL();

	/** 
	Queries the ECom registry for the record formats supported.
	
	@internalTechnology
	*/
	void GetRecordFormatsL();
	
	/**
	Returns the uri schemes of this plugin.

	@return The array of uri schemes.

	@internalTechnology
	*/
	IMPORT_C const CDesC8Array& SupportedUriSchemes() const;
	
	/**
	Tests whether the plugin supports aUriScheme.
	
	@param  aUriScheme
	        The required Uri Scheme.

	@return A boolean indicating if the plugin supports aUriScheme. ETrue if this plugin supports aUriScheme, EFalse if not.

	@internalTechnology
	*/
	IMPORT_C TBool SupportsUriScheme(const TDesC8& aUriScheme) const;
	
	/**
	Tests whether the controller plugin supports url
		
	@return A boolean indicating if the plugin supports url. ETrue for uri supporting controller, EFalse if not.
	
	@internalTechnology
	*/
	IMPORT_C TBool SupportsNetworkCapability() const;
	
	/**
	Sets the uri priority of this controller
	
	@param  aUriPriority
	        The Uri priority to be assigned.
	        
	@internalTechnology
	*/
	IMPORT_C void SetUriPriority(TInt aUriPriority);
	
	/**
	Retrieves the uri priority of this controller. 
	Higher priority implies greater number. ie UriPriority() returning 3 
	has higher prioirty than UriPriority() returning 1.
	
	@return  The assigned Uri priority.
	
	@internalTechnology
	*/
	IMPORT_C TInt UriPriority() const;
	
	/**
	Check whether the controller plugin supports secure DRM process mode
		
	@return A boolean indicating if the plugin supports secure DRM process mode. 
	ETrue for secure DRM process mode supporting controller, EFalse if not.
	
	@internalTechnology
	*/
	IMPORT_C TBool SupportsSecureDRMProcessMode() const;
	
protected:

	/**
	Constructor.
	
	@internalTechnology
	*/
	CMMFControllerImplementationInformation();

	/**
	2nd phase constructor.
	
	@internalTechnology
	*/
	void ConstructL(const CImplementationInformation& aImplInfo);

	/**
	Parses aData to get the collection UID of the play formats supported by this controller.
	
	@internalTechnology
	*/
	void SetPlayFormatCollectionUidL(const TDesC8& aData);

	/**
	Parses aData to get the collection UID of the record formats supported by this controller.
	
	@internalTechnology
	*/
	void SetRecordFormatCollectionUidL(const TDesC8& aData);

	/**
	Parses aData to get the size of the stack the controller requires.
	
	@internalTechnology
	*/
	void SetHeapSizeL(const TDesC8& aData);

	/**
	From MTaggedDataParserClient.
	*/
	void ProcessTaggedDataL(const TDesC8& aTag, const TDesC8& aData);

	/**
	Queries the ECom registry for:
		- all registry entries with an interface UID of aFormatCollectionUid
		- all format plugins with an interface UID of aFormatPluginCollectionUid (ie CMMFFormatEncode
		  or CMMFFormatDecode) that have the UID of this controller plugin in the default_data field
		  of their ECom resource file.

	CMMFFormatImplementationInformation objects are created for each entry returned, and appended to
	aFormatArray.

	@param  aFormatCollectionUid
	        See above.
	@param  aFormatPluginCollectionUid
	        See above.
	@param  aFormatArray
	        See above.
	        
	@internalTechnology

	@since  7.0s
	*/
	void GetFormatsL(TUid aFormatCollectionUid, TUid aFormatPluginCollectionUid, RMMFFormatImplInfoArray& aFormatArray);

	/**
	Creates CMMFFormatImplementationInformation objects for all CImplementationInformation objects
	in aEcomArray.  Any corrupt objects are ignored.  The objects created are added to aFormatArray.

	@param  aEcomArray
	        See above.
	@param  aFormatArray
	        See above.
	        
	@internalTechnology

	@since  7.0s
	*/
	void AddFormatsSwallowCorruptL(RImplInfoPtrArray& aEcomArray, RMMFFormatImplInfoArray& aFormatArray);
	
	/**
	Sets the Uri Scheme found in opaque data
	
	@param  aUriScheme
			Gives the uri scheme supported by the controller
	
	@internalTechnology
	*/
	void SetUriSchemeL(const TDesC8& aUriScheme);
	
	/**
	Sets the Network capability found in opaque data
	
	@param  aNetworkCapable
			Declares the incapability to support uri if matches to 'yes'. 
			If this is the case, iIsNetworkCtrl is set to EFalse
	
	@internalTechnology
	*/
	void SetNetworkCapabilityL(const TDesC8& aNetworkCapable);

private:

	/**
	The play formats supported by this controller.
	*/
	RMMFFormatImplInfoArray iPlayFormats;

	/**
	The record formats supported by this controller.
	*/
	RMMFFormatImplInfoArray iRecordFormats;

	/**
	The interface uid of the resource file definitions of the play formats supported directly by this controller.
	*/
	TUid iPlayFormatCollectionUid;

	/**
	The interface uid of the resource file definitions of the record formats supported directly by this controller.
	*/
	TUid iRecordFormatCollectionUid;
	
	/**
	The heap space required by this controller
	*/
	TUint iHeapSpaceRequired;
	
	/**
	The Uri scheme supported by this plugin
	*/
	CDesC8Array* iUriSchemes;
	
	/**
	The uri priority acquired by this controller
	*/
	TInt iUriPriority;  
	
	/**
	The uri support provided by this controller
	*/
	TBool iIsNetworkCtrl;
	
	/**
	Secure DRM process model supported by this controller
	*/
	TBool  iSupportsSecureDRMProcessMode;
	};


/**
@publishedAll

Contains the parameters used to select mmf plugins from the ECOM registry.

@released
@since 7.0s
*/
class CMMFPluginSelectionParameters : public CBase
	{
public:

/**
Describes the type of preferred supplier match to be performed on the plugins return from
the ECOM registry.
*/
enum TPreferredSupplierMatchType
	{

	/**	No preferred supplier match will be performed.
	*/
	ENoPreferredSupplierMatch,

	/** Plugins from all suppliers will be returned, but those from the preferred supplier will be first in the list.
	*/
	EPreferredSupplierPluginsFirstInList,

	/** Only plugins from the preferred supplier will be returned.
	*/
	EOnlyPreferredSupplierPluginsReturned
	};
/**
Describes the type of media ID match to be performed on the plugins return from
the ECOM registry.
*/
enum TMediaIdMatchType
	{

	/** No media ID match will be performed.
	*/
	ENoMediaIdMatch,

	/** All plugins that support the media ID supplied will be returned, even those that support
	other media IDs.  For example, if an audio plugin is requested, plugins that support
	audio and video will also be returned.
	*/
	EAllowOtherMediaIds,

	/** Only plugins that support the exact media IDs supplied will be returned.  For example, if an
	audio plugin is requested, plugins that only support audio will be returned
	(ie. no audio/video plugins).
	*/
	EAllowOnlySuppliedMediaIds
	};

public:

	/**
	Destructor.  Resets and destroys all member data.

	@since 7.0s
	*/
	virtual ~CMMFPluginSelectionParameters();


	/**
	Sets the preferred supplier of the plugin.

	@param  aPreferredSupplier
	        The preferred supplier of the plugin.
	@param  aMatchType
	        The type of match to be made.

	@since  7.0s
	*/
	IMPORT_C void SetPreferredSupplierL(const TDesC& aPreferredSupplier, TPreferredSupplierMatchType aMatchType);

	/**
	Sets the media IDs that must be supported by the plugin, for example audio, video etc.

	@param  aMediaIds
	        An array of the media IDs that the selected plugins must support.
	@param  aMatchType
	        The type of match to be made.

	@since  7.0s
	*/
	IMPORT_C void SetMediaIdsL(const RArray<TUid>& aMediaIds, TMediaIdMatchType aMatchType);

	/**
	Returns the preferred supplier.  If no preferred supplier has been set, a blank 
	string will be returned.
	
	@return The preferred supplier
	@since 7.0s
	*/
	IMPORT_C const TDesC& PreferredSupplier() const;

	/**
	Returns the type of preferred supplier match to perform.

	@return The preferred supplier match type.
	@since 7.0s
	*/
	IMPORT_C TPreferredSupplierMatchType PreferredSupplierMatchType() const;

	/**
	Returns the list of media IDs that must be supported by the plugin.

	@return The list of media IDs.

	@since	7.0s
	*/
	IMPORT_C const RArray<TUid>& MediaIds() const;

	/**
	Returns the type of preferred supplier match to perform.
	
	@return The preferred supplier match type.

	@since 7.0s
	*/
	IMPORT_C TMediaIdMatchType MediaIdMatchType() const;

	/**
	Returns the uid of the interface to be searched for plugin matches.

	@return The interface uid.

	@since 7.0s
	*/
	IMPORT_C TUid InterfaceUid() const;

protected:

	/**
	Protected constructor.

	Defaults to setting the TPreferredSupplierMatchType enum to ENoPreferredSupplierMatch and TMediaIdMatchType
	to ENoMediaIdMatch.

	@param  aPluginInterfaceUid
	        The plugin's interface UID.
	*/
	CMMFPluginSelectionParameters(TUid aPluginInterfaceUid);

	/**
	Tests whether the specified media is supported by the plugin.

	@param  aPlugin
	        The media to test.

	@return A boolean indicating if the specified media is supported by the plugin. ETrue if the specified 
	        media is supported by the plugin. EFalse if the specified media is not supported by the plugin.
	*/
	TBool CheckMediaIdSupportL(const CMMFPluginImplementationInformation& aPlugin) const;
private:
	TUid iPluginInterfaceUid;
	HBufC* iPreferredSupplier;
	TPreferredSupplierMatchType iPreferredSupplierMatchType;
	RArray<TUid> iMediaIds;
	TMediaIdMatchType iMediaIdMatchType;
	};

/**
@publishedAll

Defines the format support required.

On construction, the selection parameters are blank, causing all plugins to be returned.

@released
@since 7.0s
*/
class CMMFFormatSelectionParameters : public CBase
	{
public:
/**
Describes the type of match to be performed.
The match types are mutually exclusive.
*/
enum TMatchDataType
	{

	/** All plugins will be selected. This is the default option.
	*/
	EMatchAny,

	/** The match will be based on a file extension.
	*/
	EMatchFileExtension,

	/** The match will be based on a mime type.
	*/
	EMatchMimeType,

	/** The match will be based on a header data.
	*/
	EMatchHeaderData,
	
	/** 
	@publishedPartner
	@prototype
	
	The match will be based on Uri details.
	*/
	EMatchUri
	};

public:
	
	/**
	Allocates and constructs a new format selection parameter object with blank parameters.

	Calls NewLC().

	@return A new format selection parameter object.
	*/
	IMPORT_C static CMMFFormatSelectionParameters* NewL();

	/**
    Allocates and constructs a new format selection parameter object with blank parameters, placing it on the 
	cleanup stack.

	@return A new format selection parameter object.
	*/
	IMPORT_C static CMMFFormatSelectionParameters* NewLC();

	/**
	Allocates and constructs a new format selection parameter object with the specified parameters.

	@param  aParams
	        The required parameters.
	@return A new format selection parameter object.
	*/
	static CMMFFormatSelectionParameters* NewL(const CMMFFormatSelectionParameters& aParams);

	/**
	Sets this object to match to a file extension.

	aFileName can be a full filename or just an extension.  If there is no dot in the filename
	and it is 5 characters or less in length then it is assumed to be an extension.  If the first
	character of the filename is a dot, it assumed to be an extension.  Otherwise, the filename
	is parsed using TParse to reveal the extension.

	Once the extension has been extracted, it is converted from unicode to utf8 and copied into
	iMatchData.

	@param  aFileName
	        The file name to be matched.  Must include the extension.

	@since  7.0s
	*/
	IMPORT_C void SetMatchToFileNameL(const TDesC& aFileName);

	/**
	Sets this object to match to a file extension specified by a URI

	Once the extension has been extracted, it is copied into iMatchData.

   	@param  aUri
	        The URI containing the file name to be matched.  Must include the extension.

	@since  7.0s
	*/
	IMPORT_C void SetMatchToUriL(const TDesC& aUri);
	
	/**
	@publishedPartner
	@prototype
	
	Sets this object to match to uri scheme and file extension specified by a URI.
	
	The Uri scheme and extension are saved in iMatchReqData. Further,iMatchData contains uri extension, 
	iMatchUriScheme contains uri scheme.

	@param  aUri
	        The URI containing the scheme and uri extension to be matched. 

	*/
	IMPORT_C void SetMatchToUriSupportL(const TDesC& aUri);
	
	/**
	Sets this object to match to a MIME type.
	
	@param  aMimeType
	        The mime type to match.

	@since  7.0s
	*/
	IMPORT_C void SetMatchToMimeTypeL(const TDesC8& aMimeType);

	/**
	Sets this object to match to a pattern in header data.
	
	@param  aHeaderData
	        The header of the file in question.  This header data will be matched
	        against the match patterns provided by the plugins.

	@since  7.0s
	*/
	IMPORT_C void SetMatchToHeaderDataL(const TDesC8& aHeaderData);

	/**
	Returns the data used to perform the plugin match.
	
	@return The match data.

	@since  7.0s
	*/
	IMPORT_C const TDesC8& MatchData() const;
	
	/**
	@publishedPartner
	@prototype
	
	Returns the uri scheme used to perform the plugin match.
	
	@return The uri scheme.

	*/
	IMPORT_C const TDesC8& MatchUriScheme() const;

	/**
	Returns the type of the data used to perform the plugin match.

	@return The match data type.

	@since  7.0s
	*/
	IMPORT_C TMatchDataType MatchDataType() const;
	
	/**
	Destructor.
	*/
	virtual ~CMMFFormatSelectionParameters();
protected:

	/**
	Protected constructor.
	*/
	CMMFFormatSelectionParameters();
	void ConstructL(const CMMFFormatSelectionParameters& aParams);

private:
	CMatchData* iMatchReqData;
	TMatchDataType iMatchDataType;
	};



/**
@publishedAll
@released

Contains the parameters used to select controller plugins from the ECOM registry.

@since  7.0s
*/
class CMMFControllerPluginSelectionParameters : public CMMFPluginSelectionParameters
	{
public:

	/**
	Constructs a new controller selection parameters object.

	@return The new object created.

	@since  7.0s
	*/
	IMPORT_C static CMMFControllerPluginSelectionParameters* NewL();

	/**
	Construct a new controller selection parameters object.
	
	@return The new object created.  Note that the new object will be left on the cleanup stack.

	@since  7.0s
	*/
	IMPORT_C static CMMFControllerPluginSelectionParameters* NewLC();

	/**
	Sets the play format support required.

	Note:
	The play formats supported by the controller plugins will only be retrieved if
	this method is called.  To get all the play formats supported by the system, call this
	with a 'blank' CMMFFormatSelectionParameters object.

	@param  aRequiredSupport
	        The play format support required.

	@since  7.0s
	*/
	IMPORT_C void SetRequiredPlayFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport);

	/**
	Sets the record format support required.

	Note:
	The record formats supported by the controller plugins will only be retrieved if
	this method is called.  To get all the record formats supported by the system, call this
	with a 'blank' CMMFFormatSelectionParameters object.

	@param  aRequiredSupport
	        The record format support required.

	@return The new object created.

	@since  7.0s
	*/
	IMPORT_C void SetRequiredRecordFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport);

	/**
	Retrieves all controller plugins that support the requirements of the caller.

	@param  aImplementations	
	        After this method returns, this array will contain all the
	        controller plugins that support the caller's requirements.
	        Note: The array will be emptied by this method.

	@since  7.0s
	*/
	IMPORT_C virtual void ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const;
	
	/** 
	Destructor
	*/
	virtual ~CMMFControllerPluginSelectionParameters();
protected:
	CMMFControllerPluginSelectionParameters();
	void MatchImplementationToSelectParamsL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin, TInt& aArrayPos) const;
	TInt CheckPreferredSupplierL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin) const;
	TBool CheckFormatSupportL(CMMFFormatSelectionParameters* aSelectParams, const RMMFFormatImplInfoArray& aFormats) const;
	/**
	Checks the given Controller for uri support. Uri support may be there 
	if either requiredscheme or extension matches with that given controller
	
	@param  aSelectParams 
			Describes the selection parameter which a controller needs to 
			support in order to be selected
			
	@param	aPlugin
			The controller plugin which is checked for uri support 
			
	@param	aFormats
			The play or record formats looked for extension match
	*/
	TBool CheckUriSupport(CMMFFormatSelectionParameters* aSelectParams, CMMFControllerImplementationInformation* aPlugin, const RMMFFormatImplInfoArray& aFormats) const;

protected:
	/**
	The required play format support
	*/
	CMMFFormatSelectionParameters* iRequiredPlayFormatSupport;
	
	/**
	The required record format support
	*/
	CMMFFormatSelectionParameters* iRequiredRecordFormatSupport;
	};

/**
@publishedAll
@released

Contains the parameters used to select controller plugins which support SecureDRM model 
from the ECOM registry. Controller plugins which support SecureDRM model allow play back of DRM-protected
content by client processes without DRM capability. In such case the controller will be loaded in a separate secure DRM process.
*/
class CMMFControllerSecureDrmPluginSelectionParameters : public CMMFControllerPluginSelectionParameters
	{

public:
	/**
	Constructs a new controller selection parameters object.

	@return The new object created.
	*/
	IMPORT_C static CMMFControllerSecureDrmPluginSelectionParameters* NewL();

	/**
	Construct a new controller selection parameters object.
	
	@return The new object created.  Note that the new object will be left on the cleanup stack.
	*/
	IMPORT_C static CMMFControllerSecureDrmPluginSelectionParameters* NewLC();
	
	/**
	Retrieves all controller plugins that support SecureDRM model and the requirements of the caller.

	@param  aImplementations	
	        After this method returns, this array will contain all the
	        controller plugins that support the caller's requirements.
	        Note: The array will be emptied by this method and SecureDRM model.
	*/
	IMPORT_C virtual void ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const;

	/** 
	Destructor
	*/
	virtual ~CMMFControllerSecureDrmPluginSelectionParameters() {};
protected:
	CMMFControllerSecureDrmPluginSelectionParameters();
	};

class CMmfRecognizerUtil; // declared here.
/**
@internalAll

MMF utility class used by MMF recognizer
Maintains an array of CMMFControllerImplementationInformation objects
so that data headers can be speedily matched against.
Updates the array when notified by ECOM of a change to the global
interface implementation registration data.
*/
NONSHARABLE_CLASS( CMmfRecognizerUtil ): public CBase
	{
public:
	enum TMatchLevel
		{
		EMatchNone, //no match
		EMatchData, //data match only
		EMatchName  //suffix and data match
		};
public:
	IMPORT_C static void GetMimeTypesL(CDesC8Array* aMimeTypes);

	IMPORT_C static CMmfRecognizerUtil* NewL();

	~CMmfRecognizerUtil();
	IMPORT_C TMatchLevel GetMimeTypeL(const TDesC& aFileName, const TDesC8& aImageData, TDes8& aMimeType);

private:
	CMmfRecognizerUtil();
	void ConstructL();

private:
	class CBody;
	CBody* iBody;
	};


/**
@publishedAll
@released

Abstract class used to contain the parameters used to select format plugins from the ECOM registry.

Note: 
The classes CMMFFormatEncodePluginSelectionParamters and CMMFFormatDecodePluginSelectionParameters
should be used to list and select format plugin implementations.

@since  7.0s
*/
class CMMFFormatPluginSelectionParameters : public CMMFPluginSelectionParameters
	{
public:

	/**
	Retrieves all format plugins that support the requirements of the caller.

	@param  aImplementations
	        After this function returns, this array will contain all the
	        format plugins that support the caller's requirements.
	        Note: The array will be emptied by this method.

	@since  7.0s
	*/
	IMPORT_C void ListImplementationsL(RMMFFormatImplInfoArray& aImplementations) const;

	/**
	Sets the format support required.

	@param  aRequiredSupport
	        The format support required.

	@since  7.0s
	*/
	IMPORT_C void SetRequiredFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport);

	/**
	Destructor.
	*/
	virtual ~CMMFFormatPluginSelectionParameters();
protected:
	/**
	Protected constructor.
	*/
	CMMFFormatPluginSelectionParameters(TUid aInterfaceUid);

	void MatchImplementationToSelectParamsL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin, TInt& aArrayPos) const;
	TInt CheckPreferredSupplierL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin) const;
	TBool CheckFormatSupportL(const CMMFFormatImplementationInformation& aPlugin) const;
protected:
	/**
	The format support required
	*/
	CMMFFormatSelectionParameters* iRequiredFormatSupport;
	};

/**
@publishedAll
@released

Class used to list and select plugins implementing the CMMFFormatEncode interface.

@since 7.0s
*/
class CMMFFormatEncodePluginSelectionParameters : public CMMFFormatPluginSelectionParameters
	{
public:

	/**
	Construct a new format encode selection parameters object.
	
	@return The new object created.

	@since  7.0s
	*/
	IMPORT_C static CMMFFormatEncodePluginSelectionParameters* NewL();

	/**
	Constructs a new format encode selection parameters object.

	@return The new object created.  Note that the new object will be left on the cleanup stack.

	@since  7.0s
	*/
	IMPORT_C static CMMFFormatEncodePluginSelectionParameters* NewLC();
protected:
	/**
	Protected constructor.
	*/
	CMMFFormatEncodePluginSelectionParameters();
	};


/**
@publishedAll
@released

Class used to list and select plugins implementing the CMMFFormatDecode interface.

@since 7.0s
*/
class CMMFFormatDecodePluginSelectionParameters : public CMMFFormatPluginSelectionParameters
	{
public:

	/**
	Constructs a new format decode selection parameters object.

	@return The new object created.
	
	@since  7.0s
	*/
	IMPORT_C static CMMFFormatDecodePluginSelectionParameters* NewL();

	/**
	Constructs a new format decode selection parameters object.

	@return The new object created. Note that the new object will be left on the cleanup stack.

	@since  7.0s
	*/
	IMPORT_C static CMMFFormatDecodePluginSelectionParameters* NewLC();
protected:
	/**
	Protected constructor.
	*/
	CMMFFormatDecodePluginSelectionParameters();
	};



/** 
@publishedAll
@released

Template class CleanupResetAndDestroy to clean up the array
of implementation information from the cleanup stack.
*/

template <class T>
class CleanupResetAndDestroy
	{
public:
	/**
	Puts an item on the cleanup stack.

	@param  aRef 
	        The implementation information to be put on the cleanup stack.
	*/
	inline static void PushL(T& aRef);
private:
	static void ResetAndDestroy(TAny *aPtr);
	};
template <class T>
inline void CleanupResetAndDestroyPushL(T& aRef);
template <class T>
inline void CleanupResetAndDestroy<T>::PushL(T& aRef)
	{CleanupStack::PushL(TCleanupItem(&ResetAndDestroy,&aRef));}
template <class T>
void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)
	{(STATIC_CAST(T*,aPtr))->ResetAndDestroy();}
template <class T>
inline void CleanupResetAndDestroyPushL(T& aRef)
	{CleanupResetAndDestroy<T>::PushL(aRef);}


#endif
