/*

* Copyright (c) 2006-2008 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:  Memory store view

*

*/

// INCLUDE FILES

#include <StringLoader.h>

#include <aknlists.h>

#include <akntitle.h>

#include <CFileManagerEngine.h>

#include <filemanager.rsg>

#include <csxhelp/fmgr.hlp.hrh>

#include <FileManagerDebug.h>

#include "CFileManagerMemoryStoreView.h"

#include "CFileManagerFileListContainer.h"

#include "CFileManagerAppUi.h"

#include "CFileManagerDocument.h"

#include "FileManager.hrh"

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

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

// CFileManagerMemoryStoreView::CFileManagerMemoryStoreView

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

//

CFileManagerMemoryStoreView::CFileManagerMemoryStoreView()

    {

    }

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

// CFileManagerMemoryStoreView::NewLC

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

//

CFileManagerMemoryStoreView* CFileManagerMemoryStoreView::NewLC()

    {

    CFileManagerMemoryStoreView* self =

        new( ELeave ) CFileManagerMemoryStoreView();

    CleanupStack::PushL( self );

    self->ConstructL( R_FILEMANAGER_FOLDERS_VIEW );

    return self;

    }

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

// CFileManagerMemoryStoreView::~CFileManagerMemoryStoreView

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

// 

CFileManagerMemoryStoreView::~CFileManagerMemoryStoreView()

    {  

    }

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

// CFileManagerMemoryStoreView::DoActivateL

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

// 

void CFileManagerMemoryStoreView::DoActivateL(

        const TVwsViewId& aPrevViewId,

        TUid aCustomMessageId,

        const TDesC8& aCustomMessage )

    {

    FUNC_LOG

    // Check embedded app exit first

    CFileManagerAppUi* appUi = 

        static_cast< CFileManagerAppUi* >( AppUi() );

    appUi->ExitEmbeddedAppIfNeededL();

    CFileManagerViewBase::DoActivateL(

        aPrevViewId, aCustomMessageId, aCustomMessage );

    TBool showRemoteNotConnected( EFalse );

    // Ensure that root directory is defined

    TInt count( iEngine.NavigationLevel() );

    if ( count > 0 )

        {

        iIndex = 0;

        for ( TInt i( 0 ); i < count; i++ )

            {

            TRAP_IGNORE( iEngine.BackstepL() );

            }

        showRemoteNotConnected = ETrue;

        }

    TRAP_IGNORE ( RefreshDriveInfoL() );

    RefreshTitleL();

    iEngine.SetState( CFileManagerEngine::ENavigation );

    iEngine.SetObserver( this );

    if ( DriveAvailableL( showRemoteNotConnected ) )

        {

        iEngine.RefreshDirectory();

        }

    else

        {

        UpdateCbaL();

        }

    }

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

// CFileManagerMemoryStoreView::DoDeactivate

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

// 

void CFileManagerMemoryStoreView::DoDeactivate()

    {

    FUNC_LOG

    CFileManagerViewBase::DoDeactivate();

    }

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

// CFileManagerMemoryStoreView::DirectoryChangedL

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

// 

void CFileManagerMemoryStoreView::DirectoryChangedL()

    {

    FUNC_LOG

    TBool drvAvailable( DriveAvailableL( ETrue ) );

    if ( iContainer )

        {

        if ( drvAvailable )

            {

            TInt index = iEngine.CurrentIndex();

            if (  index != KErrNotFound )

                {

                iIndex = index;

                }

            iContainer->RefreshListL( iIndex );

            }

        else

            {

            iIndex = 0;

            }

        RefreshTitleL();

        }

    }

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

// CFileManagerMemoryStoreView::Id

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

// 

TUid CFileManagerMemoryStoreView::Id() const

    {

    return CFileManagerAppUi::KFileManagerMemoryStoreViewId;

    }

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

// CFileManagerMemoryStoreView::CreateContainerL

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

// 

CFileManagerContainerBase* CFileManagerMemoryStoreView::CreateContainerL()

    {

    return CFileManagerFileListContainer::NewL(

        ClientRect(),

        iIndex,

        CFileManagerFileListContainer::EListMemoryStore,

        R_QTN_SELEC_EMPTY_LIST,

        KFMGR_HLP_MEM_STORE_VIEW );

    }

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

// CFileManagerMemoryStoreView::HandleCommandL

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

// 

