diff -r 052d4b8fc4fd -r a2070821d450 breakdeps/mmfclientutility.h --- /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 +#include +#include +#include +#include +#include "mmf/common/mmfcontrollerpluginresolver.h" +#include +#include +#include "mmf/common/mmfcontroller.h" + +#include +#include +#include +#include +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#endif +#ifdef SYMBIAN_BUILD_GCE +#include +#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__