/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Music Player metadata editor dialog implementation

*

*/

// INCLUDE FILES

#include <eikmenub.h>

#include <eikcapc.h>

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

#include <eikedwin.h> // for edwins

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

#include <AknPopupFieldText.h>

#include <AknQueryValueText.h>

#include <aknappui.h>

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

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

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

#include <aknnavi.h>

#include <aknnavide.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <aknlists.h>

#include <aknclearer.h>

#include <hlplch.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <drmrightsmanager.rsg>

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

#include <tz.h>

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include <mplayersecondarydisplayapi.h>

#include <aknEditStateIndicator.h>

#include <AknIndicatorContainer.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <mpxmetadataeditordialog.rsg>

#include <mpxcollectionutility.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxpodcastdefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionframeworkdefs.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionplaylist.h>

#include <mpxconstants.h>

#include <mpxcollectionhelperfactory.h>

#include <mpxcollectionplugin.hrh>

#include <mpxinternalcrkeys.h>

#include <mpxuser.h>

#include "mpxcommonuihelper.h"

#include "mpxmetadataeditordialog.h"

#include "mpxmetadataeditordialog.hrh"

#include "mpxmetadataeditordialog.hlp.hrh"

#include "mpxlog.h"

// CONSTANTS

const TInt KMPXFileDetailsMaxTitleLen = 32;

const TInt KMPXFileDetailsMaxBufferLen = 255;

const TInt KMPXMinNumDateTrack = 0;

const TInt KMPXFileDetailsExtraBufferLen = 10;

const TInt KMPXMaxTimeLength = 36;

const TInt KMPXMaxVal = 512;

const TInt KMPXOneDigit = 10;

const TInt KMPXTwoDigits = 100;

const TInt KMPXBitrateFactor = 1000;

const TInt KSecondInMilliseconds = 1000;

const TInt KOneHourInSeconds = 3600;

const TInt KDigitFive = 5;

const TInt KDigitNine = 9;

const TInt KDigitTen = 10;

const TInt KDigitEleven = 11;

const TInt KDigitFourTeen = 14;

const TInt KDigitHundred = 100;

const TInt KMaxDaysInOneMonths = 31;

const TInt KMaxDaysInTwoMonths = 62;

const TInt KMaxDaysInThreeMonths = 92;

const TInt KMaxDaysInFourMonths = 123;

const TInt KMaxDaysInFiveMonths = 153;

const TInt KMaxDaysInSixMonths = 184;

const TInt KMaxDaysInSevenMonths= 215;

const TInt KMaxDaysInEightMonths = 245;

const TInt KMaxDaysInNineMonths = 276;

const TInt KMaxDaysInTenMonths = 306;

const TInt KMaxDaysInElevenMonths = 337;

const TInt KMaxDaysInTwelveMonths = 366;

// MACROS

_LIT( KMPXMetadataEditorRscPath, "mpxmetadataeditordialog.rsc" );

_LIT( KMPXDrmManagerRscPath, "drmrightsmanager.rsc" );

_LIT( KMPXSpace, " ");

const TInt KMPXDurationDisplayResvLen( 10 );

const TInt64 KSecondInMicroSeconds( 1000000 );

// FUNCTION PROTOTYPES

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

// ----------------------------------------------------------------------------

// CMPXQueryDialog::NewL

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

CMPXQueryDialog* CMPXQueryDialog::NewL()

    {

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

    return self;

    }

// ----------------------------------------------------------------------------

// CMPXQueryDialog::OfferKeyEventL

// Keyevent handler.

// ----------------------------------------------------------------------------

//

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

    {

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

    // application key and end key

    if (( aKeyEvent.iScanCode == EStdKeyNo ||

        aKeyEvent.iScanCode == EStdKeyApplication0  &&

        aType == EEventKey ) ||

        ( aKeyEvent.iScanCode == EStdKeyApplication6  &&

        aType == EEventKeyDown ))

        {

        TryExitL(EEikBidCancel);

        return EKeyWasNotConsumed;

        }

    else

        {

        return CAknQueryDialog::OfferKeyEventL( aKeyEvent,aType );

        }

    }

