/*

* 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:  Wraps removable drive functionality

*

*/

// INCLUDE FILES

#include <filemanagerengine.rsg>

#include "CFileManagerRemovableDriveHandler.h"

#include "MFileManagerProcessObserver.h"

#include "CFileManagerUtils.h"

#include "CFileManagerEngine.h"

#include <coreapplicationuisdomainpskeys.h>

#include <coemain.h>

#include <apgwgnam.h>

#include <apgtask.h>

#include <bautils.h>

#include <tz.h>

#include <babackup.h>

#include <pathinfo.h>

#include <sysutil.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif // RD_MULTIPLE_DRIVE

#include <e32property.h>

#include <centralrepository.h>

#include "CMMCScBkupEngine.h"

#include "MMCScBkupOperations.h"

#include "CMMCScBkupOperationParameters.h"

#include "CFileManagerItemProperties.h"

#include "CFileManagerBackupSettings.h"

#include "FileManagerPrivateCRKeys.h"

#include "BkupEngine.hrh"

#include "FileManagerDebug.h"

#include "CFileManagerCommonDefinitions.h"

#include "FileManagerUID.h"

#include "filemanagerprivatepskeys.h"

// CONSTANTS

const TInt KEjectScanInterval = 1000000; // 1 second

const TInt KEjectScanRoundsMax = 7;

NONSHARABLE_CLASS(TMaskLookup)

    {

    public:

        TUint32 iBkupMask;

        TUint32 iFmgrMask;

    };

const TMaskLookup KMaskLookup[] = {

    { EBUCatSettings,  EFileManagerBackupContentSettings  },

    { EBUCatMessages,  EFileManagerBackupContentMessages  },

    { EBUCatContacts,  EFileManagerBackupContentContacts  },

    { EBUCatCalendar,  EFileManagerBackupContentCalendar  },

    { EBUCatBookmarks, EFileManagerBackupContentBookmarks },

    { EBUCatUserFiles, EFileManagerBackupContentUserFiles }

};

const TUint32 KMaskLookupLen =

    sizeof( KMaskLookup ) / sizeof( KMaskLookup[ 0 ] );

const TInt KForcedFormatTimeout = 1000000;

const TInt KAppCloseTimeout = 1000000;

const TInt KFileManagerAppUid = 0x101F84EB;

NONSHARABLE_CLASS(TFileManagerVolumeNameStore)

    {

public:

    inline TFileManagerVolumeNameStore() : iDrive( KErrNotFound ), iName( KNullDesC ) {};

    TInt iDrive; // The drive using the store

    TFileName iName; // Use the same length than TVolumeInfo

    };

typedef TPckg< TFileManagerVolumeNameStore > TFileManagerVolumeNameStorePckg;

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

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

// CFileManagerRemovableDriveHandler::CFileManagerRemovableDriveHandler

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

//

CFileManagerRemovableDriveHandler::CFileManagerRemovableDriveHandler(

        RFs& aFs,

        CFileManagerUtils& aUtils,

        CFileManagerEngine& aEngine ) :

    CActive( CActive::EPriorityStandard ),

    iFs( aFs ),

    iUtils( aUtils ),

    iEngine( aEngine )

    {

    }

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

// CFileManagerRemovableDriveHandler::ConstructL

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

//

void CFileManagerRemovableDriveHandler::ConstructL()

    {

    CActiveScheduler::Add( this );

    iBkupEngine = CMMCScBkupEngine::NewL( iFs );

    PublishBurStatus( EFileManagerBkupStatusUnset );

    }

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

// CFileManagerRemovableDriveHandler::NewL

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

//

