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

//

#include "mmfcontroller.h"

#include "mmfcontrollerpluginresolver.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/mmfcontrollerextendeddata.h>

#include <mmf/common/mmfcustomcommandparsermanager.h>

#endif

/**

Constructor.

@since 7.0s

*/

EXPORT_C RMMFController::RMMFController() :

	iDestinationPckg(TMMFMessageDestination(KUidInterfaceMMFController, KMMFObjectHandleController))

	{

	}

/**

Loads a controller plugin by specifying the UID of the plugin to load.

Creates a new thread and loads the specified controller into the new thread.  Use the classes

CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters

to find the uid of the controller to load.

@param  aControllerUid

        The UID of the controller plugin to be loaded.

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@param	aUseSharedHeap

		If this value is EFalse each controller is created with its own heap. The alternative,

		if the value is ETrue, is that controllers share a special heap with other controllers

		created the same way. Each heap uses a chunk, so this avoids situations where the

		number of chunks per process is limited. The default behaviour is generally to be

		preferred, and should give lower overall memory usage. However, if many controllers are

		to be created for a particular thread, then ETrue should be provided to prevent running

		out of heaps or chunks.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see    CMMFControllerPluginSelectionParamters

@since  7.0s

*/

EXPORT_C TInt RMMFController::Open(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap)

	{

	// Load Controller

	TInt err = iControllerProxy.LoadController(aControllerUid, aUseSharedHeap);

	if (!err)

		{

		err = SetPrioritySettings(aPrioritySettings);

		}

	return err;

	}

/**

Loads a controller plugin by specifying a CMMFControllerImplementationInformation object.

CMMFControllerImplementationInformation is passed as a parameter to allow

the controller thread's heap size to be determined without a further query to ECOM.

The function creates a new thread and loads the specified controller into the new thread.  The classes

CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters are used

to find the UID of the controller to load.

@param  aControllerInfo

        A reference to a CMMFControllerImplementationInformation object

        used for determining the controller's UID & heap size

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@param	aUseSharedHeap

		If this value is EFalse each controller is created with its own heap. The alternative,

		if the value is ETrue, is that controllers share a special heap with other controllers

		created the same way. Each heap uses a chunk, so this avoids situations where the

		number of chunks per process is limited. The default behaviour is generally to be

		preferred, and should give lower overall memory usage. However, if many controllers are

		to be created for a particular thread, then ETrue should be provided to prevent running

		out of heaps or chunks.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see CMMFControllerPluginSelectionParamters

@since 7.0s

*/

EXPORT_C TInt RMMFController::Open(

	const CMMFControllerImplementationInformation& aControllerInfo,

	const TMMFPrioritySettings& aPrioritySettings,

	TBool aUseSharedHeap)

	{

	// Load Controller

	TInt err = iControllerProxy.LoadController(aControllerInfo, aUseSharedHeap);

	if (!err)

		err = SetPrioritySettings(aPrioritySettings);

	return err;

	}

/**

Loads a controller plugin by specifying the UID of the plugin to load.

Creates a new thread and loads the specified controller into the new thread.  Use the classes

CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters

to find the uid of the controller to load.

This version of Open() will give each controller its own heap which will consume one chunk. Use the

overloaded version of Open() to create controllers that share a single heap.

@param  aControllerUid

        The UID of the controller plugin to be loaded.

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see    CMMFControllerPluginSelectionParamters

@since  7.0s

*/

EXPORT_C TInt RMMFController::Open(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings)

	{

	// Load Controller

	return Open( aControllerUid, aPrioritySettings, EFalse ); // give controllers their own heaps

	}

