/*

* Copyright (c) 2002-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:  File Manager application UI class.

*

*/

// INCLUDE FILES

#include <akntitle.h>   // CAknTitlePane

#include <aknnavi.h>    // CAknNavigationControlContainer 

#include <aknnavide.h>  // CAknNavigationDecorator

#include <sendui.h>     // CSendAppUi

#include <avkon.rsg>

#include <barsread.h>

#include <hlplch.h>     // HlpLauncher

#include <eikapp.h>

#include <AknDef.h>     // For layout change event definitions

#include <utf.h>

#include <StringLoader.h>

#include <AknsUtils.h>

#include <centralrepository.h>

#include <AiwCommon.h>

#include <bautils.h>

#include <pathinfo.h>

#include <driveinfo.h>

#include <CFileManagerEngine.h>

#include <CFileManagerIRReceiver.h>

#include <FileManager.rsg>

#include <FileManagerView.rsg>

#include <FileManagerDebug.h>

#include <FileManagerUID.h>

#include <CFileManagerFeatureManager.h>

#include <CFileManagerUtils.h>

#include "CFileManagerAppUi.h"

#include "CFileManagerDocument.h"

#include "CFileManagerMainView.h"

#include "CFileManagerMemoryStoreView.h"

#ifdef RD_FILE_MANAGER_BACKUP

 #include <FileManagerSchDefinitions.h>

 #include "CFileManagerBackupView.h"

 #include "CFileManagerRestoreView.h"

 #include "CFileManagerTaskScheduler.h"

 #include "CFileManagerSchBackupHandler.h"

#endif // RD_FILE_MANAGER_BACKUP

#include "CFileManagerFoldersView.h"

#include "Cfilemanagersearchresultsview.h"

#include "CFileManagerIconArray.h"

#include "FileManager.hrh"

// CONSTANTS

const TUid CFileManagerAppUi::KFileManagerMainViewId = 

    { EFileManagerMainViewId };

const TUid CFileManagerAppUi::KFileManagerMemoryStoreViewId = 

    { EFileManagerMemoryStoreViewId };

const TUid CFileManagerAppUi::KFileManagerFoldersViewId = 

    { EFileManagerFoldersViewId };

const TUid CFileManagerAppUi::KFileManagerSearchResultsViewId = 

    { EFileManagerSearchResultsViewId };

const TUid CFileManagerAppUi::KFileManagerBackupViewId = 

    { EFileManagerBackupViewId };

const TUid CFileManagerAppUi::KFileManagerRestoreViewId = 

    { EFileManagerRestoreViewId };

const TUid KUidFileManager = { KFileManagerUID3 };

const TUid KUidGsRsfwPlugin = { 0x101F9778 };

const TUid KUidGsRsFwSettingsViewId = { 11 };

// ============================ LOCAL FUNCTIONS ================================

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

// ProcessExists

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

//

static TBool ProcessExists( const TSecureId& aSecureId )

    {

    _LIT( KFindPattern, "*" );

    TFindProcess finder( KFindPattern );

    TFullName processName;

    while( finder.Next( processName ) == KErrNone )

        {

        RProcess process;

        if ( process.Open( processName ) == KErrNone )

            {

            TSecureId processId( process.SecureId() );

            process.Close();

            if( processId == aSecureId )

                {

                return ETrue;

                }

            }

        }

    return EFalse;

    }

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

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

// CFileManagerAppUi::CFileManagerAppUi

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

// might leave.

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

//

CFileManagerAppUi::CFileManagerAppUi() :

        iInitialFolderLevel( KErrNotFound )

    {

    FUNC_LOG

    }

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

// CFileManagerAppUi::~CFileManagerAppUi

// Destructor

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

// 

