1 /*

     2 * Copyright (c) 2006 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:  Implementation of Main view

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <aknViewAppUi.h>

    22 #include <eikmenub.h>

    23 #include <eikfrlb.h>

    24 #include <eikfrlbd.h>

    25 #include <featmgr.h>

    26 #include <StringLoader.h>

    27 #include <eikapp.h>

    28 #include <AknUtils.h>

    29 #include <akntitle.h>

    30 #include <textresolver.h>

    31 #include <aknnotewrappers.h>

    32 #include <aknnavi.h>

    33 #include <hlplch.h>

    34 #include <bautils.h>

    35 #include <eikspmod.h>

    36 #include <eikclb.h>

    37 #include <avkon.hrh>

    38 #include <avkon.rsg>

    39 #include <StringLoader.h>

    40 #include <data_caging_path_literals.hrh>

    41 #include <bldvariant.hrh>

    42 #include <layoutmetadata.cdl.h>

    43 #include <aknSDData.h>

    44 #include <AknMediatorFacade.h>

    45 #include <mplayersecondarydisplayapi.h>

    46 

    47 #include <mpxplaybackutility.h>

    48 #include <mpxviewutility.h>

    49 #include <mpxcollectionutility.h>

    50 #include <mpxplaybackmessage.h>

    51 #include <mpxcollectionmessage.h>

    52 #include <mpxcollectionmessagedefs.h>

    53 #include <mpxmediageneraldefs.h>

    54 #include <mpxmediacontainerdefs.h>

    55 #include <mpxmediamusicdefs.h>

    56 #include <mpxmediacollectiondetaildefs.h>

    57 #include <mpxmedia.h>

    58 #include <mpxmediaarray.h>

    59 #include <mpxcollectionframeworkdefs.h>

    60 #include <mpxviewpluginmanager.h>

    61 

    62 #include <mpxcollectionplaylist.h>

    63 #include <mpxmusicplayerviewplugin.hrh>

    64 #include <mpxmainview.rsg>

    65 #include <mpxlog.h>

    66 #include <mpxcollectionpath.h>

    67 #include <mpxviewplugin.h>

    68 #include <mpxcollectionplugin.hrh>

    69 #include <mpxmessagegeneraldefs.h>

    70 #include <mpxcommandgeneraldefs.h>

    71 #include <mpxcollectioncommanddefs.h>

    72 #include <mpxmessagecontainerdefs.h>

    73 #include <mpxuser.h>

    74 #include "mpxcommonuihelper.h"

    75 #include "mpxalbumartutil.h"

    76 #include "mpxmainview.hrh"

    77 #include "mpxmainviewimp.h"

    78 #include "mpxmainviewcontainer.h"

    79 #include <mpxappui.hrh>

    80 

    81 // CONSTANTS

    82 _LIT( KMPXMainRscPath, "mpxmainview.rsc" );

    83 _LIT( KMPXTab, "\t" );

    84 _LIT( KMPXSpace, " " );

    85 

    86 const TInt KWaitNoteImpUid = 0x101FFC6C;

    87 

    88 // extra size for buffers

    89 const TInt KMPXDefaultBufferLength = 255;

    90 const TInt KMPXExtraBufferLength = 50;

    91 const TInt KSecondInMilliseconds = 1000;

    92 const TInt KOneHourInSeconds = 3600;

    93 

    94 // ======== MEMBER FUNCTIONS ========

    95 

    96 // ---------------------------------------------------------------------------

    97 // Two-phased constructor.

    98 // ---------------------------------------------------------------------------

    99 //

   100 CMPXMainViewImp* CMPXMainViewImp::NewL()

   101     {

   102     MPX_FUNC( "CMPXMainViewImp::NewL" );

   103     CMPXMainViewImp* self = CMPXMainViewImp::NewLC();

   104     CleanupStack::Pop( self );

   105     return self;

   106     }

   107 

   108 // ---------------------------------------------------------------------------

   109 // Two-phased constructor.

   110 // ---------------------------------------------------------------------------

   111 //

   112 CMPXMainViewImp* CMPXMainViewImp::NewLC()

   113     {

   114     CMPXMainViewImp* self = new ( ELeave ) CMPXMainViewImp();

   115     CleanupStack::PushL( self );

   116     self->ConstructL();

   117     return self;

   118     }

   119 

   120 // ---------------------------------------------------------------------------

   121 // Destructor

   122 // ---------------------------------------------------------------------------

   123 //

   124 CMPXMainViewImp::~CMPXMainViewImp()

   125     {

   126     MPX_DEBUG1( "CMPXMainViewImp::~CMPXMainViewImp entering" );

   127 

   128     if ( iCollectionUtility )

   129         {

   130         iCollectionUtility->Close();

   131         }

   132 

   133     if ( iPlaybackUtility )

   134         {

   135         TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) );

   136         iPlaybackUtility->Close();

   137         }

   138 

   139     if ( iViewUtility )

   140         {

   141         iViewUtility->Close();

   142         }

   143 

   144     if ( iResourceOffset )

   145         {

   146         iEikonEnv->DeleteResourceFile( iResourceOffset );

   147         }

   148 

   149     if ( iContainer )

   150         {

   151         AppUi()->RemoveFromStack( iContainer );

   152         delete iContainer;

   153         }

   154 

   155     delete iMPXUtility;

   156     delete iTitle;

   157     delete iCommonUiHelper;

   158     delete iCurPath;

   159     delete iMediaArray;

   160     delete iIdle;

   161     MPX_DEBUG1( "CMPXMainViewImp::~CMPXMainViewImp exiting" );

   162     }

   163 

   164 // ---------------------------------------------------------------------------

   165 // C++ default constructor can NOT contain any code, that

   166 // might leave.

   167 // ---------------------------------------------------------------------------

   168 //

   169 CMPXMainViewImp::CMPXMainViewImp()

   170     {

   171     MPX_FUNC( "CMPXMainViewImp::CMPXMainViewImp" );

   172     iInitDBNeeded = EFalse;

   173     iInitDBCorrupted = EFalse;

   174     iCurSystemEvent = KErrNotFound;

   175     iShowPlaybackIndicator = EFalse;

   176     iColInitialized = EFalse;

   177     iRefreshingCollection = EFalse;

   178     iCurPlugin = KErrNotFound;

   179     }

   180 

   181 // ---------------------------------------------------------------------------

   182 // Symbian 2nd phase constructor can leave.

   183 // ---------------------------------------------------------------------------

   184 //

   185 void CMPXMainViewImp::ConstructL()

   186     {

   187     MPX_FUNC( "CMPXMainViewImp::ConstructL" );

   188 

   189     CCoeEnv* coeEnv = iEikonEnv;

   190     TParse parse;

   191     parse.Set( KMPXMainRscPath, &KDC_APP_RESOURCE_DIR, NULL );

   192     TFileName resourceFile( parse.FullName() );

   193     User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

   194     BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

   195     iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

   196 

   197     BaseConstructL( R_MPX_MAIN_VIEW );

   198     iViewUtility = MMPXViewUtility::UtilityL();

   199     iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

   200     iPlaybackUtility->AddObserverL( *this );

   201     iCommonUiHelper = CMPXCommonUiHelper::NewL();

   202     iMPXUtility = CMPXAlbumArtUtil::NewL();

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

   204     iAlbumArtIndex = KMPXMainViewDefaultIcon;

   205 

   206     TMPXPlaybackState state = iPlaybackUtility->StateL();

   207     if( state == EPbStatePlaying ||

   208         state == EPbStatePaused )

   209         {

   210         iShowPlaybackIndicator = ETrue;

   211         }

   212     iIdle = CIdle::NewL( CActive::EPriorityStandard );

   213     iTitle = HBufC::NewL( 0 );

   214 

   215 #ifdef _DEBUG

   216     iExitOptionHidden = EFalse;

   217 #else // _DEBUG

   218     iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL() &&

   219         !iEikonEnv->StartedAsServerApp();

   220 #endif // _DEBUG

   221     }

   222 

   223 // ---------------------------------------------------------------------------

   224 // Displays error notes.

   225 // ---------------------------------------------------------------------------

   226 //

   227 void CMPXMainViewImp::HandleErrorL( TInt aError )

   228     {

   229     if ( aError )

   230         {

   231         MPX_DEBUG2( "CMPXMainViewImp::HandleErrorL(%d)", aError );

   232 

   233         // TextResolver instance for error resolving.

   234         CTextResolver* textresolver = CTextResolver::NewLC();

   235         // Resolve the error text

   236         const TDesC& text =

   237             textresolver->ResolveErrorString( aError );

   238 

   239         CAknErrorNote* dlg = new ( ELeave ) CAknErrorNote( ETrue );

   240         dlg->ExecuteLD( text );

   241         CleanupStack::PopAndDestroy( textresolver );

   242         }

   243     }

   244 

   245 // ---------------------------------------------------------------------------

   246 // Function to display information notes

   247 // ---------------------------------------------------------------------------

   248 //

   249 void CMPXMainViewImp::DisplayInfoNoteL( TInt aResourceId )

   250     {

   251     MPX_FUNC( "CMPXMainViewImp::DisplayInfoNoteL" );

   252     HBufC* text = StringLoader::LoadLC( aResourceId );

   253     CAknInformationNote* dlg = new ( ELeave ) CAknInformationNote( ETrue );

   254     dlg->ExecuteLD( *text );

   255     CleanupStack::PopAndDestroy( text );

   256     }

   257 

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

   259 // Function to display confirmation notes

   260 // ---------------------------------------------------------------------------

   261 //

   262 void CMPXMainViewImp::DisplayConfirmionNoteL( TInt aResourceId )

   263     {

   264     MPX_FUNC( "CMPXMainViewImp::DisplayConfirmionNoteL" );

   265     HBufC* text = StringLoader::LoadLC( aResourceId );

   266     CAknConfirmationNote* dlg = new ( ELeave ) CAknConfirmationNote( ETrue );

   267     dlg->ExecuteLD( *text );

   268     CleanupStack::PopAndDestroy( text );

   269     }

   270 

   271 // ---------------------------------------------------------------------------

   272 // From MMPXCollectionObserver

   273 // Handle collection message

   274 // ---------------------------------------------------------------------------

   275 //

   276 void CMPXMainViewImp::HandleCollectionMessage(

   277     CMPXMessage* aMessage, TInt aError )

   278     {

   279     if ( aError == KErrNone && aMessage )

   280         {

   281         TRAP_IGNORE( DoHandleCollectionMessageL( *aMessage ) );

   282         }

   283     }

   284 

   285 // ---------------------------------------------------------------------------

   286 // From MMPXCollectionObserver

   287 // Handles the collection entries being opened. Typically called

   288 // when client has Open()'d a folder

   289 // ---------------------------------------------------------------------------

   290 //

   291 void CMPXMainViewImp::HandleOpenL(

   292     const CMPXMedia& aEntries,

   293     TInt aIndex,

   294     TBool /*aComplete*/,

   295     TInt aError )

   296     {

   297     MPX_FUNC( "CMPXMainViewImp::HandleOpenL 4" );

   298     if( aError == KErrNone )

   299         {

   300         UpdateListBoxL( aEntries, aIndex );

   301 

   302         UpdatePluginInfo();

   303         }

   304     else if ( aError == KErrCorrupt )

   305         {

   306         DoHandleCorruptMsgL();

   307         }

   308     else

   309         {

   310         HandleErrorL( aError );

   311         }

   312     MPX_PERF_CHECKPT("MPX Main view displayed");

   313     }

   314 

   315 // ---------------------------------------------------------------------------

   316 // From MMPXCollectionObserver

   317 // Handles the collection entries being opened. Typically called

   318 // when client has Open()'d an item. Client typically responds by

   319 // 'playing' the item

   320 // ---------------------------------------------------------------------------

   321 //

   322 void CMPXMainViewImp::HandleOpenL(

   323     const CMPXCollectionPlaylist& /*aPlaylist*/,

   324     TInt /*aError*/ )

   325     {

   326     // Do Nothing: playback/fetch client should handle this stage

   327     }

   328 

   329 // ---------------------------------------------------------------------------

   330 // From MMPXCollectionObserver

   331 // Handle media properties

   332 // Notes: The client is responsible for delete the object of aMedia

   333 // ---------------------------------------------------------------------------

   334 //

   335 void CMPXMainViewImp::HandleCollectionMediaL(

   336     const CMPXMedia& aMedia,

   337     TInt aError)

   338     {

   339     MPX_FUNC( "CMPXMainViewImp::HandleCollectionMediaL" );

   340 

   341     if (aError == KErrNoMemory)

   342         {

   343         TRAP_IGNORE(

   344                 HandleErrorL( aError );

   345                 AppUi()->HandleCommandL( EEikCmdExit );

   346         );

   347         User::Exit(KErrNoMemory);

   348         return;

   349         }

   350 

   351     if (aError == KErrDiskFull)

   352         {

   353              iOutOfDisk = ETrue;

   354              CloseWaitNoteL();

   355              iCurPlugin = KErrNotFound;

   356              DoRetrieveDetailsL(ETrue);

   357         }

   358 

   359     if ( aError != KErrCorrupt )

   360         {

   361 

   362         if(!iOutOfDisk)

   363             {

   364             // Check to see if database has been created for this item

   365             //

   366             TBool dbCreated = ETrue;

   367             if( aMedia.IsSupported(KMPXMediaColDetailDBCreated))

   368                 {

   369                 dbCreated = aMedia.ValueTObjectL<TBool>(KMPXMediaColDetailDBCreated);

   370                 MPX_DEBUG2("CMPXMainViewImp::HandleCollectionMediaL dbcreated %i", dbCreated);

   371                 }

   372             iInitDBNeeded |= !dbCreated;  //lint !e514

   373 

   374             // Check to see if database was corrupted for this item

   375             //

   376             TBool dbCorrupted = EFalse;

   377             if( aMedia.IsSupported(KMPXMediaColDetailDBCorrupted))

   378                 {

   379                 dbCorrupted = aMedia.ValueTObjectL<TBool>(KMPXMediaColDetailDBCorrupted);

   380                 }

   381             iInitDBCorrupted |= dbCorrupted;

   382             }

   383 

   384         // Update the list box item, iCurPlugin++ because first item is pb state

   385         //

   386         iCurPlugin++;

   387         UpdateItemCountTotalL( aMedia );

   388 

   389 

   390         // Check to see if we need to do initial scan or refresh due to db corruption

   391         //

   392         if( iCurPlugin == iCurPath->Count() )

   393             {

   394             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMediaL plugins MediaL loaded");

   395             if ( !iColInitialized )

   396                 {

   397                 CloseWaitNoteL();

   398                 iColInitialized = ETrue;

   399                 }

   400 

   401             if( (iInitDBNeeded || iInitDBCorrupted) && !iOutOfDisk )

   402                 {

   403                 MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMediaL starting scan");

   404                 TWaitNoteType noteType = iInitDBCorrupted ? EMPXCorruptScanningNote :

   405                                                             EMPXScanningNote;

   406 

   407                 StartWaitNoteL( noteType );

   408                 iInitDBNeeded = EFalse;

   409                 iInitDBCorrupted = EFalse;

   410                 iRefreshingCollection = ETrue;

   411                 iDelayedUsbRefresh = EFalse;

   412                 }

   413             else if( iDelayedUsbRefresh )

   414                 {

   415                 DoHandleBroadcastMsgL( EMcMsgUSBMassStorageEnd );

   416                 }

   417             iCurPlugin = KErrNotFound;

   418             }

   419         else if( iCurPlugin < iCurPath->Count() )  // Fetch next

   420             {

   421             // Set which plugin

   422             iCurPath->Set(iCurPlugin);

   423 

   424             // Fetch the extra data

   425             RArray<TMPXAttribute> atts;

   426             CleanupClosePushL( atts );

   427             if(!iOutOfDisk)

   428                 {

   429                 atts.Append(KMPXMediaColDetailDBCreated);

   430                 atts.Append(KMPXMediaColDetailDBCorrupted);

   431                 }

   432 #ifndef __ENABLE_PODCAST_IN_MUSIC_MENU

   433             atts.Append(KMPXMediaGeneralTitle);

   434             atts.Append(KMPXMediaGeneralSubTitle);

   435             if(!iOutOfDisk)

   436                 {

   437                 atts.Append(KMPXMediaGeneralCount);

   438                 }

   439             atts.Append(KMPXMediaGeneralIcon);

   440 #endif // __ENABLE_PODCAST_IN_MUSIC_MENU

   441 

   442             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMediaL fetch next");

   443             // Only fetch next if we haven't been interrupted by another event

   444             //

   445             if( iCurSystemEvent == KErrNotFound )

   446                 {

   447                 iCollectionUtility->Collection().MediaL(*iCurPath, atts.Array() );

   448                 }

   449             else

   450                 {

   451                 // Reset state machine

   452                 iCurPlugin = KErrNotFound;

   453                 }

   454             CleanupStack::PopAndDestroy( &atts );

   455             }

   456 

   457         if ( aError != KErrNone ) //lint !e961

   458             {

   459             HandleErrorL( aError );

   460             }

   461         }

   462     else

   463         {

   464         DoHandleCorruptMsgL();

   465         }

   466     }

   467 

   468 // ---------------------------------------------------------------------------

   469 // From MMPXPlaybackObserver

   470 // Handle playback message.

   471 // ---------------------------------------------------------------------------

   472 //

   473 void CMPXMainViewImp::HandlePlaybackMessage(

   474     CMPXMessage* aMessage, TInt aError )

   475     {

   476     if ( aError == KErrNone && aMessage )

   477         {

   478         TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );

   479         }

   480     }

   481 

   482 // ---------------------------------------------------------------------------

   483 // From MMPXPlaybackCallback

   484 // Handle playback property.

   485 // ---------------------------------------------------------------------------

   486 //

   487 void CMPXMainViewImp::HandlePropertyL(

   488     TMPXPlaybackProperty aProperty,

   489     TInt aValue,

   490     TInt aError )

   491     {

   492     MPX_DEBUG1( "CMPXMainViewImp::HandlePropertyL" );

   493     TRAP_IGNORE( DoHandlePropertyL( aProperty, aValue, aError ) );

   494     }

   495 

   496 // ---------------------------------------------------------------------------

   497 // From MMPXPlaybackCallback

   498 // Method is called continously until aComplete=ETrue, signifying that

   499 // it is done and there will be no more callbacks

   500 // Only new items are passed each time

   501 // ---------------------------------------------------------------------------

   502 //

   503 void CMPXMainViewImp::HandleSubPlayerNamesL(

   504     TUid /* aPlayer */,

   505     const MDesCArray* /* aSubPlayers */,

   506     TBool /* aComplete */,

   507     TInt /* aError */ )

   508     {

   509     // do nothing

   510     }

   511 

   512 // ---------------------------------------------------------------------------

   513 // From MMPXPlaybackCallback

   514 // Handle extended media properties.

   515 // Notes: The client is responsible for delete the object of aProperties.

   516 // ---------------------------------------------------------------------------

   517 //

   518 void CMPXMainViewImp::HandleMediaL(

   519     const CMPXMedia& aMedia,

   520     TInt aError )

   521     {

   522     MPX_DEBUG2( "CMPXMainViewImp::HandleMediaL %i", aError );

   523     TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );

   524     }

   525 

   526 // ---------------------------------------------------------------------------

   527 // From CAknView

   528 // Returns views id.

   529 // ---------------------------------------------------------------------------

   530 //

   531 TUid CMPXMainViewImp::Id() const

   532     {

   533     return TUid::Uid( KMPXMainViewId );

   534     }

   535 

   536 // ---------------------------------------------------------------------------

   537 // From CAknView

   538 // Command handling function.

   539 // ---------------------------------------------------------------------------

   540 //

   541 void CMPXMainViewImp::HandleCommandL( TInt aCommand )

   542     {

   543     MPX_DEBUG2( "CMPXMainViewImp::HandleCommandL(%d) entering", aCommand );

   544 

   545     switch (aCommand)

   546         {

   547         case EMPXCmdGoToNowPlaying:

   548             {

   549             // update view history first

   550             iViewUtility->PushDefaultHistoryL();

   551             //then open the view first

   552             AppUi()->HandleCommandL( aCommand );

   553             break;

   554             }

   555         case EMPXMainViewRefresh:

   556             {

   557             MPX_PERF_CHECKPT("Refresh collection library");

   558             // Package the argument from 8bit to 16bit then activate view

   559             //

   560             StartWaitNoteL( EMPXRefreshingNote );

   561             iPlaybackUtility->CommandL( EPbCmdStop );

   562             break;

   563             }

   564         case EAknCmdHelp:

   565             {

   566             HlpLauncher::LaunchHelpApplicationL(

   567                 iEikonEnv->WsSession(),

   568                 AppUi()->AppHelpContextL() );

   569             break;

   570             }

   571         case EAknCmdExit:

   572         case EAknSoftkeyExit:

   573             {

   574             AppUi()->HandleCommandL( aCommand );

   575             break;

   576             }

   577         default:

   578             {

   579             AppUi()->HandleCommandL( aCommand );

   580             break;

   581             }

   582         }

   583     MPX_DEBUG1( "CMPXMainViewImp::HandleCommandL() exiting" );

   584     }

   585 

   586 // ---------------------------------------------------------------------------

   587 // From CAknView

   588 // Handles a view activation.

   589 // ---------------------------------------------------------------------------

   590 //

   591 void CMPXMainViewImp::DoActivateL(

   592     const TVwsViewId& /* aPrevViewId */,

   593     TUid /* aCustomMessageId */,

   594     const TDesC8& /* aCustomMessage */ )

   595     {

   596     MPX_FUNC( "CMPXMainViewImp::DoActivateL()" );

   597     StatusPane()->MakeVisible( ETrue );

   598     if ( StatusPane()->CurrentLayoutResId() !=

   599          R_AVKON_STATUS_PANE_LAYOUT_USUAL)

   600         {

   601         StatusPane()->SwitchLayoutL(R_AVKON_STATUS_PANE_LAYOUT_USUAL);

   602         }

   603 

   604     if ( !iContainer )

   605         {

   606         iContainer = new ( ELeave ) CMPXMainViewContainer( this );

   607         iContainer->SetMopParent( this );

   608         iContainer->ConstructL( ClientRect() );

   609         AppUi()->AddToStackL( *this, iContainer );

   610         }

   611 

   612     // Set title

   613     CAknTitlePane* title( NULL );

   614 

   615     TRAP_IGNORE(

   616         {

   617         title = static_cast<CAknTitlePane*>

   618             ( StatusPane()->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

   619         } );

   620     if ( title )

   621         {

   622         HBufC* titleText = StringLoader::LoadLC(

   623             R_MPX_MAIN_VIEW_TITLE );

   624         title->SetTextL( *titleText );

   625         CleanupStack::PopAndDestroy( titleText );

   626         }

   627 

   628     CEikButtonGroupContainer* cbgc = CEikButtonGroupContainer::Current();

   629     if ( cbgc )

   630         {

   631         if ( iViewUtility->ViewHistoryDepth() == 1 )

   632             {

   633             cbgc->SetCommandSetL( R_MPX_CUI_SOFTKEYS_OPTIONS_PHONE );

   634             }

   635         else

   636             {

   637             cbgc->SetCommandSetL( R_AVKON_SOFTKEYS_OPTIONS_BACK );

   638             }

   639 

   640 #ifdef __ENABLE_MSK

   641         iCommonUiHelper->SetMiddleSoftKeyLabelL(

   642             *cbgc,

   643             R_QTN_MSK_OPEN,

   644             EAknSoftkeyForwardKeyEvent );

   645 #endif // __ENABLE_MSK

   646 

   647         cbgc->DrawDeferred();

   648         }

   649 

   650     iAlbumArtIndex = KMPXMainViewTransparent;

   651     iPlaybackState = iPlaybackUtility->StateL();

   652     MMPXSource* s = iPlaybackUtility->Source();

   653     if ( s )

   654         {

   655         RArray<TMPXAttribute> attrs;

   656         CleanupClosePushL(attrs);

   657         attrs.Append(

   658             TMPXAttribute( KMPXMediaIdGeneral,

   659             EMPXMediaGeneralTitle | EMPXMediaGeneralUri ) );

   660         attrs.Append(KMPXMediaMusicAlbumArtFileName);

   661         s->MediaL( attrs.Array(), *this );

   662         CleanupStack::PopAndDestroy( &attrs );

   663 

   664         CMPXCollectionPlaylist* pl = s->PlaylistL();

   665         if( pl )

   666             {

   667             CleanupStack::PushL( pl );

   668             iCurPlPlayPosition = pl->Index() + 1; // offset for 0th index

   669             iCurPlTotalCount   = pl->Count();

   670             CleanupStack::PopAndDestroy( pl );

   671             }

   672         }

   673     UpdatePlaybackViewStatusL();

   674 

   675     if ( iCollectionUtility )

   676         {

   677         if( iCurSystemEvent == EMcMsgUSBMassStorageStart ||

   678             iCurSystemEvent == EMcMsgUSBMTPStart )

   679             {

   680             // Fix grey out problem by re-starting the note

   681             //

   682             CMPXViewPlugin* pi =

   683                     iViewUtility->ViewPluginManager().PluginL( TUid::Uid(KWaitNoteImpUid) );

   684             pi->DeactivateView();

   685             DoHandleBroadcastMsgL( iCurSystemEvent );

   686             iColInitialized = ETrue;

   687             }

   688         else if ( !iColInitialized )

   689 

   690             {

   691             StartWaitNoteL( EMPXOpeningNote );

   692             }

   693 

   694         // Path Depth can be 2 if rapidly pressing back.

   695         // In this case, we wait until the collection container opened message

   696         // is sent

   697         //

   698         CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();

   699         CleanupStack::PushL( cPath );

   700         MPX_DEBUG2("CMPXMainViewImp::DoActivateL path depth %i", cPath->Levels());

   701         if( cPath->Levels() == 1 )

   702             {

   703             iCollectionUtility->Collection().OpenL();

   704             iPathCorrupted = EFalse;

   705             }

   706         else

   707             {

   708             iPathCorrupted = ETrue;

   709             }

   710         CleanupStack::PopAndDestroy( cPath );

   711         }

   712     }

   713 

   714 // ---------------------------------------------------------------------------

   715 // From CAknView

   716 // View deactivation function.

   717 // ---------------------------------------------------------------------------

   718 //

   719 void CMPXMainViewImp::DoDeactivate()

   720     {

   721     MPX_FUNC( "CMPXMainViewImp::DoDeactivate" );

   722     if ( iContainer )

   723         {

   724         AppUi()->RemoveFromStack( iContainer );

   725         delete iContainer;

   726         iContainer = NULL;

   727         }

   728     }

   729 

   730 // ---------------------------------------------------------------------------

   731 // From CAknView

   732 // Foreground event handling function.

   733 // ---------------------------------------------------------------------------

   734 //

   735 void CMPXMainViewImp::HandleForegroundEventL( TBool aForeground )

   736     {

   737     MPX_FUNC( "CMPXMainViewImp::HandleForegroundEventL" );

   738     CAknView::HandleForegroundEventL( aForeground );

   739     }

   740 

   741 // ---------------------------------------------------------------------------

   742 // From MEikMenuObserver

   743 // Dynamically initialises a menu pane.

   744 // ---------------------------------------------------------------------------

   745 //

   746 void CMPXMainViewImp::DynInitMenuPaneL(

   747     TInt aResourceId,

   748     CEikMenuPane* aMenuPane )

   749     {

   750     MPX_FUNC( "CMPXMainViewImp::DynInitMenuPaneL" );

   751     switch ( aResourceId )

   752         {

   753         case R_MPX_MAIN_VIEW_MENU:

   754             {

   755             aMenuPane->SetItemDimmed( EAknCmdExit, iExitOptionHidden );

   756             break;

   757             }

   758         default:

   759             {

   760             // Do nothing

   761             break;

   762             }

   763         }

   764     AknSelectionService::HandleMarkableListDynInitMenuPane(

   765         aResourceId,

   766         aMenuPane,

   767         iContainer->ListBox() );

   768     }

   769 

   770 // ---------------------------------------------------------------------------

   771 // From MEikListBoxObserver

   772 // Handles listbox events.

   773 // ---------------------------------------------------------------------------

   774 //

   775 void CMPXMainViewImp::HandleListBoxEventL(

   776     CEikListBox* /*aListBox*/,

   777     TListBoxEvent aEventType)

   778     {

   779     MPX_FUNC( "CMPXMainViewImp::HandleListBoxEventL" );

   780 

   781     if ( aEventType == EEventEnterKeyPressed || aEventType == EEventItemDoubleClicked

   782 #ifdef SINGLE_CLICK_INCLUDED

   783         || aEventType == EEventItemSingleClicked    

   784 #endif

   785         )

   786         {

   787         TInt currentIndex = iContainer->ListBox()->CurrentItemIndex();

   788         if ( currentIndex == 0 && iShowPlaybackIndicator ) //lint !e961

   789             {

   790             MMPXPlayer* player =

   791                 iPlaybackUtility->PlayerManager().CurrentPlayer();

   792             TUid pluginUid( KNullUid );

   793             RArray<TUid> array;

   794             CleanupClosePushL( array );

   795 

   796             if ( player )

   797                 {

   798                 pluginUid = player->UidL();

   799                 MPX_DEBUG2( "CMPXMainViewImp::HandleListBoxEventL player UID = 0x%x", pluginUid.iUid );

   800                 array.AppendL( pluginUid );

   801                 }

   802             else

   803                 {

   804                 array.AppendL( TUid::Uid( KMPXPluginTypePlaybackUid ) );

   805                 }

   806 

   807             MMPXSource* source = iPlaybackUtility->Source();

   808             if ( source )

   809                 {

   810                 CMPXCollectionPlaylist* playlist = source->PlaylistL();

   811                 if ( playlist )

   812                     {

   813                     CleanupStack::PushL( playlist );

   814                     CMPXCollectionPath* pbPath =

   815                         CMPXCollectionPath::NewL( playlist->Path() );

   816                     CleanupStack::PushL( pbPath );

   817                     if ( pbPath->Levels() > 0 )

   818                         {

   819                         TMPXItemId cPathUid = pbPath->Id( 0 );

   820                         MPX_DEBUG2( "CMPXMainViewImp::HandleListBoxEventL collection uid = 0x%x", cPathUid.iId1 );

   821                         array.AppendL( TUid::Uid( cPathUid ) );

   822                         }

   823                     CleanupStack::PopAndDestroy( pbPath );

   824                     CleanupStack::PopAndDestroy( playlist );

   825                     }

   826                 }

   827             // Forced jump, clear main view from view history

   828             //

   829             iViewUtility->PushDefaultHistoryL();

   830             iViewUtility->ActivateViewL( array );

   831 

   832             CleanupStack::PopAndDestroy( &array );

   833             }

   834         else if ( currentIndex > -1 ) //lint !e961

   835             {

   836             // offset by 1 for playback view

   837             TInt offset = iShowPlaybackIndicator ? 1 : 0;

   838             iCollectionUtility->Collection().OpenL( currentIndex - offset );

   839             }

   840         }  //lint !e961

   841     }

   842 

   843 // ---------------------------------------------------------------------------

   844 // From MMPXAlbumArtUtilObserver

   845 // Notify that extraction of album art started.

   846 // ---------------------------------------------------------------------------

   847 //

   848 void CMPXMainViewImp::ExtractAlbumArtStarted()

   849     {

   850     MPX_DEBUG1("CMPXMainViewImp::ExtractAlbumArtStarted()");

   851     iAlbumArtIndex = KMPXMainViewTransparent;

   852     }

   853 

   854 // ---------------------------------------------------------------------------

   855 // From MMPXAlbumArtUtilObserver

   856 // Album art is extracted from file and ready to use.

   857 // ---------------------------------------------------------------------------

   858 //

   859 void CMPXMainViewImp::ExtractAlbumArtCompleted(

   860     CFbsBitmap* aBitmap, TInt aErr )

   861     {

   862     TRAP_IGNORE( DoExtractAlbumArtCompletedL( aBitmap, aErr ) );

   863     }

   864 

   865 // ---------------------------------------------------------------------------

   866 // Handle playback message.

   867 // ---------------------------------------------------------------------------

   868 //

   869 void CMPXMainViewImp::DoHandlePlaybackMessageL(

   870     const CMPXMessage& aMessage )

   871     {

   872     MPX_FUNC( "CMPXMainViewImp::DoHandlePlaybackMessageL" );

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

   874     if ( KMPXMessageGeneral == id )

   875         {

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

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

   878         switch ( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) )

   879             {

   880             case TMPXPlaybackMessage::EPropertyChanged:

   881                 {

   882                 TMPXPlaybackProperty property(

   883                     static_cast<TMPXPlaybackProperty>( type ) );

   884                 TInt error( KErrNone );

   885 

   886                 DoHandlePropertyL( property, data, error );

   887                 break;

   888                 }

   889             case TMPXPlaybackMessage::EStateChanged:

   890                 {

   891                 MPX_DEBUG2( "CMPXMainViewImp::HandlePlaybackMessageL - EStateChanged(%d)", type );

   892 

   893                 TMPXPlaybackState state =

   894                     static_cast<TMPXPlaybackState>( type );

   895 

   896                 DoHandleStateChangedL( state );

   897                 break;

   898                 }

   899             case TMPXPlaybackMessage::EMediaChanged:

   900                 {

   901                 if ( iContainer )

   902                     {

   903                     MMPXSource* s = iPlaybackUtility->Source();

   904                     if ( s )

   905                         {

   906                         RArray<TMPXAttribute> attrs;

   907                         CleanupClosePushL(attrs);

   908                         attrs.Append(

   909                             TMPXAttribute( KMPXMediaIdGeneral,

   910                             EMPXMediaGeneralTitle | EMPXMediaGeneralUri ) );

   911                         attrs.Append(KMPXMediaMusicAlbumArtFileName);

   912                         s->MediaL( attrs.Array(), *this );

   913                         CleanupStack::PopAndDestroy( &attrs );

   914 

   915                         CMPXCollectionPlaylist* pl = s->PlaylistL();

   916                         if( pl )

   917                             {

   918                             CleanupStack::PushL( pl );

   919                             iCurPlPlayPosition = pl->Index() + 1; // offset for 0th index

   920                             iCurPlTotalCount   = pl->Count();

   921                             CleanupStack::PopAndDestroy( pl );

   922                             }

   923                         }

   924                     }

   925                 break;

   926                 }

   927             case TMPXPlaybackMessage::ECommandReceived:

   928                 {

   929                 MPX_DEBUG2( "CMPXMainViewImp - ECommandReceived(%d)", type );

   930                 break;

   931                 }

   932             case TMPXPlaybackMessage::EActivePlayerChanged:

   933                 {

   934                 MPX_DEBUG3( "CMPXMainViewImp - EActivePlayerChanged(%d, %d)", type, data );

   935                 if ( type && data )

   936                     {

   937                     // binded to active player, change state to active

   938                     DoHandleStateChangedL( EPbStatePlaying );

   939                     // refresh media property

   940                     MMPXSource* s = iPlaybackUtility->Source();

   941                     if ( s )

   942                         {

   943                         RArray<TMPXAttribute> attrs;

   944                         CleanupClosePushL(attrs);

   945                         attrs.Append(

   946                             TMPXAttribute( KMPXMediaIdGeneral,

   947                             EMPXMediaGeneralTitle | EMPXMediaGeneralUri ) );

   948                         attrs.Append(KMPXMediaMusicAlbumArtFileName);

   949                         s->MediaL( attrs.Array(), *this );

   950                         CleanupStack::PopAndDestroy( &attrs );

   951 

   952                         CMPXCollectionPlaylist* pl = s->PlaylistL();

   953                         if( pl )

   954                             {

   955                             CleanupStack::PushL( pl );

   956                             iCurPlPlayPosition = pl->Index() + 1; // offset for 0th index

   957                             iCurPlTotalCount   = pl->Count();

   958                             CleanupStack::PopAndDestroy( pl );

   959                             }

   960                         }

   961                     }

   962                 break;

   963                 }

   964             default:

   965                 {

   966                 break;

   967                 }

   968             }

   969         }

   970     }

   971 

   972 // ---------------------------------------------------------------------------

   973 // Handle playback property.

   974 // ---------------------------------------------------------------------------

   975 //

   976 void CMPXMainViewImp::DoHandlePropertyL(

   977     TMPXPlaybackProperty aProperty,

   978     TInt aValue,

   979     TInt aError )

   980     {

   981     MPX_FUNC( "CMPXMainViewImp::DoHandlePropertyL" );

   982     MPX_DEBUG4( "CMPXMainViewImp::DoHandlePropertyL - Property(%d); Value(%d); Error(%d)", aProperty, aValue, aError );

   983 

   984     if ( KErrNone == aError )

   985         {

   986         switch ( aProperty  )

   987             {

   988             case EPbPropertyPosition:

   989                 {

   990                 iPosition = aValue;

   991                 break;

   992                 }

   993             case EPbPropertyDuration:

   994                 {

   995                 iDuration = aValue;

   996                 break;

   997                 }

   998             default:

   999                 {

  1000                 break;

  1001                 }

  1002             }

  1003         UpdatePlaybackViewStatusL();

  1004         }

  1005     }

  1006 

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

  1008 // Handle collection messages.

  1009 // ---------------------------------------------------------------------------

  1010 //

  1011 void CMPXMainViewImp::DoHandleCollectionMessageL(

  1012     const CMPXMessage& aMessage )

  1013     {

  1014     MPX_FUNC( "CMPXCommandHandler::DoHandleCollectionMessageL" );

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

  1016     if ( KMPXMessageGeneral == id )

  1017         {

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

  1019         TInt op( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

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

  1021         // End of refresh message, update the list box text

  1022         //

  1023         if( event == TMPXCollectionMessage::EBroadcastEvent &&

  1024             op == EMcMsgRefreshEnd )

  1025             {

  1026             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMessageL - refresh end");

  1027             iRefreshingCollection = EFalse;

  1028             iOutOfDisk = data == KErrDiskFull ? ETrue : EFalse;

  1029 

  1030             if (!iOutOfDisk)

  1031                 {

  1032                 ResynchronizeCollectionL();

  1033                 }

  1034             else

  1035                 {

  1036                 iCurPlugin = KErrNotFound;

  1037                 iInitDBNeeded = EFalse;

  1038                 iInitDBCorrupted = EFalse;

  1039                 }

  1040 

  1041             DoRetrieveDetailsL(iOutOfDisk);

  1042             DoSetDefaultFocusL();

  1043             }

  1044         else if(event == TMPXCollectionMessage::EBroadcastEvent &&

  1045                 op == EMcMsgRefreshStart)

  1046             {

  1047             iRefreshingCollection = ETrue;

  1048             }

  1049         // Handle other broadcast messages

  1050         //

  1051         else if( event == TMPXCollectionMessage::EBroadcastEvent )

  1052             {

  1053             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMessageL - broadcast");

  1054             DoHandleBroadcastMsgL( op );

  1055             }

  1056         // if not currently refreshing, the main view should make sure

  1057         // the collection item counters are always up to date

  1058         else if( event == TMPXCollectionMessage::EItemChanged &&

  1059                  !iRefreshingCollection )

  1060             {

  1061             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMessageL - item changed");

  1062 

  1063             if((op == EMPXItemInserted || op == EMPXItemDeleted) &&

  1064                (data >> 28 == EMPXCollection)) //lint !e702 only update if collection has changed

  1065                 {

  1066                 // refresh since the podcasting collection has been updated

  1067                 DoRetrieveDetailsL();

  1068                 }

  1069             // else ignore

  1070             }

  1071         // If user rapidly presses back, main view gets activated with a Path of level 2

  1072         // but the path change to level 1 msg comes later

  1073         //

  1074         else if( event == TMPXCollectionMessage::EPathChanged &&

  1075                  op == EMcPathChangedByOpen &&

  1076                  data == EMcContainerOpened )

  1077             {

  1078             CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();

  1079             CleanupStack::PushL( cPath );

  1080             MPX_DEBUG2("CMPXMainViewImp::HandleCollectionMessageL - Path Changed By Open %i", cPath->Levels() );

  1081 #ifndef __ENABLE_PODCAST_IN_MUSIC_MENU

  1082             if( cPath->Levels() == 1 && iContainer )

  1083                 {

  1084                 iCurPlugin = KErrNotFound;

  1085                 iCollectionUtility->Collection().CancelRequest();

  1086                 iCollectionUtility->Collection().OpenL();

  1087                 }

  1088 #else // __ENABLE_PODCAST_IN_MUSIC_MENU

  1089             if( cPath->Levels() == 2 ) // Music menu

  1090                 {

  1091                 DoRetrieveDetailsL();

  1092                 }

  1093 #endif // __ENABLE_PODCAST_IN_MUSIC_MENU

  1094 

  1095             CleanupStack::PopAndDestroy( cPath );

  1096             }

  1097         else if( event == TMPXCollectionMessage::EFocusChanged &&

  1098                  iContainer )

  1099             {

  1100             TInt offset = iShowPlaybackIndicator ? 1 : 0;

  1101             iContainer->ListBox()->SetCurrentItemIndex( data + offset );

  1102             }

  1103         else if ( event == TMPXCollectionMessage::ECollectionChanged &&

  1104                   iContainer && iPathCorrupted)

  1105             {

  1106             MPX_DEBUG1("CMPXMainViewImp::HandleCollectionMessageL -- Collection changed and Levels 1");

  1107             CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL();

  1108             CleanupStack::PushL( cPath );

  1109             if( cPath->Levels() == 1 )

  1110                 {

  1111                 iCurPlugin = KErrNotFound;

  1112                 iCollectionUtility->Collection().CancelRequest();

  1113                 iCollectionUtility->Collection().OpenL();

  1114                 iPathCorrupted = EFalse;

  1115                 }

  1116             CleanupStack::PopAndDestroy( cPath );

  1117             }

  1118         }

  1119     else if( KMPXMessageIdItemChanged == id )

  1120         {

  1121         // Loop through messages for arrays.

  1122         //

  1123         if (aMessage.IsSupported(KMPXMessageArrayContents))

  1124             {

  1125             const CMPXMessageArray* messageArray =

  1126                         aMessage.Value<CMPXMessageArray>(KMPXMessageArrayContents);

  1127             User::LeaveIfNull(const_cast<CMPXMessageArray*>(messageArray));

  1128             

  1129             for( TInt i=0; i<messageArray->Count(); ++i )

  1130                   {

  1131                   HandleCollectionMessage( (*messageArray)[i], KErrNone );

  1132                   }

  1133             }

  1134         // Single item

  1135         else