/*

* 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 album art editor dialog implementation

*

*/

// INCLUDE FILES

#include <akntitle.h>

#include <aknnavide.h>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include <aknViewAppUi.h>

#include <aknnavilabel.h>

#include <coeutils.h>

#include <hlplch.h>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionutility.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxcollectionpath.h>

#include <mpxalbumarteditordialog.rsg>

#include <mpxmessagegeneraldefs.h>

#include <mpxconstants.h>

#include <mpxlog.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxuser.h>

#include "mpxalbumartutil.h"

#include "mpxcommonuihelper.h"

#include "mpxalbumarteditordialog.hlp.hrh"

#include "mpxalbumarteditordialog.hrh"

#include "mpxalbumarteditordialogcustomcontrol.h"

#include "mpxalbumarteditorcustomcontrolcontainer.h"

#include "mpxalbumarteditordialogimagethumbnailutil.h"

#include "mpxalbumarteditordialog.h"

#include "mpxviewprivatepskeys.h"

// CONSTANTS

const TInt KMPXAlbumArtBorder = 24;

_LIT( KMPXAlubmArtEditorRscPath, "mpxalbumarteditordialog.rsc" );

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

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

// CMPXAlbumArtEditorDialog::NewL

// Two-phased constructor.

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

//

EXPORT_C CMPXAlbumArtEditorDialog* CMPXAlbumArtEditorDialog::NewL()

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::NewL" );

    CMPXAlbumArtEditorDialog* self =

        new ( ELeave ) CMPXAlbumArtEditorDialog();

    CleanupStack::PushL( self );

    self->ConstructL( R_MPX_CUI_ALBUM_ART_DIALOG_MENUBAR );

    CleanupStack::Pop( self );  // this, it will be PushL-d by executeLD...

    return self;

    }

// Destructor

EXPORT_C CMPXAlbumArtEditorDialog::~CMPXAlbumArtEditorDialog()

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::~CMPXAlbumArtEditorDialog" );

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    delete iCommonUiHelper;

    delete iOrigTitle;

    delete iNaviLabelPane;

    delete iMPXUtility;

    delete iParam;

    delete iMedia;

    delete iAlbumInfo;

    delete iMediaArray;

    delete iNewFileName;

    delete iAsyncCallNext;

    }

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

// CMPXAlbumArtEditorDialog::OfferKeyEventL

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

//

TKeyResponse CMPXAlbumArtEditorDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,

                                         TEventCode aType)

	{

	if( iFetchingPicture )

		{

        // fix for ou1cimx1#176793

	    if ( aKeyEvent.iScanCode == EStdKeyEnter || aKeyEvent.iCode == EKeyEnter )

	        {

	        return EKeyWasConsumed;

	        }

		// When the fetcher is open ignore all key presses.

		// Needed to avoid closing of the dialog before the fetcher is closed.

		return EKeyWasNotConsumed;

        }

    //response enter key as select key

    if( aKeyEvent.iScanCode == EStdKeyEnter || aKeyEvent.iScanCode == EKeyEnter )

        {

        if( aType == EEventKeyUp )

            {

            DoProcessCommandL( EMPXCmdAlbumArtEditorDlgChange );

            }

        return EKeyWasConsumed;

        }

    return CAknDialog::OfferKeyEventL(aKeyEvent,aType);

	}

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

// CMPXAlbumArtEditorDialog::CMPXAlbumArtEditorDialog

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

// might leave.

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

//

CMPXAlbumArtEditorDialog::CMPXAlbumArtEditorDialog() :

    iNewFileName( NULL )

    {

    }

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

// CMPXAlbumArtEditorDialog::SetParamL

// parameter passed in from viewframework

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

//

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

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::SetParamL" );

    delete iParam;

    iParam = NULL;

    iParam = aParam->AllocL();

    }

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

// CMPXAlbumArtEditorDialog::ConstructL

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

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

//

void CMPXAlbumArtEditorDialog::ConstructL( TInt aResource )

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::ConstructL" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

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

    iMPXUtility = CMPXAlbumArtUtil::NewL();

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    CAknDialog::ConstructL( aResource );

    iAsyncCallNext = new ( ELeave ) CAsyncCallBack(

        TCallBack( CMPXAlbumArtEditorDialog::ExtractNextAlbumArtCallBackL, this ),

        CActive::EPriorityStandard );

    }

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

