/*

* 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:  Implementation of Main view

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <aknViewAppUi.h>

#include <eikmenub.h>

#include <eikfrlb.h>

#include <eikfrlbd.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <eikapp.h>

#include <AknUtils.h>

#include <akntitle.h>

#include <textresolver.h>

#include <aknnotewrappers.h>

#include <aknnavi.h>

#include <hlplch.h>

#include <bautils.h>

#include <eikspmod.h>

#include <eikclb.h>

#include <avkon.hrh>

#include <avkon.rsg>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <bldvariant.hrh>

#include <layoutmetadata.cdl.h>

#include <aknSDData.h>

#include <AknMediatorFacade.h>

#include <mplayersecondarydisplayapi.h>

#include <mpxplaybackutility.h>

#include <mpxviewutility.h>

#include <mpxcollectionutility.h>

#include <mpxplaybackmessage.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionframeworkdefs.h>

#include <mpxviewpluginmanager.h>

#include <mpxcollectionplaylist.h>

#include <mpxmusicplayerviewplugin.hrh>

#include <mpxmainview.rsg>

#include <mpxlog.h>

#include <mpxcollectionpath.h>

#include <mpxviewplugin.h>

#include <mpxcollectionplugin.hrh>

#include <mpxmessagegeneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxuser.h>

#include "mpxcommonuihelper.h"

#include "mpxalbumartutil.h"

#include "mpxmainview.hrh"

#include "mpxmainviewimp.h"

#include "mpxmainviewcontainer.h"

#include <mpxappui.hrh>

// CONSTANTS

_LIT( KMPXMainRscPath, "mpxmainview.rsc" );

_LIT( KMPXTab, "\t" );

_LIT( KMPXSpace, " " );

const TInt KWaitNoteImpUid = 0x101FFC6C;

// extra size for buffers

const TInt KMPXDefaultBufferLength = 255;

const TInt KMPXExtraBufferLength = 50;

const TInt KSecondInMilliseconds = 1000;

const TInt KOneHourInSeconds = 3600;

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

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

// Two-phased constructor.

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

//

CMPXMainViewImp* CMPXMainViewImp::NewL()

    {

    MPX_FUNC( "CMPXMainViewImp::NewL" );

    CMPXMainViewImp* self = CMPXMainViewImp::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor.

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

//

CMPXMainViewImp* CMPXMainViewImp::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXMainViewImp::~CMPXMainViewImp()

    {

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

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    if ( iPlaybackUtility )

        {

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

        iPlaybackUtility->Close();

        }

    if ( iViewUtility )

        {

        iViewUtility->Close();

        }

    if ( iResourceOffset )

        {

        iEikonEnv->DeleteResourceFile( iResourceOffset );

        }

    if ( iContainer )

        {

        AppUi()->RemoveFromStack( iContainer );

        delete iContainer;

        }

    delete iMPXUtility;

    delete iTitle;

    delete iCommonUiHelper;

    delete iCurPath;

    delete iMediaArray;

    delete iIdle;

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

    }

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

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

// might leave.

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

//

CMPXMainViewImp::CMPXMainViewImp()

    {

    MPX_FUNC( "CMPXMainViewImp::CMPXMainViewImp" );

    iInitDBNeeded = EFalse;

    iInitDBCorrupted = EFalse;

    iCurSystemEvent = KErrNotFound;

    iShowPlaybackIndicator = EFalse;

    iColInitialized = EFalse;

    iRefreshingCollection = EFalse;

    iCurPlugin = KErrNotFound;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXMainViewImp::ConstructL()

    {

    MPX_FUNC( "CMPXMainViewImp::ConstructL" );

    CCoeEnv* coeEnv = iEikonEnv;

    TParse parse;

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

    TFileName resourceFile( parse.FullName() );

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

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

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    BaseConstructL( R_MPX_MAIN_VIEW );

    iViewUtility = MMPXViewUtility::UtilityL();

    iPlaybackUtility = MMPXPlaybackUtility::UtilityL( KPbModeDefault );

    iPlaybackUtility->AddObserverL( *this );

    iCommonUiHelper = CMPXCommonUiHelper::NewL();

    iMPXUtility = CMPXAlbumArtUtil::NewL();

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

    iAlbumArtIndex = KMPXMainViewDefaultIcon;

    TMPXPlaybackState state = iPlaybackUtility->StateL();

    if( state == EPbStatePlaying ||

        state == EPbStatePaused )

        {

        iShowPlaybackIndicator = ETrue;

        }

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

    iTitle = HBufC::NewL( 0 );

#ifdef _DEBUG

    iExitOptionHidden = EFalse;

#else // _DEBUG

    iExitOptionHidden = iCommonUiHelper->ExitOptionHiddenL() &&

        !iEikonEnv->StartedAsServerApp();

#endif // _DEBUG

    }

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

// Displays error notes.

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

//

void CMPXMainViewImp::HandleErrorL( TInt aError )

    {

    if ( aError )

        {

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

        // TextResolver instance for error resolving.

        CTextResolver* textresolver = CTextResolver::NewLC();

        // Resolve the error text

        const TDesC& text =

            textresolver->ResolveErrorString( aError );

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

        dlg->ExecuteLD( text );

        CleanupStack::PopAndDestroy( textresolver );

        }

    }

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

// Function to display information notes

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

//

void CMPXMainViewImp::DisplayInfoNoteL( TInt aResourceId )

    {

    MPX_FUNC( "CMPXMainViewImp::DisplayInfoNoteL" );

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

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

    dlg->ExecuteLD( *text );

    CleanupStack::PopAndDestroy( text );

    }

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

// Function to display confirmation notes

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

//

void CMPXMainViewImp::DisplayConfirmionNoteL( TInt aResourceId )

    {

    MPX_FUNC( "CMPXMainViewImp::DisplayConfirmionNoteL" );

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

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

    dlg->ExecuteLD( *text );

    CleanupStack::PopAndDestroy( text );

    }

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

// From MMPXCollectionObserver

// Handle collection message

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

//

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

    const CMPXMedia& aEntries,

    TInt aIndex,

    TBool /*aComplete*/,

    TInt aError )

    {

    MPX_FUNC( "CMPXMainViewImp::HandleOpenL 4" );

    if( aError == KErrNone )

        {

        UpdateListBoxL( aEntries, aIndex );

        UpdatePluginInfo();

        }

    else if ( aError == KErrCorrupt )

        {

        DoHandleCorruptMsgL();

        }

    else

        {

        HandleErrorL( aError );

        }

    MPX_PERF_CHECKPT("MPX Main view displayed");

    }

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