void CFileManagerMemoryStoreView::HandleCommandL( TInt aCommand )

    {

    switch( aCommand )

        {

        case EFileManagerOpen:

            {

            CmdOpenL();

            break;

            }

        case EAknSoftkeyBack:

            {

            CmdBackL();

            break;

            }

        default:

            {

            CFileManagerViewBase::HandleCommandL( aCommand );

            break;

            }

        }

    }

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

// CFileManagerMemoryStoreView::DriveAvailableL

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

//

TBool CFileManagerMemoryStoreView::DriveAvailableL(

        TBool aShowRemoteNotConnected )

    {

    HBufC* error = NULL;

    TFileManagerDriveInfo& drvInfo( DriveInfo() );

    if ( drvInfo.iState & (

            TFileManagerDriveInfo::EDriveRemovable |

            TFileManagerDriveInfo::EDriveRemote ) )

        {

        TRAP_IGNORE( RefreshDriveInfoL() );

        }    

    TInt drvNum = drvInfo.iDrive;

    iEngine.GetDriveInfoL(drvNum,drvInfo);

    INFO_LOG1( "CFileManagerMemoryStoreView::DriveAvailableL-drvState=%d",

        drvInfo.iState )

    if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote )

        {

        iEngine.SetMemoryL( EFmRemoteDrive );

        }

#ifdef RD_MULTIPLE_DRIVE

    else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )

        {

        iEngine.SetMemoryL( EFmMassStorage );

        }

#endif // RD_MULTIPLE_DRIVE

    else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemovable )

        {

        iEngine.SetMemoryL( EFmMemoryCard );

        }

    else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveUsbMemory )

        {

        iEngine.SetMemoryL( EFmUsbMemory );

        }

    else

        {

        iEngine.SetMemoryL( EFmPhoneMemory );

        }

#ifdef RD_MULTIPLE_DRIVE

    if ( drvInfo.iState & TFileManagerDriveInfo::EDriveMassStorage )

        {

        // Handle mass storage states

        if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) ||

             ( drvInfo.iState & TFileManagerDriveInfo::EDriveInUse ) )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_MASS_STORAGE_IN_USE );

            }

        else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveCorrupted )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_MASS_STORAGE_CORRUPTED );

            }

        }

    else

        {

        // Handle other drives

#endif // RD_MULTIPLE_DRIVE

        if ( drvInfo.iState & TFileManagerDriveInfo::EDriveInUse )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_MAINPAGE_ERROR4 );

            }

        else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveLocked )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_MAINPAGE_ERROR2 );

            }

        else if ( drvInfo.iState & TFileManagerDriveInfo::EDriveCorrupted )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_MAINPAGE_ERROR3 );

            }

        else if ( !( drvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) )

            {

            error = StringLoader::LoadLC( R_QTN_MEMC_NOT_AVAILABLE );

            }

        else if ( aShowRemoteNotConnected &&

                 ( drvInfo.iState & TFileManagerDriveInfo::EDriveRemote ) &&

                 ! ( drvInfo.iState & TFileManagerDriveInfo::EDriveConnected ) )

            {

            error = StringLoader::LoadLC( R_QTN_FMGR_EMPTY_REMOTE_DRIVE );

            }

#ifdef RD_MULTIPLE_DRIVE

        }

#endif // RD_MULTIPLE_DRIVE

    if ( error )

        {

        if ( iContainer )

            {

            iContainer->ListBoxSetTextL( *error );

            }

        CleanupStack::PopAndDestroy( error );

        return EFalse;

        }

    return ETrue;

    }

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

// CFileManagerMemoryStoreView::RefreshTitleL

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

//

void CFileManagerMemoryStoreView::RefreshTitleL()

    {

    static_cast< CFileManagerAppUi* >( AppUi() )->SetTitleL(

        iEngine.CurrentDriveName() );

    }

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

// CFileManagerMemoryStoreView::CmdOpenL

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

//

void CFileManagerMemoryStoreView::CmdOpenL()

    {

    StoreIndex();

    CFileManagerViewBase::CmdOpenL();

    }

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

// CFileManagerMemoryStoreView::CmdBackL

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

//

void CFileManagerMemoryStoreView::CmdBackL()

    {

    if ( iActiveProcess != ENoProcess )

        {

        return; // Ignore to avoid container mess up

        }

    CFileManagerAppUi* appUi =

        static_cast< CFileManagerAppUi* >( AppUi() );

    iEngine.BackstepL();

    iIndex = 0;

    appUi->CloseMemoryStoreViewL();

    }

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

// CFileManagerMemoryStoreView::UpdateCbaL

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

//

void CFileManagerMemoryStoreView::UpdateCbaL()

    {

    UpdateCommonCbaL();

    }

//  End of File