// From MMPXCollectionObserver

// Handle collection message.

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

//

void CMPXAlbumArtEditorDialog::HandleCollectionMessage(

    CMPXMessage* aMessage, TInt aError )

    {

    if ( aError == KErrNone && aMessage )

        {

        TRAP_IGNORE( DoHandleCollectionMessageL( *aMessage ) );

        }

    }

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

// From MMPXCollectionObserver

// Handles the collection entries being opened. Typically called

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

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

//

void CMPXAlbumArtEditorDialog::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 CMPXAlbumArtEditorDialog::HandleOpenL(

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

    {

    // do nothing

    }

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

// From MMPXCollectionObserver

// Handle collection media.

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

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

//

void CMPXAlbumArtEditorDialog::HandleCollectionMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::HandleCollectionMediaL" );

    if ( KErrNone == aError )

        {

        switch ( iCurrentMediaLOp )

            {

            case EMPXOpMediaLGetCurrentMode:

                {

                TMPXGeneralType type( aMedia.ValueTObjectL<TMPXGeneralType>(

                    KMPXMediaGeneralType ) );

                TMPXGeneralCategory category(

                    aMedia.ValueTObjectL<TMPXGeneralCategory>(

                        KMPXMediaGeneralCategory ) );

                if ( type != EMPXItem || category != EMPXSong )

                    {

                    delete iMedia;

                    iMedia = NULL;

                    iMedia = CMPXMedia::NewL();

                    TMPXItemId albumId( aMedia.ValueTObjectL<TMPXItemId>(

                        KMPXMediaGeneralId ) );

                    iMedia->SetTObjectValueL<TMPXItemId>(

                        KMPXMediaGeneralId,

                        albumId );

                    // not on tracks level, get container ID

                    iCurrentMediaLOp = EMPXOpMediaLGetContainerId;

                    CMPXCollectionPath* path( iCollectionUtility->Collection().PathL() );

                    CleanupStack::PushL( path );

                    path->Back();

                    RArray<TMPXAttribute> attrs;

                    CleanupClosePushL( attrs );

                    // get attributes as if it's tracks level so that we don't need to

                    // make another async call if that's the case.  if it's album level, those

                    // attributes are ignored

                    attrs.Append(

                        TMPXAttribute( KMPXMediaIdGeneral,

                        EMPXMediaGeneralId | EMPXMediaGeneralCategory ) );

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

                    CleanupStack::PopAndDestroy( &attrs );

                    CleanupStack::PopAndDestroy( path );

                    }

                else

                    {

                    delete iMedia;

                    iMedia = NULL;

                    iMedia = CMPXMedia::NewL( aMedia );

                    delete iAlbumInfo;

                    iAlbumInfo = NULL;

                    iAlbumInfo = CMPXMedia::NewL( aMedia );

                    const TDesC& albumArtFileName =

                        aMedia.ValueText( KMPXMediaMusicAlbumArtFileName );

                    MPX_DEBUG2( "CMPXAlbumArtEditorDialog::HandleCollectionMediaL album art file name = %S", &albumArtFileName );

                    const TDesC& origAlbumArtFileName =

                        aMedia.ValueText( KMPXMediaMusicOriginalAlbumArtFileName );

                    MPX_DEBUG2( "CMPXAlbumArtEditorDialog::HandleCollectionMediaL original album art file name = %S", &origAlbumArtFileName );

                    if ( albumArtFileName.Length() > 0 )

                        {

                        if ( albumArtFileName.Compare( origAlbumArtFileName ) == 0 )

                            {

                            iAlbumArtChanged = EFalse;

                            }

                        else

                            {

                            iAlbumArtChanged = ETrue;

                            }

                        }

                    ExtractAlbumArtL( aMedia );

                    iCurrentMediaLOp = EMPXOpMediaLIdle;

                    }

                // Navipane title should be the title of the artist/album/genre/composer or song/item

                //

                UpdateNaviPaneL(aMedia.ValueText(KMPXMediaGeneralTitle ));

                break;

                }

            case EMPXOpMediaLGetContainerId:

                {

                delete iAlbumInfo;

                iAlbumInfo = NULL;

                iAlbumInfo = CMPXMedia::NewL();

                TMPXGeneralCategory category(

                    aMedia.ValueTObjectL<TMPXGeneralCategory>(

                        KMPXMediaGeneralCategory ) );

                TMPXItemId albumId(

                    iMedia->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId ) );

                iAlbumInfo->SetTObjectValueL<TMPXItemId>(

                    KMPXMediaGeneralId, albumId );

                MPX_DEBUG2( "CMPXAlbumArtEditorDialog::HandleCollectionMediaL album id = 0x%x", albumId.iId1 );

                RArray<TMPXAttribute> attrs;

                CleanupClosePushL( attrs );

                AppendCommonAttributes( attrs );

                CMPXMedia* criteria = CMPXMedia::NewL();

                CleanupStack::PushL( criteria );

                criteria->SetTObjectValueL<TMPXGeneralType>(

                    KMPXMediaGeneralType, EMPXGroup );

                criteria->SetTObjectValueL<TMPXGeneralCategory>(

                    KMPXMediaGeneralCategory, EMPXSong );

                criteria->SetTObjectValueL<TMPXItemId>(

                    KMPXMediaGeneralId, albumId );

                if ( category == EMPXAlbum )

                    {

                    // in albums view

                    iAlbumArtMode = EMPXModeAlbumView;

                    }

                else

                    {

                    // in artist/albums view

                    iAlbumArtMode = EMPXModeArtistAlbumView;

                    TMPXItemId containerId( aMedia.ValueTObjectL<TMPXItemId>(

                        KMPXMediaGeneralId ) );

                    iAlbumInfo->SetTObjectValueL<TMPXItemId>(

                        KMPXMediaGeneralContainerId, containerId );

                    MPX_DEBUG2( "CMPXAlbumArtEditorDialog::HandleCollectionMediaL container id = 0x%x", containerId.iId1 );

                    criteria->SetTObjectValueL<TMPXItemId>(

                        KMPXMediaGeneralContainerId, containerId );

                    }

                iCurrentFindAllLOp = EMPXOpFindAllLGetAlbumArtInfo;

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

                CleanupStack::PopAndDestroy( criteria );

                CleanupStack::PopAndDestroy( &attrs );

                iCurrentMediaLOp = EMPXOpMediaLIdle;

                break;

                }

            case EMPXOpMediaLGetAlbumArtInfo:

                {

                delete iMedia;

                iMedia = NULL;

                iMedia = CMPXMedia::NewL( aMedia );

                const TDesC& albumArtFileName =

                    aMedia.ValueText( KMPXMediaMusicAlbumArtFileName );

                if ( albumArtFileName.Length() > 0 )

                    {

                    if ( albumArtFileName.Compare(

                        aMedia.ValueText( KMPXMediaMusicOriginalAlbumArtFileName ) ) == 0 )

                        {

                        iAlbumArtChanged = EFalse;

                        }

                    else

                        {

                        iAlbumArtChanged = ETrue;

                        }

                    }

                ExtractAlbumArtL( aMedia );

                iCurrentMediaLOp = EMPXOpMediaLIdle;

                break;

                }

            default:

                {

                iCurrentMediaLOp = EMPXOpMediaLIdle;

                break;

                }

            }

        }

    }

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

