// 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:

 //

 #ifndef __MMFCONTROLLER_H__

 #define __MMFCONTROLLER_H__

 #include <mmf/server/mmfdatasource.h>

 #include <mmf/server/mmfdatasink.h>

 #include <mmf/common/mmfcontrollerframework.h>

 #include <mmf/common/mmfcontrollerpluginresolver.h>

 #include <mmf/plugin/mmfplugininterfaceuids.hrh>

 #include <caf/caf.h>

 /**

 @publishedAll

 @released

 Error category denoting a general controller error.

 @see TMMFEvent

 @since 7.0s

 */

 const TUid KMMFErrorCategoryControllerGeneralError = {0x101F76D3};

 /**

 @publishedAll

 @released

 Error category denoting playback complete i.e. due to EOF or error condition

 @see TMMFEvent

 @since 7.0s

 */

 const TUid KMMFEventCategoryPlaybackComplete = {0x101f7ea0};

 /**

 @publishedAll

 @released

 Client representation of a controller plugin for the Multimedia Framework.

 This class allows a client to load a controller plugin into a new thread and access the

 functionality provided by that plugin.

 @since 7.0s

 */

 class RMMFController

 	{

 public:

 	IMPORT_C RMMFController();

 	IMPORT_C TInt Open(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings);

 	IMPORT_C TInt Open(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings);

 	IMPORT_C TInt Open(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap );

 	IMPORT_C TInt Open(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap );

 	IMPORT_C TInt OpenInSecureDRMProcess(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings);

 	IMPORT_C TInt OpenInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings);

 	IMPORT_C TInt OpenInSecureDRMProcess(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap );

 	IMPORT_C TInt OpenInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap );

 	IMPORT_C void Close();

 	IMPORT_C TInt SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings) const;

 	IMPORT_C TInt AddDataSource(TUid aSourceUid, const TDesC8& aSourceInitData);

 	IMPORT_C TInt AddDataSink(TUid aSinkUid, const TDesC8& aSinkInitData);

 	IMPORT_C TInt AddDataSource(TUid aSourceUid, const TDesC8& aSourceInitData, TMMFMessageDestination& aHandleInfo);

 	IMPORT_C TInt AddDataSink(TUid aSinkUid, const TDesC8& aSinkInitData, TMMFMessageDestination& aHandleInfo);

 	IMPORT_C void AddDataSource(const TMMFUidPckg& aSourceUid, const TDesC8& aSourceInitData, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void AddFileHandleDataSource(const RFile& aFile, const TDesC8& aSourceInitData, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void AddFileHandleDataSource(const RFile& aFile, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void CancelAddDataSource();

 	IMPORT_C void AddDataSink(const TMMFUidPckg& aSinkUid, const TDesC8& aSinkInitData, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void AddFileHandleDataSink(const RFile& aFile, const TDesC8& aSinkInitData, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void AddFileHandleDataSink(const RFile& aFile, TMMFMessageDestinationPckg& aHandleInfoPckg, TRequestStatus& aStatus);

 	IMPORT_C void CancelAddDataSink();

 	IMPORT_C TInt RemoveDataSource(const TMMFMessageDestination& aSourceHandleInfo);

 	IMPORT_C TInt RemoveDataSink(const TMMFMessageDestination& aSinkHandleInfo);

 	IMPORT_C TInt Reset();

 	IMPORT_C TInt Prime();

 	IMPORT_C TInt Play();

 	IMPORT_C TInt Pause();

 	IMPORT_C TInt Stop();

 	IMPORT_C TInt GetPosition(TTimeIntervalMicroSeconds& aPosition) const;

 	IMPORT_C TInt SetPosition(const TTimeIntervalMicroSeconds& aPosition) const;

 	IMPORT_C TInt GetDuration(TTimeIntervalMicroSeconds& aDuration) const;

 	IMPORT_C TInt GetNumberOfMetaDataEntries(TInt& aNumberOfEntries) const;

 	IMPORT_C CMMFMetaDataEntry* GetMetaDataEntryL(TInt aIndex) const;

 	IMPORT_C TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom);

 	IMPORT_C TInt CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2);

 	IMPORT_C void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus);

 	IMPORT_C void CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus);

 	IMPORT_C void ReceiveEvents(TMMFEventPckg& aEventPckg, TRequestStatus& aStatus);

 	IMPORT_C TInt CancelReceiveEvents();

 	IMPORT_C TInt SetThreadPriority(const TThreadPriority& aPriority) const;

 private:

 	/**

 	The controller proxy.  Used to pass messages to the controller thread.

 	*/

 	RMMFControllerProxy iControllerProxy;

 	/**

 	Used to hold the destination information for messages for the standard controller plugin interface.

 	*/

 	TMMFMessageDestinationPckg iDestinationPckg;

 	};

 /**

 @publishedAll

 @released

 Defines an object to which a client may have a direct handle.

 This class provides a way of identifying objects within the controller framework, and a means

 of passing commands to those objects.

 @since  7.0s

 */

 class CMMFObject : public CBase

 	{

 friend class CMMFObjectContainer;//to set the handle

 public:

 	IMPORT_C ~CMMFObject();

 	IMPORT_C CMMFObject(TUid aInterfaceId);

 	IMPORT_C const TMMFMessageDestination& Handle();

 	IMPORT_C TBool operator==(const CMMFObject& aOther);

 	/**

 	Passes a message to the object to handle.

 	This is a pure virtual method to be implemented by concrete classes derived from this class.

 	The message passed in MUST be completed by the object; however, it can be copied to be

 	completed at a later time, should some other asynchronous action need to occur first.

 	@param  aMessage

 	        The message to be handled.  This MUST be completed by the object.

 	@since  7.0s

 	*/

 	virtual void HandleRequest(TMMFMessage& aMessage) = 0;

 private:

 	void SetHandle(const TMMFMessageDestination& aNewHandle);

 private:

 	TMMFMessageDestination iHandle;

 	};

 /**

 @publishedAll

 @released

 Container class to hold the CMMFObject-derived objects in the controller framework.

 @since 7.0s

 */

 class CMMFObjectContainer : public CBase

 	{

 public:

 	IMPORT_C CMMFObjectContainer();

 	IMPORT_C ~CMMFObjectContainer();

 	IMPORT_C TInt AddMMFObject(CMMFObject& aObject);

 	IMPORT_C void RemoveAndDestroyMMFObject(CMMFObject& aObject);

 	IMPORT_C TInt FindMMFObject(const TMMFMessageDestination& aObjectHandle, CMMFObject*& aObjectFound);

 	IMPORT_C void DeleteAllObjects();

 	const RPointerArray<CMMFObject>& MMFObjects();

 private:

 	/**

 	Internal method to find an object in the array.

 	*/

 	TInt FindMMFObject(const CMMFObject& aObject, TInt& aPositionInArray);

 	/**

 	Internal method used to generate the object handle for a newly added object.

 	*/

 	TInt GenerateObjectHandle();

 private:

 	/**

 	The array of objects.

 	*/

 	RPointerArray<CMMFObject> iObjects;

 	/**

 	The next available object handle.

 	*/

 	TInt iNextObjectHandle;

 	};

 /**

 @publishedAll

 @released

 CMMFObject-derived class to wrap a Data Source.

 Allows a handle to be attributed to a data source, so it can be removed from the controller and

 the client can send messages directly to it.

 @since 7.0s

 */

 class CMMFDataSourceHolder : public CMMFObject

 	{

 public:

 	IMPORT_C CMMFDataSourceHolder(MDataSource& aDataSource);

 	IMPORT_C ~CMMFDataSourceHolder();

 	IMPORT_C MDataSource& DataSource();

 	//from CMMFObject

 	IMPORT_C void HandleRequest(TMMFMessage& aMessage);

 private:

 	/**

 	Pointer to the data source owned by this object.

 	*/

 	MDataSource* iDataSource;

 	};

 /**

 @publishedAll

 @released

 CMMFObject-derived class to wrap a Data Sink.

 Allows a handle to be attributed to a data sink, so it can be removed from the controller and

 the client can send messages directly to it.

 @since 7.0s

 */

 class CMMFDataSinkHolder : public CMMFObject

 	{

 public:

 	IMPORT_C CMMFDataSinkHolder(MDataSink& aDataSink);

 	IMPORT_C ~CMMFDataSinkHolder();

 	IMPORT_C MDataSink& DataSink();

 	//from CMMFObject

 	IMPORT_C void HandleRequest(TMMFMessage& aMessage);

 private:

 	/**

 	Pointer to the data sink owned by this object.

 	*/

 	MDataSink* iDataSink;

 	};

 /**

 @publishedAll

 @released

 Base class for client-side custom command classes.

 In order facilitate the use of the more common custom commands, it is desirable to write

 a concrete API class for the client to use.  This API class can then be use to wrap all the code

 involved to formulate the custom command messages.

 @since 7.0s

 */

 class RMMFCustomCommandsBase

 	{

 public:

 	IMPORT_C RMMFCustomCommandsBase(RMMFController& aController, TUid aInterfaceId);

 protected:

 	/**

 	The controller.

 	Derived classes should use iController.CustomCommandSync() and

 	iController.CustomCommandAsync() to send the custom commands to the controller

 	plugin.

 	*/

 	RMMFController& iController;

 	/**

 	The destination package.

 	Derived classes must pass this into iController.CustomCommandSync() and

 	iController.CustomCommandAsync() as the destination argument.

 	*/

 	TMMFMessageDestinationPckg iDestinationPckg;

 	};

 /**

 @publishedAll

 @released

 Base class to define the interface of a custom command parser.

 In order to facilitate the support of common custom commands by controller plugins, a

 custom command parser object can be used.  A set of custom command parsers are created

 by the controller plugin (one for each interface supported), and added to the custom command

 parser manager in the controller framework.  The controller plugin must also derive from a set of

 concrete interfaces (provided in the form of mixin classes). Then, a custom command supported by

 one of the custom command parsers will appear to the controller as a concrete API call, rather than

 a call to its own custom command API.

 @since 7.0s

 */

 class CMMFCustomCommandParserBase : public CBase

 	{

 public:

 	/**

 	Pure virtual method to be implemented by derived classes.

 	Derived classes must implement the code to decode the message from the client.

 	@param  aMessage

 	        The message to be serviced. This message must be completed by the derived class.

 	@since 7.0s

 	*/

 	virtual void HandleRequest(TMMFMessage& aMessage) = 0;

 	/**

 	Returns the UID of the custom command interface provided by this parser.

 	@return The interface UID.

 	@since  7.0s

 	*/

 	IMPORT_C TUid InterfaceId();

 	/**

 	Destructor.

 	@since 7.0s

 	*/

 	IMPORT_C ~CMMFCustomCommandParserBase();

 protected:

 	/**

 	Constructor.

 	@param  aInterfaceId

 	        The uid of the custom command interface provided by this parser.

 	        This must be the same as the interface id of the corresponding client

 	        API class. See RMMFCustomCommandsBase.

 	@since  7.0s

 	*/

 	IMPORT_C CMMFCustomCommandParserBase(TUid aInterfaceId);

 private:

 	/**

 	The uid of the custom command interface provided by this parser.

 	*/

 	TUid iInterfaceId;

 	};

 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

 #include <mmf/common/mmfcontrollerextendeddata.h>

 #include <mmf/common/mmfcustomcommandparsermanager.h>

 #endif

 class CMMFControllerExtendedData;

 class CMMFCustomCommandParserManager;

 /**

 @publishedAll

 @released

 Base class for controller plugins.

 A controller plugin for the multimedia framework must derive from this class and implement

 all the pure virtual functions.

 Controller plugins control the flow of multimedia data from one or more sources to one or

 more sinks. For example, an audio controller plugin might take data from a file source and

 output it to a speaker sink, or take data from a microphone source and save it to a file

 sink. A controller plugin typically supports one or more multimedia formats, for example

 WAV or MPEG4.

 @since 7.0s

 */

 class CMMFController : public CBase

 	{

 public:

 	/**

 	Allocates and constructs a new controller plugin.

 	Uses ECOM to instantiate a new controller plugin. Can leave with any of the system-wide error codes.

 	@param  aControllerUid

 	        The unique ID of the controller to be instantiated from ECOM.

 	@param  aEventHandler

 	        A reference to an event handling object that can be used by the

 	        controller to send events back to the client.

 	@param 	aClientTid

 			The thread Id of the client thread

 	@return A pointer to the new controller plugin.

 	@since	7.0s

 	*/

 	static CMMFController* NewL(TUid aControllerUid, MAsyncEventHandler& aEventHandler, TThreadId aClientTid);

 	/**

 	Handles a message from the client.

 	Decodes the message and calls one of the private DoXxx methods to unpackaged the parameters.

 	@param  aMessage

 	        The message to be handled.

 	@since  7.0s

 	*/

 	IMPORT_C virtual void HandleRequestL(TMMFMessage& aMessage);

 	/**

 	Default destructor.

 	*/

 	IMPORT_C virtual ~CMMFController();

 protected:

 	/**

 	Constructor.

 	*/

 	CMMFController() {};

 	// virtual functions to be implemented by controller plugin

 	/**

 	Add a data source to the controller plugin.

 	NOTE: The data source is owned by the controller framework, NOT by the controller plugin.

 	Under no circumstances should the controller plugin delete the data source.

 	@param  aDataSource

 	        A reference to the data source to be added.  The controller plugin

 	        may call aDataSource.DataSourceType() to find out

 	        exactly what type of source it is.

 	@leave  KErrNotSupported

 	        If the controller plugin does not support the data source, it should leave with this.

 	@since  7.0s

 	*/

 	virtual void AddDataSourceL(MDataSource& aDataSource) = 0;

 	/**

 	Adds a data sink to the controller plugin.

 	NOTE: The data sink is owned by the controller framework, NOT by the controller plugin.

 	Under no circumstances should the controller plugin delete the data sink.

 	@param  aDataSink

 	        A reference to the data sink to be added.  The controller plugin

 	        may call aDatasink.DatasinkType() to find out

             exactly what type of sink it is.

 	@leave  KErrNotSupported

 	        If the controller plugin does not support the data sink, it should leave with this.

 	@since 7.0s

 	*/

 	virtual void AddDataSinkL(MDataSink& aDataSink) = 0;

 	/**

 	Removes a data source from the controller plugin.

 	Note:

 	The data source is owned by the controller framework, NOT by the controller plugin.

 	Under no circumstances should the controller plugin delete the data source.

 	@param  aDataSource

 	        A reference to the data source to be removed.

 	@leave  KErrNotSupported

 	        The controller plugin may leave during this method.  If the controller plugin does

 	        not support the removal of data sources, it should leave with

 	        KErrNotSupported. If the controller plugin leaves, the data source will

 	        not be destroyed by the controller framework.  If it does not leave, the data source

 	        will be destroyed.

 	@since 7.0s

 	*/

 	virtual void RemoveDataSourceL(MDataSource& aDataSource) = 0;

 	/**

 	Removes a data sink from the controller plugin.

 	Note:

 	The data sink is owned by the controller framework, NOT by the controller plugin.

 	Under no circumstances should the controller plugin delete the data sink.

 	@param  aDataSink

 	        A reference to the data sink to be removed.

 	@leave  KErrNotSupported

 	        The controller plugin may leave during this method.  If the controller plugin does

 	        not support the removal of data sinks, it should leave with

 	        KErrNotSupported. If the controller plugin leaves, the data sink will

 	        not be destroyed by the controller framework.  If it does not leave, the data sink

 	        will be destroyed.

 	@since  7.0s

 	*/

 	virtual void RemoveDataSinkL(MDataSink& aDataSink) = 0;

 	/**

 	Resets the controller plugin.

 	The controller should revert back to its newly constructed state. If the Reset is successful

 	(i.e. it doesn't leave), the controller framework will delete all objects added to the

 	MMFObjectManager including any sources and sinks.

 	@leave  KErrNotSupported

 	        If the controller plugin does not support being reset, it should leave with KErrNotSupported.

 	@since  7.0s

 	*/

 	virtual void ResetL() = 0;

 	/**

 	Primes the controller plugin.

 	The controller must prepare to start playing, by initialising its sources, sinks and buffers.

 	This moves the controller from the STOPPED to the PRIMED state.

 	@since  7.0s

 	*/

 	virtual void PrimeL() = 0;

 	/**

 	A partner to the PrimeL() method that is overridable to allow Asynchronous

 	completion in the controller whilst maintaining a Synchronous client API.

 	The default implementation of this is to call PrimeL() and complete the message with KErrNone.

 	@since  7.0s

 	*/

 	IMPORT_C virtual void PrimeL(TMMFMessage& aMessage);

 	/**

 	Commences playback.

 	The controller must now begin transferring data from its source(s) to its sink(s).

 	This moves the controller from the PRIMED to the PLAYING state.

 	Note:

 	This method must return once playing has commenced, and not wait until playing is complete.

 	@since  7.0s

 	*/

 	virtual void PlayL()= 0;

 	/**

 	A partner to the PlayL() method that is overridable to allow Asynchronous

 	completion in the controller whilst maintaining a Synchronous client API.

 	The default implementation of this is to call PlayL() and complete the message with KErrNone.

 	@since  7.0s

 	*/

 	IMPORT_C virtual void PlayL(TMMFMessage& aMessage);

 	/**

 	Pauses the controller plugin.

 	The controller must now cease transferring data from its source(s) to its sink(s).

 	This moves the controller from the PLAYING back to the PRIMED state.

 	A subsequent call to Play() will cause the controller plugin to resume playback

 	from the point it was paused (unless there has been a call to SetPosition() in

 	the meantime.

 	@since  7.0s

 	*/

 	virtual void PauseL()= 0;

 	/**

 	A partner to the PauseL() method that is overridable to allow Asynchronous

 	completion in the controller whilst maintaining a Synchronous client API.

 	The default implementation of this is to call PauseL() and complete the message with KErrNone.

 	@since  7.0s

 	*/

 	IMPORT_C virtual void PauseL(TMMFMessage& aMessage);

 	/**

 	Stops the controller plugin.

 	The controller must now undo anything that occurred during the call to Prime().

 	This moves the controller from the PRIMED back to the STOPPED state.

 	@since  7.0s

 	*/

 	virtual void StopL()= 0;

 	/**

 	A partner to the StopL() method that is overridable to allow Asynchronous

 	completion in the controller whilst maintaining a Synchronous client API.

 	The default implementation of this is to call StopL() and complete the message with KErrNone.

 	@since  7.0s

 	*/

 	IMPORT_C virtual void StopL(TMMFMessage& aMessage);

 	/**

 	Gets the current position.

 	The controller plugin should calculate the current position in microseconds.

 	@return The current position in microseconds.

 	@since  7.0s

 	*/

 	virtual TTimeIntervalMicroSeconds PositionL() const = 0;

 	/**

 	Sets the current position.

 	The controller plugin should reposition itself to the position provided.

 	@param  aPosition

 	        The desired position in microseconds.

 	@since  7.0s

 	*/

 	virtual void SetPositionL(const TTimeIntervalMicroSeconds& aPosition) = 0;

 	/**

 	Gets the duration of the clip.

 	The controller plugin should calculate the clip duration in microseconds.

 	@return The clips duration in microseconds.

 	@since  7.0s

 	*/

 	virtual TTimeIntervalMicroSeconds DurationL() const = 0;

 	/**

 	Sets the priority settings.

 	The new priority settings must be applied to any resource being used by the controller

 	plugin that requires priority settings (for example the sound device).

 	@param  aPrioritySettings

 	        The new priority settings

 	@since  7.0s

 	*/

 	virtual void SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings) = 0;

 	/**

 	Handles a custom command.

 	Custom commands allow a controller plugin to define its own API.  If the controller framework

 	does not understand a message from the client, it is assumed this is a custom command for the

 	plugin and passed into this interface.

 	The more common custom commands can be handled by Custom Command Parsers on behalf of the

 	controller plugin.  This allows the controller plugin to implement a concrete interface

 	(defined by mixin classes) rather than having to decode the command itself.  For more

 	information, see CMMFCustomCommandParserBase.

 	The controller plugin must always complete the message passed into this method,

 	even if it does not support the interface required by the message.

 	@param  aMessage

 	        The message to be handled by the controller plugin.

     @see    CMMFCustomCommandParserBase.

 	@since 7.0s

 	*/

 	virtual void CustomCommand(TMMFMessage& aMessage)

 		{aMessage.Complete(KErrNotSupported);};//default implementation

 	/**

 	RetrieveS the number of meta data entries in the clip.

 	@param  aNumberOfEntries

 	        The controller plugin must set this to the number of meta data entries

 	        in the clip.

 	@since  7.0s

 	*/

 	virtual void GetNumberOfMetaDataEntriesL(TInt& aNumberOfEntries) = 0;

 	/**

 	Retrieves a meta data entry from the clip.

 	@param  aIndex

 	        The index of the meta data entry to retrieve.

 	@return A pointer to a newly created CMMFMetaDataEntry object containing the meta information.

 	        The controller framework will take ownership of the object when this method returns.

 	@since  7.0s

 	*/

 	virtual CMMFMetaDataEntry* GetMetaDataEntryL(TInt aIndex) = 0;

 	// Utility functions to be used by controller plugins

 	/**

 	Sends an event to the client.

 	The controller plugin can use this method to send an event to the client.

 	@param  aEvent

 	        The event to be sent to the client.

 	@return One of the system-wide error codes.

 	@since 7.0s

 	*/

 	IMPORT_C TInt DoSendEventToClient(const TMMFEvent& aEvent);

 	/**

 	Gets a reference to the multimedia framework object container.

 	The controller plugin may add CMMFObject-derived objects to the container to allow them

 	to receive messages directly from the client.

 	@return A reference to the MMFObjectContainer.

 	@since  7.0s

 	*/

 	IMPORT_C CMMFObjectContainer& MMFObjectContainerL();

 	/**

 	Adds a custom command parser to the controller framework.

 	If the controller framework receives a request it does not understand, it will

 	search through its list of custom command parsers before passing the request

 	on to the controller plugin as a custom command.

 	By using the custom command parsers, the controller plugin can implement a concrete

 	API rather than having to decode the common custom commands itself.

 	@param  aParser

 	        The parser to be added to the controller framework. The controller framework

 	        takes ownership of the parser if the call does not leave.

 	@since  7.0s

 	*/

 	IMPORT_C void AddCustomCommandParserL(CMMFCustomCommandParserBase& aParser);

 	/**

 	Retrieves the client thread Id of this controller.

 	@return Thread Id of the controller's client

 	*/

 	IMPORT_C TThreadId ClientThreadIdL();

 	/**

 	Check the Secure DRM Mode of current controller object

 	@return ETrue if the controller is running under Secure DRM mode; otherwise EFalse.

 	*/

 	IMPORT_C TBool IsSecureDrmModeL();

 private:

 	/**

 	This is internal and not intended for use.

 	*/

 	void ConstructL(MAsyncEventHandler& aEventHandler, TThreadId aClientTid);

 	// IPC decode functions

 	TBool DoAddDataSourceL(TMMFMessage& aMessage);

 	TBool DoAddDataSinkL(TMMFMessage& aMessage);

 	TBool DoAddFileHandleDataSourceL(TMMFMessage& aMessage);

 	TBool DoAddFileHandleDataSinkL(TMMFMessage& aMessage);

 	TBool DoRemoveDataSourceL(TMMFMessage& aMessage);

 	TBool DoRemoveDataSinkL(TMMFMessage& aMessage);

 	TBool DoResetL(TMMFMessage& aMessage);

 	TBool DoPrimeL(TMMFMessage& aMessage);

 	TBool DoPlayL(TMMFMessage& aMessage);

 	TBool DoPauseL(TMMFMessage& aMessage);

 	TBool DoStopL(TMMFMessage& aMessage);

 	TBool DoGetPositionL(TMMFMessage& aMessage);

 	TBool DoSetPositionL(TMMFMessage& aMessage);

 	TBool DoGetDurationL(TMMFMessage& aMessage);

 	TBool DoSetPrioritySettingsL(TMMFMessage& aMessage);

 	void DoCustomCommand(TMMFMessage& aMessage);

 	TBool DoGetNumberOfMetaDataEntriesL(TMMFMessage& aMessage);

 	TBool DoGetSizeOfMetaDataEntryL(TMMFMessage& aMessage);

 	TBool DoGetMetaDataEntryL(TMMFMessage& aMessage);

 	TBool DoPreloadSourceSinkInitDataL(TMMFMessage& aMessage);

 	TBool DoAddFileHandleDataSourceWithInitDataL(TMMFMessage& aMessage);

 	TBool DoAddFileHandleDataSinkWithInitDataL(TMMFMessage& aMessage);

 	void ReplaceFileHandleInInitDataL(RFile* aFile, TDes8& aInitData);

 	// Ownership of aSource is taken into this function

 	void AddMDataSourceAndRepondClientL(MDataSource* aSource, TMMFMessage& aMessage);

 	// Ownership of aSink is taken into this function

 	void AddMDataSinkAndRepondClientL(MDataSink* aSink, TMMFMessage& aMessage);

 	CMMFControllerExtendedData* GetExtendedDataL();

 	static CMMFControllerExtendedData* CreateExtendedDataL(TThreadId aClientTid);

 private:

 	/**

 	Buffer to assist copy of meta data over the thread boundary.

 	*/

 	CBufFlat* iMetaDataBuffer;

 	/**

 	Required by ECOM.

 	*/

 	TUid iDtor_ID_Key;

 	/**

 	The event handler for the controller plugin.

 	*/

 	MAsyncEventHandler* iAsyncEventHandler;

 	/**

 	The MMF object container.

 	*/

 	CMMFObjectContainer* iMMFObjectContainer;

 	/**

 	The custom command parser manager.

 	*/

 	CMMFCustomCommandParserManager* iCustomCommandParserManager;

 	};

 /**

 @publishedAll

 @released

 Mixin class that the user of the class CMMFControllerEventMonitor must derive from.

 @since  7.0s

 */

 class MMMFControllerEventMonitorObserver

 	{

 public:

 	/**

 	Handles an event that has been generated.

 	@param  aEvent

 	        The event to be handled.

 	@since  7.0s

 	*/

 	virtual void HandleEvent(const TMMFEvent& aEvent) = 0;

 	};

 /**

 @publishedAll

 @released

 Active object utility class that can be used to monitor a controller plugin for events.

 If an event occurs, the client will be notified via the MMMFControllerEventMonitorObserver interface.

 @since 7.0s

 */

 class CMMFControllerEventMonitor : public CActive

 	{

 public:

 	/**

 	Constructs a controller event monitor object.

 	@param  aObserver

 	        A reference to the observer of the active object.  The observer will be

 	        notified when an event occurs.

 	@param  aMMFController

 	        A reference to the client controller interface class.

 	@return A pointer to the new event monitor.

 	@since  7.0s

 	*/

 	IMPORT_C static CMMFControllerEventMonitor* NewL(MMMFControllerEventMonitorObserver& aObserver,

 		RMMFController& aMMFController);

 	/**

 	Destructor.

 	*/

 	~CMMFControllerEventMonitor();

 	/**

 	Tells the controller event monitor to start listening for events.

 	The controller plugin must have been opened before this method is called.

 	@since  7.0s

 	*/

 	IMPORT_C void Start();

 private:

 	/**

 	Calls HandleEvent on iObserver.

 	This will not leave.

 	@since  7.0s

 	*/

 	void RunL();

 	/**

 	Cancels the outstanding request on iMMFController.

 	@since  7.0s

 	*/

 	void DoCancel();

 	/**

 	Constructs a controller event monitor object.

 	@param  aObserver

 	        A reference to the observer of the active object.  The observer will be

 	        notified when an event occurs.

 	@param  aMMFController

 	        A reference to the client controller interface class.

 	@since  7.0s

 	*/

 	CMMFControllerEventMonitor(MMMFControllerEventMonitorObserver& aObserver,

 		RMMFController& aMMFController);

 private:

 	MMMFControllerEventMonitorObserver& iObserver;

 	RMMFController& iMMFController;

 	TMMFEventPckg iEventPckg;

 	};

 /**

 Mixin class that the user of the class CMMFAddDataSourceSinkAsync must derive from.

 @since 8.0

 @publishedAll

 @released

 */

 class MMMFAddDataSourceSinkAsyncObserver

 	{

 public:

 /**

 The request to add a data source or sink has completed.

 @param	"aError"		"The error resulting from adding the source/sink."

 @param  "aHandleInfo"	"This object identifies	the data source/sink inside the controller 

 						framework.  This allows the client to send custom commands directly to 

 						the data source/sink, and to also remove the data sink from the controller.

 						Note that not all data sinks support custom commands, and not all

 						controller plugins support the removal of a data sink."

 */

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

 	};

 /**

 Active object utility class that can be used to add a data source or data sink to a controller

 plugin asynchronously.  Once the command has been completed, the caller will be notified via the

 MMMFAddDataSourceSinkAsyncObserver interface.

 @since 8.0

 @publishedAll

 @released

 */

 class CMMFAddDataSourceSinkAsync : public CActive

 	{

 public:

 	IMPORT_C static CMMFAddDataSourceSinkAsync* NewL(MMMFAddDataSourceSinkAsyncObserver& aObs);

     IMPORT_C void AddDataSource(RMMFController& aController, TUid aSourceUid, const TDesC8& aSourceInitData);

 	IMPORT_C void AddFileHandleDataSource(RMMFController& aController, const RFile& aFile);

 	IMPORT_C void AddFileHandleDataSource(RMMFController& aController, const RFile& aFile, const TDesC8& aSourceInitData);

     IMPORT_C void AddDataSink(RMMFController& aController, TUid aSinkUid, const TDesC8& aSinkInitData);

 	IMPORT_C void AddFileHandleDataSink(RMMFController& aController, const RFile& aFile);

 	IMPORT_C void AddFileHandleDataSink(RMMFController& aController, const RFile& aFile, const TDesC8& aSinkInitData);

 	~CMMFAddDataSourceSinkAsync();

 private:

 	void RunL();

 	void DoCancel();

 	CMMFAddDataSourceSinkAsync(MMMFAddDataSourceSinkAsyncObserver& aObserver);

 private:

 	enum TCurrentAction {EIdle, EAddingDataSource, EAddingDataSink};

 private:

 	MMMFAddDataSourceSinkAsyncObserver& iObserver;

 	TMMFMessageDestinationPckg iHandleInfoPckg;

 	TCurrentAction iCurrentAction;

 	RMMFController* iMMFController;

 	HBufC8* iSourceSinkInitData;

 	TMMFUidPckg iSourceSinkUidPckg;

 	};

 #endif