videoplayback/hbvideoplaybackview/tsrc/testmpxvideoviewwrapper/stub/src/mpxplaybackutilityimpl.cpp
changeset 39 f6d44a0cd476
parent 38 ff53afa8ad05
child 40 13331705e488
equal deleted inserted replaced
38:ff53afa8ad05 39:f6d44a0cd476
     1 /*
       
     2 * Copyright (c) 2006 - 2007 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:  Playback Utility implementation
       
    15 *
       
    16 */
       
    17 
       
    18 // Version : %version: 4 %
       
    19 
       
    20 #include <bamdesca.h>
       
    21 #include <s32mem.h>
       
    22 #include <e32math.h>
       
    23 #include <mpxcmn.h>
       
    24 #include <mpxplaybackobserver.h>
       
    25 #include <mpxcollectionplaylist.h>
       
    26 #include <mpxmedia.h>
       
    27 #include <mpxmessagemonitor.h>
       
    28 #include <mpxtaskqueue.h>
       
    29 #include <mpxuser.h>
       
    30 #include <mpxmessagegeneraldefs.h>
       
    31 #include <mpxcommandgeneraldefs.h>
       
    32 #include <mpxcollectionpath.h>
       
    33 #include <mpxplaybackcommanddefs.h>
       
    34 #include <mpxsubscription.h>
       
    35 #include <mpxlog.h>
       
    36 
       
    37 #include "mpxplaybackutilityimpl.h"
       
    38 
       
    39 // ============================== MEMBER FUNCTIONS ============================
       
    40 
       
    41 // ---------------------------------------------------------------------------
       
    42 // Retrieves playback utility from TLS. Creates if it's not there.
       
    43 // ---------------------------------------------------------------------------
       
    44 //
       
    45 MMPXPlaybackUtility* CMPXPlaybackUtility::UtilityL(
       
    46     const TUid& aModeId,
       
    47     const TMPXCategory aCategory)
       
    48     {
       
    49     MMPXPlaybackUtility* utility( NULL );
       
    50     
       
    51     utility = CMPXPlaybackUtility::NewL( aModeId, NULL, aCategory );
       
    52 
       
    53     return utility;
       
    54     }
       
    55 
       
    56 // ----------------------------------------------------------------------------
       
    57 // Two phases constructor
       
    58 // ----------------------------------------------------------------------------
       
    59 //
       
    60 CMPXPlaybackUtility* CMPXPlaybackUtility::NewL(const TUid& aModeId,
       
    61                                                MMPXPlaybackObserver* aObs,
       
    62                                                const TMPXCategory aCategory)
       
    63     {
       
    64     CMPXPlaybackUtility* p=new(ELeave)CMPXPlaybackUtility();
       
    65     CleanupStack::PushL(p);
       
    66     p->ConstructL(aModeId,aObs,aCategory);
       
    67     CleanupStack::Pop(p);
       
    68     return p;
       
    69     }
       
    70 
       
    71 // ----------------------------------------------------------------------------
       
    72 // Destructor
       
    73 // ----------------------------------------------------------------------------
       
    74 //
       
    75 CMPXPlaybackUtility::~CMPXPlaybackUtility()
       
    76     {
       
    77     iObservers.Close();
       
    78     }
       
    79 
       
    80 // ----------------------------------------------------------------------------
       
    81 // C++ constructor
       
    82 // Create a unique name out of thread ID and this pointer: no other instance of
       
    83 // this object will have the same name; used to identify this object for
       
    84 // recieving messages
       
    85 // ----------------------------------------------------------------------------
       
    86 //
       
    87 CMPXPlaybackUtility::CMPXPlaybackUtility()
       
    88     : iCallbackOngoing(EFalse)
       
    89     {
       
    90     }
       
    91 
       
    92 // ----------------------------------------------------------------------------
       
    93 // 2nd construtor
       
    94 // ----------------------------------------------------------------------------
       
    95 //
       
    96 void CMPXPlaybackUtility::ConstructL(const TUid& /* aModeId */,
       
    97                                      MMPXPlaybackObserver* /* aObs */, 
       
    98                                      const TMPXCategory /* aCategory */)
       
    99     {
       
   100     	iState = EPbStateInitialised;
       
   101     }
       
   102 
       
   103 // ----------------------------------------------------------------------------
       
   104 // Add a observer
       
   105 // ----------------------------------------------------------------------------
       
   106 //
       
   107 void CMPXPlaybackUtility::AddObserverL(MMPXPlaybackObserver& aObs)
       
   108     {
       
   109     iObservers.AppendL(&aObs);
       
   110     }
       
   111 
       
   112 // ----------------------------------------------------------------------------
       
   113 // Remove a observer
       
   114 // ----------------------------------------------------------------------------
       
   115 //
       
   116 void CMPXPlaybackUtility::RemoveObserverL(MMPXPlaybackObserver& /* aObs */)
       
   117     {
       
   118 
       
   119     }
       
   120 
       
   121 // ----------------------------------------------------------------------------
       
   122 // Returns PIds of clients that are using the engine in the mode
       
   123 // ----------------------------------------------------------------------------
       
   124 //
       
   125 void CMPXPlaybackUtility::GetClientsL(RArray<TProcessId>& /* aClients */)
       
   126     {
       
   127 
       
   128     }
       
   129 
       
   130 // ----------------------------------------------------------------------------
       
   131 // Initializes a track given by aIndex in path aCollectionPath
       
   132 // ----------------------------------------------------------------------------
       
   133 //
       
   134 void CMPXPlaybackUtility::InitL(
       
   135     const CMPXCollectionPlaylist& /* aPlaylist */,
       
   136     TBool /*aPlay */ )
       
   137     {
       
   138 
       
   139     }
       
   140 
       
   141 // ----------------------------------------------------------------------------
       
   142 // Inititialises with a single song, may not be part of any collection
       
   143 // ----------------------------------------------------------------------------
       
   144 //
       
   145 void CMPXPlaybackUtility::InitL(const TDesC& /* aUri */, const TDesC8* /* aType */ )
       
   146     {
       
   147 
       
   148     }
       
   149 
       
   150 // ----------------------------------------------------------------------------
       
   151 // Inititialises with a single song, may not be part of any collection
       
   152 // ----------------------------------------------------------------------------
       
   153 //
       
   154 void CMPXPlaybackUtility::InitL(RFile& /* aShareableFile */)
       
   155     {
       
   156 
       
   157     }
       
   158 
       
   159 // ----------------------------------------------------------------------------
       
   160 // Inititialises with a URI
       
   161 // ----------------------------------------------------------------------------
       
   162 //
       
   163 void CMPXPlaybackUtility::InitStreamingL(const TDesC& /* aUri */, const TDesC8* /* aType */, const TInt /* aAccessPoint */)
       
   164 {
       
   165 
       
   166 }
       
   167 
       
   168 
       
   169 // ----------------------------------------------------------------------------
       
   170 // Inititialises with a file, may not be part of any collection
       
   171 // ----------------------------------------------------------------------------
       
   172 //
       
   173 void CMPXPlaybackUtility::InitStreamingL(RFile& /* aShareableFile */, const TInt /* aAccessPoint */)
       
   174 {
       
   175 
       
   176 }
       
   177 
       
   178 // ----------------------------------------------------------------------------
       
   179 // Frees up client side resources only; a player is freed when there are no
       
   180 // clients using it, and all resources are freed when the last client closed
       
   181 // ----------------------------------------------------------------------------
       
   182 //
       
   183 void CMPXPlaybackUtility::Close()
       
   184     {
       
   185 
       
   186     }
       
   187 
       
   188 // ----------------------------------------------------------------------------
       
   189 // Stops any async operations that are currently under way
       
   190 // ----------------------------------------------------------------------------
       
   191 //
       
   192 void CMPXPlaybackUtility::CancelRequest()
       
   193     {
       
   194 
       
   195     }
       
   196 
       
   197 // ----------------------------------------------------------------------------
       
   198 // Issue player commands, with optional data.
       
   199 // ----------------------------------------------------------------------------
       
   200 //
       
   201 void CMPXPlaybackUtility::CommandL(TMPXPlaybackCommand /* aCmd */, TInt /* aData */)
       
   202     {
       
   203 
       
   204     }
       
   205 
       
   206 // ----------------------------------------------------------------------------
       
   207 // Issue player commands
       
   208 // ----------------------------------------------------------------------------
       
   209 //
       
   210 void CMPXPlaybackUtility::CommandL(
       
   211     CMPXCommand& aCmd,
       
   212     MMPXPlaybackCallback* /* aCallback */)
       
   213     {
       
   214     TMPXPlaybackCommand cmdType = static_cast<TMPXPlaybackCommand>(
       
   215                           aCmd.ValueTObjectL<TInt>(KMPXCommandPlaybackGeneralType));
       
   216         
       
   217     switch ( cmdType )
       
   218         {
       
   219         case EPbCmdPlay:
       
   220             {
       
   221             iState = EPbStatePlaying;
       
   222             break;
       
   223             }
       
   224         case EPbCmdDecreaseVolume:
       
   225             {
       
   226             CMPXMessage* message = CMPXMessage::NewL();
       
   227             message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMessageGeneral );
       
   228             message->SetTObjectValueL<TInt>( KMPXMessageGeneralEvent, TMPXPlaybackMessage::EPropertyChanged ); 
       
   229             message->SetTObjectValueL<TInt>( KMPXMessageGeneralType, EPbPropertyVolume );
       
   230             message->SetTObjectValueL<TInt>( KMPXMessageGeneralData, 0 );                      
       
   231             iObservers[0]->HandlePlaybackMessage( message, KErrNone );            
       
   232             }
       
   233         }
       
   234     }
       
   235 
       
   236 // ----------------------------------------------------------------------------
       
   237 // Current state of player
       
   238 // ----------------------------------------------------------------------------
       
   239 //
       
   240 TMPXPlaybackState CMPXPlaybackUtility::StateL() const
       
   241     {
       
   242     return iState;
       
   243     }
       
   244 
       
   245 // ----------------------------------------------------------------------------
       
   246 // Determine whether there is a song by the state of the engine: if there is,
       
   247 // its OK to return MMPXMedia, else NULL is returned
       
   248 // ----------------------------------------------------------------------------
       
   249 //
       
   250 MMPXSource* CMPXPlaybackUtility::Source()
       
   251     {
       
   252     return this;
       
   253     }
       
   254 
       
   255 // ----------------------------------------------------------------------------
       
   256 // Get player manager
       
   257 // ----------------------------------------------------------------------------
       
   258 //
       
   259 MMPXPlayerManager& CMPXPlaybackUtility::PlayerManager()
       
   260     {
       
   261     return *this;
       
   262     }
       
   263 
       
   264 // ----------------------------------------------------------------------------
       
   265 // Set playback property, EPropertyChanged event when complete
       
   266 // ----------------------------------------------------------------------------
       
   267 //
       
   268 void CMPXPlaybackUtility::SetL(TMPXPlaybackProperty aProperty,TInt /* aValue */ )
       
   269     {
       
   270         if ( aProperty == EPbPropertyMute )
       
   271         {
       
   272             CMPXMessage* message = CMPXMessage::NewL();
       
   273             message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMessageGeneral );
       
   274             message->SetTObjectValueL<TInt>( KMPXMessageGeneralEvent, TMPXPlaybackMessage::EPropertyChanged ); 
       
   275             message->SetTObjectValueL<TInt>( KMPXMessageGeneralType, 0 );
       
   276             message->SetTObjectValueL<TInt>( KMPXMessageGeneralData, 0 );                      
       
   277             iObservers[0]->HandlePlaybackMessage( message, KErrNone );
       
   278         } 
       
   279         else if ( aProperty == EPbPropertyPosition )
       
   280         {
       
   281             CMPXMessage* message = CMPXMessage::NewL();
       
   282             message->SetTObjectValueL<TMPXMessageId>( KMPXMessageGeneralId, KMPXMessageGeneral );
       
   283             message->SetTObjectValueL<TInt>( KMPXMessageGeneralEvent, TMPXPlaybackMessage::EPropertyChanged ); 
       
   284             message->SetTObjectValueL<TInt>( KMPXMessageGeneralType, EPbPropertyPosition );
       
   285             message->SetTObjectValueL<TInt>( KMPXMessageGeneralData, 50 );                      
       
   286             iObservers[0]->HandlePlaybackMessage( message, KErrNone );            
       
   287         }
       
   288     }
       
   289 
       
   290 // ----------------------------------------------------------------------------
       
   291 // Send property request
       
   292 // Result will be called back in HandleProperty
       
   293 // ----------------------------------------------------------------------------
       
   294 //
       
   295 void CMPXPlaybackUtility::ValueL(MMPXPlaybackCallback& /* aCallback */,
       
   296                                  TMPXPlaybackProperty /* aProperty */)
       
   297     {
       
   298 
       
   299     }
       
   300 
       
   301 // ----------------------------------------------------------------------------
       
   302 // Send property request
       
   303 // Result will be called back in HandleProperty
       
   304 // ----------------------------------------------------------------------------
       
   305 //
       
   306 void CMPXPlaybackUtility::PropertyL(
       
   307     MMPXPlaybackCallback& /* aCallback */,
       
   308     TMPXPlaybackProperty /* aProperty */)
       
   309     {
       
   310 
       
   311     }
       
   312 
       
   313 // ----------------------------------------------------------------------------
       
   314 // Return a list of mime types supported by playback framework
       
   315 // ----------------------------------------------------------------------------
       
   316 //
       
   317 CDesCArray* CMPXPlaybackUtility::SupportedMimeTypes()
       
   318     {
       
   319     CDesCArray* desArray = NULL;
       
   320 
       
   321     return desArray;
       
   322     }
       
   323 
       
   324 // ----------------------------------------------------------------------------
       
   325 // Return a list of mime types supported by playback framework
       
   326 // ----------------------------------------------------------------------------
       
   327 //
       
   328 CDesCArray* CMPXPlaybackUtility::SupportedExtensions()
       
   329     {
       
   330     CDesCArray* desArray = NULL;
       
   331 
       
   332     return desArray;
       
   333     }
       
   334 
       
   335 // ----------------------------------------------------------------------------
       
   336 // Return a list of mime types supported by playback framework
       
   337 // ----------------------------------------------------------------------------
       
   338 //
       
   339 CDesCArray* CMPXPlaybackUtility::SupportedSchemas()
       
   340     {
       
   341     CDesCArray* desArray = NULL;
       
   342 
       
   343     return desArray;
       
   344     }
       
   345 
       
   346 // ----------------------------------------------------------------------------
       
   347 // Sets the priority of the playback utility
       
   348 // ----------------------------------------------------------------------------
       
   349 //
       
   350 void CMPXPlaybackUtility::SetPriority( TInt /* aPriority */ )
       
   351     {
       
   352 
       
   353     }
       
   354 
       
   355 
       
   356 // ----------------------------------------------------------------------------
       
   357 // CMPXPlaybackUtility::AddSubscriptionL
       
   358 // ----------------------------------------------------------------------------
       
   359 //
       
   360 void CMPXPlaybackUtility::AddSubscriptionL(
       
   361     const CMPXSubscription& /* aSubscription */)
       
   362     {
       
   363 
       
   364     }
       
   365 
       
   366 // ----------------------------------------------------------------------------
       
   367 // CMPXPlaybackUtility::RemoveSubscriptionL
       
   368 // ----------------------------------------------------------------------------
       
   369 //
       
   370 void CMPXPlaybackUtility::RemoveSubscriptionL(
       
   371     const CMPXSubscription& /* aSubscription */ )
       
   372     {
       
   373 
       
   374     }
       
   375 
       
   376 // ----------------------------------------------------------------------------
       
   377 // CMPXPlaybackUtility::ClearSubscriptionsL
       
   378 // ----------------------------------------------------------------------------
       
   379 //
       
   380 void CMPXPlaybackUtility::ClearSubscriptionsL()
       
   381     {
       
   382 
       
   383     }
       
   384 // ----------------------------------------------------------------------------
       
   385 // Get a list of player types
       
   386 // ----------------------------------------------------------------------------
       
   387 //
       
   388 void CMPXPlaybackUtility::GetPlayerTypesL(
       
   389     RArray<TMPXPlaybackPlayerType>& /* aTypes */ )
       
   390     {
       
   391 
       
   392     }
       
   393 
       
   394 // ----------------------------------------------------------------------------
       
   395 // Returns display name for custom types
       
   396 // ----------------------------------------------------------------------------
       
   397 //
       
   398 HBufC* CMPXPlaybackUtility::PlayerTypeDisplayNameL(TMPXPlaybackPlayerType /* aType */ )
       
   399     {
       
   400 		HBufC* buf=NULL;
       
   401 		return buf;
       
   402     }
       
   403 
       
   404 // ----------------------------------------------------------------------------
       
   405 // Get the list of UIDs of all players
       
   406 // ----------------------------------------------------------------------------
       
   407 //
       
   408 void CMPXPlaybackUtility::GetPlayerListL(RArray<TUid>& /* aPlayers */)
       
   409     {
       
   410 
       
   411     }
       
   412 
       
   413 // ----------------------------------------------------------------------------
       
   414 // Get the list of UIDs of players with the specific type
       
   415 // ----------------------------------------------------------------------------
       
   416 //
       
   417 void CMPXPlaybackUtility::GetPlayerListL(RArray<TUid>& /* aPlayers */,
       
   418                                          TMPXPlaybackPlayerType /* aType */)
       
   419     {
       
   420 
       
   421     }
       
   422 
       
   423 // ----------------------------------------------------------------------------
       
   424 // Asynchronous method: when server completes message, RunL() will be called
       
   425 // and then the observer is notified of the results. Data required for the
       
   426 // results that is not supplied by the server is stored; data supplied by the
       
   427 // server is written back into packaged descriptors in this address space
       
   428 // ----------------------------------------------------------------------------
       
   429 //
       
   430 void CMPXPlaybackUtility::SubPlayerNamesL(MMPXPlaybackCallback& /* aCallback */,
       
   431                                           TUid /* aPlayer */)
       
   432     {
       
   433 
       
   434     }
       
   435 
       
   436 // ----------------------------------------------------------------------------
       
   437 // Selects all players with the type
       
   438 // ----------------------------------------------------------------------------
       
   439 //
       
   440 void CMPXPlaybackUtility::SelectPlayersL(TMPXPlaybackPlayerType /* aType */)
       
   441     {
       
   442 
       
   443     }
       
   444 
       
   445 // ----------------------------------------------------------------------------
       
   446 // Selects a specific player
       
   447 // ----------------------------------------------------------------------------
       
   448 //
       
   449 void CMPXPlaybackUtility::SelectPlayerL(TUid /* aPlayer */ )
       
   450     {
       
   451 
       
   452     }
       
   453 
       
   454 // ----------------------------------------------------------------------------
       
   455 // Selects a specific player and sub player
       
   456 // ----------------------------------------------------------------------------
       
   457 //
       
   458 void CMPXPlaybackUtility::SelectSubPlayerL(TUid /* aPlayer */, TInt /* aSubPlayerIndex */)
       
   459     {
       
   460 
       
   461     }
       
   462 
       
   463 // ----------------------------------------------------------------------------
       
   464 // Clears all selection criteria.
       
   465 // ----------------------------------------------------------------------------
       
   466 //
       
   467 void CMPXPlaybackUtility::ClearSelectPlayersL()
       
   468     {
       
   469 
       
   470     }
       
   471 
       
   472 // ----------------------------------------------------------------------------
       
   473 // Retreives the current selection
       
   474 // ----------------------------------------------------------------------------
       
   475 //
       
   476 void CMPXPlaybackUtility::GetSelectionL(TMPXPlaybackPlayerType& /* aType */,
       
   477                                         TUid& /* aPlayer */,
       
   478                                         TInt& /* aSubPlayerIndex */,
       
   479                                         HBufC*& /* aSubPlayerName */)
       
   480     {
       
   481 
       
   482     }
       
   483 
       
   484 // ----------------------------------------------------------------------------
       
   485 // The current player
       
   486 // ----------------------------------------------------------------------------
       
   487 //
       
   488 MMPXPlayer* CMPXPlaybackUtility::CurrentPlayer()
       
   489     {
       
   490     return NULL;
       
   491     }
       
   492 
       
   493 // ----------------------------------------------------------------------------
       
   494 // The 'type' of the player
       
   495 // ----------------------------------------------------------------------------
       
   496 //
       
   497 TMPXPlaybackPlayerType CMPXPlaybackUtility::TypeL()
       
   498     {
       
   499     MPX_FUNC_EX("CMPXPlaybackUtility::TypeL()");
       
   500     return EPbLocal;
       
   501     }
       
   502 
       
   503 // ----------------------------------------------------------------------------
       
   504 // The name of player type
       
   505 // ----------------------------------------------------------------------------
       
   506 //
       
   507 HBufC* CMPXPlaybackUtility::TypeNameL()
       
   508     {
       
   509 		HBufC* buf=NULL;
       
   510 		return buf;
       
   511     }
       
   512 
       
   513 // ----------------------------------------------------------------------------
       
   514 // Get sub players
       
   515 // ----------------------------------------------------------------------------
       
   516 //
       
   517 void CMPXPlaybackUtility::SubPlayerNamesL(MMPXPlaybackCallback& aCallback)
       
   518     {
       
   519     MPX_FUNC_EX("CMPXPlaybackUtility::SubPlayerNamesL()");
       
   520     SubPlayerNamesL(aCallback,UidL());
       
   521     }
       
   522 
       
   523 // ----------------------------------------------------------------------------
       
   524 // Selected sub player index
       
   525 // ----------------------------------------------------------------------------
       
   526 //
       
   527 TInt CMPXPlaybackUtility::SubPlayerL() const
       
   528     {
       
   529     return 0;
       
   530     }
       
   531 
       
   532 // ----------------------------------------------------------------------------
       
   533 // The UID identifying this player
       
   534 // ----------------------------------------------------------------------------
       
   535 //
       
   536 TUid CMPXPlaybackUtility::UidL() const
       
   537     {
       
   538     return TUid::Uid( 0 );
       
   539     }
       
   540 
       
   541 // ----------------------------------------------------------------------------
       
   542 // Path to the collection
       
   543 // ----------------------------------------------------------------------------
       
   544 //
       
   545 CMPXCollectionPlaylist* CMPXPlaybackUtility::PlaylistL()
       
   546     {
       
   547     MPX_FUNC_EX("CMPXPlaybackUtility::PlaylistL()");
       
   548     CMPXCollectionPlaylist *p = NULL;
       
   549 
       
   550     return p;
       
   551     }
       
   552 
       
   553 // ----------------------------------------------------------------------------
       
   554 // Return file handle
       
   555 // ----------------------------------------------------------------------------
       
   556 //
       
   557 RFile* CMPXPlaybackUtility::FileL()
       
   558     {
       
   559     RFile* file(NULL);
       
   560     return file;
       
   561     }
       
   562 
       
   563 // ----------------------------------------------------------------------------
       
   564 // URI of current song
       
   565 // ----------------------------------------------------------------------------
       
   566 //
       
   567 HBufC* CMPXPlaybackUtility::UriL()
       
   568     {
       
   569 		HBufC* buf=NULL;
       
   570 		return buf;
       
   571     }
       
   572 
       
   573 // ----------------------------------------------------------------------------
       
   574 // Request for media properties.
       
   575 // ----------------------------------------------------------------------------
       
   576 //
       
   577 void CMPXPlaybackUtility::MediaL(
       
   578     const TArray<TMPXAttribute>& aAttrs,
       
   579     MMPXPlaybackCallback& aCallback)
       
   580     {
       
   581     MediaL( aAttrs, aCallback, NULL );
       
   582     }
       
   583 
       
   584 // ----------------------------------------------------------------------------
       
   585 // Request for media properties.
       
   586 // ----------------------------------------------------------------------------
       
   587 //
       
   588 void CMPXPlaybackUtility::MediaL(
       
   589     const TArray<TMPXAttribute>& /* aAttrs */,
       
   590     MMPXPlaybackCallback& /* aCallback */,
       
   591     CMPXAttributeSpecs* /* aSpecs */)
       
   592     {
       
   593 
       
   594     }
       
   595 
       
   596 // ----------------------------------------------------------------------------
       
   597 // Server has completed the message, and if there's no error, the results are
       
   598 // available. The server completes with the function id (or error) so the correct
       
   599 // callback is made
       
   600 // ----------------------------------------------------------------------------
       
   601 //
       
   602 void CMPXPlaybackUtility::RunL()
       
   603     {
       
   604 
       
   605     }
       
   606 
       
   607 // ----------------------------------------------------------------------------
       
   608 // Canceling by the server
       
   609 // ----------------------------------------------------------------------------
       
   610 //
       
   611 void CMPXPlaybackUtility::DoCancel()
       
   612     {
       
   613 
       
   614     }
       
   615 
       
   616 // ----------------------------------------------------------------------------
       
   617 // Sends error message to all observers - maybe it should only be to the
       
   618 // client that calls the async method
       
   619 // ----------------------------------------------------------------------------
       
   620 //
       
   621 TInt CMPXPlaybackUtility::RunError(TInt /* aError */)
       
   622     {
       
   623     return KErrNone;
       
   624     }
       
   625 
       
   626 // ----------------------------------------------------------------------------
       
   627 // Distributes messages to all observers
       
   628 // ----------------------------------------------------------------------------
       
   629 //
       
   630 void CMPXPlaybackUtility::MessageReceived(TInt /* aMsgData */, TInt /* aError */)
       
   631     {
       
   632 
       
   633     }
       
   634 
       
   635 // ----------------------------------------------------------------------------
       
   636 // Distributes messages to all observers
       
   637 // ----------------------------------------------------------------------------
       
   638 //
       
   639 void CMPXPlaybackUtility::HandleMessageL(TInt /* aMsgData */, TInt /* aError */)
       
   640     {
       
   641 
       
   642     }
       
   643 
       
   644 // ----------------------------------------------------------------------------
       
   645 //  Handle error in RunL
       
   646 // ----------------------------------------------------------------------------
       
   647 //
       
   648 void CMPXPlaybackUtility::HandleRunErrorL(TInt /* aError */)
       
   649     {
       
   650 
       
   651     }
       
   652 
       
   653 
       
   654 // ----------------------------------------------------------------------------
       
   655 // Read a buffer from server
       
   656 // ----------------------------------------------------------------------------
       
   657 //
       
   658 HBufC* CMPXPlaybackUtility::DesL(TInt /* aSize */)
       
   659     {
       
   660     HBufC* des=NULL;
       
   661 
       
   662     return des;
       
   663     }
       
   664 
       
   665 // ----------------------------------------------------------------------------
       
   666 // Adds a sync request to the queue: if there is no outstanding request,
       
   667 // it will be executed immediately
       
   668 // ----------------------------------------------------------------------------
       
   669 //
       
   670 void CMPXPlaybackUtility::AddRequestL(TMPXPlaybackServerOp /*aFunction */,
       
   671                                       MMPXPlaybackCallback* /* aCallback */,
       
   672                                       TInt /* aParamData */,
       
   673                                       CBufBase* /* aBuf */,
       
   674                                       TAny* /* aPtr */,
       
   675                                       CBase* /* aAlivePtr */)
       
   676     {
       
   677 
       
   678     }
       
   679 
       
   680 // ----------------------------------------------------------------------------
       
   681 // Executes the next request in the queue.
       
   682 // ----------------------------------------------------------------------------
       
   683 //
       
   684 void CMPXPlaybackUtility::ExecuteNextRequest()
       
   685     {
       
   686 
       
   687     }
       
   688 
       
   689 
       
   690 
       
   691 #ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
       
   692 // ----------------------------------------------------------------------------
       
   693 // Inititialises with a single song, may not be part of any collection
       
   694 // ----------------------------------------------------------------------------
       
   695 //
       
   696 void CMPXPlaybackUtility::Init64L(RFile64& /* aShareableFile */)
       
   697     {
       
   698 
       
   699     }
       
   700  
       
   701 // ----------------------------------------------------------------------------
       
   702 // Inititialises with a file, may not be part of any collection
       
   703 // ----------------------------------------------------------------------------
       
   704 //
       
   705 void CMPXPlaybackUtility::InitStreaming64L(RFile64& /* aShareableFile */, const TInt /* aAccessPoint */)
       
   706     {
       
   707 
       
   708     }
       
   709 
       
   710 // ----------------------------------------------------------------------------
       
   711 // Return file handle
       
   712 // ----------------------------------------------------------------------------
       
   713 //
       
   714 RFile64* CMPXPlaybackUtility::File64L()
       
   715     {
       
   716     RFile64* file(NULL);
       
   717 
       
   718     return file;
       
   719     }
       
   720 
       
   721 #endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
       
   722 
       
   723 // End of file