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

//

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

/**

@internalComponent

*/

const TUid KUidInterfaceMMFDataSinkHolder = {0x101F76D4};

/**

@internalComponent

*/

const TUid KUidInterfaceMMFDataSourceHolder = {0x101F76D5};

/**

@internalComponent

*/

const TUid KUidMMFControllerExtendedDataHolder = {0x102834AC};

/**

@internalComponent

Create a const TUid with the same values as the controller

ECOM plugin interface UID

*/

const TUid KUidInterfaceMMFController = {KMmfUidPluginInterfaceController};

/**

@internalComponent

IPC messages for interface KUidInterfaceMMFController in the controller framework.

*/

enum TMMFControllerMessages

	{

	EMMFControllerAddDataSource,

	EMMFControllerAddDataSink,

	EMMFControllerRemoveDataSource,

	EMMFControllerRemoveDataSink,

	EMMFControllerReset,

	EMMFControllerPrime,

	EMMFControllerPlay,

	EMMFControllerPause,

	EMMFControllerStop,

	EMMFControllerGetPosition,

	EMMFControllerSetPosition,

	EMMFControllerGetDuration,

	EMMFControllerGetNumberOfMetaDataEntries,

	EMMFControllerGetSizeOfMetaDataEntry,//use internally

	EMMFControllerGetMetaDataEntry,

	EMMFControllerSetPrioritySettings,

	EMMFControllerCancelAddDataSource,

	EMMFControllerCancelAddDataSink,

	EMMFControllerAddFileHandleDataSource,

	EMMFControllerAddFileHandleDataSink,

	EMMFControllerSourceSinkInitDataPreload,

	EMMFControllerAddFileHandleDataSourceWithInitData,

	EMMFControllerAddFileHandleDataSinkWithInitData

	};

/**

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

	};

/**

@publishedPartner

@released

Class to manage custom command parsers.

An object of this type is owned by the controller framework to contain all the custom command

parsers for the controller plugin.

@since 7.0s

*/

class CMMFCustomCommandParserManager : public CBase

	{

public:

	/**

	Factory constructor.

	@return A pointer to the newly created object.

	@since 7.0s

	*/

	IMPORT_C static CMMFCustomCommandParserManager* NewL();