1 /*

     2 * Copyright (c) 2009 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: Framework wraper for Playback - Private.

    15 *

    16 */

    17 

    18 #include <mpxplaybackutility.h>

    19 #include <mpxcollectionutility.h>

    20 #include <mpxmedia.h>

    21 #include <mpxmediageneraldefs.h>

    22 #include <mpxmediamusicdefs.h>

    23 #include <mpxcommandgeneraldefs.h>

    24 #include <mpxplaybackmessage.h>

    25 #include <mpxmessagegeneraldefs.h>

    26 #include <mpxplaybackmessagedefs.h>

    27 #include <mpxcollectionplaylist.h>

    28 #include <mpxcollectionplugin.hrh>

    29 #include <mpxcollectioncommanddefs.h>

    30 

    31 #include "mpmpxpbframeworkwrapper_p.h"

    32 #include "mpmpxpbframeworkwrapper.h"

    33 #include "mpplaybackdata.h"

    34 #include "mpcommondefs.h"

    35 #include "mptrace.h"

    36 

    37 /*!

    38     \class MpMpxPbFrameworkWrapperPrivate

    39     \brief Wrapper for mpx framework utilities - private implementation.

    40 

    41     This is a private implementation of the mpx framework wrapper utilties interface.

    42 */

    43 

    44 /*!

    45  \internal

    46  */

    47 MpMpxPbFrameworkWrapperPrivate::MpMpxPbFrameworkWrapperPrivate( MpMpxPbFrameworkWrapper *qq)

    48     : q_ptr( qq ),

    49       iPlaybackUtility(0),

    50       iCollectionUtility(0),

    51       iMedia(0),

    52       iPlaybackData(0)

    53 {

    54     TX_LOG

    55 }

    56 

    57 /*!

    58  \internal

    59  */

    60 MpMpxPbFrameworkWrapperPrivate::~MpMpxPbFrameworkWrapperPrivate()

    61 {

    62     TX_ENTRY

    63 

    64     if ( iPlaybackUtility ) {

    65         TRAP_IGNORE( ForceStopL() );

    66         iPlaybackUtility->Close();

    67     }

    68 

    69     if ( iCollectionUtility ) {

    70         iCollectionUtility->Close();

    71     }

    72 

    73     delete iMedia;

    74     delete iPlaybackData;

    75 

    76     TX_EXIT

    77 }

    78 

    79 /*!

    80  \internal

    81  */

    82 void MpMpxPbFrameworkWrapperPrivate::init()

    83 {

    84     TRAPD(err, DoInitL());

    85     if ( err != KErrNone ) {

    86         TX_LOG_ARGS("Error: " << err << "; should never get here.");

    87     }

    88 }

    89 

    90 /*!

    91  \internal

    92  */

    93 void MpMpxPbFrameworkWrapperPrivate::playPause()

    94 {

    95     TX_ENTRY

    96     TRAPD(err, iPlaybackUtility->CommandL(EPbCmdPlayPause));

    97     if ( err != KErrNone ) {

    98         TX_LOG_ARGS("Error: " << err << "; should never get here.");

    99     }

   100     TX_EXIT

   101 }

   102 

   103 /*!

   104  \internal

   105  */

   106 void MpMpxPbFrameworkWrapperPrivate::stop()

   107 {

   108     TX_ENTRY

   109     TRAPD(err, iPlaybackUtility->CommandL(EPbCmdStop));

   110     if ( err != KErrNone ) {

   111         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   112     }

   113     TX_EXIT

   114 }

   115 

   116 /*!

   117  \internal

   118  */

   119 void MpMpxPbFrameworkWrapperPrivate::skipForward()

   120 {

   121     TX_ENTRY

   122     TRAPD(err, iPlaybackUtility->CommandL(EPbCmdNext));

   123     if ( err != KErrNone ) {

   124         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   125     }

   126     TX_EXIT

   127 }

   128 

   129 /*!

   130  \internal

   131  */

   132 void MpMpxPbFrameworkWrapperPrivate::skipBackward()

   133 {

   134     TX_ENTRY

   135     TRAPD(err, iPlaybackUtility->CommandL(EPbCmdPrevious));

   136     if ( err != KErrNone ) {

   137         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   138     }

   139     TX_EXIT

   140 }

   141 

   142 /*!

   143  \internal

   144  */

   145 void MpMpxPbFrameworkWrapperPrivate::setPosition( int value )

   146 {

   147     TX_ENTRY_ARGS("value =" << value);

   148     TRAPD(err, iPlaybackUtility->SetL(EPbPropertyPosition, value));

   149     if ( err != KErrNone ) {

   150         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   151     }

   152     TX_EXIT

   153 }

   154 

   155 /*!

   156  \internal

   157  */

   158 void MpMpxPbFrameworkWrapperPrivate::setShuffle( bool mode )

   159 {

   160     TX_ENTRY_ARGS("mode =" << mode);

   161     TRAPD(err, iPlaybackUtility->SetL(EPbPropertyRandomMode, mode));

   162     if ( err != KErrNone ) {

   163         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   164     }

   165     TX_EXIT

   166 }

   167 

   168 /*!

   169  \internal

   170  */

   171 void MpMpxPbFrameworkWrapperPrivate::setRepeat( bool mode )

   172 {

   173     TX_ENTRY_ARGS("mode =" << mode);

   174     TRAPD(err, iPlaybackUtility->SetL(EPbPropertyRepeatMode, mode ? EPbRepeatAll : EPbRepeatOff));

   175     if ( err != KErrNone ) {

   176         TX_LOG_ARGS("Error: " << err << "; should never get here.");

   177     }

   178     TX_EXIT

   179 }

   180 

   181 /*!

   182  \internal

   183  */

   184 MpPlaybackData *MpMpxPbFrameworkWrapperPrivate::playbackData()

   185 {

   186     return iPlaybackData;

   187 }

   188 

   189 /*!

   190  \internal

   191  */

   192 void MpMpxPbFrameworkWrapperPrivate::HandlePlaybackMessage( CMPXMessage *aMessage, TInt aError )

   193 {

   194     TX_ENTRY_ARGS("aError=" << aError);

   195     if ( aError == KErrNone && aMessage ) {

   196         TRAP_IGNORE( DoHandlePlaybackMessageL(*aMessage) );

   197     }

   198     TX_EXIT

   199 }

   200 

   201 /*!

   202  \internal

   203  */

   204 void MpMpxPbFrameworkWrapperPrivate::HandlePropertyL(

   205     TMPXPlaybackProperty aProperty,

   206     TInt aValue,

   207     TInt aError )

   208 {

   209     TX_ENTRY_ARGS("aProperty=" << aProperty << "aValue=" << aValue << "aError=" << aError)

   210     if ( KErrNone == aError ) {

   211         switch ( aProperty  ) {

   212             case EPbPropertyPosition:

   213                 TX_LOG_ARGS("EPbPropertyPosition")

   214                 iPlaybackData->setPosition(aValue);

   215                 break;

   216             case EPbPropertyDuration:

   217                 TX_LOG_ARGS("EPbPropertyDuration")

   218                 iPlaybackData->setDuration(aValue);

   219                 break;

   220             default:

   221                 break;

   222         }

   223     }

   224     TX_EXIT

   225 }

   226 

   227 /*!

   228  \internal

   229  */

   230 void MpMpxPbFrameworkWrapperPrivate::HandleSubPlayerNamesL(

   231     TUid aPlayer,

   232     const MDesCArray *aSubPlayers,

   233     TBool aComplete,

   234     TInt aError )

   235 {

   236     Q_UNUSED(aPlayer);

   237     Q_UNUSED(aSubPlayers);

   238     Q_UNUSED(aComplete);

   239     Q_UNUSED(aError);

   240     TX_LOG

   241 }

   242 

   243 /*!

   244  \internal

   245  */

   246 void MpMpxPbFrameworkWrapperPrivate::HandleMediaL(

   247     const CMPXMedia& aProperties,

   248     TInt aError )

   249 {

   250     TX_ENTRY_ARGS("aError=" << aError);

   251     if ( KErrNone != aError || !iPlaybackData ) {

   252         TX_EXIT

   253         return;

   254     }

   255 

   256     if ( iMedia ) {

   257         delete iMedia;

   258         iMedia = NULL;

   259     }

   260     iMedia = CMPXMedia::NewL( aProperties );

   261 

   262     bool changed = false;

   263     if ( aProperties.IsSupported( KMPXMediaGeneralTitle ) ) {

   264         changed |= iPlaybackData->setTitle(

   265             QString::fromUtf16(

   266                 aProperties.ValueText( KMPXMediaGeneralTitle ).Ptr(),

   267                 aProperties.ValueText( KMPXMediaGeneralTitle ).Length() ) );

   268     }

   269     if ( aProperties.IsSupported( KMPXMediaMusicArtist ) ) {

   270         changed |= iPlaybackData->setArtist(

   271             QString::fromUtf16(

   272                 aProperties.ValueText( KMPXMediaMusicArtist ).Ptr(),

   273                 aProperties.ValueText( KMPXMediaMusicArtist ).Length() ) );

   274     }

   275     if ( aProperties.IsSupported( KMPXMediaMusicAlbum ) ) {

   276         changed |= iPlaybackData->setAlbum(

   277             QString::fromUtf16(

   278                 aProperties.ValueText( KMPXMediaMusicAlbum ).Ptr(),

   279                 aProperties.ValueText( KMPXMediaMusicAlbum ).Length() ) );

   280     }

   281 

   282     if ( changed ) {

   283         // This is required to propagate the playback info to UI at once.

   284         iPlaybackData->commitPlaybackInfo();

   285     }

   286 

   287     if ( aProperties.IsSupported( KMPXMediaGeneralUri) ) {

   288         iPlaybackData->setUri(

   289             QString::fromUtf16(

   290                 aProperties.ValueText( KMPXMediaGeneralUri ).Ptr(),

   291                 aProperties.ValueText( KMPXMediaGeneralUri ).Length() ) );

   292     }

   293     if (aProperties.IsSupported(TMPXAttribute(KMPXMediaMusicAlbumArtFileName))) {

   294         iPlaybackData->setAlbumArtUri(

   295             QString::fromUtf16(

   296                 aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Ptr(),

   297                 aProperties.ValueText(KMPXMediaMusicAlbumArtFileName).Length()));

   298     }

   299     TX_EXIT

   300 }

   301 

   302 /*!

   303  \internal

   304  */

   305 void MpMpxPbFrameworkWrapperPrivate::HandleCollectionMessage(

   306     CMPXMessage* aMessage, TInt aError )

   307 {

   308 

   309     Q_UNUSED(aMessage);

   310     Q_UNUSED(aError);

   311 }

   312 

   313 /*!

   314  \internal

   315  */

   316 void MpMpxPbFrameworkWrapperPrivate::HandleOpenL(

   317     const CMPXMedia& aEntries, TInt aIndex, TBool aComplete, TInt aError)

   318 {

   319     Q_UNUSED(aEntries);

   320     Q_UNUSED(aIndex);

   321     Q_UNUSED(aComplete);

   322     Q_UNUSED(aError);

   323 }

   324 

   325 /*!

   326  \internal

   327  */

   328 void MpMpxPbFrameworkWrapperPrivate::HandleOpenL(

   329     const CMPXCollectionPlaylist& aPlaylist, TInt aError )

   330 {

   331     Q_UNUSED(aPlaylist);

   332     Q_UNUSED(aError);

   333 }

   334 

   335 /*!

   336  \internal

   337  */

   338 void MpMpxPbFrameworkWrapperPrivate::HandleCollectionMediaL(

   339     const CMPXMedia& aMedia, TInt aError )

   340 {

   341     Q_UNUSED(aMedia);

   342     Q_UNUSED(aError);

   343 }

   344 

   345 /*!

   346  \internal

   347  */

   348 void MpMpxPbFrameworkWrapperPrivate::DoInitL()

   349 {

   350     TX_ENTRY

   351     iPlaybackUtility = MMPXPlaybackUtility::UtilityL( TUid::Uid( MpCommon::KMusicPlayerUid ) );

   352     iPlaybackUtility->AddObserverL( *this );

   353     iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );

   354 

   355     iPlaybackData = new MpPlaybackData();

   356     TX_EXIT

   357 }

   358 

   359 /*!

   360  \internal

   361  */

   362 void MpMpxPbFrameworkWrapperPrivate::DoHandlePlaybackMessageL( const CMPXMessage& aMessage )

   363 {

   364     TX_ENTRY

   365     TMPXMessageId id( aMessage.ValueTObjectL<TMPXMessageId>( KMPXMessageGeneralId ) );

   366     if ( KMPXMessageGeneral == id ) {

   367         TInt event( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );

   368         TInt type( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

   369         TInt data( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ) );

   370         TX_LOG_ARGS("event=" << event << ", type=" << type << ", data=" << data);

   371 

   372         switch ( event ) {

   373             case TMPXPlaybackMessage::EStateChanged:

   374                 TX_LOG_ARGS("TMPXPlaybackMessage::EStateChanged")

   375                 UpdateStateL();

   376                 break;

   377             case TMPXPlaybackMessage::EInitializeComplete:

   378                 TX_LOG_ARGS("TMPXPlaybackMessage::EInitializeComplete")

   379                 if ( data ) {

   380                     // Play the track

   381                     CMPXCommand *cmd( CMPXCommand::NewL() );

   382                     CleanupStack::PushL( cmd );

   383                     cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId,

   384                             KMPXCommandIdPlaybackGeneral );

   385                     cmd->SetTObjectValueL<TInt>(

   386                             KMPXCommandPlaybackGeneralType,

   387                             EPbCmdPlay );

   388                     cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync,

   389                             ETrue );

   390                     cmd->SetTObjectValueL<TBool>(

   391                             KMPXCommandPlaybackGeneralNoBuffer,

   392                             ETrue );

   393                     iPlaybackUtility->CommandL( *cmd );

   394                     CleanupStack::PopAndDestroy( cmd );

   395                 }

   396                 break;

   397             case TMPXPlaybackMessage::EPropertyChanged:

   398                 TX_LOG_ARGS("TMPXPlaybackMessage::EPropertyChanged")

   399                 TMPXPlaybackProperty property;

   400                 property = static_cast<TMPXPlaybackProperty>( type );

   401                 HandlePropertyL( property, data, KErrNone );

   402                 break;

   403             case TMPXPlaybackMessage::EMediaChanged:

   404                 TX_LOG_ARGS("TMPXPlaybackMessage::EMediaChanged")

   405                 RetrieveSongDetailsL();

   406                 break;

   407             default:

   408                 break;

   409         }

   410     }

   411     TX_EXIT

   412 }

   413 

   414 /*!

   415  \internal

   416  */

   417 void MpMpxPbFrameworkWrapperPrivate::ForceStopL()

   418 {

   419     TX_ENTRY

   420     if ( iPlaybackUtility ) {

   421         // Stop the track

   422         CMPXCommand *cmd( CMPXCommand::NewL() );

   423         CleanupStack::PushL( cmd );

   424         cmd->SetTObjectValueL<TInt>( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral );

   425         cmd->SetTObjectValueL<TInt>( KMPXCommandPlaybackGeneralType, EPbCmdStop );

   426         cmd->SetTObjectValueL<TBool>( KMPXCommandGeneralDoSync, ETrue );

   427         cmd->SetTObjectValueL<TBool>( KMPXCommandPlaybackGeneralNoBuffer, ETrue );

   428         iPlaybackUtility->CommandL( *cmd );

   429         CleanupStack::PopAndDestroy( cmd );

   430 

   431         iPlaybackUtility->RemoveObserverL(*this);

   432     }

   433     TX_EXIT

   434 }

   435 

   436 /*!

   437  \internal

   438  */

   439 void MpMpxPbFrameworkWrapperPrivate::UpdateStateL()

   440 {

   441     TX_ENTRY

   442     if ( !iPlaybackUtility->Source() ) {

   443         TX_LOG_ARGS("There is no source")

   444         iPlaybackData->setPlaybackState( MpPlaybackData::Stopped );

   445     }

   446     else {

   447         switch ( iPlaybackUtility->StateL() ) {

   448             case EPbStatePlaying:

   449                 TX_LOG_ARGS("EPbStatePlaying")

   450                 iPlaybackData->setPlaybackState( MpPlaybackData::Playing );

   451                 break;

   452             case EPbStatePaused:

   453                 TX_LOG_ARGS("EPbStatePaused")

   454                 iPlaybackData->setPlaybackState( MpPlaybackData::Paused );

   455                 break;

   456             case EPbStateStopped:

   457                 TX_LOG_ARGS("EPbStateStopped")

   458                 iPlaybackData->setPlaybackState( MpPlaybackData::Stopped );

   459                 break;

   460             default:

   461                 break;

   462         }

   463     }

   464     TX_EXIT

   465 }

   466 

   467 /*!

   468  \internal

   469  */

   470 void MpMpxPbFrameworkWrapperPrivate::RetrieveSongDetailsL()

   471 {

   472     TX_ENTRY

   473     MMPXSource *mediaSrc = iPlaybackUtility->Source();

   474     User::LeaveIfNull( mediaSrc );

   475     RArray<TMPXAttribute> requestedAttr;

   476     CleanupClosePushL( requestedAttr );

   477     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralTitle ) );

   478     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicArtist ) );

   479     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbum ) );

   480     requestedAttr.AppendL( TMPXAttribute( KMPXMediaGeneralUri ) );

   481     requestedAttr.AppendL( TMPXAttribute( KMPXMediaMusicAlbumArtFileName ) );

   482 

   483     mediaSrc->MediaL( requestedAttr.Array(), *this );

   484     CleanupStack::PopAndDestroy( &requestedAttr );

   485     TX_EXIT

   486 }

   487