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