--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/filemanager/App/src/CFileManagerSchBackupHandler.cpp Wed Sep 01 12:31:07 2010 +0100
@@ -0,0 +1,423 @@
+/*
+* 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: Handler for scheduled backup
+*
+*/
+
+
+ #define FILE_MANAGER_POWER_SAVING_MODE
+
+// INCLUDE FILES
+#include <StringLoader.h>
+#include <centralrepository.h>
+#include <avkon.hrh>
+#include <avkon.rsg>
+#include <filemanager.rsg>
+#include <FileManagerDebug.h>
+#include <FileManagerPrivateCRKeys.h>
+#include <CFileManagerEngine.h>
+#include <CFileManagerBackupSettings.h>
+#include <MFileManagerProcessObserver.h>
+#include <CFileManagerGlobalDlg.h>
+#ifdef FILE_MANAGER_POWER_SAVING_MODE
+ #include <psmsrvdomaincrkeys.h>
+#endif // FILE_MANAGER_POWER_SAVING_MODE
+#include "CFileManagerSchBackupHandler.h"
+#include "MFileManagerSchBackupObserver.h"
+
+
+// ======== MEMBER FUNCTIONS ========
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::CFileManagerSchBackupHandler
+// ----------------------------------------------------------------------------
+//
+CFileManagerSchBackupHandler::CFileManagerSchBackupHandler(
+ CFileManagerEngine& aEngine ) :
+ iEngine( aEngine )
+ {
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::NewL
+// ----------------------------------------------------------------------------
+//
+CFileManagerSchBackupHandler* CFileManagerSchBackupHandler::NewL(
+ CFileManagerEngine& aEngine )
+ {
+ CFileManagerSchBackupHandler* self =
+ new( ELeave ) CFileManagerSchBackupHandler( aEngine );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::ConstructL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::ConstructL()
+ {
+ FUNC_LOG
+
+ iGlobalDlg = CFileManagerGlobalDlg::NewL();
+ iGlobalDlg->SetObserver( this );
+
+ iCenRep = CRepository::NewL( KCRUidFileManagerSettings );
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::~CFileManagerSchBackupHandler
+// ----------------------------------------------------------------------------
+//
+CFileManagerSchBackupHandler::~CFileManagerSchBackupHandler()
+ {
+ FUNC_LOG
+
+ delete iGlobalDlg;
+ delete iCenRep;
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::HandleGlobalDlgResult
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::HandleGlobalDlgResult(
+ TInt aDlgType,
+ TInt aDlgResult )
+ {
+ INFO_LOG2(
+ "CFileManagerSchBackupHandler::HandleGlobalDlgResult-aDlgType=%d,aDlgResult=%d",
+ aDlgType, aDlgResult )
+ TInt err( KErrNone );
+ switch ( aDlgType )
+ {
+ case CFileManagerGlobalDlg::ECountdownQuery:
+ {
+ if ( aDlgResult == EAknSoftkeyYes )
+ {
+ // Backup was accepted
+ StartBackup();
+
+ err = iCenRep->Set(
+ KFileManagerLastSchBackupStatus,
+ EFileManagerSchBackupStatusInProgress );
+ }
+ else
+ {
+ // Backup was rejected
+ InformObserver( KErrCancel );
+ CancelBackupStarter();
+ }
+ break;
+ }
+ case CFileManagerGlobalDlg::EProgressDialog:
+ {
+ // Backup was canceled
+ iEngine.CancelProcess(
+ MFileManagerProcessObserver::ESchBackupProcess );
+ InformObserver( KErrCancel );
+ CancelBackupStarter();
+ break;
+ }
+ default:
+ {
+ InformObserver( aDlgResult );
+ break;
+ }
+ }
+
+ LOG_IF_ERROR1( err,
+ "CFileManagerSchBackupHandler::HandleGlobalDlgResult-err=%d", err )
+
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::StartBackupWithConfirmL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::StartBackupWithConfirmL()
+ {
+ TBool psmOn( EFalse );
+ TRAPD( err, psmOn = IsPowerSavingModeOnL() );
+ if ( psmOn && err == KErrNone )
+ {
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::EQueryWithInfoIcon,
+ R_QTN_FMGR_SCHEDULED_BACKUP_CANCELLED_PS,
+ R_AVKON_SOFTKEYS_OK_EMPTY );
+ CancelBackupStarter();
+ return;
+ }
+
+ // Show cancelable global confirm countdown before starting backup.
+ // Backup is started only if accepted or countdown has expired.
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::ECountdownQuery,
+ R_QTN_FMGR_SCHEDULED_BACKUP_QUERY );
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::StartBackupL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::StartBackupL()
+ {
+ CFileManagerBackupSettings& settings( iEngine.BackupSettingsL() );
+ TFileManagerDriveInfo drvInfo;
+ iEngine.GetDriveInfoL( settings.TargetDrive(), drvInfo );
+ TBool drvAvailable( EFalse );
+
+ if( !IsTargetDriveAvailableL(drvInfo ) )
+ {
+ for( TInt i ( EDriveA ); i <= EDriveZ; i++ )
+ {
+ iEngine.GetDriveInfoL( i , drvInfo );
+ if( ( IsTargetDriveAvailableL( drvInfo ) ) && ( drvInfo.iState & TFileManagerDriveInfo::EDriveEjectable ) )
+ {
+ settings.SetTargetDrive( i );
+ settings.SaveL();
+ drvAvailable = ETrue;
+ break;
+ }
+ }
+ }
+ else
+ {
+ drvAvailable = ETrue;
+ }
+ if ( !drvAvailable )
+ {
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::EQueryWithWarningIcon,
+ R_QTN_FMGR_SCHEDULED_BACKUP_ERROR,
+ R_AVKON_SOFTKEYS_OK_EMPTY );
+ CancelBackupStarter();
+ return;
+ }
+
+ HBufC* text = StringLoader::LoadLC(
+ R_QTN_FMGR_SCHEDULED_BACKUP_PROGRESS,
+ iEngine.DriveName( settings.TargetDrive() ) );
+
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::EProgressDialog,
+ *text );
+
+ CleanupStack::PopAndDestroy( text );
+
+ iEngine.StartBackupProcessL(
+ MFileManagerProcessObserver::ESchBackupProcess );
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::SetObserver
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::SetObserver(
+ MFileManagerSchBackupObserver* aObserver )
+ {
+ iObserver = aObserver;
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::StartBackupWithConfirm
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::StartBackupWithConfirm()
+ {
+ FUNC_LOG
+
+ if ( iBackupOngoing )
+ {
+ return;
+ }
+
+ iBackupOngoing = ETrue;
+
+ TRAPD( err, StartBackupWithConfirmL() );
+ if ( err != KErrNone )
+ {
+ InformObserver( err );
+ }
+ else
+ {
+ // Confirm scheduled backup start state
+ TInt err( iCenRep->Set(
+ KFileManagerLastSchBackupStatus,
+ EFileManagerSchBackupStatusInProgress ) );
+
+ LOG_IF_ERROR1( err,
+ "CFileManagerSchBackupHandler::StartBackupWithConfirm-err=%d", err )
+
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::StartBackup
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::StartBackup()
+ {
+ FUNC_LOG
+
+ TRAPD( err, StartBackupL() );
+ if ( err != KErrNone )
+ {
+ InformObserver( err );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::InformObserver
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::InformObserver( const TInt aValue )
+ {
+ INFO_LOG1( "CFileManagerSchBackupHandler::InformObserver-aValue=%d", aValue )
+
+ iBackupOngoing = EFalse;
+ if ( iObserver )
+ {
+ TRAP_IGNORE( iObserver->SchBackupFinishedL( aValue ) );
+ }
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::ProcessFinishedL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::ProcessFinishedL(
+ TInt aError, const TDesC& /*aName*/ )
+ {
+ INFO_LOG1( "CFileManagerSchBackupHandler::ProcessFinishedL-aError=%d",
+ aError )
+
+ iGlobalDlg->CancelDialog();
+ TInt err( KErrNone );
+ if ( aError == KErrCancel )
+ {
+ CancelBackupStarter();
+ }
+ else if ( aError != KErrNone )
+ {
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::EErrorNote,
+ R_QTN_CRITICAL_ERROR );
+
+ err = iCenRep->Set(
+ KFileManagerLastSchBackupStatus,
+ EFileManagerSchBackupStatusFailed );
+ }
+ else
+ {
+ iGlobalDlg->ShowDialogL(
+ CFileManagerGlobalDlg::EInfoNote,
+ R_QTN_BACKUP_COMPLETED );
+
+ err = iCenRep->Set(
+ KFileManagerLastSchBackupStatus,
+ EFileManagerSchBackupStatusOk );
+ }
+
+ LOG_IF_ERROR1( err,
+ "CFileManagerSchBackupHandler::ProcessFinishedL-err=%d", err )
+
+ InformObserver( aError );
+
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::ProcessAdvanceL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::ProcessAdvanceL( TInt aValue )
+ {
+ iGlobalDlg->UpdateProgressDialog( aValue );
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::ProcessStartedL
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::ProcessStartedL( TInt aFinalValue )
+ {
+ FUNC_LOG
+
+ iGlobalDlg->UpdateProgressDialog( 0, aFinalValue );
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::CancelBackupStarter
+// ----------------------------------------------------------------------------
+//
+void CFileManagerSchBackupHandler::CancelBackupStarter()
+ {
+ TInt err( iCenRep->Set(
+ KFileManagerLastSchBackupStatus,
+ EFileManagerSchBackupStatusCanceled ) );
+ LOG_IF_ERROR1( err,
+ "CFileManagerSchBackupHandler::CancelBackupStarter-err=%d", err )
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::IsPowerSavingModeOnL
+// ----------------------------------------------------------------------------
+//
+TBool CFileManagerSchBackupHandler::IsPowerSavingModeOnL()
+ {
+ TBool ret( EFalse );
+#ifdef FILE_MANAGER_POWER_SAVING_MODE
+ // Check power saving mode before start
+ CRepository* psmCenRep = CRepository::NewLC( KCRUidPowerSaveMode );
+ TInt psmMode( 0 );
+ User::LeaveIfError( psmCenRep->Get( KPsmCurrentMode, psmMode ) );
+ if ( psmMode )
+ {
+ ERROR_LOG1(
+ "CFileManagerSchBackupHandler::IsPowerSavingModeOnL-PsmMode=%d",
+ psmMode )
+ ret = ETrue;
+ }
+ CleanupStack::PopAndDestroy( psmCenRep );
+#endif // FILE_MANAGER_POWER_SAVING_MODE
+ return ret;
+ }
+
+// ----------------------------------------------------------------------------
+// CFileManagerSchBackupHandler::IsTargetDriveAvailableL
+// ----------------------------------------------------------------------------
+//
+TBool CFileManagerSchBackupHandler::IsTargetDriveAvailableL( const TFileManagerDriveInfo& aDrvInfo )
+ {
+ // Start backup with cancelable global progress dialog
+
+ // Check is target drive available
+ TBool ret( ETrue );
+ if ( !( aDrvInfo.iState & TFileManagerDriveInfo::EDrivePresent ) ||
+ ( aDrvInfo.iState &
+ ( TFileManagerDriveInfo::EDriveLocked |
+ TFileManagerDriveInfo::EDriveCorrupted |
+ TFileManagerDriveInfo::EDriveWriteProtected ) ) )
+ {
+ ERROR_LOG1(
+ "CFileManagerSchBackupHandler::IsTargetDriveAvailableL-DrvState=%d",
+ aDrvInfo.iState )
+ ret = EFalse;
+ }
+ return ret;
+ }
+
+// End of File