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:  Implementation of interface for playbackutility

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef CMPXPLAYBACKUTILITY_H

    21 #define CMPXPLAYBACKUTILITY_H

    22 

    23 #include <e32base.h>

    24 #include <f32file.h>

    25 #include <mpxplaybackobserver.h>

    26 #include <mpxplaybackmessage.h>

    27 #include <mpxsession.h>

    28 #include <mpxmessageobserver.h>

    29 #include "mpxplaybackutility.h"

    30 

    31 class CMPXMessageMonitor;

    32 class CMPXTaskQueue;

    33 

    34 NONSHARABLE_STRUCT( TMPXPlaybackUtilityStruct )

    35     {

    36     // Default mode playback utility

    37     MMPXPlaybackUtility* iDefaultPlaybackUtility;

    38     };

    39 

    40 /**

    41 *  Implementation of playback utility interface

    42 *  this interface:

    43 */

    44 NONSHARABLE_CLASS(CMPXPlaybackUtility) : public CActive,

    45                             public MMPXPlaybackUtility,

    46                             public MMPXMessageObserver,

    47                             public MMPXPlayer,

    48                             public MMPXSource,

    49                             public MMPXPlayerManager

    50     {

    51 public:

    52     /**

    53     * Two-phased constructor

    54     *

    55     * @param aModeId playback mode id

    56     * @param aObs observer

    57 	* @param aCategory category of client / engine

    58     * @return object of constructed

    59     */

    60     static CMPXPlaybackUtility* NewL(const TUid& aModeId,

    61                                      MMPXPlaybackObserver* aObs,

    62                                      const TMPXCategory aCategory);

    63 

    64     /**

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

    66     * This interface could be a singleton

    67     */

    68     static MMPXPlaybackUtility* UtilityL( const TUid& aModeId,

    69                                         const TMPXCategory aCategory);										

    70 

    71 private:

    72     /**

    73     * Destructor

    74     */

    75     ~CMPXPlaybackUtility();

    76 

    77     /**

    78     * C++ constructor

    79     */

    80     CMPXPlaybackUtility();

    81 

    82     /**

    83     * Second phase constructor

    84     *

    85     * @param aModeId playback mode id

    86     * @param aObs observer

    87 	* @param aCategory category of client / engine

    88     */

    89     void ConstructL(const TUid& aModeId, MMPXPlaybackObserver* aObs, const TMPXCategory aCategory);

    90     /**

    91     * Second phase constructor

    92     *

    93     * @param aObs observer

    94     */

    95     void ConstructL(MMPXPlaybackObserver* aObs);

    96 

    97     /**

    98     *  From MMPXPlaybackUtility

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

   100     *  to the specific mode the interface was created in

   101     *

   102     *  @param aObs, observer to be added

   103     */

   104     void AddObserverL(MMPXPlaybackObserver& aObs);

   105 

   106     /**

   107     *  From MMPXPlaybackUtility

   108     *  Remove a observer.

   109     *

   110     *  @param aObs, observer to be removed

   111     */

   112     void RemoveObserverL(MMPXPlaybackObserver& aObs);

   113 

   114     /**

   115     *  From MMPXPlaybackUtility

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

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

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

   119     *

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

   121     *       RArray<TProcessId> pids;

   122     *       m->GetClients(pids);

   123     *       .........

   124     *       pids->Close();

   125     *       m->Close();

   126     *

   127     *  @param aClients Array of Pids returned.

   128     */

   129     void GetClientsL(RArray<TProcessId>& aClients);

   130 

   131     /**

   132     *  From MMPXPlaybackUtility

   133     *  Initializes a track given by aCollectionPath

   134     *

   135     *  @param aCollectionPath collection path

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

   137     *               else just to setup the engine first

   138     */

   139     virtual void InitL(const CMPXCollectionPlaylist& aPlaylist,

   140                        TBool aPlay=ETrue);

   141 

   142     /**

   143     *  From MMPXPlaybackUtility

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

   145     *

   146     *  @param aUri URI of the item

   147     *  @param aType the mime type of the item

   148     */

   149     void InitL(const TDesC& aUri,const TDesC8* aType=NULL);

   150 

   151     /**

   152     *  From MMPXPlaybackUtility

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

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

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

   156     *  RFs::ShareProtected().

   157     *

   158     *  @param aFile file handle

   159     */

   160     void InitL(RFile& aShareableFile);

   161 

   162     /**

   163     *  From MMPXPlaybackUtility

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

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

   166     */

   167     void Close();

   168 

   169     /**

   170     *  From MMPXPlaybackUtility

   171     *  Stops any async operations that are currently under way

   172     */

   173     void CancelRequest();

   174 

   175     /**

   176     *  From MMPXPlaybackUtility

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

   178     *  ECommandComplete events should follow

   179     *

   180     *  @param aCmd the command

   181     *  @param aData optional data

   182     */

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

   184 

   185     /**

   186      *  From MMPXPlaybackUtility

   187      *  Send a command to the playback server

   188      *

   189      *  @param aCmd, reference to command object

   190      *  @param aCallback, call back when command exection completed.

   191      *                    Asynchronously command only

   192      */

   193     void CommandL(CMPXCommand& aCmd, MMPXPlaybackCallback* aCallback=NULL);

   194 

   195     /**

   196     *  From MMPXPlaybackUtility

   197     *  Current state of player

   198     *  @return current state

   199     */

   200     TMPXPlaybackState StateL() const;

   201 

   202     /**

   203     *  From MMPXPlaybackUtility

   204     *  Current source being played, NULL if none was supplied

   205     *

   206     *  @return source object

   207     */

   208     MMPXSource* Source();

   209 

   210     /**

   211     *  From MMPXPlaybackUtility

   212     *  Player manager

   213     *

   214     *  @return reference to player manager

   215     */

   216     MMPXPlayerManager& PlayerManager();

   217 

   218     /**

   219     *  From MMPXPlaybackUtility

   220     *  Set playback property, EPropertyChanged event when complete

   221     *

   222     *  @param aProperty the property to be set

   223     *  @param aValue the the value of the property

   224     */

   225     void SetL(TMPXPlaybackProperty aProperty,TInt aValue);

   226 

   227     /**

   228     *  From MMPXPlaybackUtility

   229     *  Get value of a playback property, Asyc

   230     *

   231     *  @param aCallback playback callback

   232     *  @param aProperty the property

   233     */

   234     void ValueL(MMPXPlaybackCallback& aCallback,TMPXPlaybackProperty aProperty);

   235 

   236     /**

   237      *  Get value of a playback property, Asyc

   238      *  Result will be called back in HandleProperty

   239      *

   240      *  @param aCallback playback callback

   241      *  @param aProperty the property

   242      */

   243     void PropertyL(MMPXPlaybackCallback& aCallback,

   244                    TMPXPlaybackProperty aProperty);

   245 

   246     /**

   247     *  From MMPXPlaybackUtility

   248     *  Return a list of mime types supported by playback framework

   249     *

   250     *  @return an array of mime types

   251     */

   252     virtual CDesCArray* SupportedMimeTypes();

   253 

   254     /**

   255     *  From MMPXPlaybackUtility

   256     *  Return a list of file extensions supported by playback framework

   257     *

   258     *  @return an array of extensions

   259     */

   260     virtual CDesCArray* SupportedExtensions();

   261 

   262     /**

   263     *  From MMPXPlaybackUtility

   264     *  Return a list of schemas supported by playback framework

   265     *

   266     *  @return an array of schemas

   267     */

   268     virtual CDesCArray* SupportedSchemas();

   269 

   270     /**

   271     *  Sets the priority of the playback utility

   272     *

   273     *  @param aPriority Priority to set

   274     */

   275     virtual void SetPriority( TInt aPriority );

   276 

   277     /**

   278     * Adds a message subscription for this client.

   279     * @param aSubscription subscription to be added

   280     */

   281     void AddSubscriptionL(const CMPXSubscription& aSubscription);

   282 

   283     /**

   284     * Removes a message subscription for this client.

   285     * @param aSubscription subscription to be removed.

   286     */

   287     void RemoveSubscriptionL(const CMPXSubscription& aSubscription);

   288 

   289     /**

   290     * Removes all message subscriptions for this client.

   291     */

   292     void ClearSubscriptionsL();

   293 

   294     /**

   295     *  From MMPXPlayerManager

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

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

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

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

   300     *  player).

   301     *

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

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

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

   305     *

   306     *  @param aTypes the list of player types

   307     */

   308     void GetPlayerTypesL(RArray<TMPXPlaybackPlayerType>& aTypes);

   309 

   310     /**

   311     *  From MMPXPlayerManager

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

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

   314     *  be required

   315     *

   316     *  @param aType playback type

   317     */

   318     HBufC* PlayerTypeDisplayNameL(TMPXPlaybackPlayerType aType);

   319 

   320     /**

   321     *  From MMPXPlayerManager

   322     *  Get the list of UIDs of all players

   323     *

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

   325     */

   326     void GetPlayerListL(RArray<TUid>& aPlayers);

   327 

   328     /**

   329     *  From MMPXPlayerManager

   330     *  Get the list of UIDs of players with the specific type

   331     *

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

   333     *  @param aType the type of players

   334     */

   335     void GetPlayerListL(RArray<TUid>& aPlayers,TMPXPlaybackPlayerType aType);

   336 

   337     /**

   338     *  From MMPXPlayerManager

   339     *  Get the list of sub player names, Async

   340     *

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

   342     *  @param aPlayer UID of the player

   343     */

   344     void SubPlayerNamesL(MMPXPlaybackCallback& aCallback,TUid aPlayer);

   345 

   346     /**

   347     *  From MMPXPlayerManager

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

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

   350     *

   351     *  @param aType the type of player

   352     */

   353     void SelectPlayersL(TMPXPlaybackPlayerType aType);

   354 

   355     /**

   356     *  From MMPXPlayerManager

   357     *  Client selects specific player aPlayer and sub player aSubPlayerIndex

   358     *  from array returned by SubPlayerNamesL

   359     *

   360     *  @param aPlayer the UID of player

   361     *  @param aSubPlayerIndex the index of the sub player

   362     */

   363     void SelectSubPlayerL(TUid aPlayer,TInt aSubPlayerIndex);

   364 

   365     /**

   366     *  From MMPXPlayerManager

   367     *  Client selects a specific player

   368     *

   369     *  @param aPlayer the UID of the player

   370     */

   371     void SelectPlayerL(TUid aPlayer);

   372 

   373     /**

   374     *  From MMPXPlayerManager

   375     *  Clears all selection criteria. Essentially the same as

   376     *  SelectPlayersL(EPbLocal).

   377     */

   378     void ClearSelectPlayersL();

   379 

   380     /**

   381     *  From MMPXPlayerManager

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

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

   384     *  explicitly selected

   385     *

   386     *  @param aType player type

   387     *  @param aPlayer the UID of player

   388     *  @param aSubPlayerIndex index of the subplayer

   389     *  @param aSubPlayerName friendly name of the subplayer

   390     *         Notes: Client owns the returned aSubPlayerName object.

   391     */

   392     void GetSelectionL(TMPXPlaybackPlayerType& aType,

   393                        TUid& aPlayer,

   394                        TInt& aSubPlayerIndex,

   395                        HBufC*& aSubPlayerName);

   396 

   397     /**

   398     *  From MMPXPlayerManager

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

   400     *

   401     *  @return object of current player

   402     */

   403     MMPXPlayer* CurrentPlayer();

   404 

   405     /**

   406     *  From MMPXPlayer

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

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

   409     *  which can be selected by the user

   410     *

   411     *  @return player type

   412     */

   413     TMPXPlaybackPlayerType TypeL();

   414 

   415     /**

   416     *  From MMPXPlayer

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

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

   419     *  purposes.

   420     *

   421     *  @return player name.

   422     */

   423     HBufC* TypeNameL();

   424 

   425     /**

   426     *  From MMPXPlayer

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

   428     *

   429     *  @param aCallback sub players returned in the callback

   430     */

   431     void SubPlayerNamesL(MMPXPlaybackCallback& aCallback);

   432 

   433     /**

   434     *  From MMPXPlayer

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

   436     *

   437     *  @return sub player index. KErrNotFound if none

   438     */

   439     TInt SubPlayerL() const;

   440 

   441     /**

   442     *  From MMPXPlayer

   443     *  The UID identifying this player

   444     *

   445     *  @return UID of the player

   446     */

   447     TUid UidL() const;

   448 

   449     /**

   450     *  From MMPXSource

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

   452     *  Ownership transferred

   453     *

   454     *  @return collection path

   455     */

   456     CMPXCollectionPlaylist* PlaylistL();

   457 

   458     /**

   459     *  From MMPXSource

   460     *  File passed in, or NULL if none passed in

   461     *

   462     *  @return pointer to file handle

   463     */

   464     RFile* FileL();

   465 

   466     /**

   467     *  From MMPXSource

   468     *  URI of current item

   469     *

   470     *  @return URI of the item

   471     */

   472     HBufC* UriL();

   473 

   474     /**

   475     *  From MMPXSource

   476     *

   477     *  DEPRECATED

   478     *

   479     *  Media request

   480     *  HandleMediaL of the callback

   481     *

   482     *  @param aAttrs attributes requested

   483     *  @param aCallback playback callback

   484     */

   485     void MediaL(const TArray<TMPXAttribute>& aAttrs,

   486                 MMPXPlaybackCallback& aCallback);

   487 

   488     /**

   489     *  From MMPXSource

   490     *  Media request

   491     *  HandleMediaL of the callback

   492     *

   493     *  @param aAttrs attributes requested

   494     *  @param aCallback playback callback

   495     *  @param aSpecs, specifications for attributes

   496     */

   497     void MediaL(const TArray<TMPXAttribute>& aAttrs,

   498                 MMPXPlaybackCallback& aCallback,

   499                 CMPXAttributeSpecs* aSpecs);

   500 

   501 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   502     /**

   503     *  From MMPXSource

   504     *  File passed in, or NULL if none passed in

   505     *

   506     *  @return pointer to file handle

   507     */

   508     RFile64* File64L();

   509 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   510 

   511     /**

   512     * From CActive

   513     * Handles an active object's request completion event

   514     */

   515     void RunL();

   516 

   517     /**

   518     * From CActive

   519     * Implements cancellation of an outstanding request.

   520     */

   521     void DoCancel();

   522 

   523     /**

   524     * From CActive

   525     * Handles a leave occurring in the request completion event handler RunL()

   526     *

   527     * @param aError error code

   528     */

   529     TInt RunError(TInt aError);

   530 

   531     /**

   532      * From MMPXMessageObserver

   533      * Message received

   534      * @param aMsgData message data

   535      * @param aError error code

   536      */

   537     void MessageReceived(TInt aMsgData, TInt aError);

   538     

   539     /**

   540     *  Inititialises for streaming with URI and Access Point

   541     *

   542     *  @since S60 9.2

   543     *  @param aUri URI of the item

   544     *  @param aType the mime type of the item

   545     *  @param aAccessPoint the access point of the item

   546     */

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

   548 

   549     /**

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

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

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

   553     *  RFs::ShareProtected().

   554     *

   555     *  @since S60 9.2

   556     *  @param aShareableFile shareable file handle

   557     *  @param aAccessPoint the access point of the item

   558     */

   559     virtual void InitStreamingL(RFile& aShareableFile, const TInt aAccessPoint); 

   560 

   561 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   562     /** 

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

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

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

   566     *  RFs::ShareProtected(). 

   567     * 

   568     *  @since S60 9.2 

   569     *  @param aShareableFile shareable RFile64 file handle 

   570     */ 

   571     virtual void Init64L(RFile64& aShareableFile);

   572      

   573     /** 

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

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

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

   577      *  RFs::ShareProtected(). 

   578      * 

   579      *  @since S60 9.2 

   580      *  @param aShareableFile shareable RFile64 file handle 

   581      *  @param aAccessPoint the access point of the item 

   582      */ 

   583     virtual void InitStreaming64L(RFile64& aShareableFile, const TInt aAccessPoint);

   584 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   585     

   586 private:

   587 

   588 

   589     /**

   590     * Helper to return a descriptor buffer

   591     *

   592     * @param aSize size of the buffer

   593     */

   594     HBufC* DesL(TInt aSize);

   595 

   596     /**

   597     *  Add a request

   598     *

   599     *  @param aFunction function code

   600     *  @param aCallback callback

   601     *  @param aParamData data

   602     *  @param aBuf buffer data, ownership transferred

   603     *  @param aPtr, pointer to a object

   604     *  @param aAlivePtr1, object to keep alive for a task

   605     *                     ownership transferred

   606     *  @leave leave with system error code when failed

   607     */

   608     void AddRequestL(TMPXPlaybackServerOp aFunction,

   609                      MMPXPlaybackCallback* aCallback=NULL,

   610                      TInt aParamData=0,

   611                      CBufBase* aBuf=NULL,

   612                      TAny* aPtr=NULL,

   613                      CBase* aAlivePtr=NULL);

   614 

   615     /**

   616     *  Send next request to server

   617     */

   618     void ExecuteNextRequest();

   619 

   620     /**

   621      *  Handle message from message queue

   622      *  @param aMsgData message data

   623      *  @param aError error code

   624      */

   625     void HandleMessageL(TInt aMsgData, TInt aError);

   626 

   627     /**

   628      * Handles error in RunL

   629      *

   630      * @param aError error code

   631      */

   632     void HandleRunErrorL(TInt aError);

   633 

   634 #ifdef _ENABLE_GUARD_TIMER

   635     /**

   636      *  Gaurd timer callback

   637      *

   638      *  @param aPtr pointer the this

   639      */

   640     static TInt GuardTimerCallback(TAny* aPtr);

   641 #endif

   642 

   643 private:

   644     RArray<MMPXPlaybackObserver*> iObservers;

   645     CMPXMessageMonitor* iMsgMonitor;

   646     CMPXTaskQueue* iTaskQueue;

   647     RMPXSession iPbs;

   648     CBufBase* iBuffer;

   649     TPckgBuf<TInt> iPropertyValuePckg;

   650     TPckgBuf<TBool> iCompletePckg;

   651     TPckgBuf<TInt> iResultSizePckg;

   652     RFile iFile;

   653     TBool iCallbackOngoing; // whether client is processing callback or not

   654 #ifdef _ENABLE_GUARD_TIMER

   655     CPeriodic* iGuardTimer; // guard timer for async request

   656 #endif

   657     CMPXMedia* iMediaOnError; // media object while handling error

   658     TInt iRefCount;

   659 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   660     RFile64 iFile64;

   661 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

   662     };

   663 

   664 #endif // CMPXPLAYBACKUTILITY_H