// ----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::NewL

// Two-phased constructor.

// ----------------------------------------------------------------------------

//

EXPORT_C CMPXMetadataEditorDialog* CMPXMetadataEditorDialog::NewL()

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::NewL" );

    CMPXMetadataEditorDialog* self =

          new (ELeave) CMPXMetadataEditorDialog();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog

// Destructor.

// ----------------------------------------------------------------------------

//

EXPORT_C CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog()

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::~CMPXMetadataEditorDialog" );

    delete iEmptyNaviDecorator;

    delete iTitlePaneText;

    delete iCommonUiHelper;

    delete iParam;

    delete iIdle;

    delete iDrmInfo;

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iCollectionUiHelper )

        {

        iCollectionUiHelper->Close();

        }

    if ( iMedia )

        {

        delete iMedia;

        }

    if ( iTextValues )

        {

        delete iTextValues;

        }

    if ( iValueTextArray )

        {

        delete iValueTextArray;

        }

    if ( iGenreArr )

        {

        delete iGenreArr;

        }

    if ( iLibraryTextValues )

        {

        delete iLibraryTextValues;

        }

    if ( iLibraryValueTextArray )

        {

        delete iLibraryValueTextArray;

        }

    if ( iLibraryArr )

        {

        delete iLibraryArr;

        }

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    if ( iDrmResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iDrmResourceOffset );

        }

    }

// ----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::SetParamL

// parameter passed in from viewframework

// ----------------------------------------------------------------------------

//

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

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::SetParamL" );

    delete iParam;

    iParam = NULL;

    iParam = aParam->AllocL();

    }

// -----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::OkToExitL

// This function ALWAYS returns ETrue

// -----------------------------------------------------------------------------

//

TBool CMPXMetadataEditorDialog::OkToExitL(TInt aButtonId)

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::OkToExitL" );

    TBool res = EFalse;

    switch ( aButtonId )

        {

        case EAknSoftkeyDone:

            {

            SaveFormDataL();

            RestoreNaviLabelL();

            RestoreTitlePaneL();

            res = ETrue;

            break;

            }

        case EAknSoftkeyExit:

            {

            RestoreNaviLabelL();

            RestoreTitlePaneL();

            res = ETrue;

            break;

            }

        case EAknSoftkeyOptions:

        default:

            {

            // display the options menu

            res = CAknForm::OkToExitL( aButtonId );

            break;

            }

        }

    return res;

    }

// -----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::ExecuteLD

// -----------------------------------------------------------------------------

//

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

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::ExecuteLD" );

    TInt resId = R_MPX_CUI_SONG_DETAILS_DIALOG;

    if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

        {

        resId = R_MPX_CUI_PODCAST_DETAILS_DIALOG;

        }

    else if( iDisablePodcasting )

        {

        resId = R_MPX_CUI_SONG_DETAILS_DIALOG_NO_MOVE_LIBRARY;

        }

    return CAknForm::ExecuteLD( resId );

    }

// -----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::ViewFileDetailsPopupL

// Display file details popup window