CFileManagerAppUi::~CFileManagerAppUi()

    {

    FUNC_LOG

    iCoeEnv->RemoveForegroundObserver( *this );

    delete iIRReceiver;

    delete iIRDeleteCB;

    delete iSendUi;

#ifdef RD_FILE_MANAGER_BACKUP

    delete iTaskScheduler;

    delete iSchBackupHandler;

#endif // RD_FILE_MANAGER_BACKUP

    CFileManagerEngine& engine =

        static_cast< CFileManagerDocument* >( Document() )->Engine();

    engine.SetObserver( NULL );

    }

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

// CFileManagerAppUi::ConstructL

// 

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

// 

void CFileManagerAppUi::ConstructL()

    {

    FUNC_LOG

    // Construct only must have stuff required for app start here.

    // Other stuff is constructed later to decrease app start time.

    INFO_LOG( "CFileManagerAppUi::ConstructL()-BaseConstructL" )

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    INFO_LOG( "CFileManagerAppUi::ConstructL()-Setup panes" )

    CEikStatusPane* sp = StatusPane();

    iTitlePane = static_cast< CAknTitlePane* >

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

    INFO_LOG( "CFileManagerAppUi::ConstructL()-Create main view" )

    CAknView* view = CFileManagerMainView::NewLC();

    AddViewL( view ); // Takes ownership

    CleanupStack::Pop( view );

    SetDefaultViewL( *view );

    iActiveView = view->Id();

#ifdef RD_FILE_MANAGER_BACKUP

    CFileManagerDocument* doc =

        static_cast< CFileManagerDocument* >( Document() );

    iSchBackupStandalone = doc->IsScheduledBackup();

    if ( iSchBackupStandalone )

        {

        // Do standalone scheduled backup startup

        INFO_LOG( "CFileManagerAppUi::ConstructL-Launch scheduled backup" )

        iEikonEnv->WsSession().ComputeMode( RWsSession::EPriorityControlDisabled ); 

        RThread().SetProcessPriority( EPriorityForeground );

        sp->MakeVisible( EFalse );

        sp->SwitchLayoutL( R_AVKON_STATUS_PANE_LAYOUT_EMPTY );

        StartSchBackupL();

        }

    else

        {

#endif // RD_FILE_MANAGER_BACKUP

        CFileManagerEngine& engine =

            static_cast< CFileManagerDocument* >( Document() )->Engine();

        iWaitingForParams = engine.FeatureManager().IsEmbedded();

        // Do normal application startup

        INFO_LOG( "CFileManagerAppUi::ConstructL()-Add foreground observer" )

        iCoeEnv->AddForegroundObserverL( *this );

#ifdef RD_FILE_MANAGER_BACKUP

        }

#endif // RD_FILE_MANAGER_BACKUP

    }

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

// CFileManagerAppUi::HandleCommandL

// 

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

// 

void CFileManagerAppUi::HandleCommandL( TInt aCommand )

    {

    switch( aCommand )

        {

        case EEikCmdExit: // FALLTHROUGH

        case EAknSoftkeyExit:

            {

            CFileManagerEngine& engine = 

                static_cast< CFileManagerDocument* >( Document() )->Engine();

            engine.CancelRefresh();

            Exit();

            break;

            }

        case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), 

                AppHelpContextL());

            break;

            }

        default:

            break;

        }

    }

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

// CFileManagerAppUi::HandleViewDeactivation

// 

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

// 

void CFileManagerAppUi::HandleViewDeactivation( 

                            const TVwsViewId& aViewIdToBeDeactivated, 

                            const TVwsViewId& aNewlyActivatedViewId )

    {

    if ( aNewlyActivatedViewId.iAppUid == Application()->AppDllUid() )

        {

        if ( IsFileManagerView( aNewlyActivatedViewId.iViewUid ) &&

        		View( aNewlyActivatedViewId.iViewUid ) )

            {

            iActiveView = aNewlyActivatedViewId.iViewUid;

            }

        }

    CAknViewAppUi::HandleViewDeactivation(

        aViewIdToBeDeactivated, aNewlyActivatedViewId );

    }

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