CFileManagerRemovableDriveHandler* CFileManagerRemovableDriveHandler::NewL(

        RFs& aFs,

        CFileManagerUtils& aUtils,

        CFileManagerEngine& aEngine )

    {

    CFileManagerRemovableDriveHandler* self =

        new( ELeave ) CFileManagerRemovableDriveHandler(

            aFs, aUtils, aEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CFileManagerRemovableDriveHandler::~CFileManagerRemovableDriveHandler

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

// 

CFileManagerRemovableDriveHandler::~CFileManagerRemovableDriveHandler()

    {

    Cancel();

    delete iBSWrapper;

    delete iEjectScanPeriodic;

    delete iBkupEngine;

    iFormatter.Close();

    PublishBurStatus( EFileManagerBkupStatusUnset );

    }

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

// CFileManagerRemovableDriveHandler::EjectScanAndShutdownApps

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

//

TInt CFileManagerRemovableDriveHandler::EjectScanAndShutdownApps( TAny* ptr )

    {

    CFileManagerRemovableDriveHandler* self = 

        static_cast< CFileManagerRemovableDriveHandler* >( ptr );

    TRAPD( err, self->DoEjectScanAndShutdownL() );

    if ( err != KErrNone )

        {

        self->EjectComplete( err );

        }

    return KErrNone;

    }

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

// CFileManagerRemovableDriveHandler::DoEjectScanAndShutdownL

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

//

void CFileManagerRemovableDriveHandler::DoEjectScanAndShutdownL()

    {

    RWsSession wsSession;

    User::LeaveIfError( wsSession.Connect() );

    CleanupClosePushL( wsSession );

    const TInt KDefaultWgIdArraySize = 4;

    CArrayFixFlat<TInt>* wgIds = new( ELeave ) CArrayFixFlat< TInt >(

        KDefaultWgIdArraySize );

    CleanupStack::PushL( wgIds );

    User::LeaveIfError( wsSession.WindowGroupList( 0, wgIds ) );

    TInt last( wgIds->Count() - 1 );

    TInt appsToShutDown( 0 );

    for ( TInt i( last ); i >= 0; i-- )

        {

        CApaWindowGroupName* doomedApp =

            CApaWindowGroupName::NewLC( wsSession, wgIds->At( i ) );

        TBool systemApp( doomedApp->IsSystem() );

        TBool hiddenApp( doomedApp->Hidden() );

        if ( !systemApp && !hiddenApp && doomedApp->AppUid().iUid != KFileManagerAppUid  )

            {

            appsToShutDown++;

            TApaTask* task = new (ELeave) TApaTask( wsSession );

            CleanupDeletePushL( task );

            task->SetWgId( wgIds->At( i ) );

            if ( !iEjectScanRounds )

                {

                 // applications are kindly requested to close themselves

                 // on the first round

                task->EndTask();

                }

            else if ( iEjectScanRounds >= KEjectScanRoundsMax )

                {

                task->KillTask();

                }

            CleanupStack::PopAndDestroy( task );

            }

        CleanupStack::PopAndDestroy( doomedApp );

        }

    CleanupStack::PopAndDestroy( wgIds );

    if ( !appsToShutDown || iEjectScanRounds >= KEjectScanRoundsMax )

        {

        EjectComplete( KErrNone );

        }

    iEjectScanRounds++;

    CleanupStack::PopAndDestroy( &wsSession );

    }

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

// CFileManagerRemovableDriveHandler::EjectComplete

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

//

void CFileManagerRemovableDriveHandler::EjectComplete( TInt aErr )

    {

    delete iEjectScanPeriodic;

    iEjectScanPeriodic = NULL;

    iLastError = aErr;

    TRAP_IGNORE( InformFinishL() );

    RProperty::Set(

        KPSUidCoreApplicationUIs,

        KCoreAppUIsMmcRemovedWithoutEject,

        ECoreAppUIsEjectCommandNotUsed );

    }

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

// CFileManagerRemovableDriveHandler::InformStartL

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

// 

void CFileManagerRemovableDriveHandler::InformStartL( TInt aTotalCount )

    {

    iLastError = KErrNone;

    if ( iObserver )

        {

        iObserver->ProcessStartedL( iProcess,  aTotalCount );

        }

    }

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

// CFileManagerRemovableDriveHandler::InformUpdateL

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

// 

void CFileManagerRemovableDriveHandler::InformUpdateL( TInt aCount )

    {

    if ( iObserver )

        {

        iObserver->ProcessAdvanceL( aCount );

        }

    }

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

// CFileManagerRemovableDriveHandler::InformFinishL

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

// 

void CFileManagerRemovableDriveHandler::InformFinishL()

    {

    iEngine.ClearDriveInfo();

    PublishBurStatus( EFileManagerBkupStatusUnset );

    iProcess = MFileManagerProcessObserver::ENoProcess;

    if ( iObserver )

        {

        iObserver->ProcessFinishedL( iLastError, KNullDesC );

        }

    }

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

// CFileManagerRemovableDriveHandler::InformError

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

// 

void CFileManagerRemovableDriveHandler::InformError( TInt aErr )

    {

    iLastError = aErr;

    if ( iObserver )

        {

        iObserver->Error( aErr );

        }

    }

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

// CFileManagerRemovableDriveHandler::HandleBkupEngineEventL

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

// 

TInt CFileManagerRemovableDriveHandler::HandleBkupEngineEventL(

        MMMCScBkupEngineObserver::TEvent aEvent, TInt aAssociatedData )

    {

    TInt ret( KErrNone );

    switch( aEvent )

        {

        case MMMCScBkupEngineObserver::ECommonOperationStarting:

            {

            iFinalValue = KMaxTInt;

            InformStartL( KMaxTInt );

            break;

            }

        case MMMCScBkupEngineObserver::ECommonSizeOfTaskUnderstood:

            {

            iFinalValue = aAssociatedData;

            InformStartL( aAssociatedData );

            break;

            }

        case MMMCScBkupEngineObserver::ECommonOperationPrepareEnded:

            {

            PublishBurStatus( EFileManagerBkupStatusUnset );

            // In order to show finished dialog prior SysAp's note,

            // inform observer already at prepare-ended state.

            if( iProcess == MFileManagerProcessObserver::ERestoreProcess )

                {

                if ( iFinalValue )

                    {

                    InformUpdateL( iFinalValue );

                    }

                InformFinishL();

                }

            break;

            }

        case MMMCScBkupEngineObserver::ECommonOperationEnded:

            {

            PublishBurStatus( EFileManagerBkupStatusUnset );

            if( iProcess != MFileManagerProcessObserver::ERestoreProcess )

                {

                if ( iFinalValue )

                    {

                    InformUpdateL( iFinalValue );

                    }

                InformFinishL();

                }

            break;

            }

        case MMMCScBkupEngineObserver::ECommonOperationError:

            {

            iLastError = aAssociatedData;

            break;

            }

        case MMMCScBkupEngineObserver::ECommonProgress:

            {

            InformUpdateL( aAssociatedData );

            break;

            }

        case MMMCScBkupEngineObserver::EBackupAnalysingData:

            {

            if ( iObserver &&

                iProcess == MFileManagerProcessObserver::EBackupProcess )

                {

                ret = iObserver->NotifyL(

                    MFileManagerProcessObserver::ENotifyBackupMemoryLow,

                    aAssociatedData );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    return ret;

    }

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

// CFileManagerRemovableDriveHandler::SetObserver

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

// 

void CFileManagerRemovableDriveHandler::SetObserver(

        MFileManagerProcessObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CFileManagerRemovableDriveHandler::BackupFileNameLC

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

// 

HBufC* CFileManagerRemovableDriveHandler::BackupFileNameLC(

        TBool aFullPath ) const

    {

    HBufC* file = CCoeEnv::Static()->AllocReadResourceLC(

        R_TEXT_MMC_BACKUP_FILE );

    if ( !aFullPath )

        {

        return file; // Get just name

        }

    // Get full path

#ifdef RD_MULTIPLE_DRIVE

    TInt drive( 0 );

    User::LeaveIfError( DriveInfo::GetDefaultDrive(

        DriveInfo::EDefaultRemovableMassStorage, drive ) );

    TDriveUnit driveUnit( drive );

#else // RD_MULTIPLE_DRIVE

    TDriveUnit driveUnit( PathInfo::MemoryCardRootPath() );

#endif // RD_MULTIPLE_DRIVE

    HBufC* fileAndPath = HBufC::NewLC( KMaxFileName );

    TPtr ptr( fileAndPath->Des() );

    TPtr filePtr( file->Des() );

    ptr.Copy( driveUnit.Name() );

    ptr.Append( filePtr );

    CleanupStack::Pop( fileAndPath );

    CleanupStack::PopAndDestroy( file );

    CleanupStack::PushL( fileAndPath );

    return fileAndPath;

    }

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

// CFileManagerRemovableDriveHandler::StartFormatL()

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

//  

void CFileManagerRemovableDriveHandler::StartFormatL(

        const TInt aDrive )

    {

    TInt err( KErrNone );

    iDrive = aDrive;

    iProcess = MFileManagerProcessObserver::EFormatProcess;

    iFinalValue = 0;

    TRAP( err, InformStartL( 0 ) );

    if ( err == KErrNone )

        {

        // Close apps and then start format

        TRAP( err, CloseAppsL() );

        }

    if ( err != KErrNone )

        {

        EndFormatProcessL( err );

        }

    }

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

// CFileManagerRemovableDriveHandler::StartEjectL()

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

//  

void CFileManagerRemovableDriveHandler::StartEjectL()

    {

    TRAPD( err, StartEjectScanL() );

    if ( err != KErrNone )

        {

        iProcess = MFileManagerProcessObserver::ENoProcess;

        User::Leave( err );

        }

    }

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

// CFileManagerRemovableDriveHandler::StartEjectScanL()

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

//  

void CFileManagerRemovableDriveHandler::StartEjectScanL()

    {

    iProcess = MFileManagerProcessObserver::EEjectProcess;

    InformStartL( 0 );

    RProperty::Set(

        KPSUidCoreApplicationUIs,

        KCoreAppUIsMmcRemovedWithoutEject,

        ECoreAppUIsEjectCommandUsed );

    iEjectScanRounds = 0;

    iEjectScanPeriodic = CPeriodic::NewL( CActive::EPriorityLow );

    iEjectScanPeriodic->Start(

        KEjectScanInterval,

        KEjectScanInterval,

        TCallBack( EjectScanAndShutdownApps, this ) );

    }

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

// CFileManagerRemovableDriveHandler::CancelProcess()

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

//    

void CFileManagerRemovableDriveHandler::CancelProcess()

    {

    switch( iProcess )

        {

        case MFileManagerProcessObserver::EFormatProcess:

            {

            Cancel();

            break;

            }

        case MFileManagerProcessObserver::EBackupProcess: // FALLTHROUGH

        case MFileManagerProcessObserver::ERestoreProcess:

        case MFileManagerProcessObserver::ESchBackupProcess:

            {

            PublishBurStatus( EFileManagerBkupStatusUnset );

            iBkupEngine->CancelOperation();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CFileManagerRemovableDriveHandler::BackupFileExistsL()

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

//   

TBool CFileManagerRemovableDriveHandler::BackupFileExistsL(

        const TInt /*aDrive*/ )

    {

    HBufC* backupFile = BackupFileNameLC( ETrue );

    TBool ret( iBkupEngine->ValidArchiveForRestore( *backupFile ) );

    CleanupStack::PopAndDestroy( backupFile );

    return ret;

    }

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

// CFileManagerRemovableDriveHandler::StartBackupL()

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

//  

void CFileManagerRemovableDriveHandler::StartBackupL(

        MFileManagerProcessObserver::TFileManagerProcess aProcess )

    {

    if ( aProcess != MFileManagerProcessObserver::EBackupProcess &&

        aProcess != MFileManagerProcessObserver::ESchBackupProcess )

        {