/**

Loads a controller plugin by specifying a CMMFControllerImplementationInformation object.

CMMFControllerImplementationInformation is passed as a parameter to allow

the controller thread's heap size to be determined without a further query to ECOM.

The function creates a new thread and loads the specified controller into the new thread.  The classes

CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters are used

to find the UID of the controller to load.

This version of Open() will give each controller its own heap which will consume one chunk. Use the

overloaded version of Open() to create controllers that share a single heap.

@param  aControllerInfo

        A reference to a CMMFControllerImplementationInformation object

        used for determining the controller's UID & heap size

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see CMMFControllerPluginSelectionParamters

@since 7.0s

*/

EXPORT_C TInt RMMFController::Open(

		const CMMFControllerImplementationInformation& aControllerInfo,

		const TMMFPrioritySettings& aPrioritySettings)

	{

		// Load Controller

		return Open( aControllerInfo, aPrioritySettings, EFalse ); // give controllers their own heaps

	}

/**

Same as RMMFController::Open(TUid, const TMMFPrioritySettings&) which loads a controller plugin by 

specifying the UID of the plugin to load, except that this is expected to be called by user thread 

without DRM Capability.

Creates a new thread through DRM Plugin Server and loads the specified controller into the new thread.  

Use the classes CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters

to find the uid of the controller to load.

This version of Open() will give each controller its own heap which will consume one chunk. Use the

overloaded version of Open() to create controllers that share a single heap.

@param  aControllerUid

        The UID of the controller plugin to be loaded.

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see    CMMFControllerPluginSelectionParamters

*/

EXPORT_C TInt RMMFController::OpenInSecureDRMProcess(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings)

	{

	return OpenInSecureDRMProcess(aControllerUid, aPrioritySettings, EFalse);

	}

/**

Same as Open(const CMMFControllerImplementationInformation&, const TMMFPrioritySettings&) which loads a 

controller plugin by specifying a CMMFControllerImplementationInformation object.

CMMFControllerImplementationInformation is passed as a parameter to allow

the controller thread's heap size to be determined without a further query to ECOM.

The function creates a new thread through DRM Plugin server and loads the specified controller into 

the new thread.  The classes CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters are used

to find the UID of the controller to load.

This version of Open() will give each controller its own heap which will consume one chunk. Use the

overloaded version of Open() to create controllers that share a single heap.

@param  aControllerInfo

        A reference to a CMMFControllerImplementationInformation object

        used for determining the controller's UID & heap size

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see CMMFControllerPluginSelectionParamters

*/	

EXPORT_C TInt RMMFController::OpenInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings)

	{

	return OpenInSecureDRMProcess(aControllerInfo, aPrioritySettings, EFalse);

	}

/**

Same as RMMFController::Open(TUid, const TMMFPrioritySettings&, TBool) which loads a controller 

plugin by specifying the UID of the plugin to load, except that this is expected to be called by user thread 

without DRM Capability.

Creates a new thread through DRM Plugin server and loads the specified controller into the new thread.  

Use the classes CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters

to find the uid of the controller to load.

@param  aControllerUid

        The UID of the controller plugin to be loaded.

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@param	aUseSharedHeap

		If this value is EFalse each controller is created with its own heap. The alternative,

		if the value is ETrue, is that controllers share a special heap with other controllers

		created the same way. Each heap uses a chunk, so this avoids situations where the

		number of chunks per process is limited. The default behaviour is generally to be

		preferred, and should give lower overall memory usage. However, if many controllers are

		to be created for a particular thread, then ETrue should be provided to prevent running

		out of heaps or chunks.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see    CMMFControllerPluginSelectionParamters

*/

EXPORT_C TInt RMMFController::OpenInSecureDRMProcess(TUid aControllerUid, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap )

	{

	// Load Controller

	TInt err = iControllerProxy.LoadControllerInSecureDRMProcess(aControllerUid, aUseSharedHeap);

	if (!err)

		{

		err = SetPrioritySettings(aPrioritySettings);

		}

	return err;

	}

