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:  Updates Music Content Publisher

    15 *

    16 */

    17 

    18 #include <mpxlog.h>                     // MPX_DEBUG

    19 #include <implementationproxy.h>

    20 #include <LiwServiceHandler.h>

    21 #include <LiwVariant.h>

    22 #include <LiwGenericParam.h>

    23 #include <StringLoader.h>

    24 #include <AknUtils.h>

    25 #include <AknsUtils.h>

    26 #include <aknsconstants.hrh>

    27 #include <musichomescreenicons.mbg>

    28 #include <musichomescreen.rsg>

    29 #include <bautils.h>

    30 #include <data_caging_path_literals.hrh>

    31 #include <mpxmessagegeneraldefs.h>

    32 #include <mpxcollectionmessage.h>

    33 #include <mpxcollectionutility.h>

    34 #include <mpxcollectionframeworkdefs.h>

    35 #include <AknTaskList.h>

    36 

    37 

    38 

    39 #include "cpglobals.h" //to be moved to domain API

    40 

    41 #include "mcpmusicplayer.h" 

    42 #include "mcpmusicplayeruids.hrh"

    43 #include "aiplayerpluginengine.h"

    44 #include "filemonitor.h"

    45 #include "applicationmonitor.h"

    46 #include "pnsmonitor.h"

    47 

    48 //const TUid  KLocalPlaybackUid = { 0x101FFC06 };

    49 const TInt  KMusicPlayerAppUidAsTInt =  0x102072C3;

    50 

    51 const TInt KMmUid3AsTInt( 0x101f4cd2 );

    52 const TInt KMSGUidAsTInt( 0x10003A39 );

    53 

    54 namespace TBK

    55     {

    56     const TUint  KSkeep_L          = 0x001; //000000000001

    57     const TUint  KSkeep_R          = 0x002; //000000000010

    58     const TUint  KPause            = 0x004; //000000000100

    59     const TUint  KPlay             = 0x008; //000000001000

    60     const TUint  KSkeep_L_dimmed   = 0x010; //000000010000

    61     const TUint  KSkeep_R_dimmed   = 0x020; //000000100000

    62     const TUint  KPause_dimmed     = 0x040; //000001000000

    63     const TUint  KPlay_dimmed      = 0x080; //000010000000

    64     const TUint  KPlay_last_played = 0x100; //000100000000

    65     }

    66 

    67 _LIT( KEmpty, "" );

    68 _LIT( KNowPlaying, "LOC:NOW PLAYING" );

    69 _LIT( KLastPlayed, "LOC:LAST PLAYED" );

    70 

    71 

    72 _LIT( KMIF, "z:\\resource\\apps\\musichomescreenicons.mif");

    73 

    74 _LIT( KResourceFile, "z:musichomescreen.rsc");

    75 

    76 //for music player action handler - playback command

    77 _LIT( KActionPlaybackCommand , "PlaybackCommand" );

    78 _LIT8( KPBCommand, "command" );

    79 

    80 //for music player action handler - message to music player

    81 _LIT( KactionMessageToMusicPlayer, "MessageToMusicPlayer" );

    82 _LIT( KGoToNowPlaying, "GoToNowPlaying" );

    83 _LIT( KGoToLastPlayed, "GoToLastPlayed" );

    84 _LIT( KGoToLastPlayedMinimized, "GoToLastPlayedMinimized" );

    85 

    86 _LIT8( KMessage, "message" );

    87 _LIT8( KAdditionalData, "additional_data" );

    88 

    89 //for application launcher AHPlugin

    90 _LIT( KCmdLine, "cmd_line" );

    91 _LIT( KLaunchApp, "launch_application" );

    92 _LIT( KMessageWithTail, "message_with_tail" );

    93 _LIT8( KMessageForMMOpenMusicSuiteWithHide, "mm://root/musicsuite?exit=hide");

    94 

    95 

    96 //for time

    97 //_LIT( KSeparator, "/" );

    98 _LIT( KSeparatorhyphen, " - " );

    99 //_LIT( KMPXZeroDurationMark, "--" );

   100 //_LIT( KTitleNowPlaying, "Now Playing" );

   101 //_LIT( KTitleLastPlayed, "Last Played" );

   102 

   103 const TInt KMusicPlayerOpeningTimerInterval = 15000000; // 15 seconds

   104 

   105 // ======== MEMBER FUNCTIONS ========

   106 

   107 // ---------------------------------------------------------------------------

   108 // Constructor

   109 // ---------------------------------------------------------------------------

   110 //

   111 CMCPMusicPlayer::CMCPMusicPlayer(MMCPPluginObserver* aObserver)

   112     {

   113     iMHObserver = aObserver;

   114     }

   115 

   116 // ---------------------------------------------------------------------------

   117 // Symbian 2nd phase constructor can leave.

   118 // ---------------------------------------------------------------------------

   119 //

   120 void CMCPMusicPlayer::ConstructL()

   121     {

   122     MPX_DEBUG1("CMCPMusicPlayer::ConstructL <---");

   123     MPX_DEBUG1("CMCPMusicPlayer::ConstructL creating engine");

   124     iEngine = CAiPlayerPluginEngine::NewL( *this );

   125     MPX_DEBUG1("CMCPMusicPlayer::ConstructL engine created");

   126     AknsUtils::InitSkinSupportL();

   127     //Load Loc strings

   128     MPX_DEBUG1("CMCPMusicPlayer::ConstructL getting resource file");

   129     RFs fs;

   130     User::LeaveIfError(fs.Connect());

   131     CleanupClosePushL(fs);  

   132     TFileName fileName;

   133     TParse* parseObj = new(ELeave) TParse();

   134     TInt errInt = parseObj->Set( KResourceFile(),&KDC_APP_RESOURCE_DIR,NULL );

   135     if(KErrNone != errInt)

   136       {

   137       delete parseObj;

   138       User::Leave(errInt);

   139       }

   140     fileName = parseObj->FullName();

   141     delete parseObj;

   142     BaflUtils::NearestLanguageFile(fs,fileName);

   143     if(!BaflUtils::FileExists(fs,fileName))

   144         {

   145         User::Leave(KErrNotFound);

   146         }

   147     RResourceFile resourceFile;

   148     resourceFile.OpenL(fs,fileName);

   149     CleanupClosePushL(resourceFile);

   150     resourceFile.ConfirmSignatureL();

   151     GetLocalizedStringL(resourceFile, iGoToMusicBuffer, R_MUSICHOMESCREEN_GO_TO_MUSIC);

   152     GetLocalizedStringL(resourceFile, iOpeningBuffer, R_MUSICHOMESCREEN_OPENING);

   153     CleanupStack::PopAndDestroy(&resourceFile);

   154     CleanupStack::PopAndDestroy(&fs);

   155     MPX_DEBUG1("CMCPMusicPlayer::ConstructL resources loaded");

   156     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   157     TRAPD(err, iArtBitmapMask = AknsUtils::CreateBitmapL( skin, 

   158             KAknsIIDQgnHomePhotoMask ) );

   159     if (err == KErrNone)

   160         {

   161         AknIconUtils::DisableCompression(iArtBitmapMask);

   162         TSize size( 70 , 70);

   163         AknIconUtils::SetSize( iArtBitmapMask, size );

   164         if (iArtBitmapMask->SetDisplayMode( EGray256 ) != KErrNone)

   165             {

   166             delete iArtBitmapMask;

   167             iArtBitmapMask = NULL;

   168             }

   169         }

   170     else

   171         {

   172         delete iArtBitmapMask;

   173         iArtBitmapMask = NULL;

   174         }

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

   176     iMusicPlayerOpeningTimer = CPeriodic::NewL( CActive::EPriorityLow );

   177     MPX_DEBUG1("CMCPMusicPlayer::ConstructL --->");

   178     }

   179 

   180 // ---------------------------------------------------------------------------

   181 // Two-phased constructor.

   182 // ---------------------------------------------------------------------------

   183 //

   184 CMCPMusicPlayer* CMCPMusicPlayer::NewL(MMCPPluginObserver* aObserver)

   185     {

   186     CMCPMusicPlayer* self = new ( ELeave ) 

   187     CMCPMusicPlayer( aObserver );

   188     CleanupStack::PushL( self );

   189     self->ConstructL();

   190     CleanupStack::Pop( self );

   191     return self;

   192     }

   193 

   194 // ---------------------------------------------------------------------------

   195 // Destructor

   196 // ---------------------------------------------------------------------------

   197 //

   198 CMCPMusicPlayer::~CMCPMusicPlayer()

   199     {

   200     MPX_DEBUG1("CMCPMusicPlayer::~CMCPMusicPlayer <---");

   201     if (iArtCached && iArtBitmap != iCachedArtBitmap)

   202         {

   203         delete iCachedArtBitmap;

   204         }

   205     delete iArtBitmap;

   206     delete iArtBitmapMask;

   207     delete iEngine;

   208     delete iFileMonitor;

   209     delete iAppMonitor;

   210     delete iPNSMonitor;

   211     delete iGoToMusicBuffer;

   212     delete iOpeningBuffer;

   213     if ( iCollectionUtility )

   214     	{

   215     	iCollectionUtility->Close();

   216     	}

   217     delete iMusicPlayerOpeningTimer;

   218     MPX_DEBUG1("CMCPMusicPlayer::~CMCPMusicPlayer --->");

   219     }

   220 

   221 

   222 // ---------------------------------------------------------------------------

   223 // 

   224 // ---------------------------------------------------------------------------

   225 //

   226 TBool CMCPMusicPlayer::IsOKToPublishData()

   227     {

   228     return iActive;

   229     }

   230 

   231 // ---------------------------------------------------------------------------

   232 // 

   233 // ---------------------------------------------------------------------------

   234 //

   235 void CMCPMusicPlayer::InstallPlaybackCommandActionL(TMPXPlaybackCommand aCmd,

   236         TMCPTriggerDestination aDestination)

   237     {

   238     MPX_DEBUG1("CMCPMusicPlayer::InstallPlaybackCommandActionL <---");

   239     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   240     CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

   241     

   242     mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10207C16 ) ) );

   243     mapData->InsertL( KType, TLiwVariant( KActionPlaybackCommand ) );

   244     TInt32 cmd;

   245     cmd=static_cast<TInt32>( aCmd );

   246     mapData->InsertL( KPBCommand, TLiwVariant( cmd ) );

   247     mapTrigger->InsertL( KData , TLiwVariant( mapData ) );

   248     

   249     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   250     

   251     CleanupStack::PopAndDestroy( mapData  );

   252     CleanupStack::PopAndDestroy( mapTrigger );

   253     MPX_DEBUG1("CMCPMusicPlayer::InstallPlaybackCommandActionL --->");

   254     }

   255 

   256 // ---------------------------------------------------------------------------

   257 // 

   258 // ---------------------------------------------------------------------------

   259 //

   260 void CMCPMusicPlayer::InstallLaunchMusicPlayerL(

   261         TMCPTriggerDestination aDestination )

   262     {

   263     MPX_DEBUG1("CMCPMusicPlayer::InstallLaunchMusicPlayerL <---");

   264     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   265     CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

   266     mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10282E5F ) ) );

   267     mapData->InsertL( KType, TLiwVariant( KLaunchApp ) );

   268     mapData->InsertL( KLaunchMethod, TLiwVariant( KCmdLine ) );

   269     mapData->InsertL(KApplicationUid,

   270             TLiwVariant(TInt32(KMusicPlayerAppUidAsTInt) ) );

   271     mapTrigger->InsertL( KData, TLiwVariant( mapData ) );

   272     

   273     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   274     

   275     CleanupStack::PopAndDestroy( mapData );

   276     CleanupStack::PopAndDestroy( mapTrigger );

   277     MPX_DEBUG1("CMCPMusicPlayer::InstallLaunchMusicPlayerL --->");

   278     }

   279 

   280 

   281 // ---------------------------------------------------------------------------

   282 // 

   283 // ---------------------------------------------------------------------------

   284 //

   285 void CMCPMusicPlayer::InstallGoToNowPlayingL(

   286         TMCPTriggerDestination aDestination )

   287     {

   288     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToNowPlayingL <---");

   289     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   290     CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

   291     

   292     mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10207C16 ) ) );

   293     mapData->InsertL( KType, TLiwVariant( KactionMessageToMusicPlayer ) );

   294     mapData->InsertL( KMessage, TLiwVariant( KGoToNowPlaying ) );

   295     mapTrigger->InsertL( KData , TLiwVariant( mapData ) );

   296 

   297     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   298     

   299     CleanupStack::PopAndDestroy( mapData  );

   300     CleanupStack::PopAndDestroy( mapTrigger );

   301     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToNowPlayingL --->");

   302     }

   303 

   304 // ---------------------------------------------------------------------------

   305 // 

   306 // ---------------------------------------------------------------------------

   307 //

   308 void CMCPMusicPlayer::InstallGoToLastPlayedL(

   309         TMCPTriggerDestination aDestination, TBool aMinimized )

   310     {

   311     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToLastPlayedL <---");

   312     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   313     CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

   314     

   315     mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10207C16 ) ) );

   316     mapData->InsertL( KType, TLiwVariant( KactionMessageToMusicPlayer ) );

   317     if (aMinimized)

   318         {

   319         mapData->InsertL( KMessage, TLiwVariant( KGoToLastPlayedMinimized ) );

   320         }

   321     else

   322         {

   323         mapData->InsertL( KMessage, TLiwVariant( KGoToLastPlayed ) );

   324         }

   325     mapTrigger->InsertL( KData , TLiwVariant( mapData ) );

   326 

   327     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   328     

   329     CleanupStack::PopAndDestroy( mapData  );

   330     CleanupStack::PopAndDestroy( mapTrigger );

   331     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToLastPlayedL --->");

   332     }

   333 

   334 // ---------------------------------------------------------------------------

   335 // 

   336 // ---------------------------------------------------------------------------

   337 //

   338 void CMCPMusicPlayer::InstallGoToMusicL(

   339         TMCPTriggerDestination aDestination )

   340     {

   341     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToMusicL <---");

   342     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   343     CLiwDefaultMap* mapData = CLiwDefaultMap::NewLC();

   344 

   345     mapTrigger->InsertL( KPluginUid, TLiwVariant( TUid::Uid( 0x10282E5F ) ) );

   346     

   347     mapData->InsertL( KType, TLiwVariant( KLaunchApp ) );

   348     mapData->InsertL( KLaunchMethod, TLiwVariant( KMessageWithTail ) );

   349     mapData->InsertL(KApplicationUid,

   350             TLiwVariant(TInt32(KMmUid3AsTInt) ) );

   351         mapData->InsertL( KAdditionalData, 

   352             TLiwVariant( KMessageForMMOpenMusicSuiteWithHide ) );

   353     mapData->InsertL(KMessageUid,

   354             TLiwVariant(TInt32(KMSGUidAsTInt) ) );

   355     

   356     mapTrigger->InsertL( KData, TLiwVariant( mapData ) );

   357     

   358     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   359     

   360     CleanupStack::PopAndDestroy( mapData );

   361     CleanupStack::PopAndDestroy( mapTrigger );

   362     MPX_DEBUG1("CMCPMusicPlayer::InstallGoToMusicL --->");

   363     }

   364 

   365 

   366 // ---------------------------------------------------------------------------

   367 // 

   368 // ---------------------------------------------------------------------------

   369 //

   370 void CMCPMusicPlayer::InstallEmptyActionL(

   371         TMCPTriggerDestination aDestination )

   372     {

   373     MPX_DEBUG1("CMCPMusicPlayer::InstallEmptyActionL <---");

   374     CLiwDefaultMap* mapTrigger = CLiwDefaultMap::NewLC();

   375     iMHObserver->PublishActionL( this, aDestination, mapTrigger );

   376     CleanupStack::PopAndDestroy( mapTrigger );

   377     MPX_DEBUG1("CMCPMusicPlayer::InstallEmptyActionL --->");

   378     }

   379 

   380 // ---------------------------------------------------------------------------

   381 // Installs actions and icons in the toolbar.

   382 // ---------------------------------------------------------------------------

   383 //

   384 

   385 void CMCPMusicPlayer::UpdateToolBarL(TUint aToolBarState)

   386     {

   387     MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL <---");

   388     if (IsOKToPublishData())

   389         {

   390         TInt updateState;

   391         //we update if there is a change on the state and if the new propery

   392         //was set.

   393         // updateState = ( new ^ old ) & new = new & ~old

   394         updateState = aToolBarState & ~iToolBarState;

   395         TAknsItemID iconId;

   396         

   397         if ( TBK::KSkeep_L & updateState )

   398             {

   399             iconId.Set( EAknsMajorGeneric, 

   400                     EAknsMinorGenericQgnPropImageTbPrev);

   401             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB1, iconId, 

   402                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_prev, 

   403                     EMbmMusichomescreeniconsQgn_prop_image_tb_prev_mask);

   404             InstallPlaybackCommandActionL(EPbCmdPrevious, 

   405                     EMusicWidgetTB1Trigger);

   406             iToolBarState |= TBK::KPlay_dimmed;

   407             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KSkeep_L");

   408             }

   409         

   410         if ( TBK::KSkeep_R & updateState )

   411             {

   412             iconId.Set( EAknsMajorGeneric, 

   413                     EAknsMinorGenericQgnPropImageTbNext);

   414             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB3, iconId, 

   415                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_next, 

   416                     EMbmMusichomescreeniconsQgn_prop_image_tb_next_mask);

   417             InstallPlaybackCommandActionL(EPbCmdNext, EMusicWidgetTB3Trigger);

   418             iToolBarState |= TBK::KSkeep_R;

   419             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KSkeep_R");

   420             }

   421         

   422         if ( TBK::KPause & updateState )

   423             {

   424             iconId.Set( EAknsMajorGeneric, 

   425                     EAknsMinorGenericQgnPropImageTbPause);

   426             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB2, iconId, 

   427                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_pause, 

   428                     EMbmMusichomescreeniconsQgn_prop_image_tb_pause_mask);

   429             InstallPlaybackCommandActionL(EPbCmdPlayPause,

   430                     EMusicWidgetTB2Trigger);

   431             iToolBarState |= TBK::KPause;

   432             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KPause");

   433             }

   434         

   435         if ( TBK::KPlay & updateState )

   436             {

   437             iconId.Set( EAknsMajorGeneric, 

   438                     EAknsMinorGenericQgnPropImageTbPlay2 );

   439             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB2, iconId,

   440                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_play2, 

   441                     EMbmMusichomescreeniconsQgn_prop_image_tb_play2_mask);

   442             InstallPlaybackCommandActionL(EPbCmdPlayPause, 

   443                     EMusicWidgetTB2Trigger);

   444             iToolBarState |= TBK::KPlay;

   445             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KPlay");

   446             }

   447         

   448         if ( TBK::KPlay_last_played & updateState )

   449             {

   450             iconId.Set( EAknsMajorGeneric, 

   451                     EAknsMinorGenericQgnPropImageTbPlay2 );

   452             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB2, iconId,

   453                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_play2, 

   454                     EMbmMusichomescreeniconsQgn_prop_image_tb_play2_mask);

   455             InstallGoToLastPlayedL(EMusicWidgetTB2Trigger, ETrue); 

   456             iToolBarState |= TBK::KPlay_last_played;

   457             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KPlay_last_played");

   458             }

   459         

   460         if ( TBK::KSkeep_L_dimmed & updateState )

   461             {

   462             iconId.Set( EAknsMajorGeneric, 

   463                     EAknsMinorGenericQgnPropImageTbPrevDimmed);

   464             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB1, iconId, 

   465                     KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_prev_dimmed, 

   466                     EMbmMusichomescreeniconsQgn_prop_image_tb_prev_dimmed_mask);

   467             InstallEmptyActionL( EMusicWidgetTB1Trigger);

   468             iToolBarState |= TBK::KSkeep_L_dimmed;

   469             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KSkeep_L_dimmed");

   470             }

   471         

   472         if ( TBK::KSkeep_R_dimmed & updateState )

   473             {

   474             iconId.Set( EAknsMajorGeneric, 

   475                     EAknsMinorGenericQgnPropImageTbNextDimmed);

   476             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB3, iconId, 

   477                 KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_next_dimmed, 

   478                 EMbmMusichomescreeniconsQgn_prop_image_tb_next_dimmed_mask);

   479             InstallEmptyActionL( EMusicWidgetTB3Trigger);

   480             iToolBarState |= TBK::KSkeep_R_dimmed;

   481             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KSkeep_R_dimmed");

   482             }

   483         

   484         if ( TBK::KPause_dimmed & updateState )

   485             {

   486             iconId.Set( EAknsMajorGeneric, 

   487                     EAknsMinorGenericQgnPropImageTbPauseDimmed);

   488             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB2, iconId, 

   489                 KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_pause_dimmed, 

   490                 EMbmMusichomescreeniconsQgn_prop_image_tb_pause_dimmed_mask);

   491             InstallEmptyActionL( EMusicWidgetTB2Trigger);

   492             iToolBarState |= TBK::KPause_dimmed;

   493             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KPause_dimmed");

   494             }

   495         

   496         if ( TBK::KPlay_dimmed & updateState )

   497             {

   498             iconId.Set( EAknsMajorGeneric, 

   499                     EAknsMinorGenericQgnPropImageTbPlay2Dimmed);

   500             iMHObserver->PublishImageL( this, EMusicWidgetToolbarB2, iconId, 

   501                 KMIF, EMbmMusichomescreeniconsQgn_prop_image_tb_play2_dimmed, 

   502                 EMbmMusichomescreeniconsQgn_prop_image_tb_play2_dimmed_mask);

   503             InstallEmptyActionL( EMusicWidgetTB2Trigger);

   504             iToolBarState |= TBK::KPlay_dimmed;

   505             MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL KPlay_dimmed");

   506             }

   507         

   508         iToolBarState = aToolBarState;

   509         }

   510     MPX_DEBUG1("CMCPMusicPlayer::UpdateToolBarL <---");

   511     }

   512 

   513 // ---------------------------------------------------------------------------

   514 // Resets the widget an Music Suite.

   515 // ---------------------------------------------------------------------------

   516 //

   517 void CMCPMusicPlayer::ResetL()

   518     {

   519     MPX_DEBUG1("CMCPMusicPlayer::ResetL <---");

   520     //Note that we are not checking if IsOKToPublishData()This will only get

   521     //published if the plugin is still active on the music content publisher

   522     //meaning that no other plugin has preempted us.

   523     if ( iAppMonitor )

   524         {

   525         delete iAppMonitor;

   526         iAppMonitor = NULL;

   527         }

   528     if (iFileMonitor)

   529         {

   530         delete iFileMonitor;

   531         iFileMonitor = NULL;

   532         }

   533     if ( iPNSMonitor )

   534         {

   535         delete iPNSMonitor;

   536         iPNSMonitor = NULL;

   537         }

   538     //Reset

   539     iMHObserver->PublishTextL( this,EMusicWidgetDefaultText, iGoToMusicBuffer->Des() );

   540     iMHObserver->PublishImageL(this,EMusicWidgetImage1,KEmpty);

   541     InstallGoToMusicL( EMusicWidgetTrigger1 );

   542     iMHObserver->PublishTextL( this,EMusicWidgetText1, KEmpty );

   543     iMHObserver->PublishImageL(this,EMusicWidgetToolbarB1,KEmpty);

   544     iMHObserver->PublishImageL(this,EMusicWidgetToolbarB2,KEmpty);

   545     iMHObserver->PublishImageL(this,EMusicWidgetToolbarB3,KEmpty);

   546     InstallEmptyActionL(EMusicWidgetTB1Trigger);

   547     InstallEmptyActionL(EMusicWidgetTB2Trigger);

   548     InstallEmptyActionL(EMusicWidgetTB3Trigger);

   549     InstallGoToMusicL( EMusicWidgetTrigger2 );

   550     

   551 

   552     

   553     //Reset the music menu info

   554     InstallEmptyActionL(EMusicMenuMusicInfoTrigger);

   555     iMHObserver->PublishTextL( this, EMusicMenuMusicInfoLine1, 

   556             KLastPlayed );

   557     iMHObserver->PublishTextL( this, EMusicMenuMusicInfoLine2, 

   558             KEmpty );

   559     iMHObserver->PublishImageL( this, EMusicMenuMusicInfoImage1,

   560         KAknsIIDQgnIndiMupDefaultAlbum, 

   561         KMIF,

   562         EMbmMusichomescreeniconsQgn_indi_mup_default_album,

   563         EMbmMusichomescreeniconsQgn_indi_mup_default_album_mask); 

   564     MPX_DEBUG1("CMCPMusicPlayer::ResetL --->");

   565     }

   566 

   567 // ----------------------------------------------------------------------------

   568 // Get a heap descriptor from the resource file

   569 // ----------------------------------------------------------------------------

   570 //

   571 void CMCPMusicPlayer::GetLocalizedStringL(RResourceFile& aResourceFile ,HBufC*& aRetBuf,

   572         TInt aResourceId )

   573    {

   574    MPX_DEBUG1("CMCPMusicPlayer::GetLocalizedStringL <---");

   575    HBufC8* dataBuffer = aResourceFile.AllocReadLC(aResourceId);

   576    TResourceReader theReader;

   577    theReader.SetBuffer(dataBuffer);

   578    aRetBuf = theReader.ReadHBufCL();

   579    CleanupStack::PopAndDestroy(dataBuffer);

   580    MPX_DEBUG1("CMCPMusicPlayer::GetLocalizedStringL --->");

   581    }

   582 

   583 // ----------------------------------------------------------------------------

   584 // Sets the plugin as active.

   585 // ----------------------------------------------------------------------------

   586 //

   587 void CMCPMusicPlayer::ActivateL()

   588     {

   589     MPX_DEBUG1("CMCPMusicPlayer::ActivateL <---");

   590     if ( iPNSMonitor )

   591         {

   592         delete iPNSMonitor;

   593         iFileMonitor = NULL;

   594         MPX_DEBUG1("CMCPMusicPlayer::ActivateL pns monitor deleted");

   595         }

   596     iPNSMonitor = CPNSMonitor::NewL(*this);

   597     MPX_DEBUG1("CMCPMusicPlayer::ActivateL pns monitor created");

   598     iPNSMonitor->Start();

   599     if ( iAppMonitor )

   600         {

   601         delete iAppMonitor;

   602         iAppMonitor = NULL;

   603         }

   604     MPX_DEBUG1("CMCPMusicPlayer::ActivateL app monitor deleted");

   605     iAppMonitor = CApplicationMonitor::NewL(*this);

   606     MPX_DEBUG1("CMCPMusicPlayer::ActivateL app monitor created");

   607     TRAPD(err, 

   608             iAppMonitor->StartL( TUid::Uid( KMusicPlayerAppUidAsTInt ) ) 

   609           );

   610     MPX_DEBUG1("CMCPMusicPlayer::ActivateL app monitor started");

   611     if (KErrNone != err) //Music player is not running, it died somehow. 

   612         {

   613         MPX_DEBUG1("CMCPMusicPlayer::ActivateL music player is not running");

   614         if (iFileMonitor)

   615             {

   616             delete iFileMonitor;

   617             iFileMonitor = NULL;

   618             }

   619         MPX_DEBUG1("CMCPMusicPlayer::ActivateL file monitor deleted");

   620         const TDesC& uri = iEngine->Uri();

   621         if ( uri != KNullDesC )

   622             {

   623             MPX_DEBUG1("CMCPMusicPlayer::ActivateL uri is not null creatin file monitor");

   624             iFileMonitor = CFileMonitor::NewL(*this);

   625             iFileMonitor->StartL( uri );

   626             }

   627         iActive = EFalse;

   628         }

   629     else //Music player is running

   630         {

   631         MPX_DEBUG1("CMCPMusicPlayer::ActivateL music player is running, activating...");

   632         iMHObserver->BecameActiveL(this);

   633         iActive = ETrue;

   634         MPX_DEBUG1("CMCPMusicPlayer::ActivateL we are active now");

   635         

   636         iMHObserver->PublishTextL( this, EMusicWidgetDefaultText, KEmpty );

   637         InstallGoToNowPlayingL(EMusicWidgetTrigger1);

   638         InstallGoToLastPlayedL(EMusicMenuMusicInfoTrigger, EFalse);

   639         iMHObserver->PublishTextL(this, EMusicMenuMusicInfoLine1, 

   640                  KNowPlaying);

   641         DoUpdateTrackInfoL(iEngine->TitleL(), iEngine->Artist());

   642         iToolBarState = 0;

   643         DoUpdatePlayerStateL( iEngine->PlayerState() );

   644         DoUpdateAlbumArtL(iArtCached ? iCachedArtBitmap : iArtBitmap);

   645         }

   646     MPX_DEBUG1("CMCPMusicPlayer::ActivateL --->");

   647     }

   648 

   649 

   650 void CMCPMusicPlayer::DoUpdatePlayerStateL(TMPlayerState aState)

   651     {

   652     MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL <---");

   653     switch ( aState )

   654             {

   655             case EMPlayerStatePlaying:

   656                 {

   657                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL EMPlayerStatePlaying");

   658                 UpdateToolBarL(TBK::KSkeep_L|TBK::KPause|TBK::KSkeep_R);

   659                 break;

   660                 }

   661             case EMPlayerStatePaused:

   662                 {

   663                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL EMPlayerStatePaused");

   664                 UpdateToolBarL(TBK::KSkeep_L|TBK::KPlay|TBK::KSkeep_R);

   665                 break;

   666                 }

   667             case EMPlayerStateSeeking:

   668                 {

   669                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL EMPlayerStateSeeking");

   670                 UpdateToolBarL(TBK::KSkeep_L_dimmed |

   671                         TBK::KPlay_dimmed |

   672                         TBK::KSkeep_R_dimmed);

   673                 break;

   674                 }

   675             case EMPlayerStateStopped:

   676                 {

   677                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL EMPlayerStateStopped");

   678                 if ( iUSBOnGoing )

   679                     {

   680                     UpdateToolBarL( TBK::KSkeep_L_dimmed |

   681                             TBK::KPlay_dimmed |

   682                             TBK::KSkeep_R_dimmed );

   683                     }

   684                 else

   685                     {

   686                     UpdateToolBarL(TBK::KSkeep_L|TBK::KPlay|TBK::KSkeep_R);

   687                     }

   688                 break;

   689                 }

   690             default:

   691                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL default");

   692                 break;

   693             }

   694     MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL --->");

   695     }

   696 

   697 void CMCPMusicPlayer::DoUpdateTrackInfoL(const TDesC& aTitle, const TDesC& aArtist)

   698     {

   699     MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL <---");

   700     if ( IsOKToPublishData() )

   701             {

   702             HBufC* nowPlayingForMM = HBufC::NewLC( aTitle.Length() + 

   703             		                               KSeparatorhyphen().Length() + aArtist.Length() );     

   704             TPtr nowPlayingForMMPtr = nowPlayingForMM->Des();

   705             if ( &aTitle && aTitle.Length() )

   706                 {

   707                 nowPlayingForMMPtr.Copy( aTitle );

   708                 }

   709             if ( &aArtist && aArtist.Length() )

   710                 {

   711                 nowPlayingForMMPtr.Append(KSeparatorhyphen);

   712                 nowPlayingForMMPtr.Append(aArtist);

   713                 }            

   714             iMHObserver->PublishTextL( this,EMusicWidgetText1, *nowPlayingForMM );

   715             iMHObserver->PublishTextL(this, EMusicMenuMusicInfoLine2,

   716                     *nowPlayingForMM);

   717             CleanupStack::PopAndDestroy( nowPlayingForMM );

   718             MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL deliting file monitor");

   719             if (iFileMonitor)

   720                 {

   721                 delete iFileMonitor;

   722                 iFileMonitor = NULL;

   723                 }

   724             

   725             const TDesC& uri = iEngine->Uri();

   726             if ( uri != KNullDesC )

   727                 {

   728                 MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL creating file monitor");

   729                 iFileMonitor = CFileMonitor::NewL(*this);

   730                 iFileMonitor->StartL( uri );

   731                 }

   732             }

   733     MPX_DEBUG1("CMCPMusicPlayer::DoUpdatePlayerStateL --->");

   734     }

   735 

   736 void CMCPMusicPlayer::DoUpdatePlaybackPositionL(TInt /*aPosition*/)

   737     {

   738     /*

   739      * 

   740      * This code was left here in case some parts are helpfull

   741      *  in the future, here is some code that used to work, 

   742      *  Members and APIs used migh have changed.

   743      *  

   744         if ( IsOKToPublishData() )

   745             {

   746             const TInt KMPXMinSecSeparatorIndex = 2;

   747             const TInt KMPXOneSecInMicroSecs = 1000000;

   748             const TInt KMPXOneHourInSeconds = 60 * 60;

   749             const TInt KMPXTimeIndicatorLength = 16;

   750             

   751             TBuf<KMPXTimeIndicatorLength> elapsed;

   752             TBuf<KMPXTimeIndicatorLength> total;

   753         

   754             TInt64 playbackPosInSeconds;

   755             TInt64 totalLengthInSeconds;

   756         

   757             playbackPosInSeconds = aPosition;

   758             totalLengthInSeconds = iEngine->Duration();

   759             HBufC* longFormatString;

   760             HBufC* shortFormatString;

   761         

   762             longFormatString = StringLoader::LoadL(

   763                     R_QTN_TIME_DURAT_LONG_WITH_ZERO );

   764             shortFormatString = StringLoader::LoadL(

   765                     R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO) ;

   766             TPtrC format = *shortFormatString;

   767         

   768             if ( totalLengthInSeconds >= KMPXOneHourInSeconds )

   769                 {

   770                 // For tracks longer than an hour we use different time format and

   771                 //a slightly different layout which has more space for the time

   772                 //labels.

   773                 format.Set( *longFormatString );

   774                 }

   775         

   776             TTime elapsedTime( playbackPosInSeconds * KMPXOneSecInMicroSecs );

   777             TTime totalTime( totalLengthInSeconds * KMPXOneSecInMicroSecs );

   778         

   779             if ( aPosition == 0 )

   780                 {

   781                 totalLengthInSeconds = 0;

   782                 }

   783         

   784             // Convert total playing time to texts.

   785             elapsedTime.FormatL( elapsed, format );

   786         

   787             if ( totalLengthInSeconds )

   788                 {

   789                 // Time remaining

   790                 totalTime.FormatL( total, format );

   791                 }

   792             else

   793                 {

   794                 // Time remaining: --:--

   795                 TLocale locale;

   796                 TBuf<KMPXTimeIndicatorLength> pos;

   797                 TChar separator = locale.TimeSeparator(KMPXMinSecSeparatorIndex);

   798                 total = KMPXZeroDurationMark;

   799                 total.Append( separator );

   800                 total += KMPXZeroDurationMark;

   801                 }

   802         

   803             AknTextUtils::LanguageSpecificNumberConversion( elapsed );

   804             AknTextUtils::LanguageSpecificNumberConversion( total );

   805             TBuf<128> duration;

   806             TBuf<128> elapsedTimebuf;

   807         

   808             elapsedTimebuf.Copy( elapsed );

   809         

   810             duration.Copy( elapsed );

   811             duration.Append( KSeparator );

   812             duration.Append( total );

   813         

   814             iMHObserver->PublishTextL( this, EMusicWidgetText3, duration );

   815         

   816             delete longFormatString;

   817             delete shortFormatString;

   818             }

   819      */

   820     }

   821 

   822 void CMCPMusicPlayer::DoUpdateAlbumArtL( CFbsBitmap* aBitmap )

   823     {

   824     MPX_DEBUG1("CMCPMusicPlayer::DoUpdateAlbumArtL <---");

   825     //Make sure that iCachedArtBitmap is deleted or nulled in case it is an alias.

   826     //This ensures that the data is not double deleted nor orphan.

   827     if ( iCachedArtBitmap && iCachedArtBitmap !=  aBitmap  && iCachedArtBitmap != iArtBitmap)

   828         {

   829         MPX_DEBUG1("CMCPMusicPlayer::DoUpdateAlbumArtL delete iCachedArtBitmap");

   830         delete iCachedArtBitmap;

   831         }

   832     iCachedArtBitmap = NULL;

   833     //Store the new bitmap.

   834     if ( aBitmap != iArtBitmap )

   835         {

   836         MPX_DEBUG1("CMCPMusicPlayer::DoUpdateAlbumArtL delete iArtBitmap");

   837         delete iArtBitmap;

   838         }

   839     iArtBitmap = aBitmap;

   840     iArtCached = EFalse;

   841     

   842     if (iArtBitmap)

   843         {

   844         TInt handle = iArtBitmap->Handle();

   845         if (iArtBitmapMask)

   846             {

   847             TInt mskHandle = iArtBitmapMask->Handle();

   848             iMHObserver->PublishImageL(this,EMusicWidgetImage1,handle,

   849                     mskHandle);

   850             }

   851         else

   852             {

   853             iMHObserver->PublishImageL(this,EMusicWidgetImage1,handle);

   854             }

   855         iMHObserver->PublishImageL( this, EMusicMenuMusicInfoImage1, 

   856                 handle );

   857         }

   858     else

   859         {

   860         iMHObserver->PublishImageL( this, EMusicMenuMusicInfoImage1,

   861                     KAknsIIDQgnIndiMupDefaultAlbum, 

   862                     KMIF, EMbmMusichomescreeniconsQgn_indi_mup_default_album, 

   863                     EMbmMusichomescreeniconsQgn_indi_mup_default_album_mask); 

   864         iMHObserver->PublishImageL( this, EMusicWidgetImage1,

   865                     KAknsIIDQgnIndiMupDefaultAlbum, 

   866                     KMIF, EMbmMusichomescreeniconsQgn_indi_mup_default_album, 

   867                     EMbmMusichomescreeniconsQgn_indi_mup_default_album_mask);

   868         }

   869     MPX_DEBUG1("CMCPMusicPlayer::DoUpdateAlbumArtL --->");

   870     }

   871 

   872 void CMCPMusicPlayer::DoHandleOpeningL()

   873     {

   874     MPX_DEBUG1("CMCPMusicPlayer::DoHandleOpeningL <---");

   875     if ( IsOKToPublishData() )

   876         {

   877         iMHObserver->PublishTextL( this,EMusicWidgetText1, iOpeningBuffer->Des() );

   878         }

   879     MPX_DEBUG1("CMCPMusicPlayer::DoHandleOpeningL --->");

   880     }

   881 

   882 void CMCPMusicPlayer::DoHandlePlaylisIsEmptyL()

   883     {

   884     MPX_DEBUG1("CMCPMusicPlayer::DoHandlePlaylisIsEmptyL <---");

   885     iActive = EFalse;

   886     ResetL();

   887     MPX_DEBUG1("CMCPMusicPlayer::DoHandlePlaylisIsEmptyL --->");

   888     }

   889 void CMCPMusicPlayer::DoHandleSkinChangedL()

   890     {

   891     MPX_DEBUG1("CMCPMusicPlayer::DoHandleSkinChangedL <---");

   892     //To make sure the mask gets recreated even if we don't use it right now.

   893     delete iArtBitmapMask;

   894     iArtBitmapMask = NULL;

   895     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   896     

   897     TRAPD(err, iArtBitmapMask = AknsUtils::CreateBitmapL( skin, 

   898             KAknsIIDQgnHomePhotoMask ) );

   899     if (err == KErrNone)

   900         {

   901         AknIconUtils::DisableCompression(iArtBitmapMask);

   902         TSize size( 70 , 70);

   903         AknIconUtils::SetSize( iArtBitmapMask, size );

   904         if (iArtBitmapMask->SetDisplayMode( EGray256 ) != KErrNone)

   905             {

   906             delete iArtBitmapMask;

   907             iArtBitmapMask = NULL;

   908             }

   909         }

   910     else

   911         {

   912         delete iArtBitmapMask;

   913         iArtBitmapMask = NULL;

   914         }

   915     

   916     if (iArtBitmap)

   917         {

   918         TInt handle = iArtBitmap->Handle();

   919         if (iArtBitmapMask)

   920             {

   921             TInt mskHandle = iArtBitmapMask->Handle();

   922             iMHObserver->PublishImageL(

   923                     this,

   924                     EMusicWidgetImage1,

   925                     handle, 

   926                     mskHandle);

   927             }

   928         else

   929             {

   930             iMHObserver->PublishImageL(

   931                     this,

   932                     EMusicWidgetImage1,

   933                     handle);

   934             }

   935         }

   936     else

   937         {

   938         iMHObserver->PublishImageL( this, EMusicMenuMusicInfoImage1,

   939                     KAknsIIDQgnIndiMupDefaultAlbum, 

   940                     KMIF, EMbmMusichomescreeniconsQgn_indi_mup_default_album, 

   941                     EMbmMusichomescreeniconsQgn_indi_mup_default_album_mask); 

   942         iMHObserver->PublishImageL( this, EMusicWidgetImage1,

   943                     KAknsIIDQgnIndiMupDefaultAlbum, 

   944                     KMIF, EMbmMusichomescreeniconsQgn_indi_mup_default_album, 

   945                     EMbmMusichomescreeniconsQgn_indi_mup_default_album_mask);

   946         }

   947        

   948     TUint tbstate = iToolBarState;

   949     //To Force a change on the toolbar with the current properties.

   950     iToolBarState = 0;

   951     if (!iActive)

   952         {

   953         //This is to force the icons to update, but we still want to keep

   954         //the plugin as incative.

   955         iActive = ETrue;

   956         UpdateToolBarL(tbstate);

   957         iActive = EFalse;

   958         }

   959     else

   960         {

   961         UpdateToolBarL(tbstate);

   962         }

   963     MPX_DEBUG1("CMCPMusicPlayer::DoHandleSkinChangedL --->");

   964     }

   965    

   966 

   967 

   968 // ---------------------------------------------------------------------------

   969 // From CMCPPlugin

   970 // ---------------------------------------------------------------------------

   971 //  

   972 void CMCPMusicPlayer::Deactivate()

   973     {

   974     MPX_DEBUG1("CMCPMusicPlayer::Deactivate() <---");

   975     iActive = EFalse;

   976     if (iFileMonitor)

   977         {

   978         delete iFileMonitor;

   979         iFileMonitor = NULL;

   980         }

   981     if (iAppMonitor)

   982         {

   983         delete iAppMonitor;

   984         iAppMonitor = NULL;

   985         }

   986     if ( iPNSMonitor )

   987         {

   988         delete iPNSMonitor;

   989         iPNSMonitor = NULL;

   990         }

   991     MPX_DEBUG1("CMCPMusicPlayer::Deactivate() --->");

   992     }

   993 

   994 // ---------------------------------------------------------------------------

   995 // From CMCPPlugin

   996 // ---------------------------------------------------------------------------

   997 //  

   998 void CMCPMusicPlayer::SkinChanged()

   999     {

  1000     MPX_DEBUG1("CMCPMusicPlayer::SkinChanged() <---");

  1001     TRAP_IGNORE( DoHandleSkinChangedL() );

  1002     MPX_DEBUG1("CMCPMusicPlayer::SkinChanged() --->");

  1003     }

  1004 

  1005 // ---------------------------------------------------------------------------

  1006 // From MAiPlayerPluginEngineObserver

  1007 // ---------------------------------------------------------------------------

  1008 //  

  1009 void CMCPMusicPlayer::PlayerStateChanged( TMPlayerState aState )

  1010     {

  1011     MPX_DEBUG1("CMCPMusicPlayer::PlayerStateChanged <---");

  1012     //we want to activate only with states that can be triggered by the user.

  1013     if (!iActive && 

  1014 	        aState == EMPlayerStatePlaying)

  1015         {

  1016         //ActivateL updates the whole widget and music suite data.

  1017         MPX_DEBUG1("CMCPMusicPlayer::PlayerStateChanged activating");

  1018         TRAP_IGNORE( ActivateL() );

  1019         }

  1020     else

  1021         {

  1022         MPX_DEBUG1("CMCPMusicPlayer::PlayerStateChanged updating state");

  1023         TRAP_IGNORE(DoUpdatePlayerStateL(aState));

  1024         }

  1025     MPX_DEBUG1("CMCPMusicPlayer::PlayerStateChanged --->");

  1026     }

  1027 

  1028 // ---------------------------------------------------------------------------

  1029 // From MAiPlayerPluginEngineObserver

  1030 // ---------------------------------------------------------------------------

  1031 //  

  1032 void CMCPMusicPlayer::TrackInfoChanged( const TDesC& aTitle, 

  1033         const TDesC& aArtist )

  1034     

  1035     {

  1036     MPX_DEBUG1("CMCPMusicPlayer::TrackInfoChanged <---");

  1037     if (iActive)

  1038         {

  1039         MPX_DEBUG1("CMCPMusicPlayer::TrackInfoChanged updating track info");

  1040         TRAP_IGNORE(DoUpdateTrackInfoL(aTitle, aArtist));

  1041         }

  1042     MPX_DEBUG1("CMCPMusicPlayer::TrackInfoChanged --->");

  1043     }

  1044 

  1045 // ---------------------------------------------------------------------------

  1046 // From MAiPlayerPluginEngineObserver

  1047 // ---------------------------------------------------------------------------

  1048 //  

  1049 void CMCPMusicPlayer::PlaybackPositionChanged( TInt aPosition )

  1050     {

  1051     TRAP_IGNORE( DoUpdatePlaybackPositionL( aPosition ) );

  1052     }

  1053 

  1054 // ---------------------------------------------------------------------------

  1055 // From MAiPlayerPluginEngineObserver

  1056 // ---------------------------------------------------------------------------

  1057 // 

  1058 void CMCPMusicPlayer::AlbumArtChanged( CFbsBitmap* aBitmap )

  1059     {

  1060     MPX_DEBUG1("CMCPMusicPlayer::AlbumArtChanged <---");

  1061     if (!iActive)

  1062         {

  1063         iCachedArtBitmap = aBitmap;

  1064         iArtCached = ETrue;

  1065         }

  1066     else

  1067         {

  1068         MPX_DEBUG1("CMCPMusicPlayer::AlbumArtChanged updating album art");

  1069         TRAP_IGNORE( DoUpdateAlbumArtL( aBitmap ) );

  1070         }

  1071     MPX_DEBUG1("CMCPMusicPlayer::AlbumArtChanged --->");

  1072     }

  1073 

  1074 // ---------------------------------------------------------------------------

  1075 // From MAiPlayerPluginEngineObserver

  1076 // ---------------------------------------------------------------------------

  1077 //  

  1078 void CMCPMusicPlayer::Opening()

  1079     {

  1080     MPX_DEBUG1("CMCPMusicPlayer::Opening <---");

  1081     TRAP_IGNORE( DoHandleOpeningL() );

  1082     MPX_DEBUG1("CMCPMusicPlayer::Opening --->");

  1083     }

  1084 

  1085 

  1086 // ---------------------------------------------------------------------------

  1087 // From MAiPlayerPluginEngineObserver

  1088 // ---------------------------------------------------------------------------

  1089 //  

  1090 void CMCPMusicPlayer::PlaylisIsEmpty()

  1091     {

  1092     //TRAP_IGNORE( DoHandlePlaylisIsEmptyL() );

  1093     }

  1094 // ---------------------------------------------------------------------------

  1095 // From MAiPlayerPluginEngineObserver

  1096 // ---------------------------------------------------------------------------

  1097 //  

  1098 void CMCPMusicPlayer::HandleFileRemovedL()

  1099     {

  1100     MPX_DEBUG1("CMCPMusicPlayer::HandleFileRemovedL <---");

  1101     iActive = EFalse;

  1102     ResetL();

  1103     MPX_DEBUG1("CMCPMusicPlayer::HandleFileRemovedL --->");

  1104     }

  1105 

  1106 

  1107 // ---------------------------------------------------------------------------

  1108 // From MApplicationMonitorObserver

  1109 // ---------------------------------------------------------------------------

  1110 // 

  1111 void CMCPMusicPlayer::HandleApplicationClosedL(TExitType aReason)

  1112     {

  1113     MPX_DEBUG1("CMCPMusicPlayer::HandleApplicationClosedL <---");

  1114     if (aReason == EExitPanic)

  1115         {

  1116         MPX_DEBUG1("CMCPMusicPlayer::HandleApplicationClosedL panic");

  1117         iActive = EFalse;

  1118         ResetL();

  1119         }

  1120     else

  1121         {

  1122         MPX_DEBUG1("CMCPMusicPlayer::HandleApplicationClosedL normal close");

  1123         UpdateToolBarL( TBK::KSkeep_L_dimmed |

  1124                 TBK::KPlay_last_played |

  1125                 TBK::KSkeep_R_dimmed );

  1126         if (IsOKToPublishData() )

  1127             {

  1128             iMHObserver->PublishTextL( this, EMusicWidgetDefaultText, KEmpty );

  1129             InstallGoToLastPlayedL(EMusicMenuMusicInfoTrigger, EFalse);       

  1130             iMHObserver->PublishTextL(this, EMusicMenuMusicInfoLine1,

  1131                                 KLastPlayed);     

  1132             DoUpdateTrackInfoL(iEngine->TitleL(), iEngine->Artist());

  1133             DoUpdateAlbumArtL(iArtCached ? iCachedArtBitmap : iArtBitmap);

  1134             }