diff -r 000000000000 -r a2952bb97e68 mpx/playbackframework/playbackengine/inc/mpxplaybackengine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpx/playbackframework/playbackengine/inc/mpxplaybackengine.h Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,1009 @@ +/* +* 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: Controls playback via plug-ins +* +*/ + + + +#ifndef CMPXPLAYBACKENGINE_H +#define CMPXPLAYBACKENGINE_H + + +#include +#include +// +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mpxplaybackpluginhandler.h" +#include "mpxplaybackcommandbufferobserver.h" +#include "mpxaccessoryobserver.h" +#include "mpxplaybacksettings.h" + +class CMPXPluginMonitor; +class CMPXPlaybackPluginHandler; +class CMPXAutoResumeHandler; +class CMPXPlaybackCmdBuffer; +class CMPXCollectionPlaylist; +class MMPXPlaybackActiveEngineObserver; +class CMPXActiveTaskQueue; +class CMPXPlaybackInitializer; +class CMPXPlaybackMediaHelper; +class CMPXPlaybackDummyMediaObserver; + +// Constants +_LIT(KMPXPlaybackPluginVersion2, "MPXPlaybackPluginVersion2"); +/** +* The playback 'engine' which delegates to plug-ins (or 'players'). Unless +* stated otherwise, methods apply to currently loaded plug-in (player) and +* currently initialised song. +*/ +class CMPXPlaybackEngine : public CBase, + public MMPXPlaybackPluginObserver, + public MMPXPlaybackCmdBufferObserver, + public MBeating, + public MMPXAccessoryEventObserver, + public MMPXTaskQueueObserver, + public MMPXCollectionMediaObserver, + public MMPXCollectionPlaylistObserver, + public MMPXPluginHandlerObserver + { +public: + + /** + * Two-phased constructor. + * + * @param aPluginMonitor plugin monitor + * @param aObserver engine observer + * @param aClientListObserver client list observer + * @param aModeId denotes whether this player is designated for the + * stand-alone application + * @return Constructed object + */ + IMPORT_C static CMPXPlaybackEngine* NewL( + CMPXPluginMonitor& aPluginMonitor, + MMPXPlaybackActiveEngineObserver& aObserver, + MMPXClientlistObserver* aClientListObserver, + const TUid& aModeId); + + + /** + * Two-phased constructor. + * + * @param aPluginMonitor plugin monitor + * @param aObserver engine observer + * @param aClientListObserver client list observer + * @param aModeId denotes whether this player is designated for the + * stand-alone application + * @param aCategory category of engine (Music, Video) + * @return Constructed object + */ + IMPORT_C static CMPXPlaybackEngine* NewL( + CMPXPluginMonitor& aPluginMonitor, + MMPXPlaybackActiveEngineObserver& aObserver, + MMPXClientlistObserver* aClientListObserver, + const TUid& aModeId, + const TInt aCategory); + + + /** + * Destructor + */ + IMPORT_C ~CMPXPlaybackEngine(); + +public: + + /** + * Returns reference to client list + * + * @return client list object + */ + inline CMPXClientList* ClientList(); + + /** + * Returns object encapsulating list of clients and its management + * + * @return playback plugin handler + */ + inline CMPXPlaybackPluginHandler* PluginHandler(); + + /** + * Does this player (i.e. the currently loaded plug-in) have access to + * audio resources + * + * @return ETrue audio resource is used by the player + */ + inline TBool IsPlayerActive() const; + + /** + * Return mode id of this engine + * + * @return mode id + */ + inline const TUid& ModeId() const; + + + /** + * Return category of this engine + * + * @return category + */ + + inline const TInt Category() const; + + + /** + * Current state + * + * @return playback state + */ + inline TMPXPlaybackState State() const; + + /** + * Current collection path, or NULL if none (i.e. not from collection) + */ + inline const CMPXCollectionPlaylist* Playlist() const; + + /** + * Current song index, or KErrNotFound if none (i.e. not from collection) + */ + inline TInt SongIndex() const; + + /** + * Current uri, or KNullDesC if none (i.e. uri not supplied) + */ + inline const TDesC& Uri() const; + + /** + * Current file handle + */ + inline const RFile& File() const; + + /** + * Retursn last active process id + * + * @return process id of last active process + */ + inline TProcessId LastActiveProcessId() const; + + /** + * Retursn last inactive process id + * + * @return process id of last inactive process + */ + inline TProcessId LastInactiveProcessId() const; + + /** + * Initializes the player with a song in the collection + * + * @param aCollectionPath collection path + * @param aPlay Whether to initialize for playback, or + * else just to setup the engine first + */ + IMPORT_C void InitL( const CMPXCollectionPlaylist& aPlaylist, + TBool aPlay ); + + /** + * Initializes the player with a uri - doesn't use collection + * + * @param aUri URI of the song + * @param aType the type of song + */ + IMPORT_C void InitL(const TDesC& aUri,const TDesC8& aType); + + /** + * Initializes the player with a file - doesn't use collection + * + * @aFile file handle + */ + IMPORT_C void InitL(const RFile& aFile); + + /** + * Initializes the player with a uri and Access Point + * + * @since S60 9.2 + * @param aUri URI of the item + * @param aType the mime type of the item + * @param aAccessPoint the access point of the item + */ + IMPORT_C void InitStreamingL(const TDesC& aUri, const TDesC8& aType, const TInt aAccessPoint); + + /** + * Initializes the player with a file and access point + * + * @since S60 9.2 + * @param aFile file handle + * @param aAccessPoint the access point of the item + */ + IMPORT_C void InitStreamingL(const RFile& aFile, const TInt aAccessPoint); + + /** + * Cancel all outstanding, asynchronous requests + */ + IMPORT_C void CancelRequests(); + + /** + * Issue a playback command + * + * @param aCmd playback command + * @param aData optional data + */ + IMPORT_C void CommandL(TMPXPlaybackCommand aCmd,TInt aData=0); + + /** + * Issue a playback command + * + * @param aCmd playback command + * @param aMsgQueue Message Queue for the client + */ + IMPORT_C void CommandL(CMPXCommand& aCmd, const CMPXMessageQueue& aMsgQueue); + + /** + * Sets the property value. Value not set until a property changed event is + * returned to the client + */ + IMPORT_C void SetL(TMPXPlaybackProperty aProperty,TInt aValue); + + /** + * Asynchronously retrieves the value of a property. Result will be called + * back by using MMPXPlaybackEngineObserver + */ + IMPORT_C void PropertyL(TMPXPlaybackProperty aProperty, + MMPXPlaybackEngineObserver& aCallback); + + /** + * DEPRECATED + * + * Asynchronously return media properties + * using MMPXPlaybackEngineObserver + * + * @param aCallback playback callback + * @param aBuf parameter buffer, take over the ownership + */ + IMPORT_C void MediaL(MMPXPlaybackEngineObserver& aCallback, CBufBase* aBuf); + + /** + * Asynchronously return media properties + * using MMPXPlaybackEngineObserver + * + * @param aCallback playback callback + * @param aCmd Command object containing attribute spec and attribute array + */ + IMPORT_C void MediaL(MMPXPlaybackEngineObserver& aCallback, const CMPXCommand& aCmd); + + /** + * Asynchronously retrieves the sub player names. See MMPXPlayerManager + * + * @param aCallback playback callback + */ + IMPORT_C void SubPlayerNamesL(TUid aPlayerUid, + MMPXPlaybackEngineObserver& aCallback); + + /** + * Gets media from the plugin + * + * @param aCallback Callback method to call after retrieving media + * @param aCmd Command containing the media attributes and attribute specs. + * Ownership transfered + */ + void MediaFromPluginL( MMPXPlaybackEngineObserver* aCallback, + CMPXCommand* aCmd ); + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + /** + * Current file handle + */ + inline const RFile64& File64() const; + + /** + * Initializes the player with a file - doesn't use collection + * + * @aFile file handle + */ + IMPORT_C void Init64L(const RFile64& aFile); + + /** + * Initializes the player with a file and access point + * + * @since S60 9.2 + * @param aFile file handle + * @param aAccessPoint the access point of the item + */ + IMPORT_C void InitStreaming64L(const RFile64& aFile, const TInt aAccessPoint); +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +public: + + /** + * Handle command + * + * @param aCmd command + */ + void HandleCommandL(TMPXPlaybackCommand aCmd, TInt aData=0); + +private: + enum TPlaySource + { + EPlayNone, + EPlayFromCollection, + EPlayFromUri, + EPlayFromFile, + EPlayFromFile64 + }; + + enum TAsyncRequest + { + EProperty, + EMedia, + ESubPlayerNames, + EHandleNext + }; + + /** + * Helper class to reflect playback call back to engine itself. + */ + class TCallbackReflector : public MMPXPlaybackEngineObserver + { + public: + + /** + * Contructor + * + * @param aEngine playback engine + */ + inline TCallbackReflector(CMPXPlaybackEngine& aEngine); + + /** + * From MMPXPlaybackEngineObserver + * Handle playback property + * + * @param aProperty the property + * @param aValue the value of the property + * @param aError error code + */ + inline void HandleProperty(TMPXPlaybackProperty aProperty, + TInt aValue, + TInt aError); + + /** + * From MMPXPlaybackEngineObserver + * Method is called continously until aComplete=ETrue, signifying that + * it is done and there will be no more callbacks + * Only new items are passed each time + * + * @param aPlayer UID of the subplayer + * @param aSubPlayers a list of sub players + * @param aComplete ETrue no more sub players. EFalse more subplayer + * expected + * @param aError error code + */ + inline void HandleSubPlayerNames(TUid aPlayer, + const MDesCArray* aSubPlayers, + TBool aComplete, + TInt aError); + + /** + * From MMPXPlaybackEngineObserver + * Handle media object + * + * @param aMedia media object + * @param aError error code + */ + inline void HandleMedia(CMPXMedia* aMedia, TInt aError); + + private: + CMPXPlaybackEngine& iEngine; + }; + +private: + + /** + * C++ constructor + * + * @param aPluginMonitor plugin monitor + * @param aObserver engine observer + * @param aModeId player engine mode + */ + CMPXPlaybackEngine(CMPXPluginMonitor& aPluginMonitor, + MMPXPlaybackActiveEngineObserver& aObserver, + const TUid& aModeId); + + + /** + * C++ constructor + * + * @param aPluginMonitor plugin monitor + * @param aObserver engine observer + * @param aModeId player engine mode + * @param aCategory player engine category + */ + + CMPXPlaybackEngine(CMPXPluginMonitor& aPluginMonitor, + MMPXPlaybackActiveEngineObserver& aObserver, + const TUid& aModeId, + const TInt aCategory); + + + /** + * 2nd phase contructor + * + * @param aClientListObserver client list observer + */ + void ConstructL(MMPXClientlistObserver* aClientListObserver); + + +private: // Functions from base class + + /** + * From MBeating + * Handles a regular heartbeat timer event + */ + void Beat(); + + /** + * From MBeating + * Synchronises the heartbeat timer with system clock + */ + void Synchronize(); + + /** + * From MMPXPlayerAccessoryEventObserver + * Handle accessory event + * + * @param aMode playback accessory mode + */ + void HandleAccesoryEventL(TMPXPlaybackAccessoryMode aMode); + + /** + * From MMPXPlaybackPluginObserver + * Handle plugin event + * + * @param aEvent the event type + * @param aData optional data + * @param aError error code of the event + */ + void HandlePluginEvent(TEvent aEvent,TInt aData,TInt aError); + + /** + * From MMPXPlaybackPluginObserver + * Handle message from plug-in + * + * @param aMsg, message from the plug-in. Ownership not transferred. + * @param aErr system error code. if aErr is not KErrNone, aMsg will not be + * used/dereferenced at playback engine. + */ + void HandlePlaybackMessage(CMPXMessage* aMsg, TInt aErr); + + /** + * From MMPXPlaybackPluginObserver + * Async response for Value request + * + * @param aProperty property key + * @param aValue property value + * @param aError error code + */ + void HandleProperty(TMPXPlaybackProperty aProperty, + TInt aValue, TInt aError); + + /** + * From MMPXPlaybackPluginObserver + * Async response for MediaL request + * + * @param aMedia media object + * @param aError error code + */ + void HandleMedia(CMPXMedia* aMedia, TInt aError); + + /** + * From MMPXPlaybackPluginObserver + * Async response for subplayer request + * + * @param aPlayer UID of the subplayer + * @param aSubPlayers array of subplayers + * @param aComplete ETrue, completed, EFalse, not completed + * @param aError error code + */ + void HandleSubPlayerNames(TUid aPlayer, const MDesCArray* aSubPlayers, + TBool aComplete, TInt aError); + + /** + * From MMPXPlaybackCmdBufferObserver + * Handle command from buffering + * + * @param aEvent comand info + */ + void HandleCmdBufferEventL(const TMPXPlaybackCmdInfo& aEvent); + + /** + * From MMPXPlaybackCmdBufferObserver + * Handle command skip event from key buffering + * + * @param aSkipEvent Skip event + */ + void HandleCmdBufferSkipEventL(const TMPXPlaybackSkipEvent aSkipEvent); + + /////////////////////////////////////////////////////////////////////////// + // From MMPXTaskQueueObserver + + /** + * Execute a task + * @param aTask task number + * @param aParamData, parameter + * @param aPtrData, any object + * @param aBuf, buffer containing externalized parameters for the task. + * @param aCallback call back function pointer + * @param aCObject1 object 1 owned by task queue + * @param aCObject2 object 2 owned by task queue + */ + void ExecuteTask(TInt aTask, + TInt aParamData, + TAny* aPtrData, + const CBufBase& aBuf, + TAny* aCallback, + CBase* aCObject1, + CBase* aCObject2); + + /** + * From MMPXCollectionMediaObserver + * Handle media properties from collection + * + * @param aMedia media + * @param aError error code + */ + void HandleCollectionMediaL(const CMPXMedia& aProperties, TInt aError); + + /** + * From MMPXCollectionPlaylistObserver + * Handle collection playlist change + * + * @param aError KErrNotFound - Playlist is updated, current item removed + * KErrNone - Playlist is updated, current item is valid + * KErrEof - Playlist is updated, current item removed and + * reached to the end of playlist + */ + void HandleCollectionPlaylistChange(TInt aError); + + /////////////////////////////////////////////////////////////////////////// + // From MMPXPluginHandlerObserver + + /* + * @see MMPXPluginHandlerObserver + */ + void HandlePluginHandlerEvent(TPluginHandlerEvents aEvent, const TUid& aPluginUid, + TBool aLoaded, TInt aData); + +private: // New functions + + + /** + * Return current plugin + * + * @return plugin object + */ + inline CMPXPlaybackPlugin* PluginL() const; + + /** + * Suspend playback + */ + void Suspend(); + + /** + * Seek timer tick + */ + void SeekTimerTick(); + + /** + * Seek timer callback + * + * @param aPtr pointer the this + */ + static TInt SeekTimerCallback(TAny* aPtr); + + /** + * Init plugin + * + * @param aSong, song path + * @param aType, song type + * @param aFile, file handle + * @param aAccessPoint aAccessPoint + */ + void InitL(const TDesC* aSong,const TDesC8* aType,RFile* aFile, + TInt aAccessPoint=0); + + /** + * Handle play command + */ + void HandlePlayL(); + + /** + * Handle play command with fade in + */ + void HandlePlayWithFadeInL(); + + /** + * Handle pause command + */ + void HandlePauseL(); + + /** + * Handle stop command + */ + void HandleStopL(); + + /** + * Stop play back + * @param aSavePlaybackInfo flag to determine if the PlaybackInfo should be saved + */ + void DoStopL(TBool aSavePlaybackInfo = ETrue); + + /** + * Handle next command + * @param aOffset offset to current index + * @param aIgnoreRepeat ETrue to ignore repeat setting + */ + void HandleNextL( TInt aOffset = 1, TBool aIgnoreRepeat=EFalse ); + + /** + * Handle previous command + * @param aOffset offset to current index + * @param aIgnoreRepeat ETrue to ignore repeat setting + */ + void HandlePreviousL(TInt aOffset = -1, TBool aIgnoreRepeat=EFalse ); + + /** + * Handle replay command + */ + void HandleReplayL(); + + /** + * Handle sart seekingcommand + */ + void HandleStartSeekL(TBool aForward); + + /** + * Handle stop seeking command + */ + void HandleStopSeekingL(); + + /** + * Handle increase volume command + */ + void HandleIncreaseVolumeL(); + + /** + * Handle decrease volume command + */ + void HandleDecreaseVolumeL(); + + /** + * Handle set volume command + */ + void HandleSetVolumeL(TInt aVolume); + + /** + * Handle mute command + */ + void HandleMuteL(TBool aMute); + + /** + * Handle close command + * @param aData data to be forwarded to the player + */ + void HandleCloseL( TInt aData = KErrNone ); + + /** + * Handle a custom command + */ + void HandleEffectL(TInt aData); + + /** + * Handle a custom command + */ + void HandleDisableEffectL(); + + /** + * Handle a request to close the file handle for an item + * @param aItemId item that is requested to be freed + */ + void HandleCloseItemL( TInt aItemId ); + + /** + * Sets the current properties for the plug-in + */ + void SetPropertiesL(); + + /** + * Stop seeking timer + */ + void EndSeek(); + + /** + * Set a playback state + * @param aState new state + */ + void SetStateL(TMPXPlaybackState aState); + + /** + * Set a playback state, takes in a TMPXPlaybackMessage with the + * state already set as the iType parameter. This Allows caller to + * set iData information as well. + * @param aMessage Message containing state information + */ + void SetStateL( TMPXPlaybackMessage& aMsg ); + + /** + * Set player activated + * @param aActive ETrue actived, EFalse inactived. + */ + void SetPlayerActivated(TBool aActive); + + /** + * Execute a task + * @param aTask task number + * @param aParamData, parameter + * @param aPtrData, any object + * @param aCallback call back function pointer + * @param aBuf buffer data + * @param aCObject1 object 1 owned by task queue + * @param aCObject2 object 2 owned by task queue + */ + void ExecuteTaskL(TInt aTask, + TInt aParamData, + TAny* aPtrData, + TAny* aCallback, + const CBufBase& aBuf, + CBase* aCObject1, + CBase* aCObject2); + + /** + * @see MMPXTaskQueueObserver + */ + void HandleTaskError(TInt aTask, + TAny* aPtrData, + TAny* aCallback, + TInt aError); + + /** + * Handle error of execution + * @param aTask task number + * @param aErr error number + * @param aParamData parameter + */ + void HandleError(TInt aTask, TInt aErr, TInt aParamData = 0); + + /** + * Get command from state + */ + TMPXPlaybackCommand CommandFromState( TMPXPlaybackState aState ); + + /** + * Cleanup when the engine closed + */ + void DoClose(); + + /** + * Media request from collection + */ + void MediaFromCollectionL(); + + /** + * Handle plugin event + * + * @param aEvent the event type + * @param aData optional data + * @param aError error code of the event + */ + void DoHandlePluginEventL(TEvent aEvent,TInt aData,TInt aError); + + /** + * Update playbackengine state machine + * Handles plugin events that could cause state change in playback-engine + * + * @param aEvent the event type + * @param aData optional data + * @param aError error code of the event + */ + void UpdateStateMachineL(TEvent aEvent,TInt aData,TInt aError); + + /* + * Handle plugin event error handling + * This is internal function called from DoHandlePluginEvent() + * @param aEvent the event type + * @param aError error code of the event + */ + void HandlePluginEventErrorHandling(TEvent aEvent, TInt aError); + + /* + * Handle Plugin Event: Initialised + * Handles the event called Initialised + * @param aState the mpx playbackstate + * @param aData data passed from playback plugin in call to HandlePluginEvent + */ + void HandlePluginEventInitialisedL(TMPXPlaybackState& aState, TInt aData); + + /** + * Save playback Information + */ + void SavePlaybackInfoL(); + + /** + * Increments play count + */ + void SavePlaybackCompleteInfoL(); + + /** + * Restore playback position and state if it was saved previously + */ + void RestorePlaybackPositionAndStateL( const CMPXMedia& aMedia ); + + /** + * Sets the volume increment depending on accessory state + */ + void SetVolumeIncrement( TMPXPlaybackAccessoryMode aMode ); + + /** + * Marks the current item as corrupted + * @param aCorrupted Flag if corrupted or not + */ + void MarkItemCorrupted( const TBool aCorrupted ); + + /** + * Marks the current item as invalid + * @param aInvalid Flag if invalid or not + */ + void MarkItemInvalid( const TBool aInvalid ); + + /** + * Marks the current item as DRM invalid (e.g. no rights) + * @param aDrmInvalid Flag if invalid or not + */ + void MarkItemDrmInvalid( const TBool aDrmInvalid ); + + /** + * Sets flag bits + * @aSet ETrue to set, EFalse to unset + * @aFlag Flag bits to set/unset + */ + void SetFlagBitsL( const TBool aSet, const TUint aFlag ); + + /** + * Creates a CMPXMedia object to be used to Set attributes + * @param aPath Collection Path + * @return CMPXMedia object + */ + CMPXMedia* CreateMediaToSetLC( const CMPXCollectionPath& aPath ); + + /** + * Sends a request to iMediaHelper to request media + */ + void RequestMediaL(); + + /** + * Sends a plugin handler message to all clients. + * @param aMessageId the value of the KMPXMessageGeneralId attribute + * @param aPluginUid plugin UID this message is for + * @param aLoaded ETrue if the plugin is loaded + * @param aVersion plugin version + */ + void SendPluginHandlerMessageL(TInt aMessageId, const TUid& aPluginUid, + TBool aLoaded, TInt aVersion = 0); + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + /** + * Init plugin + * + * @param aSong, song path + * @param aType, song type + * @param aFile, file handle + * @param aAccessPoint aAccessPoint + */ + void Init64L(RFile64* aFile, TInt aAccessPoint=0); +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + +private: + friend class TCallbackReflector; + friend class CMPXPlaybackInitializer; + + TCallbackReflector iReflector; + CMPXPluginMonitor& iPluginMonitor; + CMPXClientList* iClientList; + CMPXPlaybackInitializer* iInitializer; + CMPXPlaybackPluginHandler* iPluginHandler; + TBool iInitNext; + /** + * Utilities + */ + CHeartbeat* iProgressTimer; + CPeriodic* iSeekTimer; + CMPXAccessoryObserver* iAccessoryObs; + CMPXPlaybackCmdBuffer* iCmdBuffer; + CMPXPlaybackSettings* iPlaybackSettings; + CMPXAutoResumeHandler* iAutoResumeHandler; + + /** + * Playlist/song data + */ + CMPXCollectionPlaylist* iPlaylist; + HBufC* iUri; + TMPXItemId iItemId; + RFile iFile; + TPlaySource iPlaySource; + TUint iDbFlag; + TInt iMediaDuration; // Duration value inside CMPXMedia + + TInt iAccessPoint; + TBool iAccessPointSet; // Access Point is set + + /** + * This player data + */ + TMPXPlaybackState iState; // current state + TMPXPlaybackState iNextState; // next possible state when handling commands + TMPXPlaybackState iPluginState; // plugin state + TBool iEmbeddedMode; + TUid iModeId; + TInt iCategory; + TBool iPlayerActive; + // + TFixedArray iProperties; + TInt iSeekStep; // millisecond + TInt iMaxSeekStep; // millisecond + MMPXPlaybackActiveEngineObserver& iObserver; + CMPXActiveTaskQueue* iTaskQueue; + MMPXPlaybackEngineObserver* iCallback; // Not owned. + + TMPXPlaybackState iPreservedState; + TInt iPreservedPosition; + + TInt iVolumeIncrement; + RArray iMediaAttrs; + TBool iSkipping; + CMPXPlaybackMediaHelper* iMediaHelper; + + CMPXPlaybackDummyMediaObserver* iDummyMediaObserver; + TUid iPluginUid; // plugin uid for current item of current playlist + TProcessId iLastActiveProcess; // Last active process for this engine + TProcessId iLastInactiveProcess; // Last inactive process for this engine + TBool iInitVolume; // Initialize volume on first creation + // the index which be firstly saved when request media + TInt iFirstRequestMediaIndex; +#if defined(__HIGH_RESOLUTION_VOLUME) + // flag to indicate whether the volume setting has been rounded up last + // used to adjust volume up button setting + TBool iVolRoundedUp; +#endif + +#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + RFile64 iFile64; +#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + }; + +#include "mpxplaybackengine.inl" + +#endif // CMPXPLAYBACKENGINE_H +