// CFileManagerAppUi::ActivateFoldersViewL

// 

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

// 

TBool CFileManagerAppUi::ActivateFoldersViewL()

    {

    if ( iActiveView != KFileManagerFoldersViewId )

        {

        if ( iSearchViewOpen )

            {

            CreateAndActivateLocalViewL( KFileManagerFoldersViewId,

                CFileManagerFoldersView::KOpenFromSearchResultsView,

                KNullDesC8 );

            }

        else

            {

            CreateAndActivateLocalViewL( KFileManagerFoldersViewId );

            }

        return ETrue;

        }

    return EFalse;

    }

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

// CFileManagerAppUi::CloseFoldersViewL

// 

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

// 

void CFileManagerAppUi::CloseFoldersViewL()

    {

    if ( iSearchViewOpen )

        {

        CreateAndActivateLocalViewL( KFileManagerSearchResultsViewId );

        iActiveView = KFileManagerSearchResultsViewId;

        }

    else 

        {

        ExitEmbeddedAppIfNeededL();

        ActivateMemoryStoreViewL();

        iActiveView = KFileManagerMemoryStoreViewId;

        }

    }

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

// CFileManagerAppUi::ActivateSearchResultsViewL

// 

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

// 

void CFileManagerAppUi::ActivateSearchResultsViewL()

    {

    if ( iActiveView != KFileManagerSearchResultsViewId )

        {

        // Activate with refresh

        CreateAndActivateLocalViewL(

            KFileManagerSearchResultsViewId,

            KNullUid,

            KFileManagerSearchViewRefreshMsg );

        iSearchViewOpen = ETrue;

        }

    CFileManagerEngine& engine = 

        static_cast< CFileManagerDocument* >( Document() )->Engine();

    SetTitleL( engine.SearchString() );

    }

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

// CFileManagerAppUi::CloseSearchResultsViewL

// 

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

// 

void CFileManagerAppUi::CloseSearchResultsViewL()

    {

    CFileManagerEngine& engine =

        static_cast< CFileManagerDocument* >( Document() )->Engine();

    TInt level( engine.FolderLevel() );

    // If embedded, then ensure that the return folder is not below given level

    // or on different drive

    if ( engine.FeatureManager().IsEmbedded() )

        {

        TPtrC dir( engine.CurrentDirectory().Left(

            iFolderToOpenAtStartup.Length() ) );

        if ( engine.FolderLevel() < iInitialFolderLevel ||

             dir.CompareF( iFolderToOpenAtStartup ) )

            {

            engine.SetDirectoryWithBackstepsL( iFolderToOpenAtStartup );

            level = iInitialFolderLevel;

            }

        }

    if ( level > 0 )

        {

        CreateAndActivateLocalViewL( KFileManagerFoldersViewId );

        iActiveView = KFileManagerFoldersViewId;

        }

    else if ( !level )

        {

        CreateAndActivateLocalViewL( KFileManagerMemoryStoreViewId );

        iActiveView = KFileManagerMemoryStoreViewId;

        }

    else

        {

        CreateAndActivateLocalViewL( KFileManagerMainViewId );

        iActiveView = KFileManagerMainViewId;

        }

    iSearchViewOpen = EFalse;

    }

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

// CFileManagerAppUi::RestoreDefaultTitleL

// 

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

// 

void CFileManagerAppUi::RestoreDefaultTitleL()

    {

    TResourceReader reader;

    iCoeEnv->CreateResourceReaderLC( reader, R_FILEMANAGER_TITLE_PANE );

    iTitlePane->SetFromResourceL( reader ); // restore title pane

    CleanupStack::PopAndDestroy(); // reader

    }

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

// CFileManagerAppUi::SendUiL

// 

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

// 

CSendUi& CFileManagerAppUi::SendUiL()

    {

    if ( !iSendUi )

        {

        iSendUi = CSendUi::NewL();

        }

    return *iSendUi;

    }

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

