--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmfenh/enhancedmediaclient/Client/src/Components/StreamControl/ClientUtility.h Tue Feb 02 01:08:46 2010 +0200
@@ -0,0 +1,500 @@
+/*
+* Copyright (c) 2006 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: Definition of the ClientUtility class.
+* Version : %version: bh1mmcf#8 %
+*
+*/
+
+
+// ClientUtility.h
+//
+// Copyright (c) Symbian Software Ltd 2002-2006. All rights reserved.
+//
+// Client utility functions
+
+#ifndef CLIENTUTILITY_H
+#define CLIENTUTILITY_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/mmfstandardcustomcommandsimpl.h>
+#endif
+
+class RMMFDRMPluginServerProxy;
+namespace multimedia
+ {
+ class CMMSourceSink; // declared here.
+
+ NONSHARABLE_CLASS( CMMSourceSink ): public CBase
+ {
+ public:
+ static CMMSourceSink* NewL(TUid aUid, const TDesC8& aDescriptor);
+ 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:
+ static CMMFileSourceSink* NewL(TUid aUid, const RFile& aFile);
+ static CMMFileSourceSink* NewLC(TUid aUid, const RFile& aFile);
+
+ static CMMFileSourceSink* NewL(TUid aUid, const TMMSource& aMMSource);
+ 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;
+
+ 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:
+ static CMMFMdaObjectStateChangeObserverCallback* NewL(MMdaObjectStateChangeObserver& aCallback);
+ virtual ~CMMFMdaObjectStateChangeObserverCallback();
+ 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:
+ static TUid ConvertMdaFormatUidToECOMWrite(TUid aMdaFormatUid);
+ static TUid ConvertMdaFormatUidToECOMRead(TUid aMdaFormatUid);
+ static TFourCC ConvertMdaCodecToFourCC(TMdaPackage& aCodec);
+ static TInt GetFileHeaderData(const TDesC& aFileName, TDes8& aHeaderData, TInt aMaxLength);
+ 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.
+
+ 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:
+ TSourceSink(TUid aUid, const TDesC8& aData = KNullDesC8);
+ TSourceSink(TUid aUid, const RFile& aFile);
+
+ TUid iUid;
+ const TDesC8& iConfigData;
+ TBool iUseFileHandle;
+ RFile iFileHandle;
+ };
+
+
+
+
+ public:
+ 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);
+
+ void Configure(
+ TUid aMediaId,
+ TMMFPrioritySettings aPrioritySettings,
+ CMMFPluginSelectionParameters::TMediaIdMatchType aMediaIdMatchType = CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);
+
+ void ConfigureController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
+ void ConfigureSecondaryController(RMMFController& aController, CMMFControllerEventMonitor& aEventMonitor, TControllerMode aControllerMode = EPlayback);
+
+ void UseSharedHeap();
+
+ void ConfigureSourceSink(
+ TSourceSink aSource,
+ TSourceSink aSink);
+ void ConfigureSecondarySourceSink(
+ TSourceSink aSource,
+ TSourceSink aSink);
+
+ void ConfigureSourceSink(
+ const TMMSource& aSource,
+ TSourceSink aSink);
+
+ void OpenByFileSource(const TMMSource& aFileSource, const TDesC& aFileNameSecondary = KNullDesC);
+
+ void OpenByFormatUid(TUid aFormatUid, TUid aFormatUidSecondary = KNullUid);
+ void OpenByDescriptor(const TDesC8& aDescriptor);
+ void OpenByUrl(const TDesC& aUrl, TInt aIapId, const TDesC8& aMimeType);
+ void OpenByControllerUid(TUid aControllerUid, TUid aSecondaryControllerUid = KNullUid);
+ void OpenByMimeType(const TDesC8& aMimeType);
+
+ void FindByMimeTypeL(const TDesC8& aMimeType);
+ void OpenController();
+
+ void ReOpen();
+ void Close();
+
+ static TMMFFileConfig GetConfigFile(const TDesC& aFileName);
+ static TMMFDescriptorConfig GetConfigDescriptor(const TDesC8& aDescriptor);
+ static TInt GetConfigUrl(CBufFlat*& aUrlCfgBuffer, const TDesC& aUrl, TInt aIapId);
+ void CloseConfig();
+
+ /** 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;
+ void SetInitScreenNumber(TInt aScreenNumber, RMMFVideoSetInitScreenCustomCommands* aVideoSetInitScreenCustomCommands);
+
+ 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 BuildControllerListMimeTypeL();
+ 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,
+ EOpenByMimeType
+ };
+ 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 iUseFileSource;
+ 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 iOwnFileHandle;
+ TBool iStopTryLoadController; //stop to try loading the selected conrollers from the list
+ RMMFVideoSetInitScreenCustomCommands* iVideoSetInitScreenCustomCommands;
+ TInt iScreenNumber;
+ TBool iHasDrmCapability;
+ TBool iUsingSecureDrmProcess;
+ };
+
+inline TInt CMMFFindAndOpenController::ControllerIndex() const
+ {
+ return iControllerIndex;
+ }
+
+inline TInt CMMFFindAndOpenController::ControllerCount() const
+ {
+ return iControllerCount;
+ }
+
+inline TBool CMMFFindAndOpenController::StopTryLoadController() const
+ {
+ return iStopTryLoadController;
+ }
+ } // namespace multimedia
+
+#endif //CLIENTUTILITY_H
+
+ // End of File