diff -r 000000000000 -r b8ed18f6c07b mmlibs/mmfw/src/ControllerFramework/mmfcontrollerclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmlibs/mmfw/src/ControllerFramework/mmfcontrollerclient.cpp Thu Oct 07 22:34:12 2010 +0100 @@ -0,0 +1,1621 @@ +// 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 +#include +#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. + +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 "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, + TMMFMessageDestinationPckg& aHandleInfo, TRequestStatus& aStatus) + { + TIpcArgs ipcArgs(&iDestinationPckg, NULL, NULL, &aHandleInfo); + TInt error = aFile.TransferToServer(ipcArgs, 1, 2); + + if (!error) + { + iControllerProxy.SendAsync(EMMFControllerAddFileHandleDataSource, + ipcArgs, + aStatus); + } + else + { + TRequestStatus* status = &aStatus; + User::RequestComplete(status, error); + } + + } + +/** +Adds a file handle data sink, together with its source info, to the controller, and receives +a handle to allow removal and direct communication with that data sink. + +Note: only one call to this method can be outstanding at any time. + +The data sink would be a file for this API. +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 aFile + The shared session file handle sink to be added. +@param aSinkInitData + 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. +@param aHandleInfo + This object is filled in by the controller framework, and identifies + the data sink inside the controller framework. This allows + the caller to send custom commands directly to the data 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. +@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::AddFileHandleDataSink(const RFile& aFile, const TDesC8& aSinkInitData, + TMMFMessageDestinationPckg& aHandleInfoPckg, + TRequestStatus& aStatus) + { + TInt error = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerSourceSinkInitDataPreload, + aSinkInitData, + KNullDesC8); + TIpcArgs ipcArgs(&iDestinationPckg, NULL, NULL, &aHandleInfoPckg); + if (!error) + { + error = aFile.TransferToServer(ipcArgs, 1, 2); + } + + if (!error) + { + iControllerProxy.SendAsync(EMMFControllerAddFileHandleDataSinkWithInitData, + ipcArgs, + aStatus); + } + else + { + TRequestStatus* status = &aStatus; + User::RequestComplete(status, error); + } + } + +/** +Adds a file handle data sink, together with its source info, to the controller, and receives +a handle to allow removal and direct communication with that data sink. + +Note: only one call to this method can be outstanding at any time. + +The data sink would be a file for this API. +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 aFile + The shared session file handle sink to be added. +@param aHandleInfo + This object is filled in by the controller framework, and identifies + the data sink inside the controller framework. This allows + the caller to send custom commands directly to the data 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. +@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::AddFileHandleDataSink(const RFile& aFile, + TMMFMessageDestinationPckg& aHandleInfo, TRequestStatus& aStatus) + { + TIpcArgs ipcArgs(&iDestinationPckg, NULL, NULL, &aHandleInfo); + TInt error = aFile.TransferToServer(ipcArgs, 1, 2); + + if (!error) + { + iControllerProxy.SendAsync(EMMFControllerAddFileHandleDataSink, + ipcArgs, + aStatus); + } + else + { + TRequestStatus* status = &aStatus; + User::RequestComplete(status, error); + } + + } + + +/** +Adds a data sink to the controller, and receives a handle to allow removal and direct +communication with that data sink. + +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 + 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. +@param aHandleInfo + This object is filled in by the controller framework, and identifies + the data sink inside the controller framework. This allows + the caller to send custom commands directly to the data 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. + +@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& aHandleInfo) + { + TMMFMessageDestinationPckg pckg; + TMMFUidPckg uidPckg(aSinkUid); + TInt error = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerAddDataSink, + uidPckg, + aSinkInitData, + pckg); + if (!error) + { + aHandleInfo = pckg(); + } + return error; + } + + +/** +Add a data source to the controller asynchronously, and receive a handle to allow removal and direct +communication with that data source. + +Note: only one call to this method can be outstanding at any time. + +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, packaged for async data transfer. + The reference must remain valid until the command has been completed or + cancelled." +@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." +@since 8.0 +*/ +EXPORT_C void RMMFController::AddDataSource(const TMMFUidPckg& aSourceUid, const TDesC8& aSourceInitData, + TMMFMessageDestinationPckg& aHandleInfoPckg, + TRequestStatus& aStatus) + { + iControllerProxy.SendAsync(iDestinationPckg, + EMMFControllerAddDataSource, + aSourceUid, + aSourceInitData, + aHandleInfoPckg, + aStatus); + } + +/** +Cancels an outstanding call to the asynchronous version of AddDataSource(). +@since 8.0 +*/ +EXPORT_C void RMMFController::CancelAddDataSource() + { + iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerCancelAddDataSource, + KNullDesC8, + KNullDesC8); + } + +/** +Add a data sink to the controller asynchronously, and receive a handle to allow removal and direct +communication with that data sink. + +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, packaged for async data transfer. + The reference must remain valid until the command has been completed or + cancelled." +@param "aSinkInitData" "Data used to initialise the data sink. The reference must remain valid + until the command has been completed or cancelled. 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." +@param "aHandleInfoPckg" "This object is filled in by the controller framework, and identifies + the data sink inside the controller framework. This allows + the caller to send custom commands directly to the data 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." +@param "aStatus" "TRequestStatus of the active object to be signalled on completion + of this request." +@since 8.0 +*/ +EXPORT_C void RMMFController::AddDataSink(const TMMFUidPckg& aSinkUid, const TDesC8& aSinkInitData, + TMMFMessageDestinationPckg& aHandleInfoPckg, + TRequestStatus& aStatus) + { + iControllerProxy.SendAsync(iDestinationPckg, + EMMFControllerAddDataSink, + aSinkUid, + aSinkInitData, + aHandleInfoPckg, + aStatus); + } + + +/** +Cancels an outstanding call to the asynchronous version of AddDataSink(). +@since 8.0 +*/ +EXPORT_C void RMMFController::CancelAddDataSink() + { + iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerCancelAddDataSink, + KNullDesC8, + KNullDesC8); + } + +/** +Removes a data source from the controller. + +In certain situations, it may be necessary to remove a data source from a controller, for +example when you need to play a different file of the same format as the current one. + +It should be noted that not all controller plugins will support the removal of a data source. + +@param aHandleInfo + The handle object returned by the controller framework when the + data source was added. + +@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::RemoveDataSource(const TMMFMessageDestination& aHandleInfo) + { + TMMFMessageDestinationPckg pckg(aHandleInfo); + TInt error = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerRemoveDataSource, + pckg, + KNullDesC8); + return error; + } + +/** +Removes a data sink from the controller. + +In certain situations, it may be necessary to remove a data sink from a controller, for +example when you need change output devices on the fly. + +It should be noted that not all controller plugins will support the removal of a data sink. + +@param aHandleInfo + The handle object returned by the controller framework when the + data sink was added. + +@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::RemoveDataSink(const TMMFMessageDestination& aHandleInfo) + { + TMMFMessageDestinationPckg pckg(aHandleInfo); + TInt error = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerRemoveDataSink, + pckg, + KNullDesC8); + return error; + } + +/** +Reverts the controller plugin back to the state it was in just after it had been Opened. + +Note: All sources and sinks will be removed from the controller. + +@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::Reset() + { + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerReset, + KNullDesC8, + KNullDesC8); + } + +/** +Prepares the controller to start playing. + +The controller should initialise its sources, sinks and buffers. This moves the controller +from the STOPPED to the PRIMED state. + +@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::Prime() + { + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerPrime, + KNullDesC8, + KNullDesC8); + } + +/** +Starts the controller playing. +The controller will begin transferring data from its data source(s) to its data sink(s). + +This moves the controller from the PRIMED to the PLAYING state. + +Play() means "Start Playing" - i.e. this method will return as soon as +playback has begun. + +If the data transfer comes to an end due to an internal event (e.g. source runs out of data), +the caller will be notified via the ReceiveEvents() interface. + +Note: +Prime() must have been called prior to calling Play(). + +@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::Play() + { + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerPlay, + KNullDesC8, + KNullDesC8); + } + +/** +Pauses the controller. + +The controller will cease transferring data from its data source(s) to its data sink(s). +A subsequent call to Play() will result in the data transfer resuming from the +same place as when the Pause() was called. + +This moves the controller from the PLAYING back to the PRIMED state. + +Note: +Play() must have been called prior to calling Pause(). + +@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::Pause() + { + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerPause, + KNullDesC8, + KNullDesC8); + } + +/** +Stops the controller. + +The controller will cease transferring data from its data source(s) to its data sink(s), reset +its position and delete any allocated buffers. +In effect, calling Stop() undoes any actions performed by the controller +during the call to Prime(). + +This moves the controller from the PRIMED back to the STOPPED state. + +@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::Stop() + { + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerStop, + KNullDesC8, + KNullDesC8); + } + +/** +Gets the current position microseconds. + +Note: The controller must be in the PRIMED or PLAYING state before this can be called. + +@param aPosition + The current position in microseconds, filled in by the controller framework. + +@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::GetPosition(TTimeIntervalMicroSeconds& aPosition) const + { + TMMFTimeIntervalMicroSecondsPckg pckg; + TInt err = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerGetPosition, + KNullDesC8, + KNullDesC8, + pckg); + if (!err) + aPosition = pckg(); + return err; + } + +/** +Sets the current position microseconds. + +Note: The controller must be in the PRIMED or PLAYING state before this can be called. + +@param aPosition + The new transfer position in microseconds. + +@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::SetPosition(const TTimeIntervalMicroSeconds& aPosition) const + { + TMMFTimeIntervalMicroSecondsPckg pckg(aPosition); + return iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerSetPosition, + pckg, + KNullDesC8); + } + +/** +Gets the duration of the clip in microseconds. + +Note: The controller must be in the PRIMED or PLAYING state before this can be called. + +@param aDuration + The duration of the clip in microseconds, filled in by the + controller framework. + +@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::GetDuration(TTimeIntervalMicroSeconds& aDuration) const + { + TMMFTimeIntervalMicroSecondsPckg pckg; + TInt err = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerGetDuration, + KNullDesC8, + KNullDesC8, + pckg); + if (!err) + aDuration = pckg(); + return err; + } + +/** +Sends a custom command synchronously to the controller plugin. + +Custom commands allow controller plugins to extend the standard API. + +Note: This method will not return until the controller plugin has serviced the command. + +@param aDestination + The destination of the custom command, consisting of the UID of + the interface of this custom command and a special handle ID, + KMMFObjectHandleController to indicate that the custom + command is to be handled by the controller plugin. +@param aFunction + The function number to indicate which function is to be called + on the controller's custom command interface. +@param aDataTo1 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataTo2 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataFrom + A reference to an area of memory to which the controller plugin will + write any data to be passed back to the client. + +@return The result of the custom command. Exact range of values is dependent on the custom command interface. +@since 7.0s +*/ +EXPORT_C TInt RMMFController::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom) + { + return iControllerProxy.SendSync(aDestination, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom); + } + +/** +Sends a custom command synchronously to the controller plugin. + +Custom commands allow controller plugins to extend the standard API. + +Note: This method will not return until the controller plugin has serviced the command. + +@param aDestination + The destination of the custom command, consisting of the UID of + the interface of this custom command and a special handle ID, + KMMFObjectHandleController to indicate that the custom + command is to be handled by the controller plugin. +@param aFunction + The function number to indicate which function is to be called + on the controller's custom command interface. +@param aDataTo1 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataTo2 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. + +@return The result of the custom command. Exact range of values is dependent on the custom command interface. +@since 7.0s +*/ +EXPORT_C TInt RMMFController::CustomCommandSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2) + { + return iControllerProxy.SendSync(aDestination, + aFunction, + aDataTo1, + aDataTo2); + } + +/** +Sends a custom command asynchronously to the controller plugin. + +Custom commands allow controller plugins to extend the standard API. + +Note: This method will return immediately. The RunL of the active object owning the aStatus +parameter will be called when the command is completed by the controller plugin. + +@param aDestination + The destination of the custom command, consisting of the UID of + the interface of this custom command and a special handle ID, + KMMFObjectHandleController to indicate that the custom + command is to be handled by the controller plugin. +@param aFunction + The function number to indicate which function is to be called + on the controller's custom command interface. +@param aDataTo1 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataTo2 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataFrom + A reference to an area of memory to which the controller plugin will + write any data to be passed back to the client. +@param aStatus + The TRequestStatus of an active object. This will contain the + result of the custom command on completion. The exact range of + result values is dependent on the custom command interface. + +@since 7.0s +*/ +EXPORT_C void RMMFController::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus) + { + iControllerProxy.SendAsync(aDestination, + aFunction, + aDataTo1, + aDataTo2, + aDataFrom, + aStatus); + } + +/** +Sends a custom command asynchronously to the controller plugin. + +Custom commands allow controller plugins to extend the standard API. + +Note: This method will return immediately. The RunL() of the active object owning the aStatus +parameter will be called when the command is completed by the controller plugin. + +@param aDestination + The destination of the custom command, consisting of the UID of + the interface of this custom command and a special handle ID, + KMMFObjectHandleController to indicate that the custom + command is to be handled by the controller plugin. +@param aFunction + The function number to indicate which function is to be called + on the controller's custom command interface. +@param aDataTo1 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aDataTo2 + A reference to data to be copied to the controller plugin. The exact + contents of the data are dependent on the custom command interface + of the controller. Use a value of KNullDesC8 if you have no data to send. +@param aStatus + The TRequestStatus of an active object. This will contain the + result of the custom command on completion. The exact range of + result values is dependent on the custom command interface. + +@since 7.0s +*/ +EXPORT_C void RMMFController::CustomCommandAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus) + { + iControllerProxy.SendAsync(aDestination, + aFunction, + aDataTo1, + aDataTo2, + aStatus); + } + +/** +Registers to receive events from the controller plugin. + +Events can be generated at any time, and are generally associated with things that occur +due to something happening internally within the controller. For example, an event will +be generated if the controller stops playing due to reaching the end of a file. + +@param aEventPckg + A reference to a TMMFEventPckg object that must be member data + of the active object calling this method. The details of the event + will be copied into this object when an event occurs. +@param aStatus + The TRequestStatus of the active object calling this method. + +@see TMMFEvent +@see CMMFControllerEventMonitor +@since 7.0s +*/ +EXPORT_C void RMMFController::ReceiveEvents(TMMFEventPckg& aEventPckg, TRequestStatus& aStatus) + { + iControllerProxy.ReceiveEvents(aEventPckg, aStatus); + } + +/** +Cancels a previous registration to receive events from the controller plugin. + +This must be called from the DoCancel() method of the active object using the +ReceiveEvents() API function. + +@return An error code indicating if the function call was successful. KErrNone on success, otherwise + another of the system-wide error codes. +@see TMMFEvent +@since 7.0s +*/ +EXPORT_C TInt RMMFController::CancelReceiveEvents() + { + return iControllerProxy.CancelReceiveEvents(); + } + +/** +Gets the number a meta data entries in the clip. + +A clip may contain zero or more entries of meta data, e.g Author, Copyright etc. + +@param aNumberOfEntries + The number of meta data entries in the clip, filled in by the controller framework. + +@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::GetNumberOfMetaDataEntries(TInt& aNumberOfEntries) const + { + TPckgBuf pckg; + TInt error = iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerGetNumberOfMetaDataEntries, + KNullDesC8, + KNullDesC8, + pckg); + if (!error) + aNumberOfEntries = pckg(); + return error; + } + +/** +Returns a particular meta data entry from the clip. + +All meta data entries can be retrieved by multiple calls to this method, iterating +aIndex from 0 to the value returned by GetNumberOfMetaDataEntries(). + +@param aIndex + The index of the meta data entry to retrieve. + +@return The meta data entry retrieved from the controller plugin. Ownership of the entry is + passed to the caller. + +@see CMMFMetaDataEntry +@since 7.0s +*/ +EXPORT_C CMMFMetaDataEntry* RMMFController::GetMetaDataEntryL(TInt aIndex) const + { + // Get the size of the entry + TPckgBuf indexPckg(aIndex); + TPckgBuf sizePckg; + User::LeaveIfError(iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerGetSizeOfMetaDataEntry, + indexPckg, + KNullDesC8, + sizePckg)); + // Create a buffer of appropriate size and get the entry data + HBufC8* buf = HBufC8::NewLC(sizePckg()); + TPtr8 ptr = buf->Des(); + User::LeaveIfError(iControllerProxy.SendSync(iDestinationPckg, + EMMFControllerGetMetaDataEntry, + KNullDesC8, + KNullDesC8, + ptr)); + // Create the entry and internalize the data + CMMFMetaDataEntry* entry = CMMFMetaDataEntry::NewL(); + CleanupStack::PushL(entry); + RDesReadStream stream(ptr); + CleanupClosePushL(stream); + + entry->InternalizeL(stream); + + CleanupStack::PopAndDestroy();//stream + CleanupStack::Pop(entry);//entry + CleanupStack::PopAndDestroy(buf);//buf + + return entry; + } + +/** +Set the priority of the controller's sub thread. + +This can be used to increase the responsiveness of the audio plugin to minimise +any lag in processing. This function should be used with care as it may have knock-on +effects elsewhere in the system. + +@param aPriority + The TThreadPriority that the thread should run under. The default is EPriorityNormal. +@return TInt + A standard error code: KErrNone if successful, KErrNotReady if the thread does not have a + valid handle. +*/ +EXPORT_C TInt RMMFController::SetThreadPriority(const TThreadPriority& aPriority) const + { + return iControllerProxy.SetThreadPriority(aPriority); + } + +/** +Create a new Controller Event Monitor. + +@param aObserver "The observer to notify whenever an event is received. +@param aMMFController "A reference to the controller that is to be monitored for events. +@return "A pointer to the object created." +*/ +EXPORT_C CMMFControllerEventMonitor* CMMFControllerEventMonitor::NewL(MMMFControllerEventMonitorObserver& aObserver, + RMMFController& aMMFController) + { + return (new(ELeave) CMMFControllerEventMonitor(aObserver, aMMFController)); + } + +CMMFControllerEventMonitor::CMMFControllerEventMonitor(MMMFControllerEventMonitorObserver& aObserver, + RMMFController& aMMFController) : + CActive(EPriorityStandard), + iObserver(aObserver), + iMMFController(aMMFController) + { + CActiveScheduler::Add(this); + } + +CMMFControllerEventMonitor::~CMMFControllerEventMonitor() + { + Cancel(); + } + + +/** +Start receiving events from the controller. +This can only be called once the controller is open. +*/ +EXPORT_C void CMMFControllerEventMonitor::Start() + { + iMMFController.ReceiveEvents(iEventPckg, iStatus); + SetActive(); + } + +void CMMFControllerEventMonitor::RunL() + { + if (iStatus.Int() == KErrNone) + { + // Save the package buf as calling Start() will overwrite the contents of iEventPckg + TMMFEventPckg packageBuf = iEventPckg; + Start(); + iObserver.HandleEvent(packageBuf()); + } + else + { + //something's gone wrong with trying to receive events (e.g. server died etc) + TMMFEvent event(KMMFErrorCategoryControllerGeneralError, iStatus.Int()); + iObserver.HandleEvent(event); + //we don't want to receive events again here... + } + } + +void CMMFControllerEventMonitor::DoCancel() + { + iMMFController.CancelReceiveEvents(); + } + +/** +Constructs a CMMFAddDataSourceSinkAsync object. + +@param aObs A reference to the observer of the active object. The observer will be + notified when the AddDataSource/Sink command is complete. +@return A pointer to the new object. +@leave This method can leave with one of the standard system-wide error codes. +@since 7.0s +*/ +EXPORT_C CMMFAddDataSourceSinkAsync* CMMFAddDataSourceSinkAsync::NewL(MMMFAddDataSourceSinkAsyncObserver& aObs) + { + return new(ELeave) CMMFAddDataSourceSinkAsync(aObs); + } + +CMMFAddDataSourceSinkAsync::CMMFAddDataSourceSinkAsync(MMMFAddDataSourceSinkAsyncObserver& aObserver) : + CActive(EPriorityNormal), + iObserver(aObserver) + { + CActiveScheduler::Add(this); + iCurrentAction = EIdle; + } +/** +Destructor. +*/ +CMMFAddDataSourceSinkAsync::~CMMFAddDataSourceSinkAsync() + { + Cancel(); + delete iSourceSinkInitData; + } +/** +Add a data source to the controller. The caller will be signalled on completion via the +MMMFAddDataSourceSinkAsyncObserver interface. + +Only one method call may be outstanding on this object at any one time. + +@param aMMFController A reference to the client controller interface class. +@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 are dependent on the type of data source. For more + information, see the documentation for the data source you wish + to add. +@since 7.0s +*/ +EXPORT_C void CMMFAddDataSourceSinkAsync::AddDataSource(RMMFController& aMMFController, TUid aSourceUid, const TDesC8& aSourceInitData) + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aMMFController; + iSourceSinkUidPckg() = aSourceUid; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + iSourceSinkInitData = aSourceInitData.Alloc(); + if (!iSourceSinkInitData) + { + iObserver.MadssaoAddDataSourceSinkAsyncComplete(KErrNoMemory, iHandleInfoPckg()); + } + else + { + iMMFController->AddDataSource(iSourceSinkUidPckg, *iSourceSinkInitData, iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSource; + } + } + +/** +Add a data sink to the controller. The caller will be signalled on completion via the +MMMFAddDataSourceSinkAsyncObserver interface. + +Only one method call may be outstanding on this object at any one time. + +@param aMMFController A reference to the client controller interface class. +@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 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. +@since 7.0s +*/ +EXPORT_C void CMMFAddDataSourceSinkAsync::AddDataSink(RMMFController& aMMFController, TUid aSinkUid, const TDesC8& aSinkInitData) + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aMMFController; + iSourceSinkUidPckg() = aSinkUid; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + iSourceSinkInitData = aSinkInitData.Alloc(); + if (!iSourceSinkInitData) + { + iObserver.MadssaoAddDataSourceSinkAsyncComplete(KErrNoMemory, iHandleInfoPckg()); + } + else + { + iMMFController->AddDataSink(iSourceSinkUidPckg, *iSourceSinkInitData, iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSink; + } + } + + +void CMMFAddDataSourceSinkAsync::RunL() + { + iCurrentAction = EIdle; + iMMFController = NULL; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + + iObserver.MadssaoAddDataSourceSinkAsyncComplete(iStatus.Int(), iHandleInfoPckg()); + } + +void CMMFAddDataSourceSinkAsync::DoCancel() + { + // although the server does nothing with the cancel message, + // by calling it we can at least be assured that by the time it completes, + // the async AddSource/Sink message will have been completed too + // so we don't get any stray events. + if (iCurrentAction == EAddingDataSource) + iMMFController->CancelAddDataSource(); + else if (iCurrentAction == EAddingDataSink) + iMMFController->CancelAddDataSink(); + + iCurrentAction = EIdle; + iMMFController = NULL; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + } + + +EXPORT_C void CMMFAddDataSourceSinkAsync::AddFileHandleDataSource(RMMFController& aMMFController, const RFile& aFile) + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aMMFController; + iMMFController->AddFileHandleDataSource(aFile,iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSource; + } + +EXPORT_C void CMMFAddDataSourceSinkAsync::AddFileHandleDataSource(RMMFController& aController, const RFile& aFile, + const TDesC8& aSourceInitData) + { + if (aSourceInitData.Length() == 0) + { + AddFileHandleDataSource(aController, aFile); + } + else + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aController; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + iSourceSinkInitData = aSourceInitData.Alloc(); + if (!iSourceSinkInitData) + { + iObserver.MadssaoAddDataSourceSinkAsyncComplete(KErrNoMemory, iHandleInfoPckg()); + } + else + { + iMMFController->AddFileHandleDataSource(aFile, *iSourceSinkInitData, iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSource; + } + } + } + +EXPORT_C void CMMFAddDataSourceSinkAsync::AddFileHandleDataSink(RMMFController& aMMFController, const RFile& aFile) + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aMMFController; + iMMFController->AddFileHandleDataSink(aFile,iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSink; + } + +EXPORT_C void CMMFAddDataSourceSinkAsync::AddFileHandleDataSink(RMMFController& aController, const RFile& aFile, + const TDesC8& aSinkInitData) + { + if (aSinkInitData.Length() == 0) + { + AddFileHandleDataSink(aController, aFile); + } + else + { + ASSERT(iCurrentAction == EIdle); + + iMMFController = &aController; + delete iSourceSinkInitData; + iSourceSinkInitData = NULL; + iSourceSinkInitData = aSinkInitData.Alloc(); + if (!iSourceSinkInitData) + { + iObserver.MadssaoAddDataSourceSinkAsyncComplete(KErrNoMemory, iHandleInfoPckg()); + } + else + { + iMMFController->AddFileHandleDataSink(aFile, *iSourceSinkInitData, iHandleInfoPckg, iStatus); + SetActive(); + iCurrentAction = EAddingDataSink; + } + } + } +