// -----------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::ViewFileDetailsPopupL()

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::ViewFileDetailsPopupL" );

    CAknDoublePopupMenuStyleListBox* listBox =

        new (ELeave) CAknDoublePopupMenuStyleListBox();

    CleanupStack::PushL( listBox );

    CAknPopupList* popupList = CAknPopupList::NewL(

                                listBox,

                                R_AVKON_SOFTKEYS_OK_EMPTY,

                                AknPopupLayouts::EMenuDoubleWindow );

    CleanupStack::PushL( popupList );

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

    listBox->CreateScrollBarFrameL( ETrue );

    listBox->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto );

    // Enable Marquee

    static_cast<CEikFormattedCellListBox*>

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

    // Retrieve heading array

    CDesCArrayFlat* headingsArray = NULL;

    TInt itemCount = 0;

    if ( iCurrentLibrary == EMPXMetadataEditorDlgCollection )

        {

        headingsArray = iCoeEnv->ReadDesCArrayResourceL(

            R_MPX_CUI_FD_HEADINGS_SONGS );

        itemCount = EMPXSongsFileDetailsHeadingCount;

        }

    else if ( iCurrentLibrary == EMPXMetadataEditorDlgPodcast )

        {

        headingsArray = iCoeEnv->ReadDesCArrayResourceL(

            R_MPX_CUI_FD_HEADINGS_PODCASTS );

        itemCount = EMPXPodcastsFileDetailsHeadingCount;

        }

    else

        {

        User::Leave( KErrArgument );

        }

    CleanupStack::PushL( headingsArray );

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

    CDesCArray* itemArray =

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

    CDesCArrayFlat* dataArray =

        new ( ELeave ) CDesCArrayFlat( itemCount );

    CleanupStack::PushL( dataArray );

    if ( iMedia )

        {

        PopulateFileDetailsL( headingsArray, dataArray );

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

        // DRM content details

        itemCount = headingsArray->MdcaCount();

        }

    else

        {

        // properties not available

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

            {

            dataArray->AppendL( KNullDesC );

            }

        }

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

        {

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

        }

    CleanupStack::PopAndDestroy( dataArray );

    CleanupStack::PopAndDestroy( clearer );

    CleanupStack::PopAndDestroy( headingsArray );

    // Set title

    TBuf<KMPXFileDetailsMaxTitleLen> title;

    iCoeEnv->ReadResourceL( title, R_MPX_CUI_FD_TITLE );

    popupList->SetTitleL( title );

    // Show popup list

    popupList->ExecuteLD();

    CleanupStack::Pop();

    CleanupStack::PopAndDestroy( listBox );

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver

// Handle collection message.

// ---------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::HandleCollectionMessage(

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

    {

    // do nothing

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver

// Handles the collection entries being opened. Typically called

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

// ---------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::HandleOpenL(

    const CMPXMedia& /*aEntries*/,

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

    {

    // do nothing

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver

// Handles the item being opened. Typically called

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

// 'playing' the item via the playlist

// ---------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::HandleOpenL(

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

    {

    // do nothing

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver

// Handle media properties.

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

// ---------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::HandleCollectionMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::HandleCollectionMediaL" );

    TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );

    }

// ----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::CMPXMetadataEditorDialog

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

// might leave.

// ----------------------------------------------------------------------------

//

CMPXMetadataEditorDialog::CMPXMetadataEditorDialog()

    {

    // do nothing

    }

// ----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::ConstructL

// Symbian 2nd phase constructor can leave.

// ----------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::ConstructL()

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::ConstructL" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

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

    TFileName drmResourceFile( parse.FullName() );

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

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

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

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

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

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    CAknForm::ConstructL( R_MPX_CUI_SONG_DETAILS_MENUBAR );

    iCurrentLibrary = EMPXMetadataEditorDlgCollection;

    // check if it's podcast collection

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

    CleanupStack::PushL( cpath );

    if ( cpath->Levels() > 0 )

        {

        RArray<TUid> ary;

        CleanupClosePushL( ary );

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

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

        CleanupStack::PopAndDestroy( &ary );

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

            {

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

            iCurrentLibrary = EMPXMetadataEditorDlgPodcast;

            }

        }

    iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL();

    CleanupStack::PopAndDestroy( cpath );

    // Get podcasting key

    TInt val(0);

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

    repository->Get( KMPXMPLocalVariation, val );

    iDisablePodcasting = val&KMPXDisablePodcastingOption ? ETrue : EFalse;

    delete repository;

    }

// -----------------------------------------------------------------------------

// CMPXMetadataEditorDialog::CleanUpGenreText

// Clean up function for genre related members.

// -----------------------------------------------------------------------------

//

void CMPXMetadataEditorDialog::CleanUpGenreText()

    {

    MPX_FUNC( "CMPXMetadataEditorDialog::CleanUpGenreText" );

    if ( iGenreArr )

        {