--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/filemanager/src/filemanager/src/operationservice/fmoperationservice.cpp Tue Aug 31 15:06:05 2010 +0300
@@ -0,0 +1,549 @@
+/*
+ * Copyright (c) 2009 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:
+ * The source file of the operation service of file manager
+ */
+
+#include "fmoperationservice.h"
+#include "fmoperationthread.h"
+#include "fmbackupconfigloader.h"
+#include "fmbkupengine.h"
+#include "fmbackupsettings.h"
+#include "fmviewdetailsdialog.h"
+#include "fmoperationresultprocesser.h"
+#include "fmoperationcopyormove.h"
+#include "fmoperationremove.h"
+#include "fmoperationformat.h"
+#include "fmoperationviewdetails.h"
+#include "fmbackuprestorehandler.h"
+#include <hbaction.h>
+
+/* \fn void driveSpaceChanged( FmOperationBase* operationBase )
+ * This signal is emitted when disk size changed.
+ */
+
+/* \fn void notifyWaiting( FmOperationBase* operationBase, bool cancelable )
+ * This signal is emitted when the operation emits notifyWaiting.
+ */
+
+/* \fn void notifyPreparing( FmOperationBase* operationBase, bool cancelable )
+ * This signal is emitted when the operation emits notifyPreparing.
+ */
+
+/* \fn void notifyStart( FmOperationBase* operationBase, bool cancelable, int maxSteps )
+ * This signal is emitted when the operation emits notifyStart.
+ */
+
+/* \fn void notifyProgress( FmOperationBase* operationBase, int currentStep )
+ * This signal is emitted when the operation emits notifyProgress.
+ */
+
+/* \fn void notifyFinish( FmOperationBase* operationBase )
+ * This signal is emitted when the operation emits notifyFinish.
+ */
+
+/* \fn void notifyError( FmOperationBase* operationBase, int error, QString errString )
+ * This signal is emitted when the operation emits notifyError.
+ */
+
+/* \fn void notifyCanceled( FmOperationBase* operationBase )
+ * This signal is emitted when the operation emits notifyCanceled.
+ */
+
+/*
+ * Constructs one operation Service with \a parent.
+ */
+FmOperationService::FmOperationService( QObject *parent ) : QObject( parent ),
+ mCurrentOperation( 0 ), mBackupRestoreHandler( 0 )
+{
+ mThread = new FmOperationThread( this );
+ mThread->setObjectName( "operationThread" );
+ mOperationResultProcesser = new FmOperationResultProcesser( this );
+
+ QMetaObject::connectSlotsByName( this );
+}
+
+/*
+ * Destructs the operation service.
+ */
+FmOperationService::~FmOperationService()
+{
+ delete mThread;
+ mThread = 0;
+ delete mBackupRestoreHandler;
+ mBackupRestoreHandler = 0;
+}
+
+/*
+ * Returns true if the thread is running, false if not.
+ */
+bool FmOperationService::isRunning()
+{
+ return mThread->isRunning();
+}
+
+/*
+ * Copies the file or foler \a targetPath asynchronously.
+ */
+int FmOperationService::asyncCopy( const QStringList &sourceList, const QString &targetPath )
+{
+ Q_ASSERT( !mCurrentOperation );
+ mCurrentOperation = new FmOperationCopyOrMove( this, FmOperationService::EOperationTypeCopy, sourceList, targetPath );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Moves the file or foler \a sourceList to \a targetPath asynchronously.
+ */
+int FmOperationService::asyncMove( const QStringList &sourceList, const QString &targetPath )
+{
+ Q_ASSERT( !mCurrentOperation );
+
+ mCurrentOperation = new FmOperationCopyOrMove( this, FmOperationService::EOperationTypeMove, sourceList, targetPath );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Removes the file or dir \a pathList asynchronously.
+ */
+int FmOperationService::asyncRemove( const QStringList &pathList )
+{
+ Q_ASSERT( !mCurrentOperation );
+
+ mCurrentOperation = new FmOperationRemove( this, pathList );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Formats the drive \a driverName asynchronously.
+ */
+int FmOperationService::asyncFormat( const QString &driverName )
+{
+ Q_ASSERT( !mCurrentOperation );
+
+ mCurrentOperation = new FmOperationFormat( this, driverName );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Views drive \a driverName details asynchronously.
+ */
+int FmOperationService::asyncViewDriveDetails( const QString &driverName )
+{
+ Q_ASSERT( !mCurrentOperation );
+
+ mCurrentOperation = new FmOperationDriveDetails( this, driverName );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Views folder \a folderPath details asynchronously.
+ */
+int FmOperationService::asyncViewFolderDetails( const QString &folderPath )
+{
+ Q_ASSERT( !mCurrentOperation );
+
+ mCurrentOperation = new FmOperationFolderDetails( this, folderPath );
+ connectSignalsAndSlots( mCurrentOperation );
+ int ret = mThread->prepareOperationAndStart( mCurrentOperation );
+ if ( ret!= FmErrNone ) {
+ resetOperation();
+ return ret;
+ }
+ return FmErrNone;
+}
+
+/*
+ * Backups asynchronously.
+ */
+int FmOperationService::asyncBackup()
+{
+ if ( isRunning() )
+ return FmErrAlreadyStarted;
+ Q_ASSERT( !mCurrentOperation );
+
+ // BackupSettingsL will not leave, coding convention will be improvied in another task.
+ QString targetDrive( backupRestoreHandler()->bkupEngine()->BackupSettingsL()->availableTargetDrive() );
+ quint32 content( backupRestoreHandler()->bkupEngine()->BackupSettingsL()->content() );
+ FmOperationBackup *operationBackup =
+ new FmOperationBackup( backupRestoreHandler(), targetDrive, content );
+ mCurrentOperation = operationBackup;
+ int ret = backupRestoreHandler()->startBackup( operationBackup );
+ if( ret ){
+ return FmErrNone;
+ } else {
+ resetOperation();
+ return backupRestoreHandler()->error();
+ }
+}
+
+/*
+ * Restores asynchronously.
+ * \a selection selected restore items
+ */
+int FmOperationService::asyncRestore( quint64 selection )
+{
+ if ( isRunning() )
+ return FmErrAlreadyStarted;
+ Q_ASSERT( !mCurrentOperation );
+
+ FmOperationRestore* operationRestore = new FmOperationRestore( mBackupRestoreHandler, selection );
+ mCurrentOperation = operationRestore;
+ int ret = backupRestoreHandler()->startRestore( operationRestore );
+ if( ret ){
+ return FmErrNone;
+ } else {
+ resetOperation();
+ return backupRestoreHandler()->error();
+ }
+}
+
+/*
+ * Delete backup synchronously.
+ * \a selection selected backup items
+ */
+int FmOperationService::syncDeleteBackup( quint64 selection )
+{
+ return backupRestoreHandler()->deleteBackup( selection );
+}
+
+/*
+ * Cancels current operation.
+ */
+void FmOperationService::cancelOperation()
+{
+ switch( mCurrentOperation->operationType() )
+ {
+ case EOperationTypeBackup:
+ backupRestoreHandler()->cancelBackup();
+ break;
+ case EOperationTypeDriveDetails:
+ mThread->stop();
+ break;
+ case EOperationTypeFolderDetails:
+ mThread->stop();
+ break;
+ case EOperationTypeFormat:
+ //can not cancel format
+ break;
+ case EOperationTypeCopy:
+ mThread->stop();
+ break;
+ case EOperationTypeMove:
+ mThread->stop();
+ break;
+ case EOperationTypeRemove:
+ mThread->stop();
+ break;
+ default:
+ Q_ASSERT( false );
+ }
+}
+
+/*
+ * Set valume synchronously. not used.
+ */
+int FmOperationService::syncSetVolume( const QString &driverName, const QString &volume )
+{
+ Q_UNUSED( driverName );
+ Q_UNUSED( volume );
+ return FmErrNone;
+}
+
+/*
+ * Set drive password synchronously. not used.
+ */
+int FmOperationService::syncSetdDriverPassword( const QString &driverName,
+ const QString &oldPassword,
+ const QString &newPassword )
+{
+ Q_UNUSED( driverName );
+ Q_UNUSED( oldPassword );
+ Q_UNUSED( newPassword );
+ return FmErrNone;
+}
+
+/*
+ * Rename synchronously. not used.
+ */
+int FmOperationService::syncRename( const QString &oldPath, const QString &newName )
+{
+ Q_UNUSED( oldPath );
+ Q_UNUSED( newName );
+ return FmErrNone;
+}
+
+/*
+ * Launches the file in synchronous way.
+ */
+int FmOperationService::syncLaunchFileOpen( const QString &filePath )
+{
+ return FmUtils::launchFile( filePath );
+}
+
+/*
+ * Returns the backup handler.
+ */
+FmBackupRestoreHandler *FmOperationService::backupRestoreHandler()
+{
+ if( !mBackupRestoreHandler ) {
+ mBackupRestoreHandler = new FmBackupRestoreHandler( this );
+ mBackupRestoreHandler->setObjectName( "backupRestore" ) ;
+ QMetaObject::connectSlotsByName( this );
+ }
+ return mBackupRestoreHandler;
+}
+
+/*
+ * Deletes the operation and set it to be 0.
+ */
+void FmOperationService::resetOperation()
+{
+ if( mCurrentOperation ) {
+ delete mCurrentOperation;
+ mCurrentOperation = 0;
+ }
+}
+
+/*
+ * Connects \a operation's sinals to slots
+ */
+void FmOperationService::connectSignalsAndSlots( FmOperationBase *operation )
+{
+
+ connect( operation, SIGNAL( showNote( QString ) ),
+ this, SLOT( on_operation_showNote( QString )), Qt::BlockingQueuedConnection );
+ connect( operation, SIGNAL( notifyError( int, QString ) ),
+ this, SLOT( on_operation_notifyError( int, QString ) ) );
+ connect( operation, SIGNAL( notifyStart( bool, int ) ),
+ this, SLOT( on_operation_notifyStart( bool, int ) ) );
+ connect( operation, SIGNAL( notifyProgress( int ) ),
+ this, SLOT( on_operation_notifyProgress( int ) ) );
+ connect( operation, SIGNAL( notifyFinish() ),
+ this, SLOT( on_operation_notifyFinish()) );
+ connect( operation, SIGNAL( notifyWaiting( bool ) ),
+ this, SLOT( on_operation_notifyWaiting( bool )) );
+
+}
+
+/*
+ * Responds to mCurrentOperation's askForRename signal.
+ * \a srcFile the source file.
+ * \a destFile the new file name.
+ */
+void FmOperationService::on_operation_askForRename( const QString &srcFile, QString *destFile )
+{
+ mOperationResultProcesser->onAskForRename(
+ mCurrentOperation, srcFile, destFile );
+}
+
+/*
+ * Responds to mCurrentOperation's askForReplace signal.
+ * \a srcFile the source file.
+ * \a destFile the target file.
+ * \a isAccepted whether to replace the target file.
+ */
+void FmOperationService::on_operation_askForReplace( const QString &srcFile, const QString &destFile, bool *isAccepted )
+{
+ mOperationResultProcesser->onAskForReplace(
+ mCurrentOperation, srcFile, destFile, isAccepted );
+}
+
+/*
+ * Responds to mCurrentOperation's showNote signal.
+ * \a noteString the note content.
+ */
+void FmOperationService::on_operation_showNote( const char *noteString )
+{
+ mOperationResultProcesser->onShowNote( mCurrentOperation, noteString );
+}
+
+/*
+ * Responds to mCurrentOperation's showNote signal.
+ * \a noteString the note content.
+ */
+void FmOperationService::on_operation_notifyWaiting( bool cancelable )
+{
+ mOperationResultProcesser->onNotifyWaiting(
+ mCurrentOperation, cancelable );
+ emit notifyWaiting( mCurrentOperation, cancelable );
+}
+
+/*
+ * Responds to mCurrentOperation's notifyPreparing signal.
+ * \a cancelable indicates whether the progress bar could be cancelled.
+ */
+void FmOperationService::on_operation_notifyPreparing( bool cancelable )
+{
+ mOperationResultProcesser->onNotifyPreparing(
+ mCurrentOperation, cancelable );
+ emit notifyPreparing( mCurrentOperation, cancelable );
+}
+
+/*
+ * Responds to mCurrentOperation's notifyPreparing signal.
+ * \a cancelable indicates whether the progress bar could be cancelled.
+ * \maxSteps the length of progress bar.
+ */
+void FmOperationService::on_operation_notifyStart( bool cancelable, int maxSteps )
+{
+ mOperationResultProcesser->onNotifyStart(
+ mCurrentOperation, cancelable, maxSteps );
+ emit notifyStart( mCurrentOperation, cancelable, maxSteps );
+}
+
+/*
+ * Responds to mCurrentOperation's notifyPreparing signal.
+ * \a currentStep indicates the current length of progress bar.
+ */
+void FmOperationService::on_operation_notifyProgress( int currentStep )
+{
+ mOperationResultProcesser->onNotifyProgress(
+ mCurrentOperation, currentStep );
+ emit notifyProgress( mCurrentOperation, currentStep );
+}
+
+/*
+ * Responds to mCurrentOperation's notifyFinish signal, indicate the
+ * progress is over.
+ */
+void FmOperationService::on_operation_notifyFinish()
+{
+ mOperationResultProcesser->onNotifyFinish( mCurrentOperation );
+ emit notifyFinish( mCurrentOperation );
+ resetOperation();
+}
+
+/*
+ * Responds to mCurrentOperation's notifyError signal.
+ * \a error error id.
+ * \a errString the error string.
+ */
+void FmOperationService::on_operation_notifyError(int error, QString errString )
+{
+ mOperationResultProcesser->onNotifyError(
+ mCurrentOperation, error, errString );
+ emit notifyError( mCurrentOperation, error, errString );
+ resetOperation();
+}
+
+/*
+ * Responds to mCurrentOperation's driveSpaceChanged
+ */
+void FmOperationService::on_operation_driveSpaceChanged()
+{
+ emit driveSpaceChanged( mCurrentOperation );
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyPreparing
+ * \a cancelable indicates whether it could be cancelled.
+ */
+void FmOperationService::on_backupRestore_notifyPreparing( bool cancelable )
+{
+ mOperationResultProcesser->onNotifyPreparing(
+ mCurrentOperation, cancelable );
+ emit notifyPreparing( mCurrentOperation, cancelable );
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyStart
+ * \a cancelable indicates whether it could be cancelled.
+ * \a maxSteps the lenth of progress bar.
+ */
+void FmOperationService::on_backupRestore_notifyStart( bool cancelable, int maxSteps )
+{
+ mOperationResultProcesser->onNotifyStart(
+ mCurrentOperation, cancelable, maxSteps );
+ emit notifyStart( mCurrentOperation, cancelable, maxSteps );
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyProgress
+ * \a currentStep the current progress bar's step.
+ */
+void FmOperationService::on_backupRestore_notifyProgress( int currentStep )
+{
+ mOperationResultProcesser->onNotifyProgress(
+ mCurrentOperation, currentStep );
+ emit notifyProgress( mCurrentOperation, currentStep );
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyFinish
+ */
+void FmOperationService::on_backupRestore_notifyFinish()
+{
+ mOperationResultProcesser->onNotifyFinish( mCurrentOperation );
+ emit notifyFinish( mCurrentOperation );
+ resetOperation();
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyError
+ * \a error the error id.
+ * \a errString the error string.
+ */
+void FmOperationService::on_backupRestore_notifyError(int error, const QString &errString )
+{
+ mOperationResultProcesser->onNotifyError(
+ mCurrentOperation, error, errString );
+ emit notifyError( mCurrentOperation, error, errString );
+ resetOperation();
+}
+
+/*
+ * Responds to mBackupRestoreHandler's notifyCanceled
+ */
+void FmOperationService::on_backupRestore_notifyCanceled()
+{
+ mOperationResultProcesser->onNotifyError(
+ mCurrentOperation, FmErrCancel, QString() );
+ emit notifyError( mCurrentOperation, FmErrCancel, QString() );
+ resetOperation();
+}
+
+///
+/////////////////////////////////////////////////////