musichomescreen_multiview/musicplayeractionhandlerplugin/src/musicplayeractionhandler.cpp
changeset 0 ff3acec5bc43
child 2 b70d77332e66
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     1 /*
       
     2 * Copyright (c) 2008-2008 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:  Music Player Action Handler Plugin
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include <liwvariant.h>                 // TLiwVariant
       
    20 #include <apgcli.h>                     // RApaLsSession, TApaAppInfo
       
    21 #include <apacmdln.h>                   // CApaCommandLine
       
    22 #include <apgtask.h>                    // TApaTaskList
       
    23 #include <mpxlog.h>                     // MPX_DEBUG
       
    24 #include <mpxparameter.h>               // CMPXParameter
       
    25 #include <mpxplaybackutility.h>         // MMPXPlaybackUtility
       
    26 #include <mpxconstants.h>               // KAppUidMusicPlayerX
       
    27 #include <mpxmusicplayerviewplugin.hrh> // KMPXPluginTypePlaybackUid
       
    28 #include <AknTaskList.h>                // CAknTaskList
       
    29 
       
    30 #include <mpxcommonuihelper.h>
       
    31 #include <mpxcollectionhelperfactory.h>
       
    32 #include "musicplayeractionhandler.h"
       
    33 #include <mpxcollectionpath.h>
       
    34 
       
    35 
       
    36 
       
    37 
       
    38 const TInt KPlayerMusicPlayerParameterGranularity = 50;
       
    39 const TUid  KMusicPlayerAppUid = { 0x102072C3 };
       
    40 
       
    41 // RProperty key to identify the case when Music Player launching
       
    42 // in the background
       
    43 const TInt KMPXLaunchingOnBackground( 100 );
       
    44 
       
    45 //map values
       
    46 _LIT( KActionPlaybackCommand , "PlaybackCommand" );
       
    47 _LIT( KactionMessageToMusicPlayer, "MessageToMusicPlayer" );
       
    48 _LIT( KGoToNowPlaying, "GoToNowPlaying" );
       
    49 _LIT( KGoToLastPlayed, "GoToLastPlayed" );
       
    50 _LIT( KGoToLastPlayedMinimized, "GoToLastPlayedMinimized" );
       
    51 _LIT( KGoToMusicLibrary, "GoToMusicLibrary" );
       
    52 _LIT( KGoToAlbumView, "GoToAlbumView" );
       
    53 
       
    54 //map keys
       
    55 _LIT8( KType, "type" );
       
    56 _LIT8( KCommand, "command" );
       
    57 _LIT8( KMessage, "message" );
       
    58 
       
    59 // ======== MEMBER FUNCTIONS ========
       
    60 
       
    61 // ---------------------------------------------------------------------------
       
    62 // Symbian 2nd phase constructor can leave.
       
    63 // ---------------------------------------------------------------------------
       
    64 //
       
    65 void CMusicPlayerActionHandler::ConstructL()
       
    66     {
       
    67     MPX_DEBUG1("-->CMusicPlayerActionHandler::ConstructL()");
       
    68     
       
    69     //iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeActivePlayer );
       
    70     iPlaybackUtility = MMPXPlaybackUtility::NewL( KMusicPlayerAppUid);
       
    71 
       
    72     MPX_DEBUG1("<--CMusicPlayerActionHandler::ConstructL()");
       
    73     }
       
    74 
       
    75 // ---------------------------------------------------------------------------
       
    76 // Two-phased constructor.
       
    77 // ---------------------------------------------------------------------------
       
    78 //
       
    79 CMusicPlayerActionHandler* CMusicPlayerActionHandler::NewL()
       
    80     {
       
    81     CMusicPlayerActionHandler* self = CMusicPlayerActionHandler::NewLC();
       
    82     CleanupStack::Pop( self );
       
    83     return self;
       
    84     }
       
    85 
       
    86 // ---------------------------------------------------------------------------
       
    87 // Two-phased constructor.
       
    88 // ---------------------------------------------------------------------------
       
    89 //
       
    90 CMusicPlayerActionHandler* CMusicPlayerActionHandler::NewLC()
       
    91     {
       
    92     CMusicPlayerActionHandler* self = new( ELeave ) CMusicPlayerActionHandler;
       
    93     CleanupStack::PushL( self );
       
    94     self->ConstructL();
       
    95     return self;
       
    96     }
       
    97 
       
    98 // ---------------------------------------------------------------------------
       
    99 // destructor
       
   100 // ---------------------------------------------------------------------------
       
   101 //
       
   102 CMusicPlayerActionHandler::~CMusicPlayerActionHandler()
       
   103     {
       
   104     MPX_DEBUG1("-->CMusicPlayerActionHandler::~CMusicPlayerActionHandler()");
       
   105     if ( iPlaybackUtility )
       
   106         {
       
   107         iPlaybackUtility->Close();
       
   108         }
       
   109     MPX_DEBUG1("<--CMusicPlayerActionHandler::~CMusicPlayerActionHandler()");
       
   110     }
       
   111 
       
   112 // ---------------------------------------------------------------------------
       
   113 // Executes Playback command on current player
       
   114 // ---------------------------------------------------------------------------
       
   115 //
       
   116 TInt CMusicPlayerActionHandler::ExecutePlaybackCommandL(const CLiwMap* aMap)
       
   117     {
       
   118     MPX_DEBUG1("-->CMusicPlayerActionHandler::ExecutePlaybackCommandL()");
       
   119     TInt errCode;
       
   120     TLiwVariant variant;
       
   121     variant.PushL();
       
   122     errCode = ExtractVariantL( aMap, variant, KCommand );
       
   123     if ( errCode == KErrNone )
       
   124         {
       
   125         TMPXPlaybackCommand Command;
       
   126         Command = static_cast<TMPXPlaybackCommand>( variant.AsTInt32() );
       
   127         iPlaybackUtility->CommandL( Command );
       
   128         }
       
   129     CleanupStack::PopAndDestroy( &variant);
       
   130     MPX_DEBUG1("<--CMusicPlayerActionHandler::ExecutePlaybackCommandL()");
       
   131     return errCode;
       
   132     }
       
   133 
       
   134 // ---------------------------------------------------------------------------
       
   135 // Sends a message to music player
       
   136 // ---------------------------------------------------------------------------
       
   137 //
       
   138 TInt CMusicPlayerActionHandler::ExecuteMessageToMusicPlayerL(
       
   139         const CLiwMap* aMap )
       
   140     {
       
   141     MPX_DEBUG1("-->CMusicPlayerActionHandler::"
       
   142             "ExecuteMessageToMusicPlayerL()");
       
   143     TInt errCode;
       
   144     RBuf msg;
       
   145     CleanupClosePushL( msg );
       
   146     errCode = ExtractDesL( aMap, msg, KMessage );
       
   147     if ( errCode == KErrNone )
       
   148         {
       
   149         if ( ! msg.CompareF( KGoToNowPlaying ) )
       
   150             {
       
   151             errCode = GoToNowPlayingL();
       
   152             }
       
   153         else if ( ! msg.CompareF( KGoToLastPlayed ) )
       
   154             {
       
   155             errCode = GoToLastPlayedL( EFalse );
       
   156             }
       
   157         else if ( ! msg.CompareF( KGoToLastPlayedMinimized ) )
       
   158             {
       
   159             errCode = GoToLastPlayedL( ETrue );
       
   160             }
       
   161         else if ( ! msg.CompareF( KGoToMusicLibrary ) )
       
   162             {
       
   163             errCode = GoToMusicLibraryL();
       
   164             }  
       
   165         else if ( ! msg.CompareF( KGoToAlbumView ) )
       
   166         	{
       
   167             errCode = GoToAlbumViewL();
       
   168             } 
       
   169         }
       
   170     CleanupStack::PopAndDestroy( &msg );
       
   171     MPX_DEBUG1("<--CMusicPlayerActionHandler::"
       
   172             "ExecuteMessageToMusicPlayerL()");
       
   173     return errCode;
       
   174     }
       
   175 
       
   176 // ---------------------------------------------------------------------------
       
   177 // Opens musicplayer in library view, even if it is already open and playing.
       
   178 // ---------------------------------------------------------------------------
       
   179 //
       
   180 TInt CMusicPlayerActionHandler::GoToMusicLibraryL()
       
   181     {
       
   182     MPX_DEBUG1("-->CMusicPlayerActionHandler::GoToMusicLibraryL()");
       
   183     //Launch player
       
   184     RWsSession wsSession;
       
   185     User::LeaveIfError( wsSession.Connect() );
       
   186     CAknTaskList *taskList = CAknTaskList::NewL( wsSession );
       
   187     TApaTask task = taskList->FindRootApp( KAppUidMusicPlayerX );
       
   188     delete taskList;
       
   189     CMPXParameter* param = new ( ELeave ) CMPXParameter();
       
   190     CleanupStack::PushL( param );
       
   191     param->iType.iUid = KMPXPluginTypeCollectionUid;
       
   192     param->iCmdForward = EMPXCmdFwdNone;
       
   193 
       
   194     MMPXCollectionUiHelper* collectionHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
       
   195     CMPXCollectionPath* path = collectionHelper->MusicMenuPathL();
       
   196 	path->AppendL(3); // Albums
       
   197     if (path)
       
   198         {
       
   199         param->iCollectionPath = path;
       
   200         param->iPathType = EMPXTypeCollectionPath;
       
   201         }
       
   202     collectionHelper->Close();
       
   203     
       
   204     CBufBase* buffer =
       
   205             CBufFlat::NewL( KPlayerMusicPlayerParameterGranularity );
       
   206     CleanupStack::PushL( buffer );
       
   207     RBufWriteStream writeStream( *buffer );
       
   208     CleanupClosePushL( writeStream );
       
   209     param->ExternalizeL( writeStream );
       
   210     writeStream.CommitL();
       
   211     buffer->Compress();
       
   212     CleanupStack::PopAndDestroy( &writeStream );
       
   213     if ( task.Exists() )
       
   214         {
       
   215 //        task.SendMessage( KAppUidMusicPlayerX, buffer->Ptr( 0 ));
       
   216         wsSession.SendMessageToWindowGroup( task.WgId(), KAppUidMusicPlayerX,
       
   217                     buffer->Ptr( 0 ) );
       
   218         }
       
   219     else        //Application needs to be launched. The first view is library view.
       
   220         {
       
   221         // Launch Music Player Application
       
   222         RApaLsSession   appArcSession;
       
   223         _LIT(KEmpty,"");
       
   224         User::LeaveIfError(appArcSession.Connect());    // connect to AppArc server
       
   225         TThreadId id;
       
   226         appArcSession.StartDocument( KEmpty, KAppUidMusicPlayerX, id );
       
   227         appArcSession.Close();                                
       
   228         }
       
   229     CleanupStack::PopAndDestroy( buffer );
       
   230     CleanupStack::PopAndDestroy( param );
       
   231     wsSession.Close();
       
   232     MPX_DEBUG1("<--CMusicPlayerActionHandler::GoToMusicLibraryL()");
       
   233     return KErrNone;
       
   234     }
       
   235 	
       
   236 // ---------------------------------------------------------------------------
       
   237 // Opens musicplayer in Album and Artist view, even if it is already open and playing.
       
   238 // ---------------------------------------------------------------------------
       
   239 //
       
   240 TInt CMusicPlayerActionHandler::GoToAlbumViewL()
       
   241     {
       
   242     MPX_DEBUG1("-->CMusicPlayerActionHandler::GoToAlbumViewL()");
       
   243     //Launch player
       
   244     RWsSession wsSession;
       
   245     User::LeaveIfError( wsSession.Connect() );
       
   246     CAknTaskList *taskList = CAknTaskList::NewL( wsSession );
       
   247     TApaTask task = taskList->FindRootApp( KAppUidMusicPlayerX );
       
   248     delete taskList;
       
   249     CMPXParameter* param = new ( ELeave ) CMPXParameter();
       
   250     CleanupStack::PushL( param );
       
   251     param->iType.iUid = KMPXPluginTypeCollectionUid;
       
   252     param->iCmdForward = EMPXCmdFwdNone;
       
   253    
       
   254     MMPXCollectionUiHelper* collectionHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();
       
   255     CMPXCollectionPath* path = collectionHelper->MusicMenuPathL();
       
   256     path->AppendL(3); // Albums
       
   257     if (path)
       
   258         {
       
   259         param->iCollectionPath = path;
       
   260         param->iPathType = EMPXTypeCollectionPath;
       
   261         }
       
   262     collectionHelper->Close();
       
   263     
       
   264     CBufBase* buffer =
       
   265             CBufFlat::NewL( KPlayerMusicPlayerParameterGranularity );
       
   266     CleanupStack::PushL( buffer );
       
   267     RBufWriteStream writeStream( *buffer );
       
   268     CleanupClosePushL( writeStream );
       
   269     param->ExternalizeL( writeStream );
       
   270     writeStream.CommitL();
       
   271     buffer->Compress();
       
   272     CleanupStack::PopAndDestroy( &writeStream );
       
   273     if ( task.Exists() )
       
   274         {
       
   275 //        task.SendMessage( KAppUidMusicPlayerX, buffer->Ptr( 0 ));
       
   276         wsSession.SendMessageToWindowGroup( task.WgId(), KAppUidMusicPlayerX,
       
   277                     buffer->Ptr( 0 ) );
       
   278         }
       
   279     else        //Application needs to be launched. The first view is library view.
       
   280         {
       
   281         // Launch Music Player Application
       
   282         RApaLsSession   appArcSession;
       
   283         _LIT(KEmpty,"");
       
   284         User::LeaveIfError(appArcSession.Connect());    // connect to AppArc server
       
   285         TThreadId id;
       
   286         appArcSession.StartDocument( KEmpty, KAppUidMusicPlayerX, id );
       
   287         appArcSession.Close();                                
       
   288         }
       
   289     CleanupStack::PopAndDestroy( buffer );
       
   290     CleanupStack::PopAndDestroy( param );
       
   291     wsSession.Close();
       
   292     MPX_DEBUG1("<--CMusicPlayerActionHandler::GoToAlbumViewL()");
       
   293     return KErrNone;
       
   294     }
       
   295 
       
   296 
       
   297 // ---------------------------------------------------------------------------
       
   298 // Opens musicplayer, if it is already open and playing it goes to nowplaying.
       
   299 // ---------------------------------------------------------------------------
       
   300 //
       
   301 TInt CMusicPlayerActionHandler::GoToNowPlayingL()
       
   302     {
       
   303     MPX_DEBUG1("-->CMusicPlayerActionHandler::GoToNowPlayingL()");
       
   304     //Launch player
       
   305     RWsSession wsSession;
       
   306     User::LeaveIfError( wsSession.Connect() );
       
   307     CAknTaskList *taskList = CAknTaskList::NewL( wsSession );
       
   308     TApaTask task = taskList->FindRootApp( KAppUidMusicPlayerX );
       
   309     delete taskList;
       
   310     CMPXParameter* param = new ( ELeave ) CMPXParameter();
       
   311     CleanupStack::PushL( param );
       
   312     param->iType.iUid = KMPXPluginTypePlaybackUid;
       
   313     param->iCmdForward = EMPXCmdFwdNone;
       
   314     CBufBase* buffer =
       
   315             CBufFlat::NewL( KPlayerMusicPlayerParameterGranularity );
       
   316     CleanupStack::PushL( buffer );
       
   317     RBufWriteStream writeStream( *buffer );
       
   318     CleanupClosePushL( writeStream );
       
   319     param->ExternalizeL( writeStream );
       
   320     writeStream.CommitL();
       
   321     buffer->Compress();
       
   322     CleanupStack::PopAndDestroy( &writeStream );
       
   323     if ( task.Exists() )
       
   324         {
       
   325         wsSession.SendMessageToWindowGroup( task.WgId(), KAppUidMusicPlayerX,
       
   326                     buffer->Ptr( 0 ) );
       
   327         
       
   328         
       
   329         }
       
   330     else
       
   331         {
       
   332         RApaLsSession ls;
       
   333         CleanupClosePushL( ls );
       
   334         User::LeaveIfError( ls.Connect() );
       
   335         TApaAppInfo appInfo;
       
   336         User::LeaveIfError( ls.GetAppInfo( appInfo, KAppUidMusicPlayerX ) );
       
   337         CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
       
   338         apaCommandLine->SetExecutableNameL( appInfo.iFullName );
       
   339         apaCommandLine->SetTailEndL( buffer->Ptr( 0 ) );
       
   340         User::LeaveIfError( ls.StartApp( *apaCommandLine ) );
       
   341         CleanupStack::PopAndDestroy(); // apaCommandLine
       
   342         CleanupStack::PopAndDestroy(); // ls
       
   343         }
       
   344     CleanupStack::PopAndDestroy( buffer );
       
   345     CleanupStack::PopAndDestroy( param );
       
   346     wsSession.Close();
       
   347     MPX_DEBUG1("<--CMusicPlayerActionHandler::GoToNowPlayingL()");
       
   348     return KErrNone;
       
   349     }
       
   350 
       
   351 
       
   352 // ---------------------------------------------------------------------------
       
   353 // Opens Stand alone MP and goes to now playing, it will display last played
       
   354 // ---------------------------------------------------------------------------
       
   355 //
       
   356 TInt CMusicPlayerActionHandler::GoToLastPlayedL( TBool aMinimized )
       
   357     {
       
   358     MPX_DEBUG1("-->CMusicPlayerActionHandler::GoToLastPlayed()");
       
   359     //Launch player
       
   360     RWsSession wsSession;
       
   361     User::LeaveIfError( wsSession.Connect() );
       
   362     CAknTaskList *taskList = CAknTaskList::NewL( wsSession );
       
   363     TApaTask task = taskList->FindRootApp( KAppUidMusicPlayerX );
       
   364     delete taskList;
       
   365     CMPXParameter* param = new ( ELeave ) CMPXParameter();
       
   366     CleanupStack::PushL( param );
       
   367     param->iType.iUid = KMPXPluginTypeLastPlayedUid;//KMPXPluginTypePlaybackUid;
       
   368     param->iCmdForward = EMPXCmdFwdNone;
       
   369     CBufBase* buffer =
       
   370             CBufFlat::NewL( KPlayerMusicPlayerParameterGranularity );
       
   371     CleanupStack::PushL( buffer );
       
   372     RBufWriteStream writeStream( *buffer );
       
   373     CleanupClosePushL( writeStream );
       
   374     param->ExternalizeL( writeStream );
       
   375     writeStream.CommitL();
       
   376     buffer->Compress();
       
   377     CleanupStack::PopAndDestroy( &writeStream );
       
   378     if ( task.Exists() )
       
   379         {
       
   380         wsSession.SendMessageToWindowGroup( task.WgId(), KAppUidMusicPlayerX,
       
   381                     buffer->Ptr( 0 ) );
       
   382         if (!aMinimized)
       
   383             {
       
   384             task.BringToForeground();
       
   385             }
       
   386         }
       
   387     else
       
   388         {
       
   389         RApaLsSession ls;
       
   390         CleanupClosePushL( ls );
       
   391         User::LeaveIfError( ls.Connect() );
       
   392         TApaAppInfo appInfo;
       
   393         User::LeaveIfError( ls.GetAppInfo( appInfo, KAppUidMusicPlayerX ) );
       
   394         CApaCommandLine* apaCommandLine = CApaCommandLine::NewLC();
       
   395         if (aMinimized)
       
   396             {
       
   397             apaCommandLine->SetCommandL(EApaCommandBackground);
       
   398             
       
   399             TInt err( RProperty::Define(
       
   400                 KAppUidMusicPlayerX, KMPXLaunchingOnBackground, RProperty::EInt ) );
       
   401             MPX_DEBUG2( "CMusicPlayerActionHandler::GoToLastPlayed() RProperty define err = %d", err );
       
   402             if ( err == KErrNone || err == KErrAlreadyExists )
       
   403                 {
       
   404                 err = RProperty::Set( KAppUidMusicPlayerX,
       
   405                             KMPXLaunchingOnBackground,
       
   406                             ETrue );
       
   407                 MPX_DEBUG2( "CMusicPlayerActionHandler::GoToLastPlayed() RProperty set to true err = %d", err );
       
   408                 }
       
   409             }
       
   410         apaCommandLine->SetExecutableNameL( appInfo.iFullName );
       
   411         apaCommandLine->SetTailEndL( buffer->Ptr( 0 ) );
       
   412         User::LeaveIfError( ls.StartApp( *apaCommandLine ) );
       
   413         CleanupStack::PopAndDestroy(); // apaCommandLine
       
   414         CleanupStack::PopAndDestroy(); // ls
       
   415         
       
   416         if ( aMinimized )
       
   417             {
       
   418             TInt err = RProperty::Set( KAppUidMusicPlayerX,
       
   419                         KMPXLaunchingOnBackground,
       
   420                         EFalse );
       
   421             MPX_DEBUG2( "CMusicPlayerActionHandler::GoToLastPlayed() RProperty set to false err = %d", err );
       
   422             }
       
   423         }
       
   424     CleanupStack::PopAndDestroy( buffer );
       
   425     CleanupStack::PopAndDestroy( param );
       
   426     wsSession.Close();
       
   427     MPX_DEBUG1("<--CMusicPlayerActionHandler::GoToLastPlayed()");
       
   428     return KErrNone;
       
   429     }
       
   430 // ---------------------------------------------------------------------------
       
   431 // Extracts a descriptor
       
   432 // ---------------------------------------------------------------------------
       
   433 //
       
   434 TInt CMusicPlayerActionHandler::ExtractDesL( const CLiwMap* aMap,
       
   435         RBuf& aString, const TDesC8& aMapName )
       
   436     {
       
   437     MPX_DEBUG1("-->CMusicPlayerActionHandler::ExtractDesL()");
       
   438     TInt errCode( KErrArgument );
       
   439     TLiwVariant variant;
       
   440     variant.PushL();
       
   441     TPtrC tempString( KNullDesC );
       
   442     if ( aMap->FindL( aMapName, variant) )
       
   443         {
       
   444         variant.Get( tempString );
       
   445         aString.ReAllocL( tempString.Length() );
       
   446         aString.Append( tempString );
       
   447         errCode = KErrNone;
       
   448         }
       
   449     CleanupStack::PopAndDestroy( &variant );
       
   450     MPX_DEBUG1("<--CMusicPlayerActionHandler::ExtractDesL()");
       
   451     return errCode;
       
   452     }
       
   453 
       
   454 // ---------------------------------------------------------------------------
       
   455 // Extract variant
       
   456 // ---------------------------------------------------------------------------
       
   457 //
       
   458 TInt CMusicPlayerActionHandler::ExtractVariantL( const CLiwMap* aMap,
       
   459         TLiwVariant& aVariant, const TDesC8& aMapName )
       
   460     {
       
   461     MPX_DEBUG1("-->CMusicPlayerActionHandler::ExtractVariantL()");
       
   462     TInt errCode( KErrNone );
       
   463     if ( ! aMap->FindL( aMapName, aVariant ) )
       
   464         {
       
   465         errCode = KErrArgument;
       
   466         }
       
   467     MPX_DEBUG1("<--CMusicPlayerActionHandler::ExtractVariantL()");
       
   468     return errCode;
       
   469     }
       
   470 
       
   471 // ---------------------------------------------------------------------------
       
   472 // From CAHPlugin
       
   473 // Executes provided action
       
   474 // ---------------------------------------------------------------------------
       
   475 //
       
   476 TInt CMusicPlayerActionHandler::ExecuteActionL( const CLiwMap* aMap )
       
   477     {
       
   478     MPX_DEBUG1("-->CMusicPlayerActionHandler::ExecuteActionL()");
       
   479     TInt errCode;
       
   480     RBuf type;
       
   481     CleanupClosePushL( type );
       
   482     errCode = ExtractDesL( aMap, type, KType );
       
   483     if ( errCode == KErrNone )
       
   484         {
       
   485         if ( ! type.CompareF( KActionPlaybackCommand ) )
       
   486             {
       
   487             errCode = ExecutePlaybackCommandL( aMap );
       
   488             }
       
   489         else
       
   490             if ( ! type.CompareF( KactionMessageToMusicPlayer ) )
       
   491                 {
       
   492                 errCode = ExecuteMessageToMusicPlayerL( aMap );
       
   493                 }
       
   494         }
       
   495     CleanupStack::PopAndDestroy( &type );
       
   496     MPX_DEBUG1("<--CMusicPlayerActionHandler::ExecuteActionL()");
       
   497     return errCode;
       
   498     }
       
   499 
       
   500 //  End of File
       
   501