// From MMPXCollectionObserver

// Handles the collection entries being opened. Typically called

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

// 'playing' the item

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

//

void CMPXMainViewImp::HandleOpenL(

    const CMPXCollectionPlaylist& /*aPlaylist*/,

    TInt /*aError*/ )

    {

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

    }

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

// From MMPXCollectionObserver

// Handle media properties

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

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

//

void CMPXMainViewImp::HandleCollectionMediaL(

    const CMPXMedia& aMedia,

    TInt aError)

    {

    MPX_FUNC( "CMPXMainViewImp::HandleCollectionMediaL" );

    if (aError == KErrNoMemory)

        {

        TRAP_IGNORE(

                HandleErrorL( aError );

                AppUi()->HandleCommandL( EEikCmdExit );

        );

        User::Exit(KErrNoMemory);

        return;

        }

    if (aError == KErrDiskFull)

        {

             iOutOfDisk = ETrue;

             CloseWaitNoteL();

             iCurPlugin = KErrNotFound;

             DoRetrieveDetailsL(ETrue);

        }

    if ( aError != KErrCorrupt )

        {

        if(!iOutOfDisk)

            {

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

            //

            TBool dbCreated = ETrue;

            if( aMedia.IsSupported(KMPXMediaColDetailDBCreated))

                {

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

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

                }

            iInitDBNeeded |= !dbCreated;  //lint !e514

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

            //

            TBool dbCorrupted = EFalse;

            if( aMedia.IsSupported(KMPXMediaColDetailDBCorrupted))

                {

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

                }

            iInitDBCorrupted |= dbCorrupted;

            }

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

        //

        iCurPlugin++;

        UpdateItemCountTotalL( aMedia );

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

        //

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

            {

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

            if ( !iColInitialized )

                {

                CloseWaitNoteL();

                iColInitialized = ETrue;

                }

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

                {

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

                TWaitNoteType noteType = iInitDBCorrupted ? EMPXCorruptScanningNote :

                                                            EMPXScanningNote;

                StartWaitNoteL( noteType );

                iInitDBNeeded = EFalse;

                iInitDBCorrupted = EFalse;

                iRefreshingCollection = ETrue;

                iDelayedUsbRefresh = EFalse;

                }

            else if( iDelayedUsbRefresh )

                {

                DoHandleBroadcastMsgL( EMcMsgUSBMassStorageEnd );

                }

            iCurPlugin = KErrNotFound;

            }

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

            {

            // Set which plugin

            iCurPath->Set(iCurPlugin);

            // Fetch the extra data

            RArray<TMPXAttribute> atts;

            CleanupClosePushL( atts );

            if(!iOutOfDisk)

                {

                atts.Append(KMPXMediaColDetailDBCreated);

                atts.Append(KMPXMediaColDetailDBCorrupted);

                }

#ifndef __ENABLE_PODCAST_IN_MUSIC_MENU

            atts.Append(KMPXMediaGeneralTitle);

            atts.Append(KMPXMediaGeneralSubTitle);

            if(!iOutOfDisk)

                {

                atts.Append(KMPXMediaGeneralCount);

                }

            atts.Append(KMPXMediaGeneralIcon);

#endif // __ENABLE_PODCAST_IN_MUSIC_MENU

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

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

            //

            if( iCurSystemEvent == KErrNotFound )

                {

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

                }

            else

                {

                // Reset state machine

                iCurPlugin = KErrNotFound;

                }

            CleanupStack::PopAndDestroy( &atts );

            }

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

            {

            HandleErrorL( aError );

            }

        }

    else

        {

        DoHandleCorruptMsgL();

        }

    }

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

