1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Interface to playback

    15 *

    16 */

    17 

    18 

    19 #ifndef MMPXPLAYBACKUTILITY_H

    20 #define MMPXPLAYBACKUTILITY_H

    21 

    22 #include <mpxplaybackframeworkdefs.h>

    23 #include <mpxcommonframeworkdefs.h>

    24 #include <badesca.h>

    25 #include <mpxattribute.h>

    26 #include <mpxcommand.h>

    27 #include <mpxattributespecs.h>

    28 

    29 class RFile;

    30 class CMPXMedia;

    31 class MMPXPlayer;

    32 class MMPXSource;

    33 class MMPXPlayerManager;

    34 class MMPXPlaybackObserver;

    35 class MMPXPlaybackCallback;

    36 class CMPXCollectionPlaylist;

    37 class CMPXSubscription;

    38 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    39 class RFile64;

    40 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

    41 

    42 /**

    43 *  Main client interface for playback. Some terms used in the documentation of

    44 *  this interface:

    45 *

    46 *    Engine - it is the 'engine' which manages the playback and maintains the

    47 *             state. An abstract concept for where the playback functionality

    48 *             is somehow implemented, but is completely hidden from the client.

    49 *

    50 *    Player - the engine may access of a number of 'players' for playback,

    51 *             using only one at a time. A player is an abstract concept

    52 *             representing the knowledge to play either a 'specific kind of item',

    53 *             or 'play in a specific way', or both. The player may therefore

    54 *             automatically change between items if required

    55 *             ('specific kind of item'), or the client may choose the players

    56 *             that are used ('play in a specific way').

    57 *

    58 *    Sub player - a player may support 0 or more 'sub' players, a logical

    59 *             concept whereby the client,having chosen a player, can select

    60 *             options within this player identified by name (text)

    61 *

    62 *    Playlist - an abstract list of items. A collection path allows the client

    63 *             to cross reference the playlist with a collection, for example to

    64 *             iterate through the playlist, extract user-supplied metadata etc.

    65 *

    66 *    @lib mpxplaybackutility.lib

    67 *

    68 */

    69 class MMPXPlaybackUtility

    70     {

    71 public:

    72     /**

    73     *  Creates the interface for the client. This interface is bound to (i.e.

    74     *  controls and recieves events from) either an existing engine or a new

    75     *  one, according to:

    76     *

    77     *    aModeId=KPbModeDefault - bound to the same engine as any other player

    78     *                           running in same thread, or KPbModeNewPlayer if none.

    79     *    aModeId=KPbModeActivePlayer - bound to whichever engine has audio access,

    80     *                           else whichever is running, provided the category 

    81 	*							of client and engine match. Else KPbModeNewPlayer if none.

    82     *    aModeId=KPbModeNewPlayer - new engine created specifically for client,

    83     *                            may be shared later.

    84     *    aModeId=Application UID - bound to the same engine as the stand alone

    85     *                            Application.

    86     *	When no category is supplied (as with this API), EMPXCategoryMusic is assumed.

    87 	*	For category description, refer to next API. 

    88 	*

    89     *  @since S60 3.2.3

    90     *  @param aModeId playback mode

    91     *  @param aObs plabyback observer

    92     *  @return playback utility object

    93     */

    94     IMPORT_C static MMPXPlaybackUtility* NewL(

    95                                         const TUid& aModeId = KPbModeDefault,

    96                                         MMPXPlaybackObserver* aObs=NULL);

    97 

    98 

    99     /**

   100     *  Creates the interface for the client. This interface is bound to (i.e.

   101     *  controls and recieves events from) either an existing engine or a new

   102     *  one, according to:

   103     *

   104     *    aModeId=KPbModeDefault - bound to the same engine as any other player

   105     *                           running in same thread, or KPbModeNewPlayer if none.

   106     *    aModeId=KPbModeActivePlayer - bound to whichever engine has audio access,

   107     *                           else whichever is running, provided the category 

   108 	*							of client and engine match. Else KPbModeNewPlayer if none.

   109     *    aModeId=KPbModeNewPlayer - new engine created specifically for client,

   110     *                            may be shared later.

   111     *    aModeId=Application UID - bound to the same engine as the stand alone

   112     *                            Application.

   113     *		

   114 	*	 aCategory - a client can associate itself with a category (TMPXCategory).

   115 	*	 Category is used primarily with the KPbModeActivePlayer mode. The client gets 

   116 	*	 EActivePlayerChanged message only when an engine with the same category becomes  

   117 	*	 active. If a new engine (player) is created, the engine is tagged 

   118 	*	 with the category. When no category is supplied, EMPXCategoryMusic is assumed.

   119 	*	 

   120     *  @since S60 3.2.3

   121     *  @param aCategory engine category (TMPXCategory)

   122     *  @param aModeId playback mode

   123     *  @param aObs plabyback observer

   124     *  @return playback utility object

   125     */

   126     IMPORT_C static MMPXPlaybackUtility* NewL(

   127                                             const TMPXCategory aCategory,

   128                                             const TUid& aModeId = KPbModeDefault,

   129                                             MMPXPlaybackObserver* aObs=NULL);

   130 

   131     /*

   132     * Gets the interface for the client, or creates a new one.

   133     * This interface could be a singleton.

   134     *

   135     * @since S60 3.2.3

   136     */

   137     IMPORT_C static MMPXPlaybackUtility* UtilityL(

   138                                         const TUid& aModeId = KPbModeDefault );

   139 

   140     /*

   141     * Gets the interface for the client, or creates a new one.

   142     * This interface could be a singleton.

   143     * Variant of API with supplied category

   144 	*

   145     * @since S60 3.2.3

   146     */

   147     IMPORT_C static MMPXPlaybackUtility* UtilityL(

   148                                         const TMPXCategory aCategory,

   149                                         const TUid& aModeId = KPbModeDefault );

   150 

   151 

   152     /**

   153     *  Add a Observer. Clients only receive events from the engine corresponding

   154     *  to the specific mode the interface was created in.

   155     *

   156     *  @since S60 3.2.3

   157     *  @param aObs observer to be added

   158     */

   159     virtual void AddObserverL(MMPXPlaybackObserver& aObs)=0;

   160 

   161     /**

   162     *  Remove a observer.

   163     *

   164     *  @since S60 3.2.3

   165     *  @param aObs observer to be removed

   166     */

   167     virtual void RemoveObserverL(MMPXPlaybackObserver& aObs)=0;

   168 

   169     /**

   170     *  Returns PIds of clients that are using the engine in the mode this

   171     *  interface was created in. For example, if a client was interested in all

   172     *  the clients' pids with an active engine, they would:

   173     *

   174     *       MMPXPlaybackUtility* m=MMPXPlaybackUtility::NewL(EActivePlayer);

   175     *       RArray<TProcessId> pids;

   176     *       m->GetClients(pids);

   177     *       .........

   178     *       pids->Close();

   179     *       m->Close();

   180     *  From the Array of clients returned, the first one will be the

   181     *  last active one.

   182     *

   183     *  @since S60 3.2.3

   184     *  @param aClients Array of Pids returned.

   185     */

   186     virtual void GetClientsL(RArray<TProcessId>& aClients)=0;

   187 

   188     /**

   189     *  Initializes a track given by aCollectionPath.

   190     *

   191     *  @since S60 3.2.3

   192     *  @param aCollectionPath collection path

   193     *  @param aPlay Whether to initialize for playback, or

   194     *               else just to setup the engine first

   195     */

   196     virtual void InitL(const CMPXCollectionPlaylist& aPlaylist,

   197                        TBool aPlay=ETrue)=0;

   198 

   199     /**

   200     *  Inititialises with a single item, may not be part of any collection.

   201     *

   202     *  @since S60 3.2.3

   203     *  @param aUri URI of the item

   204     *  @param aType the mime type of the item

   205     */

   206     virtual void InitL(const TDesC& aUri, const TDesC8* aType=NULL)=0;

   207 

   208     /**

   209     *  Inititialises with a single item, may not be part of any collection

   210     *  Before this function can be called, the file server session which owns

   211     *  this file handle must first be marked as shareable by calling

   212     *  RFs::ShareProtected().

   213     *

   214     *  @since S60 3.2.3

   215     *  @param aShareableFile shareable file handle

   216     */

   217     virtual void InitL(RFile& aShareableFile)=0;

   218 

   219     /**

   220     *  Frees up client side resources only; a player is freed when there are no

   221     *  clients using it, and all resources are freed when the last client closed.

   222     *

   223     *  @since S60 3.2.3

   224     */

   225     virtual void Close()=0;

   226 

   227     /**

   228     *  Stops any async operations that are currently under way.

   229     *

   230     *  @since S60 3.2.3

   231     */

   232     virtual void CancelRequest()=0;

   233 

   234     /** 

   235     *  Issue player commands, with optional data. ECommandReceived and

   236     *  ECommandComplete events should follow.

   237     *

   238     *  @since S60 3.2.3

   239     *  @param aCmd the command

   240     *  @param aData optional data

   241     *  @deprecated Use method MMPXPlaybackUtility::CommandL(CMPXCommand& aCmd,

   242     *             MMPXPlaybackCallback* aCallback=NULL) instead.

   243     */

   244     virtual void CommandL(TMPXPlaybackCommand aCmd, TInt aData=0)=0;

   245 

   246     /**

   247      *  Send a command to the playback server.

   248      *

   249      *  @since S60 3.2.3

   250      *  @param aCmd reference to command object

   251      *  @param aCallback call back when command exection completed.

   252      *                    Asynchronously command only

   253      */

   254     virtual void CommandL(CMPXCommand& aCmd,

   255                           MMPXPlaybackCallback* aCallback=NULL)=0;

   256 

   257     /**

   258     *  Current state of player.

   259     *

   260     *  @since S60 3.2.3

   261     *  @return current state

   262     */

   263     virtual TMPXPlaybackState StateL() const=0;

   264 

   265     /**

   266     *  Current source of playlist being played, NULL if none was supplied.

   267     *

   268     *  @since S60 3.2.3

   269     *  @return source object

   270     */

   271     virtual MMPXSource* Source()=0;

   272 

   273     /**

   274     *  Player manager.

   275     *

   276     *  @since S60 3.2.3

   277     *  @return reference to player manager

   278     */

   279     virtual MMPXPlayerManager& PlayerManager()=0;

   280 

   281     /**

   282     *  Set playback property, EPropertyChanged event when complete.

   283     *

   284     *  @since S60 3.2.3

   285     *  @param aProperty the property to be set

   286     *  @param aValue the the value of the property

   287     */

   288     virtual void SetL(TMPXPlaybackProperty aProperty, TInt aValue)=0;

   289 

   290     /** 

   291     *  Get value of a playback property, Asyc.

   292     *

   293     *  @since S60 3.2.3

   294     *  @param aCallback playback callback

   295     *  @param aProperty the property

   296     *  @deprecated Use method MMPXPlaybackUtility::PropertyL(

   297     *       MMPXPlaybackCallback& aCallback, 

   298     *       TMPXPlaybackProperty aProperty) instead.

   299     */

   300     virtual void ValueL(MMPXPlaybackCallback& aCallback,

   301                         TMPXPlaybackProperty aProperty)=0;

   302 

   303     /**

   304      *  Get value of a playback property, Asyc.

   305      *  Result will be called back in HandleProperty.

   306      *

   307      *  @since S60 3.2.3

   308      *  @param aCallback playback callback

   309      *  @param aProperty the property

   310      */

   311     virtual void PropertyL(MMPXPlaybackCallback& aCallback,

   312                            TMPXPlaybackProperty aProperty)=0;

   313 

   314 

   315     /**

   316     *  Return a list of mime types supported by playback framework.

   317     *

   318     *  @since S60 3.2.3

   319     *  @return an array of mime types

   320     */

   321     virtual CDesCArray* SupportedMimeTypes()=0;

   322 

   323     /**

   324     *  Return a list of file extensions supported by playback framework.

   325     *

   326     *  @since S60 3.2.3

   327     *  @return an array of extensions

   328     */

   329     virtual CDesCArray* SupportedExtensions()=0;

   330 

   331     /**

   332     *  Return a list of schemas supported by playback framework.

   333     *

   334     *  @since S60 3.2.3

   335     *  @return an array of schemas

   336     */

   337     virtual CDesCArray* SupportedSchemas()=0;

   338 

   339     /**

   340     *  Sets the priority of the playback utility.

   341     *

   342     *  @since S60 3.2.3

   343     *  @param aPriority Priority to set

   344     */

   345     virtual void SetPriority( TInt aPriority )=0;

   346 

   347     /**

   348     * Adds a message subscription for this client.

   349     *

   350     * @since S60 3.2.3

   351     * @param aSubscription subscription to be added

   352     */

   353     virtual void AddSubscriptionL(const CMPXSubscription& aSubscription) = 0;

   354 

   355     /**

   356     * Removes a message subscription for this client.

   357     *

   358     * @since S60 3.2.3

   359     * @param aSubscription subscription to be removed.

   360     */

   361     virtual void RemoveSubscriptionL(const CMPXSubscription& aSubscription) = 0;

   362 

   363     /**

   364     * Removes all message subscriptions for this client.

   365     *

   366     * @since S60 3.2.3

   367     */

   368     virtual void ClearSubscriptionsL() = 0;

   369     

   370     /**

   371     *  Inititialises for streaming with URI and Access Point

   372     *

   373     *  @since S60 9.2

   374     *  @param aUri URI of the item

   375     *  @param aType the mime type of the item

   376     *  @param aAccessPoint the access point of the item

   377     */

   378     virtual void InitStreamingL(const TDesC& aUri, const TDesC8* aType, const TInt aAccessPoint)=0;

   379 

   380     /**

   381     *  Inititialises for streaming with URI and Access Point, the file may not be part of any collection

   382     *  Before this function can be called, the file server session which owns

   383     *  this file handle must first be marked as shareable by calling

   384     *  RFs::ShareProtected().

   385     *

   386     *  @since S60 9.2

   387     *  @param aShareableFile shareable file handle

   388     *  @param aAccessPoint the access point of the item

   389     */

   390     virtual void InitStreamingL(RFile& aShareableFile, const TInt aAccessPoint)=0;

   391     

   392 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   393     /** 

   394     *  Inititialises with a single item, may not be part of any collection 

   395     *  Before this function can be called, the file server session which owns 

   396     *  this file handle must first be marked as shareable by calling 

   397     *  RFs::ShareProtected(). 

   398     * 

   399     *  @since S60 9.2 

   400     *  @param aShareableFile shareable RFile64 file handle 

   401     */ 

   402     virtual void Init64L(RFile64& /*aShareableFile*/) {};

   403      

   404     /** 

   405      *  Inititialises for streaming with URI and Access Point, the file may not be part of any collection 

   406      *  Before this function can be called, the file server session which owns 

   407      *  this file handle must first be marked as shareable by calling 

   408      *  RFs::ShareProtected(). 

   409      * 

   410      *  @since S60 9.2 

   411      *  @param aShareableFile shareable RFile64 file handle 

   412      *  @param aAccessPoint the access point of the item 

   413      */ 

   414     virtual void InitStreaming64L(RFile64& /*aShareableFile*/, const TInt /*aAccessPoint*/) {};

   415 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   416     };

   417 

   418 /**

   419 *  Manages the players. Golden rules: by default, all players of type EPbLocal

   420 *  are tried and the first one found which can handle the content is used; when

   421 *  a specific player is selected by uid, (i.e. SelectPlayerL(TUid aPlayer))

   422 *  then only that player will be considered in the search; when players are

   423 *  selected by type (i.e. SelectPlayersL(TMPXPlaybackPlayerType aType)), then only

   424 *  players with that type are considered; When a sub player is explicitly

   425 *  selected (i.e. SelectSubPlayerL()), then only that player and its sub player

   426 *  are considered.

   427 *

   428 *  @lib mpxplaybackutility.lib

   429 */

   430 class MMPXPlayerManager

   431     {

   432 public:

   433     /**

   434     *  Typically, a client will obtain the list of all the (non-duplicated)

   435     *  player 'types' in the system from GetPlayerTypesL and present localized

   436     *  type names (e.g. "Local","Home network", if possible, else if

   437     *  non-standard type,should use PlayerTypeDisplayNameL to get text from

   438     *  player).

   439     *

   440     *  User should be given opportunity to choose IF there is more than one

   441     *  type available, or if there is one type but more than one sub players,

   442     *  the user could be presented with the sub player list.

   443     *

   444     *  @since S60 3.2.3

   445     *  @param aTypes the list of player types

   446     */

   447     virtual void GetPlayerTypesL(RArray<TMPXPlaybackPlayerType>& aTypes)=0;

   448 

   449     /**

   450     *  Returns display name for custom types; standard types should be

   451     *  recognized by client and localized - calling this method would then not

   452     *  be required.

   453     *

   454     *  @since S60 3.2.3

   455     *  @param aType playback type

   456     */

   457     virtual HBufC* PlayerTypeDisplayNameL(TMPXPlaybackPlayerType aType)=0;

   458 

   459     /**

   460     *  Get the list of UIDs of all players.

   461     *

   462     *  @since S60 3.2.3

   463     *  @param aPlayers All the players' uids in the system

   464     */

   465     virtual void GetPlayerListL(RArray<TUid>& aPlayers)=0;

   466 

   467     /**

   468     *  Get the list of UIDs of players with the specific type.

   469     *

   470     *  @since S60 3.2.3

   471     *  @param aPlayers All the players' uids with the same type

   472     *  @param aType the type of players

   473     */

   474     virtual void GetPlayerListL(RArray<TUid>& aPlayers,

   475                                TMPXPlaybackPlayerType aType)=0;

   476 

   477     /**

   478     *  Get the list of sub player names, Async.

   479     *

   480     *  @since S60 3.2.3

   481     *  @param aCallback sub players returned in call back interface

   482     *  @param aPlayer UID of the player

   483     */

   484     virtual void SubPlayerNamesL(MMPXPlaybackCallback& aCallback,

   485                                  TUid aPlayer)=0;

   486 

   487     /**

   488     *  Client selects all players with the type aType, the specific player used

   489     *  then being resolved on the basis of the content.

   490     *

   491     *  @since S60 3.2.3

   492     *  @param aType the type of player

   493     */

   494     virtual void SelectPlayersL(TMPXPlaybackPlayerType aType)=0;

   495 

   496     /**

   497     *  Client selects specific player aPlayer and sub player aSubPlayerIndex

   498     *  from array returned by SubPlayerNamesL.

   499     *  NOTE: Once a player is manually selected by UID, all subsequent

   500     *        InitL() will continue to use that player, it will not

   501     *        try to resolve a plugin.  If the client later wants

   502     *        the engine to auto resolve the proper plugin, the client must

   503     *        call ClearSelectPlayersL() to reset the engine.

   504     *

   505     *  @since S60 3.2.3

   506     *  @param aPlayer the UID of player

   507     *  @param aSubPlayerIndex the index of the sub player

   508     */

   509     virtual void SelectSubPlayerL(TUid aPlayer, TInt aSubPlayerIndex)=0;

   510 

   511     /**

   512     *  Client selects a specific player.

   513     *  NOTE: Once a player is manually selected by UID, all subsequent

   514     *        InitL() will continue to use that player, it will not

   515     *        try to resolve a plugin.  If the client later wants

   516     *        the engine to auto resolve the proper plugin, the client must

   517     *        call ClearSelectPlayersL() to reset the engine.

   518     *

   519     *  @since S60 3.2.3

   520     *  @param aPlayer the UID of the player

   521     */

   522     virtual void SelectPlayerL(TUid aPlayer)=0;

   523 

   524     /**

   525     *  Clears all selection criteria. Essentially the same as

   526     *  SelectPlayersL(EPbLocal).

   527     *

   528     *  @since S60 3.2.3

   529     */

   530     virtual void ClearSelectPlayersL()=0;

   531 

   532     /**

   533     *  Retreives the current selection: KNullUid and KErrNotFound are possible

   534     *  return values for aPlayer and aSubPlayerIndex respectively if none are

   535     *  explicitly selected.

   536     *

   537     *  @since S60 3.2.3

   538     *  @param aType player type

   539     *  @param aPlayer the UID of player

   540     *  @param aSubPlayerIndex index of the subplayer

   541     *  @param aSubPlayerName friendly name of the subplayer.

   542     *         Notes: Client owns the returned aSubPlayerName object.

   543     */

   544     virtual void GetSelectionL(TMPXPlaybackPlayerType& aType,

   545                                TUid& aPlayer,

   546                                TInt& aSubPlayerIndex,

   547                                HBufC*& aSubPlayerName)=0;

   548 

   549     /**

   550     *  The current player, may change with each item, NULL if none found.

   551     *

   552     *  @since S60 3.2.3

   553     *  @return object of current player

   554     */

   555     virtual MMPXPlayer* CurrentPlayer()=0;

   556     };

   557 

   558 

   559 /**

   560 *  Player functionality specific to selected player.

   561 *

   562 *  @lib mpxplaybackutility.lib

   563 */

   564 class MMPXPlayer

   565     {

   566 public:

   567     /**

   568     *  The 'type' of the player. Built-in types are EPbLocal and EPbRemote, but

   569     *  the plug-ins could extend this if they desire to be a different type

   570     *  which can be selected by the user.

   571     *

   572     *  @since S60 3.2.3

   573     *  @return player type

   574     */

   575     virtual TMPXPlaybackPlayerType TypeL()=0;

   576 

   577     /**

   578     *  If TypeL returns a value that is not known to the UI (and therefore

   579     *  can't localize it),then TypeNameL can be used for unlocalized display

   580     *  purposes.

   581     *

   582     *  @since S60 3.2.3

   583     *  @return player name.

   584     */

   585     virtual HBufC* TypeNameL()=0;

   586 

   587     /**

   588     *  If the player supports other 'players', else array count == 0.

   589     *

   590     *  @since S60 3.2.3

   591     *  @param aCallback sub players returned in the callback

   592     */

   593     virtual void SubPlayerNamesL(MMPXPlaybackCallback& aCallback)=0;

   594 

   595     /**

   596     *  Selected sub player index, corresponding to sub player names array.

   597     *

   598     *  @since S60 3.2.3

   599     *  @return sub player index. KErrNotFound if none

   600     */

   601     virtual TInt SubPlayerL() const=0;

   602 

   603     /**

   604     *  The UID identifying this player.

   605     *

   606     *  @since S60 3.2.3

   607     *  @return UID of the player

   608     */

   609     virtual TUid UidL() const=0;

   610     };

   611 

   612 /**

   613 *  Media functionality. Each media is identified by its index into a container,

   614 *  which is the same as supplied in InitL(const CMPXCollectionPlaylist& aPlaylist).

   615 *

   616 *  @lib mpxplaybackutility.lib

   617 */

   618 class MMPXSource

   619     {

   620 public:

   621     /**

   622     *  Path to the collection, or NULL if not in any collection.

   623     *  Ownership transferred.

   624     *

   625     *  @since S60 3.2.3

   626     *  @return collection path

   627     */

   628     virtual CMPXCollectionPlaylist* PlaylistL()=0;

   629 

   630     /**

   631     *  File passed in, or NULL if none passed in.

   632     *

   633     *  @since S60 3.2.3

   634     *  @return pointer to file handle

   635     */

   636     virtual RFile* FileL()=0;

   637 

   638     /**

   639     *  URI of current item.

   640     *

   641     *  @since S60 3.2.3

   642     *  @return URI of the item

   643     */

   644     virtual HBufC* UriL()=0;

   645 

   646     /**

   647     *  

   648     *  Request for media properties of current playing item

   649     *  HandleMediaL of the callback.

   650     *

   651     *  @since S60 3.2.3

   652     *  @param aAttrs attributes requested

   653     *  @param aCallback playback callback

   654     *  @deprecated Use method MMPXPlaybackUtility::MediaL(

   655     *                   const TArray<TMPXAttribute>& aAttrs,

   656     *                   MMPXPlaybackCallback& aCallback,

   657     *                   CMPXAttributeSpecs* aSpecs) instead.

   658     */

   659     virtual void MediaL(const TArray<TMPXAttribute>& aAttrs,

   660                         MMPXPlaybackCallback& aCallback)=0;

   661 

   662     /**

   663     *  Request for media properties of current playing item

   664     *  HandleMediaL of the callback.

   665     *

   666     *  @since S60 3.2.3

   667     *  @param aAttrs attributes requested

   668     *  @param aCallback playback callback

   669     *  @param aSpecs specifications for attributes

   670     */

   671     virtual void MediaL(const TArray<TMPXAttribute>& aAttrs,

   672                         MMPXPlaybackCallback& aCallback,

   673                         CMPXAttributeSpecs* aSpecs)=0;

   674 

   675 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   676     /**

   677     *  File passed in, or NULL if none passed in.

   678     *

   679     *  @since S60 9.2

   680     *  @return pointer to file handle

   681     */

   682     virtual RFile64* File64L() {return NULL;};

   683 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   684     };

   685 

   686 #endif      // MMPXPLAYBACKUTILITY_H

   687 

   688 // End of File