// CFileManagerAppUi::HandleResourceChangeL

//

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

//

void CFileManagerAppUi::HandleResourceChangeL( TInt aType )

    {

    if( aType == KAknsMessageSkinChange ||

        aType == KEikDynamicLayoutVariantSwitch )

        {

        CEikStatusPane* sp = StatusPane();

        sp->HandleResourceChange( aType );

        CFileManagerDocument* doc =

            static_cast< CFileManagerDocument* >( Document() );

        doc->ClearStringCache();

        doc->IconArray()->UpdateIconsL();

        if ( iActiveView == KFileManagerFoldersViewId )

            {

            CFileManagerFoldersView* view =

                static_cast< CFileManagerFoldersView* >(

                    View( KFileManagerFoldersViewId ) );

            view->HandleResourceChangeL( KAknsMessageSkinChange );

            }

        NotifyViewScreenDeviceChanged();

        }

    CAknViewAppUi::HandleResourceChangeL( aType );

    }

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

// CFileManagerAppUi::HandleGainingForeground

//

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

//

void CFileManagerAppUi::HandleGainingForeground()

    {

    if ( !iForeGround ) 

        {

        iForeGround = ETrue;

        CFileManagerViewBase* view =

            static_cast< CFileManagerViewBase* >( View( iActiveView ) );

        CFileManagerEngine& engine =

            static_cast< CFileManagerDocument* >( Document() )->Engine();

        engine.SetObserver( view );

        view->NotifyForegroundStatusChange( iForeGround );

        if ( view->CurrentProcess() ==

            MFileManagerProcessObserver::ENoProcess )

            {

            engine.FileSystemEvent( EFalse );

            }

        }

    }

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

// CFileManagerAppUi::HandleLosingForeground

//

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

//

void CFileManagerAppUi::HandleLosingForeground()

    {

    iForeGround = EFalse;

    CFileManagerViewBase* view =

        static_cast< CFileManagerViewBase* >( View( iActiveView ) );

    CFileManagerEngine& engine =

        static_cast< CFileManagerDocument* >( Document() )->Engine();

    engine.SetObserver( view );

    view->StoreIndex();

    view->NotifyForegroundStatusChange( iForeGround );

    if ( view->CurrentProcess() ==

        MFileManagerProcessObserver::ENoProcess )

        {

        engine.FileSystemEvent( ETrue );

        }

    }

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

// CFileManagerAppUi::IsFmgrForeGround

//

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

//

TBool CFileManagerAppUi::IsFmgrForeGround()

    {

    return iForeGround;

    }

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

// CFileManagerAppUi::HandleScreenDeviceChangedL()

//

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

//

void CFileManagerAppUi::HandleScreenDeviceChangedL()

    {

    CAknViewAppUi::HandleScreenDeviceChangedL();

    NotifyViewScreenDeviceChanged();

    }

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

// CFileManagerAppUi::HandleError()

//

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

//

TErrorHandlerResponse CFileManagerAppUi::HandleError( TInt aError,

        const SExtendedError& aExtErr, TDes& aErrorText, TDes& aContextText )

    {

    ERROR_LOG1( "CFileManagerAppUi::HandleError()-aError=%d", aError )

    switch ( aError )

        {

        case KErrCancel: // FALLTHROUGH

        case KErrNotReady: 

            {

            // Suppress notes for canceled operations.

            // Suppress notes for not ready when caused by hotswap.

            if ( View( iActiveView ) )

                {

                return ENoDisplay;

                }

            break;

            }

        case KErrNotFound: // Fall through

        case KErrPathNotFound:

            {

            CFileManagerViewBase* view =

                static_cast< CFileManagerViewBase* >( View( iActiveView ) );

            TBool handled( EFalse );

            TRAPD( err, handled = view->HandleFileNotFoundL( aError ) );

            if ( err == KErrNone && handled )

                {

                // Suppress not found when handled by refresh.

                return ENoDisplay;

                }