// From MMPXPlaybackObserver

// Handle playback message.

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

//

void CMPXMainViewImp::HandlePlaybackMessage(

    CMPXMessage* aMessage, TInt aError )

    {

    if ( aError == KErrNone && aMessage )

        {

        TRAP_IGNORE( DoHandlePlaybackMessageL( *aMessage ) );

        }

    }

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

// From MMPXPlaybackCallback

// Handle playback property.

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

//

void CMPXMainViewImp::HandlePropertyL(

    TMPXPlaybackProperty aProperty,

    TInt aValue,

    TInt aError )

    {

    MPX_DEBUG1( "CMPXMainViewImp::HandlePropertyL" );

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

    }

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

// From MMPXPlaybackCallback

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

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

// Only new items are passed each time

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

//

void CMPXMainViewImp::HandleSubPlayerNamesL(

    TUid /* aPlayer */,

    const MDesCArray* /* aSubPlayers */,

    TBool /* aComplete */,

    TInt /* aError */ )

    {

    // do nothing

    }

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

// From MMPXPlaybackCallback

// Handle extended media properties.

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

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

//

void CMPXMainViewImp::HandleMediaL(

    const CMPXMedia& aMedia,

    TInt aError )

    {

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

    TRAP_IGNORE( DoHandleMediaL( aMedia, aError ) );

    }

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

// From CAknView

// Returns views id.