Mercurial Mercurial > oss > FCL > sf > app > musicplayer / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mpengine/src/mpmpxplaybackframeworkwrapper_p.cpp
changeset 43 0f32e550d9d8
parent 36 a0afa279b8fe
child 45 612c4815aebe
equal deleted inserted replaced
38:b93f525c9244 43:0f32e550d9d8 
    17 
    17 
    18 #include <mpxplaybackutility.h>
 
    18 #include <mpxplaybackutility.h>
 
    19 #include <mpxmedia.h>
 
    19 #include <mpxmedia.h>
 
    20 #include <mpxmediageneraldefs.h>
 
    20 #include <mpxmediageneraldefs.h>
 
    21 #include <mpxmediamusicdefs.h>
 
    21 #include <mpxmediamusicdefs.h>
 
       
    22 #include <mpxmediaaudiodefs.h>
 
       
    23 #include <mpxmediadrmdefs.h>
 
    22 #include <mpxcommandgeneraldefs.h>
 
    24 #include <mpxcommandgeneraldefs.h>
 
    23 #include <mpxplaybackmessage.h>
 
    25 #include <mpxplaybackmessage.h>
 
    24 #include <mpxmessagegeneraldefs.h>
 
    26 #include <mpxmessagegeneraldefs.h>
 
    25 #include <mpxplaybackmessagedefs.h>
 
    27 #include <mpxplaybackmessagedefs.h>
 
    26 #include <mpxplaybackframeworkdefs.h>
 
    28 #include <mpxplaybackframeworkdefs.h>
 
    31 #include "mpmpxplaybackframeworkwrapper.h"
 
    33 #include "mpmpxplaybackframeworkwrapper.h"
 
    32 #include "mpplaybackdata.h"
 
    34 #include "mpplaybackdata.h"
 
    33 #include "mpcommondefs.h"
 
    35 #include "mpcommondefs.h"
 
    34 #include "mptrace.h"
 
    36 #include "mptrace.h"
 
    35 #include "mpxaudioeffectengine.h"
 
    37 #include "mpxaudioeffectengine.h"
 
       
    38 #include "mpsongdata.h"
 
    36 
    39 
    37 _LIT(KMPXPnRealAudioMimeType, "audio/x-pn-realaudio");
 
    40 _LIT(KMPXPnRealAudioMimeType, "audio/x-pn-realaudio");
 
    38 _LIT(KMPXRealAudioMimeType, "audio/x-realaudio");
 
    41 _LIT(KMPXRealAudioMimeType, "audio/x-realaudio");
 
    39 _LIT(KMPXRnRealAudioMimeType, "audio/vnd.rn-realaudio");
 
    42 _LIT(KMPXRnRealAudioMimeType, "audio/vnd.rn-realaudio");
 
    40 /*!
 
    43 /*!
 
    46 
    49 
    47 /*!
 
    50 /*!
 
    48  \internal
 
    51  \internal
 
    49  */
 
    52  */
 
    50 MpMpxPlaybackFrameworkWrapperPrivate::MpMpxPlaybackFrameworkWrapperPrivate( MpMpxPlaybackFrameworkWrapper *qq)
 
    53 MpMpxPlaybackFrameworkWrapperPrivate::MpMpxPlaybackFrameworkWrapperPrivate( MpMpxPlaybackFrameworkWrapper *qq)
 
    51     : q_ptr( qq ),
 
    54     : q_ptr(qq),
 
    52       iPlaybackUtility( 0 ),
 
    55       iPlaybackUtility(0),
 
    53       iMedia( 0 ),
 
    56       iPlaybackData(0),
 
    54       iPlaybackData( 0 )
 
    57       iDetailsRequest(false)
 
    55 {
 
    58 {
 
    56     TX_LOG
 
    59     TX_LOG
 
    57 }
 
    60 }
 
    58 
    61 
    59 /*!
 
    62 /*!
 
    60  \internal
 
    63  \internal
 
    61  */
 
    64  */
 
    62 MpMpxPlaybackFrameworkWrapperPrivate::~MpMpxPlaybackFrameworkWrapperPrivate()
 
    65 MpMpxPlaybackFrameworkWrapperPrivate::~MpMpxPlaybackFrameworkWrapperPrivate()
 
    63 {
 
    66 {
 
    64     TX_ENTRY
 
    67     TX_ENTRY
 
    65 
       
    66     if ( iPlaybackUtility ) {
 
    68     if ( iPlaybackUtility ) {
 
    67         TRAP_IGNORE( ForceStopL() );
 
    69         TRAP_IGNORE( ForceStopL() );
 
    68         TRAP_IGNORE( iPlaybackUtility->RemoveObserverL(*this) );
 
    70         TRAP_IGNORE( iPlaybackUtility->RemoveObserverL(*this) );
 
    69         iPlaybackUtility->Close();
 
    71         iPlaybackUtility->Close();
 
    70     }
 
    72     }
 
    71 
       
    72     delete iMedia;
 
       
    73     delete iPlaybackData;
 
    73     delete iPlaybackData;
 
    74 
    74     TX_EXIT
 
    75     TX_EXIT
 
    75 }
 
    76 }
 
    76 
    77 
    77 /*!
 
    78 /*!
 
    78  \internal
 
    79  \internal
 
    79  */
 
    80  */
 
    80 void MpMpxPlaybackFrameworkWrapperPrivate::init( TUid hostUid, MpSongData *songData )
 
    81 void MpMpxPlaybackFrameworkWrapperPrivate::init( TUid hostUid )
 
    81 {
 
    82 {
 
    82     TX_ENTRY
 
    83     mHostUid = hostUid;
 
    83     iHostUid = hostUid;
 
       
    84     iSongData = songData;
 
    84     TRAPD(err, DoInitL());
 
    85     TRAPD(err, DoInitL());
 
    85     if ( err != KErrNone ) {
 
    86     if ( err != KErrNone ) {
 
    86         TX_LOG_ARGS("Error: " << err << "; should never get here.");
 
    87         TX_LOG_ARGS("Error: " << err << "; should never get here.");
 
    87     }
 
    88     }
 
       
    89     TX_EXIT
 
    88 }
 
    90 }
 
    89 
    91 
    90 /*!
 
    92 /*!
 
    91  \internal
 
    93  \internal
 
    92  */
 
    94  */
 
   281  \internal
 
   283  \internal
 
   282  */
 
   284  */
 
   283 MpPlaybackData *MpMpxPlaybackFrameworkWrapperPrivate::playbackData()
 
   285 MpPlaybackData *MpMpxPlaybackFrameworkWrapperPrivate::playbackData()
 
   284 {
 
   286 {
 
   285     return iPlaybackData;
 
   287     return iPlaybackData;
 
       
   288 }
 
       
   289 
       
   290 /*!
 
       
   291  \internal
 
       
   292  */
 
       
   293 void MpMpxPlaybackFrameworkWrapperPrivate::retrieveSongDetails()
 
       
   294 {
 
       
   295     TX_ENTRY
 
       
   296     TRAPD( err, DoRetrieveSongDetailsL(true) );
 
       
   297     if ( err == KErrNone ) {
 
       
   298         iDetailsRequest = true;
 
       
   299     }
 
       
   300     else {
 
       
   301         TX_LOG_ARGS( "Error: " << err << "; should never get here." );
 
       
   302     }
 
       
   303     TX_EXIT
 
   286 }
 
   304 }
 
   287 
   305 
   288 /*!
 
   306 /*!
 
   289  \internal
 
   307  \internal
 
   290  */
 
   308  */
 
   341 
   359 
   342 /*!
 
   360 /*!
 
   343  \internal
 
   361  \internal
 
   344  */
 
   362  */
 
   345 void MpMpxPlaybackFrameworkWrapperPrivate::HandleMediaL(
 
   363 void MpMpxPlaybackFrameworkWrapperPrivate::HandleMediaL(
 
   346     const CMPXMedia& aProperties,
 
   364     const CMPXMedia& aMedia,
 
   347     TInt aError )
 
   365     TInt aError )
 
   348 {
 
   366 {
 
   349     TX_ENTRY_ARGS("aError=" << aError);
 
   367     TX_ENTRY
 
   350     if ( KErrNone != aError || !iPlaybackData ) {
 
   368     if ( KErrNone != aError ){
 
       
   369         TX_LOG_ARGS( "Error: " << aError << "; should never get here." );
 
   351         TX_EXIT
 
   370         TX_EXIT
 
   352         return;
 
   371         return;
 
   353     }
 
   372     }
 
   354 
   373 
   355     if ( iMedia ) {
 
   374     if ( iDetailsRequest ) {
 
   356         delete iMedia;
 
   375         iDetailsRequest = false;
 
   357         iMedia = NULL;
 
   376         iSongData->setMpxMedia( aMedia );
 
   358     }
 
       
   359     iMedia = CMPXMedia::NewL( aProperties );
 
       
   360 
       
   361     bool changed = false;
 
       
   362     if ( aProperties.IsSupported( KMPXMediaGeneralTitle ) ) {
 
       
   363         changed |= iPlaybackData->setTitle(
 
       
   364             QString::fromUtf16(
 
       
   365                 aProperties.ValueText( KMPXMediaGeneralTitle ).Ptr(),
 
       
   366                 aProperties.ValueText( KMPXMediaGeneralTitle ).Length() ) );
 
       
   367     }
 
   377     }
 
   368     else {
 
   378     else {
 
   369         changed |= iPlaybackData->setTitle(
 
   379         bool changed = false;
 
   370             QString::fromUtf16(
 
   380         if ( aMedia.IsSupported( KMPXMediaGeneralTitle ) ) {
 
   371                 aProperties.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   381             changed |= iPlaybackData->setTitle(
 
   372                 aProperties.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   382                 QString::fromUtf16(
 
   373     }
 
   383                     aMedia.ValueText( KMPXMediaGeneralTitle ).Ptr(),
 
   374     
   384                     aMedia.ValueText( KMPXMediaGeneralTitle ).Length() ) );
 
   375     if ( aProperties.IsSupported( KMPXMediaMusicArtist ) ) {
 
   385         }
 
   376         changed |= iPlaybackData->setArtist(
 
   386         else {
 
   377             QString::fromUtf16(
 
   387             changed |= iPlaybackData->setTitle(
 
   378                 aProperties.ValueText( KMPXMediaMusicArtist ).Ptr(),
 
   388                 QString::fromUtf16(
 
   379                 aProperties.ValueText( KMPXMediaMusicArtist ).Length() ) );
 
   389                     aMedia.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   380     }
 
   390                     aMedia.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   381     else {
 
   391         }
 
   382             changed |= iPlaybackData->setArtist(QString());
 
   392 
   383     }
 
   393         if ( aMedia.IsSupported( KMPXMediaMusicArtist ) ) {
 
   384     if ( aProperties.IsSupported( KMPXMediaMusicAlbum ) ) {
 
   394             changed |= iPlaybackData->setArtist(
 
   385         changed |= iPlaybackData->setAlbum(
 
   395                 QString::fromUtf16(
 
   386             QString::fromUtf16(
 
   396                     aMedia.ValueText( KMPXMediaMusicArtist ).Ptr(),
 
   387                 aProperties.ValueText( KMPXMediaMusicAlbum ).Ptr(),
 
   397                     aMedia.ValueText( KMPXMediaMusicArtist ).Length() ) );
 
   388                 aProperties.ValueText( KMPXMediaMusicAlbum ).Length() ) );
 
   398         }
 
   389     }
 
   399         else {
 
   390     else {
 
   400                 changed |= iPlaybackData->setArtist(QString());
 
   391             changed |= iPlaybackData->setAlbum(QString());
 
   401         }
 
   392     }
 
   402         if ( aMedia.IsSupported( KMPXMediaMusicAlbum ) ) {
 
   393     if (aProperties.IsSupported(TMPXAttribute(KMPXMediaGeneralMimeType))) {
 
   403             changed |= iPlaybackData->setAlbum(
 
   394         
   404                 QString::fromUtf16(
 
   395             const TDesC& mimeType = aProperties.ValueText ( KMPXMediaGeneralMimeType );
 
   405                     aMedia.ValueText( KMPXMediaMusicAlbum ).Ptr(),
 
   396             
   406                     aMedia.ValueText( KMPXMediaMusicAlbum ).Length() ) );
 
   397             bool realAudioMode =
 
   407         }
 
   398                     ( mimeType.Compare( KMPXPnRealAudioMimeType ) == 0 ) ||
 
   408         else {
 
   399                     ( mimeType.Compare( KMPXRealAudioMimeType ) == 0) ||
 
   409                 changed |= iPlaybackData->setAlbum(QString());
 
   400                     ( mimeType.Compare( KMPXRnRealAudioMimeType ) == 0 );
 
   410         }
 
   401             
   411         if (aMedia.IsSupported(TMPXAttribute(KMPXMediaGeneralMimeType))) {
 
   402             changed |= iPlaybackData->setRealAudio( realAudioMode );
 
   412 
   403     }
 
   413                 const TDesC& mimeType = aMedia.ValueText ( KMPXMediaGeneralMimeType );
 
   404 
   414 
   405 
   415                 bool realAudioMode =
 
   406     if ( aProperties.IsSupported( KMPXMediaGeneralUri) ) {
 
   416                         ( mimeType.Compare( KMPXPnRealAudioMimeType ) == 0 ) ||
 
   407         iPlaybackData->setUri(
 
   417                         ( mimeType.Compare( KMPXRealAudioMimeType ) == 0) ||
 
   408             QString::fromUtf16(
 
   418                         ( mimeType.Compare( KMPXRnRealAudioMimeType ) == 0 );
 
   409                 aProperties.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   419 
   410                 aProperties.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   420                 changed |= iPlaybackData->setRealAudio( realAudioMode );
 
   411     }
 
   421         }
 
   412     if (aProperties.IsSupported(TMPXAttribute(KMPXMediaMusicAlbumArtFileName))) {
 
   422 
   413         iPlaybackData->setAlbumArtUri(
 
   423         if ( aMedia.IsSupported( KMPXMediaGeneralUri) ) {
 
   414             QString::fromUtf16(
 
   424             iPlaybackData->setUri(
 
   415                 aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Ptr(),
 
   425                 QString::fromUtf16(
 
   416                 aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Length()));
 
   426                     aMedia.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   417     }
 
   427                     aMedia.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   418     else {
 
   428         }
 
   419         iPlaybackData->setAlbumArtUri(
 
   429         if (aMedia.IsSupported(TMPXAttribute(KMPXMediaMusicAlbumArtFileName))) {
 
   420             QString::fromUtf16(
 
   430             iPlaybackData->setAlbumArtUri(
 
   421                 aProperties.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   431                 QString::fromUtf16(
 
   422                 aProperties.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   432                     aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Ptr(),
 
   423     }
 
   433                     aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Length()));
 
   424     if ( aProperties.IsSupported( KMPXMediaMusicAlbumId) ) {
 
   434         }
 
   425     changed |= iPlaybackData->setAlbumId( 
   435         else {
 
   426                 aProperties.ValueTObjectL<TInt>( KMPXMediaMusicAlbumId ) );
 
   436             iPlaybackData->setAlbumArtUri(
 
   427     }
 
   437                 QString::fromUtf16(
 
   428     
   438                     aMedia.ValueText( KMPXMediaGeneralUri ).Ptr(),
 
   429     if ( aProperties.IsSupported( KMPXMediaGeneralId) ) {
 
   439                     aMedia.ValueText( KMPXMediaGeneralUri ).Length() ) );
 
   430     changed |= iPlaybackData->setId( 
   440         }
 
   431                 aProperties.ValueTObjectL<TInt>( KMPXMediaGeneralId ) );
 
   441         if ( aMedia.IsSupported( KMPXMediaMusicAlbumId) ) {
 
   432     }
 
   442         changed |= iPlaybackData->setAlbumId(
 
   433     
   443                 aMedia.ValueTObjectL<TMPXItemId>( KMPXMediaMusicAlbumId ) );
 
   434     if ( changed ) {
 
   444         }
 
   435         // This is required to propagate the playback info to UI at once.
 
   445 
   436         iPlaybackData->commitPlaybackInfo();
 
   446         if ( aMedia.IsSupported( KMPXMediaGeneralId ) ) {
 
       
   447         changed |= iPlaybackData->setId(
 
       
   448                     aMedia.ValueTObjectL<TInt>( KMPXMediaGeneralId ) );
 
       
   449         }
 
       
   450 
       
   451         if ( changed ) {
 
       
   452             // This is required to propagate the playback info to UI at once.
 
       
   453             iPlaybackData->commitPlaybackInfo();
 
       
   454         }
 
   437     }
 
   455     }
 
   438     TX_EXIT
 
   456     TX_EXIT
 
   439 }
 
   457 }
 
   440 
   458 
   441 /*!
 
   459 /*!
 
   442  \internal
 
   460  \internal
 
   443  */
 
   461  */
 
   444 void MpMpxPlaybackFrameworkWrapperPrivate::DoInitL()
 
   462 void MpMpxPlaybackFrameworkWrapperPrivate::DoInitL()
 
   445 {
 
   463 {
 
   446     TX_ENTRY
 
   464     TX_ENTRY
 
   447     iPlaybackUtility = MMPXPlaybackUtility::UtilityL( mHostUid );
 
   465     iPlaybackUtility = MMPXPlaybackUtility::UtilityL( iHostUid );
 
   448     iPlaybackUtility->AddObserverL( *this );
 
   466     iPlaybackUtility->AddObserverL( *this );
 
   449     iPlaybackData = new MpPlaybackData();
 
   467     iPlaybackData = new MpPlaybackData();
 
   450 
   468 
   451     UpdateStateL();
 
   469     UpdateStateL();
 
   452     if ( iPlaybackUtility->Source() ) {
 
   470     if ( iPlaybackUtility->Source() ) {
 
   453         RetrieveSongDetailsL();
 
   471         DoRetrieveSongDetailsL(false);
 
   454     }
 
   472     }
 
   455     TX_EXIT
 
   473     TX_EXIT
 
   456 }
 
   474 }
 
   457 
   475 
   458 /*!
 
   476 /*!
 
   472  \internal
 
   490  \internal
 
   473  */
 
   491  */
 
   474 void MpMpxPlaybackFrameworkWrapperPrivate::DoPlayL( const XQSharableFile& file )
 
   492 void MpMpxPlaybackFrameworkWrapperPrivate::DoPlayL( const XQSharableFile& file )
 
   475 {
 
   493 {
 
   476     TX_ENTRY
 
   494     TX_ENTRY
 
   477         
   495 
   478     RFile xqfile;
 
   496     RFile xqfile;
 
   479     bool ok = file.getHandle( xqfile );
 
   497     bool ok = file.getHandle( xqfile );
 
   480     if ( ok ) {
 
   498     if ( ok ) {
 
   481         iPlaybackUtility->InitL( xqfile );
 
   499         iPlaybackUtility->InitL( xqfile );
 
   482     }
 
   500     }
 
   530                 property = static_cast<TMPXPlaybackProperty>( type );
 
   548                 property = static_cast<TMPXPlaybackProperty>( type );
 
   531                 HandlePropertyL( property, data, KErrNone );
 
   549                 HandlePropertyL( property, data, KErrNone );
 
   532                 break;
 
   550                 break;
 
   533             case TMPXPlaybackMessage::EMediaChanged:
 
   551             case TMPXPlaybackMessage::EMediaChanged:
 
   534                 TX_LOG_ARGS("TMPXPlaybackMessage::EMediaChanged")
 
   552                 TX_LOG_ARGS("TMPXPlaybackMessage::EMediaChanged")
 
   535                 RetrieveSongDetailsL();
 
   553                 DoRetrieveSongDetailsL(false);
 
   536                 break;
 
   554                 break;
 
   537             case TMPXPlaybackMessage::EPlaylistUpdated:
 
   555             case TMPXPlaybackMessage::EPlaylistUpdated:
 
   538                 TX_LOG_ARGS( "EPlaylistUpdated" )
 
   556                 TX_LOG_ARGS( "EPlaylistUpdated" )
 
   539             case TMPXPlaybackMessage::EActivePlayerChanged:
 
   557             case TMPXPlaybackMessage::EActivePlayerChanged:
 
   540                 TX_LOG_ARGS( "EActivePlayerChanged or fall through from EPlaylistUpdated" )
 
   558                 TX_LOG_ARGS( "EActivePlayerChanged or fall through from EPlaylistUpdated" )
 
   541                 UpdateStateL();
 
   559                 UpdateStateL();
 
   542                 RetrieveSongDetailsL();
 
   560                 DoRetrieveSongDetailsL(false);
 
   543                 break;
 
   561                 break;
 
   544             default:
 
   562             default:
 
   545                 break;
 
   563                 break;
 
   546         }
 
   564         }
 
   547     }
 
   565     }
 
   604 }
 
   622 }
 
   605 
   623 
   606 /*!
 
   624 /*!
 
   607  \internal
 
   625  \internal
 
   608  */
 
   626  */
 
   609 void MpMpxPlaybackFrameworkWrapperPrivate::RetrieveSongDetailsL()
 
   627 void MpMpxPlaybackFrameworkWrapperPrivate::DoRetrieveSongDetailsL( bool detailsRequest )
 
   610 {
 
   628 {
 
   611     TX_ENTRY
 
   629     TX_ENTRY
 
   612     MMPXSource *mediaSrc = iPlaybackUtility->Source();
 
   630     MMPXSource *mediaSrc = iPlaybackUtility->Source();
 
   613     User::LeaveIfNull( mediaSrc );
 
   631     User::LeaveIfNull( mediaSrc );
 
   614     RArray<TMPXAttribute> requestedAttr;
 
   632     RArray<TMPXAttribute> requestedAttr;
 
   615     CleanupClosePushL( requestedAttr );
 
   633     CleanupClosePushL( requestedAttr );
 
       
   634     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralId ) );
 
   616     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralTitle ) );
 
   635     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralTitle ) );
 
   617     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicArtist ) );
 
   636     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicArtist ) );
 
   618     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbum ) );
 
   637     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbum ) );
 
       
   638     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumId ) );
 
   619     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralUri ) );
 
   639     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralUri ) );
 
   620     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) );
 
   640     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) );
 
   621     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumId ) );
 
   641     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralMimeType ) );
 
   622 	requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralMimeType ) );
 
   642     if ( detailsRequest ) {
 
   623 	requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralId ) );
 
   643         requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumTrack ) );
 
   624 	
   644         requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicComposer ) );
 
   625 
   645         requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicYear ) );
 
       
   646         requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicGenre ) );
 
       
   647         requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralDuration ) );
 
       
   648         requestedAttr.AppendL( TMPXAttribute( KMPXMediaAudioBitrate ) );
 
       
   649         requestedAttr.AppendL( TMPXAttribute( KMPXMediaAudioSamplerate ) );
 
       
   650         requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralCopyright ) );
 
       
   651         requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicURL ) );
 
       
   652         requestedAttr.AppendL( TMPXAttribute( KMPXMediaDrmProtected ) );
 
       
   653     }
 
   626     mediaSrc->MediaL( requestedAttr.Array(), *this );
 
   654     mediaSrc->MediaL( requestedAttr.Array(), *this );
 
   627     CleanupStack::PopAndDestroy( &requestedAttr );
 
   655     CleanupStack::PopAndDestroy( &requestedAttr );
 
   628     TX_EXIT
 
   656     TX_EXIT
 
   629 }
 
   657 }
 
   630 
   658
FCL/sf/app/musicplayer