// CMPXAlbumArtEditorDialog::HandleCommandComplete

// Handle completion of async commands

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

//

void CMPXAlbumArtEditorDialog::HandleCommandComplete(CMPXCommand* /*aCommandResult*/,

                                                     TInt aError )

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::HandleCommandComplete" );

    MPX_DEBUG2( "CMPXAlbumArtEditorDialog::HandleCommandComplete aError = %d", aError );

    MPX_DEBUG1( "CMPXAlbumArtEditorDialog::HandleCommandComplete dismiss wait note" );

    if( !iInvalidFileExist )

        {

        TRAP_IGNORE( DoHandleOperationCompleteL( aError ) );

        }

    }

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

// CMPXAlbumArtEditorDialog::GetCurrentModeL

// Sends request to determine if it's album level or track level

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

//

void CMPXAlbumArtEditorDialog::GetCurrentModeL()

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::GetCurrentModeL" );

    iCurrentMediaLOp = EMPXOpMediaLGetCurrentMode;

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

    CleanupStack::PushL( path );

    if ( iParam )

        {

        TLex indexLex( iParam->Des() );

        TInt lexToInt = NULL;

        if ( indexLex.Val( lexToInt ) == KErrNone )

            {

            path->Set( lexToInt );

            }

        }

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    // get attributes as if it's tracks level so that we don't need to

    // make another async call if that's the case.  if it's album level, those

    // attributes are ignored

    AppendCommonAttributes( attrs );

    attrs.Append( KMPXMediaGeneralTitle );

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

    CleanupStack::PopAndDestroy( &attrs );

    CleanupStack::PopAndDestroy( path );

    }

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