/**

Same as Open(const CMMFControllerImplementationInformation&, const TMMFPrioritySettings&, TBool) which 

loads a controller plugin by specifying a CMMFControllerImplementationInformation object.

CMMFControllerImplementationInformation is passed as a parameter to allow

the controller thread's heap size to be determined without a further query to ECOM.

The function creates a new thread through DRM Plugin Server and loads the specified controller into 

the new thread.  The classes CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParamters are used

to find the UID of the controller to load.

@param  aControllerInfo

        A reference to a CMMFControllerImplementationInformation object

        used for determining the controller's UID & heap size

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@param	aUseSharedHeap

		If this value is EFalse each controller is created with its own heap. The alternative,

		if the value is ETrue, is that controllers share a special heap with other controllers

		created the same way. Each heap uses a chunk, so this avoids situations where the

		number of chunks per process is limited. The default behaviour is generally to be

		preferred, and should give lower overall memory usage. However, if many controllers are

		to be created for a particular thread, then ETrue should be provided to prevent running

		out of heaps or chunks.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@see CMMFControllerPluginSelectionParamters

*/

EXPORT_C TInt RMMFController::OpenInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, const TMMFPrioritySettings& aPrioritySettings, TBool aUseSharedHeap )

	{

	// Load Controller

	TInt err = iControllerProxy.LoadControllerInSecureDRMProcess(aControllerInfo, aUseSharedHeap);

	if (!err)

		err = SetPrioritySettings(aPrioritySettings);

	return err;

	}

/**

Closes the controller plugin.

Calling this method will unload the controller plugin and close down the controller thread.

@since	7.0s

*/

EXPORT_C void RMMFController::Close()

	{

	iControllerProxy.Close();

	}

/**

Sets the priority settings for this controller.

@param  aPrioritySettings

        The priority settings for this plugin, used by the policy

        component to arbitrate between different controllers that are

        attempting to use the same hardware resource simultaneously.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@since	7.0s

*/

EXPORT_C TInt RMMFController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings) const

	{

	TMMFPrioritySettingsPckg pckg(aPrioritySettings);

	return iControllerProxy.SendSync(iDestinationPckg, 

									 EMMFControllerSetPrioritySettings, 

									 pckg, 

									 KNullDesC8);

	}

/**

Adds a data source to the controller.

A typical data source would be a file, descriptor, audio input (microphone) or camera.

A controller plugin may require multiple data sources to be added (for example a video

recorder controller would require two); the exact number is plugin-specific.

Data sources are plugins themselves, and are loaded by the controller framework

inside the controller thread.

@param  aSourceUid

        The uid of the data source to be added. For more information,

        see the documentation for the data source you wish to add.

@param  aSourceInitData

        The data used to initialise the data source.  The exact contents

        of this data are dependent on the type of data source. For more

        information, see the documentation for the data source you wish

        to add.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@since	7.0s

*/

EXPORT_C TInt RMMFController::AddDataSource(TUid aSourceUid, const TDesC8& aSourceInitData)

	{

	TMMFMessageDestination handleInfo;

	return AddDataSource(aSourceUid, aSourceInitData, handleInfo);

	}

/**

Adds a data sink to the controller.

A typical data sink would be a file, descriptor, audio output (speaker) or display.

A controller plugin may require multiple data sinks to be added (for example a video

playing controller would require two); the exact number is plugin-specific.

Data sinks are plugins themselves, and are loaded by the controller framework

inside the controller thread.

@param  aSinkUid

        The UID of the data sink to be added. For more information,

        see the documentation for the data sink you wish to add.

@param  aSinkInitData

        The data used to initialise the data sink.  The exact contents

        of this data are dependent on the type of data sink. For more

        information, see the documentation for the data sink you wish

        to add.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@since  7.0s

*/

EXPORT_C TInt RMMFController::AddDataSink(TUid aSinkUid, const TDesC8& aSinkInitData)

	{

	TMMFMessageDestination handleInfo;

	return AddDataSink(aSinkUid, aSinkInitData, handleInfo);

	}

