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:  Music Player metadata editor dialog implementation

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <eikmenub.h>

    21 #include <eikcapc.h>

    22 #include <eikdialg.h> // for dialog functions

    23 #include <eikedwin.h> // for edwins

    24 #include <eikmfne.h>  // for number editor

    25 #include <AknPopupFieldText.h>

    26 #include <AknQueryValueText.h>

    27 #include <aknappui.h>

    28 #include <eikspane.h> // for status pane update/restore

    29 #include <akntitle.h> // for title pane

    30 #include <aknnavilabel.h> // for navi label

    31 #include <aknnavi.h>

    32 #include <aknnavide.h>

    33 #include <StringLoader.h>

    34 #include <aknnotewrappers.h>

    35 #include <aknlists.h>

    36 #include <aknclearer.h>

    37 #include <hlplch.h>

    38 #include <bautils.h>

    39 #include <data_caging_path_literals.hrh>

    40 #include <drmrightsmanager.rsg>

    41 #include <centralrepository.h> // for podcasting cenrep key

    42 #include <tz.h>

    43 

    44 #include <aknSDData.h>

    45 #include <AknMediatorFacade.h>

    46 #include <mplayersecondarydisplayapi.h>

    47 #include <aknEditStateIndicator.h>

    48 #include <AknIndicatorContainer.h>

    49 #include <avkon.hrh>

    50 #include <avkon.rsg>

    51 #include <mpxmetadataeditordialog.rsg>

    52 #include <mpxcollectionutility.h>

    53 #include <mpxmedia.h>

    54 #include <mpxmediaarray.h>

    55 #include <mpxmediamusicdefs.h>

    56 #include <mpxmediaaudiodefs.h>

    57 #include <mpxmediacontainerdefs.h>

    58 #include <mpxmediadrmdefs.h>

    59 #include <mpxpodcastdefs.h>

    60 #include <mpxcommandgeneraldefs.h>

    61 #include <mpxcollectioncommanddefs.h>

    62 

    63 #include <mpxcollectionframeworkdefs.h>

    64 #include <mpxcollectionmessage.h>

    65 #include <mpxcollectionpath.h>

    66 #include <mpxcollectionplaylist.h>

    67 #include <mpxconstants.h>

    68 #include <mpxcollectionhelperfactory.h>

    69 #include <mpxcollectionplugin.hrh>

    70 #include <mpxinternalcrkeys.h>

    71 #include <mpxuser.h>

    72 #include "mpxcommonuihelper.h"

    73 #include "mpxmetadataeditordialog.h"

    74 #include "mpxmetadataeditordialog.hrh"

    75 #include "mpxmetadataeditordialog.hlp.hrh"

    76 #include "mpxlog.h"

    77 

    78 // CONSTANTS

    79 const TInt KMPXFileDetailsMaxTitleLen = 32;

    80 const TInt KMPXFileDetailsMaxBufferLen = 255;

    81 const TInt KMPXMinNumDateTrack = 0;

    82 const TInt KMPXFileDetailsExtraBufferLen = 10;

    83 

    84 const TInt KMPXMaxTimeLength = 36;

    85 const TInt KMPXMaxVal = 512;

    86 const TInt KMPXOneDigit = 10;

    87 const TInt KMPXTwoDigits = 100;

    88 

    89 const TInt KMPXBitrateFactor = 1000;

    90 const TInt KSecondInMilliseconds = 1000;

    91 const TInt KOneHourInSeconds = 3600;

    92 

    93 

    94 

    95 const TInt KDigitFive = 5;

    96 const TInt KDigitNine = 9;

    97 const TInt KDigitTen = 10;

    98 const TInt KDigitEleven = 11;

    99 const TInt KDigitFourTeen = 14;

   100 const TInt KDigitHundred = 100;

   101 

   102 const TInt KMaxDaysInOneMonths = 31;

   103 const TInt KMaxDaysInTwoMonths = 62;

   104 const TInt KMaxDaysInThreeMonths = 92;

   105 const TInt KMaxDaysInFourMonths = 123;

   106 const TInt KMaxDaysInFiveMonths = 153;

   107 const TInt KMaxDaysInSixMonths = 184;

   108 const TInt KMaxDaysInSevenMonths= 215;

   109 const TInt KMaxDaysInEightMonths = 245;

   110 const TInt KMaxDaysInNineMonths = 276;

   111 const TInt KMaxDaysInTenMonths = 306;

   112 const TInt KMaxDaysInElevenMonths = 337;

   113 const TInt KMaxDaysInTwelveMonths = 366;

   114 

   115 // MACROS

   116 _LIT( KMPXMetadataEditorRscPath, "mpxmetadataeditordialog.rsc" );

   117 _LIT( KMPXDrmManagerRscPath, "drmrightsmanager.rsc" );

   118 _LIT( KMPXSpace, " ");

   119 

   120 const TInt KMPXDurationDisplayResvLen( 10 );

   121 const TInt64 KSecondInMicroSeconds( 1000000 );

   122 

   123 // FUNCTION PROTOTYPES

   124 

   125 // ============================ MEMBER FUNCTIONS ===============================

   126 

   127 // ----------------------------------------------------------------------------

   128 // CMPXQueryDialog::NewL

   129 // Two-phased constructor.

   130 // ----------------------------------------------------------------------------

   131 //

   132 CMPXQueryDialog* CMPXQueryDialog::NewL()

   133     {

   134     CMPXQueryDialog* self = new (ELeave) CMPXQueryDialog();

   135     return self;

   136     }

   137 

   138 // ----------------------------------------------------------------------------

   139 // CMPXQueryDialog::OfferKeyEventL

   140 // Keyevent handler.

   141 // ----------------------------------------------------------------------------

   142 //

   143 TKeyResponse CMPXQueryDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

   144     {

   145     // exit from query dialog whever lost forground, currently implementing by mornitor

   146     // application key and end key

   147     if (( aKeyEvent.iScanCode == EStdKeyNo ||

   148         aKeyEvent.iScanCode == EStdKeyApplication0  &&

   149         aType == EEventKey ) ||

   150         ( aKeyEvent.iScanCode == EStdKeyApplication6  &&

   151         aType == EEventKeyDown ))

   152         {

   153         TryExitL(EEikBidCancel);

   154         return EKeyWasNotConsumed;

   155         }

   156     else

   157         {

   158         return CAknQueryDialog::OfferKeyEventL( aKeyEvent,aType );

   159         }

   160     }

   161 

   162 // ----------------------------------------------------------------------------

   163 // CMPXMetadataEditorDialog::NewL

   164 // Two-phased constructor.

   165 // ----------------------------------------------------------------------------

   166 //

   167 EXPORT_C CMPXMetadataEditorDialog* CMPXMetadataEditorDialog::NewL()

   168     {

   169     MPX_FUNC( "CMPXMetadataEditorDialog::NewL" );

   170     CMPXMetadataEditorDialog* self =

   171           new (ELeave) CMPXMetadataEditorDialog();

   172     CleanupStack::PushL(self);

   173     self->ConstructL();

   174     CleanupStack::Pop();

   175     return self;

   176     }

   177 

   178 // ----------------------------------------------------------------------------

   179 // CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog

   180 // Destructor.

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

   182 //

   183 EXPORT_C CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog()

   184     {

   185     MPX_FUNC( "CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog" );

   186     delete iEmptyNaviDecorator;

   187     delete iTitlePaneText;

   188     delete iCommonUiHelper;

   189     delete iParam;

   190     delete iIdle;

   191     delete iDrmInfo;

   192     if ( iCollectionUtility )

   193         {

   194         iCollectionUtility->Close();

   195         }

   196     if ( iCollectionUiHelper )

   197         {

   198         iCollectionUiHelper->Close();

   199         }

   200     if ( iMedia )

   201         {

   202         delete iMedia;

   203         }

   204     if ( iTextValues )

   205         {

   206         delete iTextValues;

   207         }

   208     if ( iValueTextArray )

   209         {

   210         delete iValueTextArray;

   211         }

   212     if ( iGenreArr )

   213         {

   214         delete iGenreArr;

   215         }

   216     if ( iLibraryTextValues )

   217         {

   218         delete iLibraryTextValues;

   219         }

   220     if ( iLibraryValueTextArray )

   221         {

   222         delete iLibraryValueTextArray;

   223         }

   224     if ( iLibraryArr )

   225         {

   226         delete iLibraryArr;

   227         }

   228     if ( iResourceOffset )

   229         {

   230         iEikonEnv->DeleteResourceFile( iResourceOffset );

   231         }

   232     if ( iDrmResourceOffset )

   233         {

   234         iEikonEnv->DeleteResourceFile( iDrmResourceOffset );

   235         }

   236     }

   237 

   238 // ----------------------------------------------------------------------------

   239 // CMPXMetadataEditorDialog::SetParamL

   240 // parameter passed in from viewframework

   241 // ----------------------------------------------------------------------------

   242 //

   243 EXPORT_C void CMPXMetadataEditorDialog::SetParamL( const TDesC* aParam )

   244     {

   245     MPX_FUNC( "CMPXMetadataEditorDialog::SetParamL" );

   246     delete iParam;

   247     iParam = NULL;

   248     iParam = aParam->AllocL();

   249     }

   250 

   251 // -----------------------------------------------------------------------------

   252 // CMPXMetadataEditorDialog::OkToExitL

   253 // This function ALWAYS returns ETrue

   254 // -----------------------------------------------------------------------------

   255 //

   256 TBool CMPXMetadataEditorDialog::OkToExitL(TInt aButtonId)

   257     {

   258     MPX_FUNC( "CMPXMetadataEditorDialog::OkToExitL" );

   259     TBool res = EFalse;

   260 

   261     switch ( aButtonId )

   262         {

   263         case EAknSoftkeyDone:

   264             {

   265             SaveFormDataL();

   266             RestoreNaviLabelL();

   267             RestoreTitlePaneL();

   268             res = ETrue;

   269             break;

   270             }

   271         case EAknSoftkeyExit:

   272             {

   273             RestoreNaviLabelL();

   274             RestoreTitlePaneL();

   275             res = ETrue;

   276             break;

   277             }

   278         case EAknSoftkeyOptions:

   279         default:

   280             {

   281             // display the options menu

   282             res = CAknForm::OkToExitL( aButtonId );

   283             break;

   284             }

   285         }

   286     return res;

   287     }

   288 

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

   290 // CMPXMetadataEditorDialog::ExecuteLD

   291 // -----------------------------------------------------------------------------

   292 //

   293 TInt CMPXMetadataEditorDialog::ExecuteLD( TInt /*aResourceId*/ )

   294     {

   295     MPX_FUNC( "CMPXMetadataEditorDialog::ExecuteLD" );

   296     TInt resId = R_MPX_CUI_SONG_DETAILS_DIALOG;

   297     if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

   298         {

   299         resId = R_MPX_CUI_PODCAST_DETAILS_DIALOG;

   300         }

   301     else if( iDisablePodcasting )

   302         {

   303         resId = R_MPX_CUI_SONG_DETAILS_DIALOG_NO_MOVE_LIBRARY;

   304         }

   305     return CAknForm::ExecuteLD( resId );

   306     }

   307 

   308 // -----------------------------------------------------------------------------

   309 // CMPXMetadataEditorDialog::ViewFileDetailsPopupL

   310 // Display file details popup window

   311 // -----------------------------------------------------------------------------

   312 //

   313 void CMPXMetadataEditorDialog::ViewFileDetailsPopupL()

   314     {

   315     MPX_FUNC( "CMPXMetadataEditorDialog::ViewFileDetailsPopupL" );

   316     CAknDoublePopupMenuStyleListBox* listBox =

   317         new (ELeave) CAknDoublePopupMenuStyleListBox();

   318     CleanupStack::PushL( listBox );

   319     CAknPopupList* popupList = CAknPopupList::NewL(

   320                                 listBox,

   321                                 R_AVKON_SOFTKEYS_OK_EMPTY,

   322                                 AknPopupLayouts::EMenuDoubleWindow );

   323     CleanupStack::PushL( popupList );

   324 

   325     listBox->ConstructL( popupList, CEikListBox::ELeftDownInViewRect );

   326     listBox->CreateScrollBarFrameL( ETrue );

   327     listBox->ScrollBarFrame()->SetScrollBarVisibilityL(

   328         CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

   329 

   330     // Enable Marquee

   331     static_cast<CEikFormattedCellListBox*>

   332         ( listBox )->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

   333 

   334     // Retrieve heading array

   335     CDesCArrayFlat* headingsArray = NULL;

   336     TInt itemCount = 0;

   337     if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )

   338         {

   339         headingsArray = iCoeEnv->ReadDesCArrayResourceL(

   340             R_MPX_CUI_FD_HEADINGS_SONGS );

   341         itemCount = EMPXSongsFileDetailsHeadingCount;

   342         }

   343     else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

   344         {

   345         headingsArray = iCoeEnv->ReadDesCArrayResourceL(

   346             R_MPX_CUI_FD_HEADINGS_PODCASTS );

   347         itemCount = EMPXPodcastsFileDetailsHeadingCount;

   348         }

   349     else

   350         {

   351         User::Leave( KErrArgument );

   352         }

   353     CleanupStack::PushL( headingsArray );

   354 

   355     CAknLocalScreenClearer* clearer = CAknLocalScreenClearer::NewLC( EFalse );

   356     CDesCArray* itemArray =

   357         static_cast<CDesCArray*>( listBox->Model()->ItemTextArray() );

   358     CDesCArrayFlat* dataArray =

   359         new ( ELeave ) CDesCArrayFlat( itemCount );

   360     CleanupStack::PushL( dataArray );

   361 

   362     if ( iMedia )

   363         {

   364         PopulateFileDetailsL( headingsArray, dataArray );

   365         // item count might have been updated due to addition of

   366         // DRM content details

   367         itemCount = headingsArray->MdcaCount();

   368         }

   369     else

   370         {

   371         // properties not available

   372         for ( TInt i = 0; i < itemCount; i++ )

   373             {

   374             dataArray->AppendL( KNullDesC );

   375             }

   376         }

   377 

   378     for ( TInt i = 0; i < itemCount; i++ )

   379         {

   380         AddItemToListBoxL( headingsArray->MdcaPoint( i ), dataArray->MdcaPoint( i ), itemArray );

   381         }

   382     CleanupStack::PopAndDestroy( dataArray );

   383     CleanupStack::PopAndDestroy( clearer );

   384     CleanupStack::PopAndDestroy( headingsArray );

   385 

   386     // Set title

   387     TBuf<KMPXFileDetailsMaxTitleLen> title;

   388     iCoeEnv->ReadResourceL( title, R_MPX_CUI_FD_TITLE );

   389     popupList->SetTitleL( title );

   390 

   391     // Show popup list

   392     popupList->ExecuteLD();

   393     CleanupStack::Pop();

   394     CleanupStack::PopAndDestroy( listBox );

   395     }

   396 

   397 // ---------------------------------------------------------------------------

   398 // From MMPXCollectionObserver

   399 // Handle collection message.

   400 // ---------------------------------------------------------------------------

   401 //

   402 void CMPXMetadataEditorDialog::HandleCollectionMessage(

   403     CMPXMessage* /*aMessage*/, TInt /*aError*/ )

   404     {

   405     // do nothing

   406     }

   407 

   408 // ---------------------------------------------------------------------------

   409 // From MMPXCollectionObserver

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

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

   412 // ---------------------------------------------------------------------------

   413 //

   414 void CMPXMetadataEditorDialog::HandleOpenL(

   415     const CMPXMedia& /*aEntries*/,

   416     TInt /*aIndex*/, TBool /*aComplete*/, TInt /*aError*/ )

   417     {

   418     // do nothing

   419     }

   420 

   421 // ---------------------------------------------------------------------------

   422 // From MMPXCollectionObserver

   423 // Handles the item being opened. Typically called

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

   425 // 'playing' the item via the playlist

   426 // ---------------------------------------------------------------------------

   427 //

   428 void CMPXMetadataEditorDialog::HandleOpenL(

   429     const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ )

   430     {

   431     // do nothing

   432     }

   433 

   434 // ---------------------------------------------------------------------------

   435 // From MMPXCollectionObserver

   436 // Handle media properties.

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

   438 // ---------------------------------------------------------------------------

   439 //

   440 void CMPXMetadataEditorDialog::HandleCollectionMediaL(

   441     const CMPXMedia& aMedia,

   442     TInt aError )

   443     {

   444     MPX_FUNC( "CMPXMetadataEditorDialog::HandleCollectionMediaL" );

   445     TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );

   446     }

   447 

   448 // ----------------------------------------------------------------------------

   449 // CMPXMetadataEditorDialog::CMPXMetadataEditorDialog

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

   451 // might leave.

   452 // ----------------------------------------------------------------------------

   453 //

   454 CMPXMetadataEditorDialog::CMPXMetadataEditorDialog()

   455     {

   456     // do nothing

   457     }

   458 

   459 // ----------------------------------------------------------------------------

   460 // CMPXMetadataEditorDialog::ConstructL

   461 // Symbian 2nd phase constructor can leave.

   462 // ----------------------------------------------------------------------------

   463 //

   464 void CMPXMetadataEditorDialog::ConstructL()

   465     {

   466     MPX_FUNC( "CMPXMetadataEditorDialog::ConstructL" );

   467 

   468     CCoeEnv* coeEnv = iEikonEnv;

   469     TParse parse;

   470     parse.Set( KMPXMetadataEditorRscPath, &KDC_APP_RESOURCE_DIR, NULL );

   471     TFileName resourceFile( parse.FullName() );

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

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

   474     iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

   475 

   476     parse.Set( KMPXDrmManagerRscPath, &KDC_APP_RESOURCE_DIR, NULL );

   477     TFileName drmResourceFile( parse.FullName() );

   478     User::LeaveIfError( MPXUser::CompleteWithDllPath( drmResourceFile ) );

   479     BaflUtils::NearestLanguageFile( coeEnv->FsSession(), drmResourceFile );

   480     TRAPD(drmResourceError,iDrmResourceOffset = coeEnv->AddResourceFileL( drmResourceFile ));

   481     iDrmDetails = (drmResourceError == KErrNone) ? ETrue: EFalse;

   482 

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

   484     iCommonUiHelper = CMPXCommonUiHelper::NewL();

   485 

   486     CAknForm::ConstructL( R_MPX_CUI_SONG_DETAILS_MENUBAR );

   487 

   488     iCurrentLibrary = EMPXMetadataEditorDlgCollection;

   489     // check if it's podcast collection

   490     CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();

   491     CleanupStack::PushL( cpath );

   492     if ( cpath->Levels() > 0 )

   493         {

   494         RArray<TUid> ary;

   495         CleanupClosePushL( ary );

   496         ary.AppendL( TUid::Uid(EMPXCollectionPluginPodCast) );

   497         TUid podcastUid = iCollectionUtility->CollectionIDL( ary.Array() );

   498         CleanupStack::PopAndDestroy( &ary );

   499 

   500         if ( cpath->Id( 0 ) == podcastUid.iUid )

   501             {

   502             MPX_DEBUG1( "CMPXMetadataEditorDialog::ConstructL Podcast collection" );

   503             iCurrentLibrary = EMPXMetadataEditorDlgPodcast;

   504             }

   505         }

   506     iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

   507     CleanupStack::PopAndDestroy( cpath );

   508 

   509     // Get podcasting key

   510     TInt val(0);

   511     CRepository* repository = CRepository::NewL( KCRUidMPXMPFeatures );

   512     repository->Get( KMPXMPLocalVariation, val );

   513     iDisablePodcasting = val&KMPXDisablePodcastingOption ? ETrue : EFalse;

   514     delete repository;

   515     }

   516 

   517 // -----------------------------------------------------------------------------

   518 // CMPXMetadataEditorDialog::CleanUpGenreText

   519 // Clean up function for genre related members.

   520 // -----------------------------------------------------------------------------

   521 //

   522 void CMPXMetadataEditorDialog::CleanUpGenreText()

   523     {

   524     MPX_FUNC( "CMPXMetadataEditorDialog::CleanUpGenreText" );

   525 

   526     if ( iGenreArr )

   527         {

   528         delete iGenreArr;

   529         iGenreArr = NULL;

   530         }

   531     if ( iValueTextArray )

   532         {

   533         delete iValueTextArray;

   534         iValueTextArray = NULL;

   535         }

   536     if ( iTextValues )

   537         {

   538         delete iTextValues;

   539         iTextValues = NULL;

   540         }

   541     }

   542 

   543 // -----------------------------------------------------------------------------

   544 // CMPXMetadataEditorDialog::FetchGenreL

   545 // Populates genre popup with genre list for tracks.

   546 // -----------------------------------------------------------------------------

   547 //

   548 void CMPXMetadataEditorDialog::FetchGenreL()

   549     {

   550     MPX_FUNC( "CMPXMetadataEditorDialog::FetchGenreL" );

   551     RArray<TMPXAttribute> attrs;

   552     CleanupClosePushL( attrs );

   553     attrs.Append( KMPXMediaGeneralTitle );

   554     CMPXMedia* criteria = CMPXMedia::NewL();

   555     CleanupStack::PushL( criteria );

   556     criteria->SetTObjectValueL<TUid>(

   557         KMPXMediaGeneralCollectionId, TUid::Uid( 0x101FFC3A ) );

   558     criteria->SetTObjectValueL<TMPXGeneralType>(

   559         KMPXMediaGeneralType, EMPXGroup );

   560     criteria->SetTObjectValueL<TMPXGeneralCategory>(

   561         KMPXMediaGeneralCategory, EMPXGenre );

   562     iCollectionUtility->Collection().FindAllL( *criteria, attrs.Array(), *this );

   563     CleanupStack::PopAndDestroy( criteria );

   564     CleanupStack::PopAndDestroy( &attrs );

   565     }

   566 

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

   568 // Handle media properties.

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

   570 //

   571 void CMPXMetadataEditorDialog::DoHandleMediaL(

   572     const CMPXMedia& aMedia,

   573     TInt aError )

   574     {

   575     MPX_FUNC( "CMPXMetadataEditorDialog::DoHandleMediaL" );

   576 

   577     if ( iCurrentMediaLOp == EMPXMetadataEditorGetSongInfo )

   578         {

   579         delete iMedia;

   580         iMedia = NULL;

   581         if ( aError == KErrNone )

   582             {

   583             iMedia = CMPXMedia::NewL( aMedia );

   584             // common for both music and podcast

   585             // Fetch the artist

   586 

   587             if ( iMedia->IsSupported( KMPXMediaDrmProtected ) )

   588                 {

   589                 iIsDrmProtected = iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected );

   590                 }

   591 

   592             SetControlTextL( EMPXMetadataEditorDlgCtrlIdArtist,

   593                 iMedia->ValueText( KMPXMediaMusicArtist ), KNullDesC );

   594 

   595             // Fetch the album

   596             SetControlTextL( EMPXMetadataEditorDlgCtrlIdAlbum,

   597                 iMedia->ValueText( KMPXMediaMusicAlbum ), KNullDesC );

   598 

   599             // Fetch the track number

   600             SetControlNumberL( EMPXMetadataEditorDlgCtrlIdTrackNumber,

   601                 iMedia->ValueText( KMPXMediaMusicAlbumTrack ),

   602                 KMPXSongDetailsTrackNumMin, KMPXSongDetailsTrackNumMax );

   603 

   604             // Fetch the year

   605             TInt64 year(0);

   606             if ( iMedia->IsSupported (KMPXMediaMusicYear ) )

   607                 {

   608                 year = iMedia->ValueTObjectL<TInt64>( KMPXMediaMusicYear );

   609                 }

   610             TTime yearTime( year);

   611             iYear = yearTime.DateTime().Year ( );

   612             HBufC* yearBuf = HBufC::NewLC ( KMPXMaxTimeLength );

   613             yearBuf->Des().AppendNum ( iYear );

   614             SetControlNumberL ( EMPXMetadataEditorDlgCtrlIdYear, *yearBuf,

   615                     KMPXSongDetailsYearMin, KMPXSongDetailsYearMax );

   616             CleanupStack::PopAndDestroy ( yearBuf );

   617 

   618             // Fetch genre

   619             FetchGenreL();

   620 

   621             // Fetch the comment

   622             SetControlTextL( EMPXMetadataEditorDlgCtrlIdComment,

   623                 iMedia->ValueText( KMPXMediaGeneralComment ), KNullDesC );

   624 

   625             // Fetch the song name

   626             TParsePtrC fileDetail( iMedia->ValueText( KMPXMediaGeneralUri ) );

   627             SetControlTextL( EMPXMetadataEditorDlgCtrlIdSongName,

   628                 iMedia->ValueText( KMPXMediaGeneralTitle ), fileDetail.Name() );

   629 

   630             if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )

   631                 {

   632                 // Fetch the composer

   633                 SetControlTextL( EMPXMetadataEditorDlgCtrlIdComposer,

   634                     iMedia->ValueText( KMPXMediaMusicComposer ), KNullDesC );

   635                 }

   636             DrawNow();

   637             }

   638         else

   639             {

   640             // if error getting metadata, exit editor

   641             iCommonUiHelper->HandleErrorL( aError );

   642             if ( iIdle )

   643                 {

   644                 iIdle->Cancel();

   645                 delete iIdle;

   646                 iIdle = NULL;

   647                 }

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

   649             iIdle->Start( TCallBack( CMPXMetadataEditorDialog::DeferredExitCallback, this ) );

   650             }

   651         }

   652     else if ( iCurrentMediaLOp == EMPXMetadataEditorGetDrmInfo )

   653         {

   654         delete iDrmInfo;

   655         iDrmInfo = NULL;

   656         if ( aError == KErrNone )

   657             {

   658             iDrmInfo = CMPXMedia::NewL( aMedia );

   659             }

   660         else

   661             {

   662             iDrmInfo = CMPXMedia::NewL();

   663             }

   664         if ( iIdle )

   665             {

   666             iIdle->Cancel();

   667             delete iIdle;

   668             iIdle = NULL;

   669             }

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

   671         iIdle->Start( TCallBack( CMPXMetadataEditorDialog::DeferredFileDetailsCallback, this ) );

   672         }

   673     else

   674         {

   675         // Should not reach here

   676         ASSERT( 0 );

   677         }

   678     iCurrentMediaLOp = EMPXMetadataEditorIdle;

   679     }

   680 

   681 // ----------------------------------------------------------------------------

   682 // CMPXMetadataEditorDialog::SaveFormDataL

   683 // Save form data.

   684 // ----------------------------------------------------------------------------

   685 //

   686 TBool CMPXMetadataEditorDialog::SaveFormDataL()

   687     {

   688     MPX_FUNC( "CMPXMetadataEditorDialog::SaveFormDataL" );

   689     if ( iMedia )

   690         {

   691         MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL Saving.." );

   692         CMPXMedia* media = CMPXMedia::NewL();

   693         CleanupStack::PushL( media );

   694 

   695         TBool changed = EFalse;

   696 

   697         // common to both music and podcast

   698         // update local copy of media as well because getting media prop is slow

   699         changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdSongName,

   700             media, KMPXMediaGeneralTitle );

   701 

   702         changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdArtist,

   703             media, KMPXMediaMusicArtist ) || changed;

   704 

   705         changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdAlbum,

   706             media, KMPXMediaMusicAlbum ) || changed;

   707 

   708         changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdTrackNumber,

   709             media, KMPXMediaMusicAlbumTrack ) || changed;

   710 

   711         changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdComment,

   712             media, KMPXMediaGeneralComment ) || changed;

   713 

   714         // special handling needed for year

   715         CCoeControl* coeControl = ControlOrNull( EMPXMetadataEditorDlgCtrlIdYear );

   716         if ( coeControl )

   717             {

   718             CEikNumberEditor* control = static_cast<CEikNumberEditor*>( coeControl );

   719             if ( control )

   720                 {

   721                 TInt num = control->Number();

   722                 if ( num != iYear )

   723                     {

   724                     MPX_DEBUG3( "CMPXMetadataEditorDialog::SaveFormDataL year changed from %d to %d", iYear, num );

   725                     TDateTime newYear;

   726                     newYear.Set( num, EJanuary, 0, 0, 0, 0, 0 );

   727                     TTime year( newYear );

   728                     iMedia->SetTObjectValueL<TInt64>(

   729                         KMPXMediaMusicYear, year.Int64() );

   730                     media->SetTObjectValueL<TInt64>(

   731                         KMPXMediaMusicYear, year.Int64() );

   732                     iYear = num;

   733                     changed = ETrue;

   734                     }

   735                 else

   736                     {

   737                     MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL year not changed" );

   738                     }

   739                 }

   740             }

   741 

   742         if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )

   743             {

   744             changed = UpdateMediaObjectWithControlL( EMPXMetadataEditorDlgCtrlIdComposer,

   745                 media, KMPXMediaMusicComposer ) || changed;

   746             }

   747         else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

   748             {

   749             // no special handling, all covered in common

   750             }

   751         if ( changed )

   752             {

   753             // save it back to collection engine

   754             SaveMediaPropertiesL( media );

   755             MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL Saved" );

   756             }

   757 #ifdef _DEBUG

   758         else

   759             {

   760             MPX_DEBUG1( "CMPXMetadataEditorDialog::SaveFormDataL All equal, not saved" );

   761             }

   762 #endif

   763         CleanupStack::PopAndDestroy( media );

   764         }

   765     return ETrue;

   766     }

   767 

   768 // ----------------------------------------------------------------------------

   769 // CMPXMetadataEditorDialog::DoNotSaveFormDataL

   770 // Does not save form data.

   771 // ----------------------------------------------------------------------------

   772 //

   773 void CMPXMetadataEditorDialog::DoNotSaveFormDataL()

   774     {

   775     // Do nothing

   776     }

   777 

   778 // -----------------------------------------------------------------------------

   779 // CMPXMetadataEditorDialog::SetTitlePane

   780 // Set Title Pane from descriptor.

   781 // -----------------------------------------------------------------------------

   782 //

   783 void CMPXMetadataEditorDialog::SetTitlePaneL()

   784     {

   785     MPX_FUNC( "CMPXMetadataEditorDialog::SetTitlePaneL" );

   786     // Saving the current title before it's overwritten

   787     CEikStatusPane* statusPane = iAvkonAppUi->StatusPane();

   788 

   789     iTitlePane =

   790         static_cast<CAknTitlePane*>

   791             ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

   792     const TDesC* text = iTitlePane->Text();

   793     iTitlePaneText = text->AllocL();

   794 

   795     HBufC* newText = NULL;

   796     if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )

   797         {

   798         newText = StringLoader::LoadLC( R_MPX_CUI_SONG_DETAILS_TITLE );

   799         }

   800     else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

   801         {

   802         newText = StringLoader::LoadLC( R_MPX_CUI_SONG_DETAILS_EPISODE );

   803         }

   804 

   805     // Update Title Pane

   806     if ( newText )

   807         {

   808         iTitlePane->SetTextL( *newText );

   809         }

   810     CleanupStack::PopAndDestroy( newText );

   811     }

   812 

   813 // -----------------------------------------------------------------------------

   814 // CMPXMetadataEditorDialog::RestoreTitlePane

   815 // Restore Title Pane from the member data.

   816 // -----------------------------------------------------------------------------

   817 //

   818 void CMPXMetadataEditorDialog::RestoreTitlePaneL()

   819     {

   820     MPX_FUNC( "CMPXMetadataEditorDialog::RestoreTitlePaneL" );

   821     // Update Title Pane

   822     iTitlePane->SetTextL( *iTitlePaneText );

   823     }

   824 

   825 // -----------------------------------------------------------------------------

   826 // CMPXMetadataEditorDialog::SetNaviLabelL

   827 // Set Navi Label from descriptor.

   828 // -----------------------------------------------------------------------------

   829 //

   830 void CMPXMetadataEditorDialog::SetNaviLabelL()

   831     {

   832     MPX_FUNC( "CMPXMetadataEditorDialog::SetNaviLabelL" );

   833     MAknEditingStateIndicator *editingStateIndicator = CAknEnv::Static()->EditingStateIndicator();

   834     CAknIndicatorContainer* indicContainerEditing = editingStateIndicator->IndicatorContainer();

   835     indicContainerEditing->SetIndicatorValueL( TUid::Uid( EAknNaviPaneEditorIndicatorMessageInfo), KNullDesC );

   836     // Saving the current title before it's overwritten

   837     CEikStatusPane* statusPane = iAvkonAppUi->StatusPane();

   838 

   839     iNaviPane = static_cast<CAknNavigationControlContainer*>

   840         ( statusPane->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

   841 

   842     // store the latest navi pane

   843     iNaviDecorator = iNaviPane->Top();

   844 

   845     // set the new navi label

   846     iEmptyNaviDecorator =

   847         iNaviPane->CreateNavigationLabelL(KNullDesC);

   848 

   849     iNaviPane->PushL( *iEmptyNaviDecorator );

   850     }

   851 

   852 // -----------------------------------------------------------------------------

   853 // CMPXMetadataEditorDialog::RestoreNaviLabelL

   854 // Restore Navi Label from the member data.

   855 // -----------------------------------------------------------------------------

   856 //

   857 void CMPXMetadataEditorDialog::RestoreNaviLabelL()

   858     {

   859     MPX_FUNC( "CMPXMetadataEditorDialog::RestoreNaviLabelL" );

   860     iNaviPane->Pop( iEmptyNaviDecorator ); // pop out the empty navi

   861     if ( iNaviDecorator )

   862         {

   863         iNaviPane->PushL( *iNaviDecorator );

   864         }

   865     }

   866 

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

   868 // CMPXMetadataEditorDialog::DynInitMenuPaneL

   869 // Dynamically initialises a menu pane.

   870 // (other items were commented in a header).

   871 // -----------------------------------------------------------------------------

   872 //

   873 void CMPXMetadataEditorDialog::DynInitMenuPaneL(

   874     TInt aResourceId,

   875     CEikMenuPane* aMenuPane)

   876     {

   877     MPX_FUNC( "CMPXMetadataEditorDialog::DynInitMenuPaneL" );

   878     CAknForm::DynInitMenuPaneL(aResourceId, aMenuPane);

   879 

   880     if ( aResourceId == R_AVKON_FORM_MENUPANE )

   881         {

   882         if ( ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdGenre ) ||

   883             ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary ) )

   884             {

   885             aMenuPane->SetItemDimmed( EMPXCmdSongDetailsChange, EFalse );

   886             }

   887         else

   888             {

   889             aMenuPane->SetItemDimmed( EMPXCmdSongDetailsChange, ETrue );

   890             }

   891         // Dim out the Avkon menu items

   892         aMenuPane->SetItemDimmed( EAknFormCmdEdit, ETrue );

   893         aMenuPane->SetItemDimmed( EAknFormCmdAdd, ETrue );

   894         aMenuPane->SetItemDimmed( EAknFormCmdSave, ETrue );

   895         aMenuPane->SetItemDimmed( EAknFormCmdLabel, ETrue );

   896         aMenuPane->SetItemDimmed( EAknFormCmdDelete, ETrue );

   897         }

   898     }

   899 

   900 // ----------------------------------------------------------------------------

   901 // CMPXMetadataEditorDialog::ProcessCommandL

   902 // Act on the menu selection if menu is showing.

   903 // ----------------------------------------------------------------------------

   904 //

   905 void CMPXMetadataEditorDialog::ProcessCommandL( TInt aCommandId )

   906     {

   907     MPX_FUNC( "CMPXMetadataEditorDialog::ProcessCommandL" );

   908     CAknForm::ProcessCommandL(aCommandId);

   909 

   910     switch (aCommandId)

   911         {

   912         case EMPXCmdSongDetailsChange:

   913             {

   914             if ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdGenre )

   915                 {

   916                 iPopup = static_cast<CAknPopupField*>

   917                     ( ControlOrNull( EMPXMetadataEditorDlgCtrlIdGenre ) );

   918                 }

   919             else if ( IdOfFocusControl() == EMPXMetadataEditorDlgCtrlIdLibrary )

   920                 {

   921                 iPopup = static_cast<CAknPopupField*>

   922                     ( ControlOrNull( EMPXMetadataEditorDlgCtrlIdLibrary ) );

   923                 }

   924             if ( iPopup )

   925                 {

   926                 iPopup->ActivateSelectionListL();

   927                 }

   928 

   929             break;

   930             }

   931         case EMPXCmdSongDetails:

   932             {

   933             if ( iIsDrmProtected && !iDrmInfo )

   934                 {

   935                 CMPXCollectionPath* cpath = iCollectionUtility->Collection().PathL();

   936                 CleanupStack::PushL( cpath );

   937                 if ( iParam )

   938                     {

   939                     TLex yearLex( iParam->Des() );

   940                     TInt lexToInt = NULL;

   941                     if ( yearLex.Val( lexToInt ) == KErrNone )

   942                         {

   943                         cpath->Set( lexToInt );

   944                         RArray<TMPXAttribute> attrs;

   945                         CleanupClosePushL(attrs);

   946                         attrs.Append( KMPXMediaGeneralUri );

   947                         attrs.Append( KMPXMediaDrmAll );

   948                         iCurrentMediaLOp = EMPXMetadataEditorGetDrmInfo;

   949                         iCollectionUtility->Collection().MediaL( *cpath, attrs.Array() );

   950                         CleanupStack::PopAndDestroy( &attrs );

   951                         }

   952                     }

   953                 CleanupStack::PopAndDestroy( cpath );

   954                 }

   955             else

   956                 {

   957                 if( iMedia )

   958                     {

   959                     ViewFileDetailsPopupL();

   960                     }

   961                 }

   962             break;

   963             }

   964         case EAknCmdHelp:

   965             {

   966             TCoeHelpContext helpContext;

   967             GetHelpContext( helpContext );

   968 

   969             CArrayFixFlat<TCoeHelpContext>* array =

   970                 new(ELeave)CArrayFixFlat<TCoeHelpContext>( 1 );

   971 

   972             CleanupStack::PushL( array );

   973             array->AppendL( helpContext );

   974             CleanupStack::Pop(); // array

   975 

   976             // HlpLauncher deletes array

   977             HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), array );

   978             break;

   979             }

   980         case EAknCmdExit:

   981             {

   982             static_cast<MEikCommandObserver*>(iEikonEnv->EikAppUi())->

   983                 ProcessCommandL(aCommandId);

   984             }

   985         default :

   986             break;

   987         }

   988     }

   989 

   990 // -----------------------------------------------------------------------------

   991 // CMPXMetadataEditorDialog::PopulateFileDetailsL

   992 // -----------------------------------------------------------------------------

   993 //

   994 void CMPXMetadataEditorDialog::PopulateFileDetailsL(

   995     CDesCArrayFlat* aHeadingsArray, CDesCArrayFlat* aDataArray )

   996     {

   997 

   998     MPX_FUNC( "CMPXMetadataEditorDialog::PopulateFileDetailsL" );

   999 

  1000     TBool drmProtected( iMedia->ValueTObjectL<TBool>( KMPXMediaDrmProtected ) );

  1001     MPX_DEBUG2( "CMPXMetadataEditorDialog::PopulateFileDetailsL drm protected: %d", drmProtected );

  1002 

  1003     if ( drmProtected )

  1004         {

  1005         MakeDrmItemsL( aHeadingsArray, aDataArray );

  1006         }

  1007 

  1008     // Get filename

  1009     const TDesC& uri = iMedia->ValueText( KMPXMediaGeneralUri );

  1010     TParsePtrC parse(uri);

  1011 

  1012     AppendStringToArrayL( aDataArray, parse.Name() );

  1013 

  1014     // Get mime type

  1015     const TDesC& mimeType = iMedia->ValueText( KMPXMediaGeneralMimeType );

  1016     AppendStringToArrayL( aDataArray, mimeType );

  1017 

  1018     // Get duration

  1019     TInt duration( iMedia->ValueTObjectL<TInt>( KMPXMediaGeneralDuration ) );

  1020     if ( duration > 0 )

  1021         {

  1022         // convert milliseconds to seconds

  1023         duration = duration / KSecondInMilliseconds;

  1024         CMPXCommonUiHelper::TMPXDuratDisplayMode durationMode =

  1025             CMPXCommonUiHelper::EMPXDuratAuto;

  1026         if ( duration > KOneHourInSeconds )

  1027             {

  1028             durationMode = CMPXCommonUiHelper::EMPXDuratHMS;

  1029             }

  1030         HBufC* stringBuf = iCommonUiHelper->DisplayableDurationL(

  1031             duration, durationMode );

  1032         CleanupStack::PushL( stringBuf );

  1033         aDataArray->AppendL( *stringBuf );

  1034         CleanupStack::PopAndDestroy( stringBuf );

  1035         }

  1036     else

  1037         {

  1038         aDataArray->AppendL( KNullDesC );

  1039         }

  1040 

  1041     // Get bitrate

  1042     TInt bitrate( iMedia->ValueTObjectL<TInt>( KMPXMediaAudioBitrate ) );

  1043     if ( bitrate > 0 )

  1044         {

  1045         // convert bitrate to kpbs

  1046         bitrate = bitrate / KMPXBitrateFactor;

  1047         HBufC* bitrateText = StringLoader::LoadLC(

  1048                         R_MPX_CUI_METADATAEDITOR_BITRATE_TXT, bitrate );

  1049         aDataArray->AppendL( bitrateText->Des() );

  1050         CleanupStack::PopAndDestroy( bitrateText );

  1051         }

  1052     else

  1053         {

  1054         aDataArray->AppendL( KNullDesC );

  1055         }

  1056 

  1057     // Get sampling rate

  1058     TInt samplingRateNum( ( TInt )iMedia->ValueTObjectL<TInt>( KMPXMediaAudioSamplerate ) );

  1059     if ( samplingRateNum > 0 )

  1060         {

  1061         HBufC* stringBuf = HBufC::NewLC( KMPXFileDetailsMaxBufferLen );

  1062         TPtr stringBufPtr = stringBuf->Des();

  1063         stringBufPtr.AppendNum( samplingRateNum );

  1064         HBufC* samplingrate = StringLoader::LoadLC(

  1065                         R_MPX_CUI_METADATAEDITOR_SAMPLINGRATE_TXT, stringBufPtr );

  1066         aDataArray->AppendL( samplingrate->Des() );

  1067         CleanupStack::PopAndDestroy( samplingrate );

  1068         CleanupStack::PopAndDestroy( stringBuf );

  1069         }

  1070     else

  1071         {

  1072         aDataArray->AppendL( KNullDesC );

  1073         }

  1074 

  1075     // Get size, not stored in collection, have to use RFile

  1076     //

  1077     RFs& fs = CEikonEnv::Static()->FsSession();

  1078     RFile file;

  1079     TInt sizeNum(0);

  1080     TInt err ( file.Open( fs, uri, EFileRead | EFileShareReadersOrWriters ) );

  1081     if ( err == KErrNone )

  1082         {

  1083         file.Size(sizeNum);

  1084         file.Close();

  1085         }

  1086 

  1087     if ( sizeNum > 0 )

  1088         {

  1089         HBufC* stringBuf = iCommonUiHelper->UnitConversionL( sizeNum );

  1090         CleanupStack::PushL( stringBuf );

  1091         aDataArray->AppendL( *stringBuf );

  1092         CleanupStack::PopAndDestroy( stringBuf );

  1093         }

  1094     else

  1095         {

  1096         aDataArray->AppendL( KNullDesC );

  1097         }

  1098 

  1099     if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

  1100         {

  1101         PopulatePodcastFileDetailsL( aHeadingsArray, aDataArray );

  1102         }

  1103 

  1104     // Get modified

  1105     if ( iMedia->IsSupported( KMPXMediaGeneralDate ) )

  1106         {

  1107         TInt64 timeInt( ( TInt64 )iMedia->ValueTObjectL<TInt64>(

  1108             KMPXMediaGeneralDate ) );

  1109         TTime time( timeInt );

  1110         ConvertToLocalTimeL(time);

  1111         HBufC* modDateTime = HBufC::NewLC(

  1112             KMPXMaxTimeLength + KMPXDurationDisplayResvLen );

  1113         HBufC* format = StringLoader::LoadLC(

  1114             R_QTN_DATE_USUAL_WITH_ZERO );

  1115         TPtr modDatePtr = modDateTime->Des();

  1116         MPX_TRAPD( err, time.FormatL( modDatePtr, *format ) );

  1117         CleanupStack::PopAndDestroy( format );

  1118         if (err != KErrNone)

  1119             {

  1120             aDataArray->AppendL( KNullDesC );

  1121             }

  1122         else

  1123             {

  1124             format = StringLoader::LoadLC(

  1125                 R_QTN_TIME_USUAL_WITH_ZERO );

  1126             HBufC* modTime = HBufC::NewLC(

  1127                 format->Length() + KMPXDurationDisplayResvLen );

  1128             TPtr modTimePtr = modTime->Des();

  1129             MPX_TRAPD( err, time.FormatL( modTimePtr, *format ) );

  1130             if ( err != KErrNone )

  1131                 {

  1132                 aDataArray->AppendL( KNullDesC );

  1133                 }

  1134             else