// CMPXAlbumArtEditorDialog::BackupPreviousStatusPaneL

// Backs up Status Pane information.

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

//

void CMPXAlbumArtEditorDialog::BackupPreviousStatusPaneL()

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::BackupPreviousStatusPaneL" );

    CEikStatusPane* sp = iAvkonAppUi->StatusPane();

    // Create and Push navi lable

    iNaviPane = static_cast< CAknNavigationControlContainer* >

        ( sp->ControlL( TUid::Uid( EEikStatusPaneUidNavi ) ) );

    iNaviLabelPane = iNaviPane->CreateNavigationLabelL();

    iNaviPane->PushL( *iNaviLabelPane );

    // Backup title pane

    iTitlePane = static_cast< CAknTitlePane* >

        ( sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    iOrigTitle = iTitlePane->Text()->AllocL();

    }

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

// CMPXAlbumArtEditorDialog::RestorePreviousStatusPaneL()

// Restores previous status pane.

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

//

void CMPXAlbumArtEditorDialog::RestorePreviousStatusPaneL()

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::RestorePreviousStatusPaneL" );

    if ( iOrigTitle )

        {

        // Set original title pane

        iTitlePane->SetTextL( *iOrigTitle );

        }

    // Restore original navi pane

    iNaviPane->Pop( iNaviLabelPane );

    }

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

// CMPXAlbumArtEditorDialog::FindCustomControlContainer

// Returns the Custom Control Container.

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

//

CMPXAlbumArtEditorDialogCustomControl *CMPXAlbumArtEditorDialog::

    GetAlbumArtEditorDialogCustomControl() const

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::GetAlbumArtEditorDialogCustomControl" );

    CMPXAlbumArtEditorCustomControlContainer *control =

        ( CMPXAlbumArtEditorCustomControlContainer* )

        ControlOrNull ( EMPXAlbumArtEditorDlgCtrlId );

    if ( control )

        {

        return control->iDialogCustomControl;

        }

    return NULL;

    }

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

// CMPXAlbumArtEditorDialog::LoadAlbumArtL

// loads album art information from the database

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

//

void CMPXAlbumArtEditorDialog::LoadAlbumArtL( TBool aShowWaitNote )

    {

    MPX_FUNC( "CMPXAlbumArtEditorDialog::LoadAlbumArtL" );

    HBufC* string = StringLoader::LoadLC( R_MPX_QTN_NMP_NOTE_OPENING );

    if( aShowWaitNote ) // show wait note only when needed

		{

		iCommonUiHelper->ShowWaitNoteL( *string, R_AVKON_SOFTKEYS_EMPTY, EFalse, this );

		}

    CleanupStack::PopAndDestroy( string );

    RArray<TMPXAttribute> attrs;

    CleanupClosePushL( attrs );

    if ( !iAlbumInfo )

        {

        if ( iCurrentMediaLOp == EMPXOpMediaLIdle )

            {

            MPX_DEBUG1( "CMPXAlbumArtEditorDialog::LoadAlbumArtL Using MediaL" );

            if ( iAlbumArtMode == EMPXModeTracksView )

                {

                iCurrentMediaLOp = EMPXOpMediaLGetAlbumArtInfo;

                AppendCommonAttributes( attrs );

                }

            else

                {

                iCurrentMediaLOp = EMPXOpMediaLGetCurrentMode;