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