/**

Adds a data source to the controller, and receive a handle to allow removal and direct

communication with that data source.

A typical data source would be a file, descriptor, audio input (microphone) or camera.

A controller plugin may require multiple data sources to be added (for example a video

recorder controller would require two); the exact number is plugin-specific.

Data sources are plugins themselves, and are loaded by the controller framework

inside the controller thread.

@param  aSourceUid

        The uid of the data source to be added. For more information,

        see the documentation for the data source you wish to add.

@param  aSourceInitData

        Data used to initialise the data source.  The exact contents

        of this data is dependent on the type of data source. For more

        information, see the documentation for the data source you wish

        to add.

@param  aHandleInfo

        This object is filled in by the controller framework, and identifies

        the data source inside the controller framework.  This allows

        the caller to send custom commands directly to the data source, and

        to also remove the data source from the controller.  Note that

        not all data sources support custom commands, and not all

        controller plugins support the removal of a data source.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise

        another of the system-wide error codes.

@since  7.0s

*/

EXPORT_C TInt RMMFController::AddDataSource(TUid aSourceUid, const TDesC8& aSourceInitData,

											TMMFMessageDestination& aHandleInfo)

	{

	TMMFMessageDestinationPckg pckg;

	TMMFUidPckg uidPckg(aSourceUid);

	TInt error = iControllerProxy.SendSync(iDestinationPckg,

										   EMMFControllerAddDataSource,

										   uidPckg,

										   aSourceInitData,

										   pckg);

	if (!error)

		{

		aHandleInfo = pckg();

		}

	return error;

	}

/**

Add a file handle data source, together with its source info, to the controller asynchronously, 

and receive a handle to allow removal and directcommunication with that data source.

Note: only one call to this method can be outstanding at any time.

The data source would be a file for this API.

A controller plugin may require multiple data sources to be added (for example a video

recorder controller would require two); the exact number is plugin-specific.

Data sources are plugins themselves, and are loaded by the controller framework

inside the controller thread.

@param "aFile"				"The shared session file handle source to be added."

@param "aSourceInitData"	"Data used to initialise the data source.  The reference must remain valid 

							until the command has been completed or cancelled. The exact contents

							of this data is dependent on the type of data source. For more

							information, see the documentation for the data source you wish

							to add."

@param "aHandleInfoPckg"	"This object is filled in by the controller framework, and identifies

							the data source inside the controller framework.  This allows

							the caller to send custom commands directly to the data source, and

							to also remove the data source from the controller.  Note that

							not all data sources support custom commands, and not all

							controller plugins support the removal of a data source."

@param "aStatus"			"TRequestStatus of the active object to be signalled on completion

							of this request."

@return An error code indicating if the function call was successful. 

		KErrBadHandle if the file handle is not shared through the call RFs::ShareProtected().

		KErrNone on success, otherwise another of the system-wide error codes.

*/

EXPORT_C void RMMFController::AddFileHandleDataSource(const RFile& aFile, const TDesC8& aSourceInitData, 

													  TMMFMessageDestinationPckg& aHandleInfoPckg, 

													  TRequestStatus& aStatus)

	{

	TInt error = iControllerProxy.SendSync(iDestinationPckg,

										   EMMFControllerSourceSinkInitDataPreload,

										   aSourceInitData,

										   KNullDesC8);

	TIpcArgs ipcArgs(&iDestinationPckg, NULL, NULL, &aHandleInfoPckg);

	if (error == KErrNone)

		{

		error = aFile.TransferToServer(ipcArgs, 1, 2);

		}

	if (error == KErrNone)

		{

		iControllerProxy.SendAsync(EMMFControllerAddFileHandleDataSourceWithInitData,

								   ipcArgs,

								   aStatus);

		}

	else

		{

		TRequestStatus* status = &aStatus;

		User::RequestComplete(status, error);

		}

	}

/**

Add a file handle data source to the controller asynchronously, and receive a handle to allow 

removal and directcommunication with that data source.

Note: only one call to this method can be outstanding at any time.