--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/breakdeps/mmfclientutility.h Fri Nov 12 11:56:07 2010 +0000
@@ -0,0 +1,510 @@
+// 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:
+// Client utility functions
+//
+//
+
+#ifndef __MMF_CLIENT_UTILITY_H__
+#define __MMF_CLIENT_UTILITY_H__
+
+#include <mda/common/audio.h>
+#include <mda/common/gsmaudio.h>
+#include <mda/client/utility.h>
+#include <mmf/common/mmffourcc.h>
+#include <mmfformatimplementationuids.hrh>
+#include "mmf/common/mmfcontrollerpluginresolver.h"
+#include <mmf/server/mmffile.h>
+#include <mmf/server/mmfdes.h>
+#include "mmf/common/mmfcontroller.h"
+
+#include <f32file.h>
+#include <caf/content.h>
+#include <caf/data.h>
+#include <mmf/common/mmfstandardcustomcommands.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include <mmf/common/mmfstandardcustomcommandsenums.h>
+#include <mmf/common/mmfstandardcustomcommandsimpl.h>
+#endif
+#ifdef SYMBIAN_BUILD_GCE
+#include <mmf/common/mmfvideosurfacecustomcommands.h>
+#endif
+
+class CMMSourceSink; // declared here.
+
+NONSHARABLE_CLASS( CMMSourceSink ): public CBase
+ {
+public:
+ IMPORT_C static CMMSourceSink* NewL(TUid aUid, const TDesC8& aDescriptor);
+ IMPORT_C static CMMSourceSink* NewLC(TUid aUid, const TDesC8& aDescriptor);
+
+ virtual ~CMMSourceSink();
+ virtual TUid SourceSinkUid() const;
+ virtual const TDesC8& SourceSinkData() const;
+
+ virtual TBool CarryingFileHandle() const;
+
+ virtual void EvaluateIntentL();
+protected:
+ CMMSourceSink(TUid aUid);
+
+
+private:
+ void ConstructL(const TDesC8& aDescriptor);
+
+ const TUid iUid;
+ HBufC8* iBuf;
+ };
+
+
+
+
+class CMMFileSourceSink; // declared here.
+
+NONSHARABLE_CLASS( CMMFileSourceSink ): public CMMSourceSink
+ {
+public:
+ IMPORT_C static CMMFileSourceSink* NewL(TUid aUid, const RFile& aFile);
+ IMPORT_C static CMMFileSourceSink* NewLC(TUid aUid, const RFile& aFile);
+
+ IMPORT_C static CMMFileSourceSink* NewL(TUid aUid, const TMMSource& aMMSource);
+ IMPORT_C static CMMFileSourceSink* NewLC(TUid aUid, const TMMSource& aMMSource);
+
+ const TDesC& UniqueId() const {return *iUniqueId;}
+
+ virtual ~CMMFileSourceSink();
+
+ const TDesC& FileName() const {return *iFileName;}
+ const TDesC8& SourceSinkData() const;
+
+ IMPORT_C void EvaluateIntentL(ContentAccess::TIntent aIntent);
+ virtual void EvaluateIntentL();
+
+ TBool CarryingFileHandle() const;
+
+ TBool UsingFileHandle() const {return iUsingFileHandle;};
+ const RFile& FileHandle() const {return iHandle;};
+protected:
+ CMMFileSourceSink(TUid aUid);
+
+private:
+ void ConstructL(const TMMSource& aSource);
+ void DoCreateFileSourceConfigDataL();
+ void ConstructL(const RFile& aFile);
+ void DoCreateFileHandleSourceConfigDataL();
+
+ TBool iUsingFileHandle;
+ RFile iHandle;
+ HBufC* iFileName;
+ HBufC8* iSourceSinkData;
+ HBufC* iUniqueId;
+ ContentAccess::TIntent iIntent;
+
+ TBool iEnableUI;
+ };
+
+
+
+class CMMFMdaObjectStateChangeObserverCallback; // declared here.
+/**
+Active object utility class to allow the callback to be called asynchronously.
+This should help prevent re-entrant code in clients of the mediaframework.
+*/
+NONSHARABLE_CLASS( CMMFMdaObjectStateChangeObserverCallback ): public CActive
+ {
+public:
+ IMPORT_C static CMMFMdaObjectStateChangeObserverCallback* NewL(MMdaObjectStateChangeObserver& aCallback);
+ virtual ~CMMFMdaObjectStateChangeObserverCallback();
+ IMPORT_C void CallBack(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);
+private:
+ CMMFMdaObjectStateChangeObserverCallback(MMdaObjectStateChangeObserver& aCallback);
+ void RunL();
+ void DoCancel();
+private:
+ MMdaObjectStateChangeObserver& iCallback;
+ CBase* iObject;
+ TInt iPreviousState;
+ TInt iCurrentState;
+ TInt iErrorCode;
+ };
+
+class CMMFClientUtility; // declared here.
+
+NONSHARABLE_CLASS( CMMFClientUtility )
+ {
+public:
+ IMPORT_C static TUid ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid);
+ IMPORT_C static TUid ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid);
+ IMPORT_C static TFourCC ConvertMdaCodecToFourCC(TMdaPackage& aCodec);
+ IMPORT_C static TInt GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength);
+ IMPORT_C static HBufC8* GetFileExtensionL(const TDesC& aFileName);
+ static void PrioritiseControllersL(
+ const RMMFControllerImplInfoArray& aControllers,
+ const TDesC8& aHeaderDataPlayback,
+ const TDesC8& aFileExtensionPlayback,
+ const TDesC8& aHeaderDataRecord,
+ const TDesC8& aFileExtensionRecord,
+ RMMFControllerImplInfoArray& aPrioritisedControllers);
+ static TInt GetBestMatchL(const CMMFFormatImplementationInformation* format, const TDesC8& aHeaderData, const TDesC8& aFileExtension);
+
+private:
+ CMMFClientUtility();
+ };
+
+class CMMFUtilityFileInfo; // declared here.
+class RMMFDRMPluginServerProxy;
+
+NONSHARABLE_CLASS( CMMFUtilityFileInfo ): public CBase
+ {
+public:
+
+ static CMMFUtilityFileInfo* NewL(TMMSource& aSource, TBool aSecureDRMMode = EFalse);
+ static CMMFUtilityFileInfo* NewLC(TMMSource& aSource, TBool aSecureDRMMode = EFalse);
+
+ ~CMMFUtilityFileInfo();
+
+ TBool GetFileMimeTypeL(TDes8& aMimeType);
+ void GetFileHeaderDataL(TDes8& aHeaderData, TInt aMaxLength);
+ TInt EvaluateIntent(ContentAccess::TIntent aIntent);
+
+private:
+ CMMFUtilityFileInfo();
+
+ void ConstructL(const TMMSource& aSource, TBool aSecureDRMMode);
+
+private:
+ ContentAccess::CData* iData;
+ RMMFDRMPluginServerProxy* iDrmPluginServer;
+ };
+
+inline CMMFUtilityFileInfo::CMMFUtilityFileInfo()
+ {
+ };
+
+/**
+ * Mixin class that the user of the class CMMFFindAndOpenController must derive from.
+ * @internalComponent
+ */
+class MMMFFindAndOpenControllerObserver
+ {
+public:
+ /**
+ * Callback function to indicate the success or failure
+ * of an attempt to find and open a suitable controller and
+ * to add a source and sink.
+ * @see CMMFFindAndOpenController
+ *
+ * @param aError
+ * Indicates whether a controller has been opened sucessfully
+ * This is passed by reference, mainly for the audio recorder utility
+ * which opens two controllers: if the secondary controller (which is
+ * always opened first) fails to open, then the audio recorder utility
+ * may choose to set aError = KErrNone in the MfaocComplete() callback
+ * to indicate to CFindAndOpenControler() that it should continue
+ * to open the primary controller, even though opening the secondary failed.
+ * @param aController
+ * A pointer to the controller that has been opened or has failed to open
+ * This is mainly for the audio recorder utility to indicate
+ * which controller (primary or secondary) has been opened.
+ * @param aControllerUid
+ * the UID of the controller that has been opened
+ * @param aSourceHandle
+ * a pointer to the source handle
+ * @internalComponent
+ * a pointer to the sink handle
+ */
+ virtual void MfaocComplete(
+ TInt& aError,
+ RMMFController* aController,
+ TUid aControllerUid = KNullUid,
+ TMMFMessageDestination* aSourceHandle = NULL,
+ TMMFMessageDestination* aSinkHandle = NULL) = 0;
+ };
+
+
+class CMMFFindAndOpenController; // declared here.
+/**
+ * Utility class used by the MMF client API classes.
+ * Finds and opens a suitable controller and adds a source and a sink
+ * asynchronously. Completion is indicated asynchronously
+ * using the MMMFFindAndOpenControllerObserver mixin class.
+ *
+ * @internalComponent
+ */
+NONSHARABLE_CLASS( CMMFFindAndOpenController ): public CActive, public MMMFAddDataSourceSinkAsyncObserver
+ {
+public:
+ enum TControllerMode
+ {
+ EPlayback,
+ ERecord,
+ EConvert
+ };
+
+ enum TControllerNumber
+ {
+ EPrimaryController,
+ ESecondaryController
+ };
+
+ class TSourceSink
+ {
+ public:
+ IMPORT_C TSourceSink(TUid aUid, const TDesC8& aData = KNullDesC8);
+ IMPORT_C TSourceSink(TUid aUid, const RFile& aFile);
+
+ TUid iUid;
+ const TDesC8& iConfigData;
+ TBool iUseFileHandle;
+ RFile iFileHandle;
+ };
+
+
+
+
+public:
+ IMPORT_C static CMMFFindAndOpenController* NewL(MMMFFindAndOpenControllerObserver& aObserver);
+ virtual ~CMMFFindAndOpenController();
+
+ // from CActive
+ virtual void DoCancel();
+ virtual void RunL();
+
+ // from MMMFAddDataSourceSinkAsyncObserver
+ virtual void MadssaoAddDataSourceSinkAsyncComplete(TInt aError, const TMMFMessageDestination& aHandle);
+
+ IMPORT_C void Configure(
+ TUid aMediaId,
+ TMMFPrioritySettings aPrioritySettings,
+ CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType = CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);
+
+ IMPORT_C void ConfigureController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
+ IMPORT_C void ConfigureSecondaryController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
+
+ IMPORT_C void UseSharedHeap();
+
+ IMPORT_C void ConfigureSourceSink(
+ TSourceSink aSource,
+ TSourceSink aSink);
+ IMPORT_C void ConfigureSecondarySourceSink(
+ TSourceSink aSource,
+ TSourceSink aSink);
+
+ IMPORT_C void ConfigureSourceSink(
+ const TMMSource& aSource,
+ TSourceSink aSink);
+
+ IMPORT_C void OpenByFileSource(const TMMSource& aFileSource, const TDesC& aFileNameSecondary = KNullDesC);
+
+ IMPORT_C void OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary = KNullUid);
+ IMPORT_C void OpenByDescriptor(const TDesC8& aDescriptor);
+ IMPORT_C void OpenByUrl(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType);
+ IMPORT_C void OpenByControllerUid(TUid aControllerUid, TUid aSecondaryControllerUid = KNullUid);
+ IMPORT_C void ReOpen();
+ IMPORT_C void Close();
+
+ IMPORT_C static TMMFFileConfig GetConfigFile(const TDesC& aFileName);
+ IMPORT_C static TMMFDescriptorConfig GetConfigDescriptor(const TDesC8& aDescriptor);
+ IMPORT_C void CloseConfig();
+ IMPORT_C static void GetConfigUrlL(CBufFlat*& aUrlCfgBuffer, const TDesC& aUrl, TInt aIapId);
+
+ /** made public to check for further selected controllers in the queue */
+ inline TInt ControllerIndex() const;
+ inline TInt ControllerCount() const;
+
+ /** made public to stop checking for further selected controllers in the queue */
+ inline TBool StopTryLoadController() const;
+ IMPORT_C void SetInitScreenNumber(TInt aScreenNumber, RMMFVideoSetInitScreenCustomCommands* aVideoSetInitScreenCustomCommands);
+#ifdef SYMBIAN_BUILD_GCE
+ inline void SetSurfaceMode(TBool aUseSurface, RMMFVideoPlaySurfaceSupportCustomCommands* aVideoPlaySurfaceSupportCustomCommands);
+ inline TInt SurfaceSupported();
+#endif
+
+private:
+ class CConfig: public CBase
+ {
+ public:
+ CConfig();
+ ~CConfig();
+ void Close();
+ public:
+ RMMFController* iController; // not owned
+ CMMFControllerEventMonitor* iEventMonitor; // not owned
+
+ /** indicates whether this controller is being used for
+ playback, recording or converting */
+ TControllerMode iControllerMode;
+
+ CMMSourceSink* iSource;
+ CMMSourceSink* iSink;
+ TUid iControllerUid;
+ };
+
+ CMMFFindAndOpenController(MMMFFindAndOpenControllerObserver& aObserver);
+ void ConstructL();
+
+ void Init();
+
+ void ConfigureSourceSink(
+ CConfig& config,
+ TSourceSink aSource,
+ TSourceSink aSink);
+
+ void ConfigureSourceSink(
+ CConfig& config,
+ const TMMSource& aSource,
+ TSourceSink aSink);
+
+
+ void ConfigureController(
+ CConfig& config,
+ RMMFController& aController,
+ CMMFControllerEventMonitor& aEventMonitor,
+ TControllerMode aControllerMode);
+
+ void CloseController();
+
+ void OpenPrimaryController(void);
+
+ void KickState();
+ void Process();
+ void SendError(TInt aError = KErrNone, TBool aForcedError = EFalse);
+ void SchedSendError(TInt aError = KErrNone);
+ void BuildControllerListFileNameL();
+ void BuildControllerListDescriptorL();
+ void BuildControllerListUrlL();
+ void BuildControllerListFormatL();
+ void TryNextController();
+
+ CMMSourceSink* CreateSourceSinkL(const TSourceSink& aParams);
+ CMMSourceSink* CreateSourceSinkL(const TMMSource& aSource);
+
+ CMMFUtilityFileInfo* CreateFileInfoL(TBool aSecureDRMMode = EFalse);
+ void UseSecureDRMProcessL(TBool& aIsSecureDrmProcess);
+private:
+ /** primary controller details */
+ CConfig* iPrimaryConfig;
+ /** secondary controller details */
+ CConfig* iSecondaryConfig;
+ /** points to either iPrimaryConfig or iSecondaryConfig */
+ CConfig* iCurrentConfig; // not owned
+
+ enum TMode
+ {
+ EOpenByControllerUid,
+ EOpenByFileName,
+ EOpenByDescriptor,
+ EOpenByUrl,
+ EOpenByFormatUid
+ };
+ TMode iMode;
+
+ /** indicates what state the state machine is in */
+ enum TState
+ {
+ EIdle,
+ EBuildControllerList,
+ EOpenController,
+ EAddSource,
+ EAddSink,
+ EWaitingForSource,
+ EWaitingForSink,
+ ESendError
+ };
+ TState iState;
+
+ MMMFFindAndOpenControllerObserver& iObserver;
+ CMMFAddDataSourceSinkAsync* iAddDataSourceSinkAsync;
+
+ TInt iControllerIndex;
+ TInt iControllerCount;
+
+ TFileName iFileNameSecondary; // for converting
+
+ TFileName iFileName;
+ TBool iUseFileHandle;
+ TBool iOwnFileHandle;
+ HBufC* iUniqueId;
+ RFile iFileHandle;
+ ContentAccess::TIntent iIntent;
+
+ HBufC* iUrl;
+ HBufC8* iMimeType;
+ TPtr8 iDescriptor;
+ TInt iIapId;
+ TUid iFormatUid;
+ TUid iFormatUidSecondary; // for converting
+
+ TUid iMediaId;
+ TMMFPrioritySettings iPrioritySettings;
+ CMMFPluginSelectionParameters::TMediaIdMatchType iMediaIdMatchType;
+
+ RMMFControllerImplInfoArray iControllers;
+ RMMFControllerImplInfoArray iPrioritisedControllers;
+
+ // if this is non-null, then it points to an element in
+ // either iControllers or iPrioritisedControllers
+ CMMFControllerImplementationInformation* iControllerImplInfo; // not owned
+
+ TControllerMode iControllerMode;
+ TBool iSourceSinkConfigured;
+ TInt iError;
+
+ TMMFMessageDestination iSourceHandle;
+ TMMFMessageDestination iSinkHandle;
+ TBool iEnableUi;
+
+ TBool iUseSharedHeap; // should new controllers use shared heaps?
+ TBool iStopTryLoadController; //stop to try loading the selected conrollers from the list
+ RMMFVideoSetInitScreenCustomCommands* iVideoSetInitScreenCustomCommands;
+ TInt iScreenNumber;
+ TBool iHasDrmCapability;
+ TBool iUsingSecureDrmProcess;
+
+#ifdef SYMBIAN_BUILD_GCE
+ RMMFVideoPlaySurfaceSupportCustomCommands* iVideoPlaySurfaceSupportCustomCommands;
+ TBool iUseVPU2;
+ TInt iSurfaceSupported;
+#endif
+ };
+
+inline TInt CMMFFindAndOpenController::ControllerIndex() const
+ {
+ return iControllerIndex;
+ }
+
+inline TInt CMMFFindAndOpenController::ControllerCount() const
+ {
+ return iControllerCount;
+ }
+
+inline TBool CMMFFindAndOpenController::StopTryLoadController() const
+ {
+ return iStopTryLoadController;
+ }
+
+#ifdef SYMBIAN_BUILD_GCE
+inline void CMMFFindAndOpenController::SetSurfaceMode(TBool aUseVPU2, RMMFVideoPlaySurfaceSupportCustomCommands* aVideoPlaySurfaceSupportCustomCommands)
+ {
+ iUseVPU2 = aUseVPU2;
+ iSurfaceSupported = KErrNone;
+ iVideoPlaySurfaceSupportCustomCommands = aVideoPlaySurfaceSupportCustomCommands;
+ }
+
+inline TInt CMMFFindAndOpenController::SurfaceSupported()
+ {
+ return iSurfaceSupported;
+ }
+#endif // SYMBIAN_BUILD_GCE
+
+#endif // __MMF_CLIENT_UTILITY_H__