1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * |
|
15 * Description: |
|
16 * The source file of the operation service of file manager |
|
17 */ |
|
18 |
|
19 #include "fmoperationservice.h" |
|
20 #include "fmoperationthread.h" |
|
21 #include "fmbackupconfigloader.h" |
|
22 #include "fmbkupengine.h" |
|
23 #include "fmbackupsettings.h" |
|
24 #include "fmviewdetailsdialog.h" |
|
25 #include "fmoperationresultprocesser.h" |
|
26 #include "fmoperationcopyormove.h" |
|
27 #include "fmoperationremove.h" |
|
28 #include "fmoperationformat.h" |
|
29 #include "fmoperationviewdetails.h" |
|
30 #include "fmbackuprestorehandler.h" |
|
31 #include <hbaction.h> |
|
32 |
|
33 /* \fn void driveSpaceChanged( FmOperationBase* operationBase ) |
|
34 * This signal is emitted when disk size changed. |
|
35 */ |
|
36 |
|
37 /* \fn void notifyWaiting( FmOperationBase* operationBase, bool cancelable ) |
|
38 * This signal is emitted when the operation emits notifyWaiting. |
|
39 */ |
|
40 |
|
41 /* \fn void notifyPreparing( FmOperationBase* operationBase, bool cancelable ) |
|
42 * This signal is emitted when the operation emits notifyPreparing. |
|
43 */ |
|
44 |
|
45 /* \fn void notifyStart( FmOperationBase* operationBase, bool cancelable, int maxSteps ) |
|
46 * This signal is emitted when the operation emits notifyStart. |
|
47 */ |
|
48 |
|
49 /* \fn void notifyProgress( FmOperationBase* operationBase, int currentStep ) |
|
50 * This signal is emitted when the operation emits notifyProgress. |
|
51 */ |
|
52 |
|
53 /* \fn void notifyFinish( FmOperationBase* operationBase ) |
|
54 * This signal is emitted when the operation emits notifyFinish. |
|
55 */ |
|
56 |
|
57 /* \fn void notifyError( FmOperationBase* operationBase, int error, QString errString ) |
|
58 * This signal is emitted when the operation emits notifyError. |
|
59 */ |
|
60 |
|
61 /* \fn void notifyCanceled( FmOperationBase* operationBase ) |
|
62 * This signal is emitted when the operation emits notifyCanceled. |
|
63 */ |
|
64 |
|
65 /* |
|
66 * Constructs one operation Service with \a parent. |
|
67 */ |
|
68 FmOperationService::FmOperationService( QObject *parent ) : QObject( parent ), |
|
69 mCurrentOperation( 0 ), mBackupRestoreHandler( 0 ) |
|
70 { |
|
71 mThread = new FmOperationThread( this ); |
|
72 mThread->setObjectName( "operationThread" ); |
|
73 mOperationResultProcesser = new FmOperationResultProcesser( this ); |
|
74 |
|
75 QMetaObject::connectSlotsByName( this ); |
|
76 } |
|
77 |
|
78 /* |
|
79 * Destructs the operation service. |
|
80 */ |
|
81 FmOperationService::~FmOperationService() |
|
82 { |
|
83 delete mThread; |
|
84 mThread = 0; |
|
85 delete mBackupRestoreHandler; |
|
86 mBackupRestoreHandler = 0; |
|
87 } |
|
88 |
|
89 /* |
|
90 * Returns true if the thread is running, false if not. |
|
91 */ |
|
92 bool FmOperationService::isRunning() |
|
93 { |
|
94 return mThread->isRunning(); |
|
95 } |
|
96 |
|
97 /* |
|
98 * Copies the file or foler \a targetPath asynchronously. |
|
99 */ |
|
100 int FmOperationService::asyncCopy( const QStringList &sourceList, const QString &targetPath ) |
|
101 { |
|
102 Q_ASSERT( !mCurrentOperation ); |
|
103 mCurrentOperation = new FmOperationCopyOrMove( this, FmOperationService::EOperationTypeCopy, sourceList, targetPath ); |
|
104 connectSignalsAndSlots( mCurrentOperation ); |
|
105 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
106 if ( ret!= FmErrNone ) { |
|
107 resetOperation(); |
|
108 return ret; |
|
109 } |
|
110 return FmErrNone; |
|
111 } |
|
112 |
|
113 /* |
|
114 * Moves the file or foler \a sourceList to \a targetPath asynchronously. |
|
115 */ |
|
116 int FmOperationService::asyncMove( const QStringList &sourceList, const QString &targetPath ) |
|
117 { |
|
118 Q_ASSERT( !mCurrentOperation ); |
|
119 |
|
120 mCurrentOperation = new FmOperationCopyOrMove( this, FmOperationService::EOperationTypeMove, sourceList, targetPath ); |
|
121 connectSignalsAndSlots( mCurrentOperation ); |
|
122 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
123 if ( ret!= FmErrNone ) { |
|
124 resetOperation(); |
|
125 return ret; |
|
126 } |
|
127 return FmErrNone; |
|
128 } |
|
129 |
|
130 /* |
|
131 * Removes the file or dir \a pathList asynchronously. |
|
132 */ |
|
133 int FmOperationService::asyncRemove( const QStringList &pathList ) |
|
134 { |
|
135 Q_ASSERT( !mCurrentOperation ); |
|
136 |
|
137 mCurrentOperation = new FmOperationRemove( this, pathList ); |
|
138 connectSignalsAndSlots( mCurrentOperation ); |
|
139 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
140 if ( ret!= FmErrNone ) { |
|
141 resetOperation(); |
|
142 return ret; |
|
143 } |
|
144 return FmErrNone; |
|
145 } |
|
146 |
|
147 /* |
|
148 * Formats the drive \a driverName asynchronously. |
|
149 */ |
|
150 int FmOperationService::asyncFormat( const QString &driverName ) |
|
151 { |
|
152 Q_ASSERT( !mCurrentOperation ); |
|
153 |
|
154 mCurrentOperation = new FmOperationFormat( this, driverName ); |
|
155 connectSignalsAndSlots( mCurrentOperation ); |
|
156 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
157 if ( ret!= FmErrNone ) { |
|
158 resetOperation(); |
|
159 return ret; |
|
160 } |
|
161 return FmErrNone; |
|
162 } |
|
163 |
|
164 /* |
|
165 * Views drive \a driverName details asynchronously. |
|
166 */ |
|
167 int FmOperationService::asyncViewDriveDetails( const QString &driverName ) |
|
168 { |
|
169 Q_ASSERT( !mCurrentOperation ); |
|
170 |
|
171 mCurrentOperation = new FmOperationDriveDetails( this, driverName ); |
|
172 connectSignalsAndSlots( mCurrentOperation ); |
|
173 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
174 if ( ret!= FmErrNone ) { |
|
175 resetOperation(); |
|
176 return ret; |
|
177 } |
|
178 return FmErrNone; |
|
179 } |
|
180 |
|
181 /* |
|
182 * Views folder \a folderPath details asynchronously. |
|
183 */ |
|
184 int FmOperationService::asyncViewFolderDetails( const QString &folderPath ) |
|
185 { |
|
186 Q_ASSERT( !mCurrentOperation ); |
|
187 |
|
188 mCurrentOperation = new FmOperationFolderDetails( this, folderPath ); |
|
189 connectSignalsAndSlots( mCurrentOperation ); |
|
190 int ret = mThread->prepareOperationAndStart( mCurrentOperation ); |
|
191 if ( ret!= FmErrNone ) { |
|
192 resetOperation(); |
|
193 return ret; |
|
194 } |
|
195 return FmErrNone; |
|
196 } |
|
197 |
|
198 /* |
|
199 * Backups asynchronously. |
|
200 */ |
|
201 int FmOperationService::asyncBackup() |
|
202 { |
|
203 if ( isRunning() ) |
|
204 return FmErrAlreadyStarted; |
|
205 Q_ASSERT( !mCurrentOperation ); |
|
206 |
|
207 // BackupSettingsL will not leave, coding convention will be improvied in another task. |
|
208 QString targetDrive( backupRestoreHandler()->bkupEngine()->BackupSettingsL()->availableTargetDrive() ); |
|
209 quint32 content( backupRestoreHandler()->bkupEngine()->BackupSettingsL()->content() ); |
|
210 FmOperationBackup *operationBackup = |
|
211 new FmOperationBackup( backupRestoreHandler(), targetDrive, content ); |
|
212 mCurrentOperation = operationBackup; |
|
213 int ret = backupRestoreHandler()->startBackup( operationBackup ); |
|
214 if( ret ){ |
|
215 return FmErrNone; |
|
216 } else { |
|
217 resetOperation(); |
|
218 return backupRestoreHandler()->error(); |
|
219 } |
|
220 } |
|
221 |
|
222 /* |
|
223 * Restores asynchronously. |
|
224 * \a selection selected restore items |
|
225 */ |
|
226 int FmOperationService::asyncRestore( quint64 selection ) |
|
227 { |
|
228 if ( isRunning() ) |
|
229 return FmErrAlreadyStarted; |
|
230 Q_ASSERT( !mCurrentOperation ); |
|
231 |
|
232 FmOperationRestore* operationRestore = new FmOperationRestore( mBackupRestoreHandler, selection ); |
|
233 mCurrentOperation = operationRestore; |
|
234 int ret = backupRestoreHandler()->startRestore( operationRestore ); |
|
235 if( ret ){ |
|
236 return FmErrNone; |
|
237 } else { |
|
238 resetOperation(); |
|
239 return backupRestoreHandler()->error(); |
|
240 } |
|
241 } |
|
242 |
|
243 /* |
|
244 * Delete backup synchronously. |
|
245 * \a selection selected backup items |
|
246 */ |
|
247 int FmOperationService::syncDeleteBackup( quint64 selection ) |
|
248 { |
|
249 return backupRestoreHandler()->deleteBackup( selection ); |
|
250 } |
|
251 |
|
252 /* |
|
253 * Cancels current operation. |
|
254 */ |
|
255 void FmOperationService::cancelOperation() |
|
256 { |
|
257 switch( mCurrentOperation->operationType() ) |
|
258 { |
|
259 case EOperationTypeBackup: |
|
260 backupRestoreHandler()->cancelBackup(); |
|
261 break; |
|
262 case EOperationTypeDriveDetails: |
|
263 mThread->stop(); |
|
264 break; |
|
265 case EOperationTypeFolderDetails: |
|
266 mThread->stop(); |
|
267 break; |
|
268 case EOperationTypeFormat: |
|
269 //can not cancel format |
|
270 break; |
|
271 case EOperationTypeCopy: |
|
272 mThread->stop(); |
|
273 break; |
|
274 case EOperationTypeMove: |
|
275 mThread->stop(); |
|
276 break; |
|
277 case EOperationTypeRemove: |
|
278 mThread->stop(); |
|
279 break; |
|
280 default: |
|
281 Q_ASSERT( false ); |
|
282 } |
|
283 } |
|
284 |
|
285 /* |
|
286 * Set valume synchronously. not used. |
|
287 */ |
|
288 int FmOperationService::syncSetVolume( const QString &driverName, const QString &volume ) |
|
289 { |
|
290 Q_UNUSED( driverName ); |
|
291 Q_UNUSED( volume ); |
|
292 return FmErrNone; |
|
293 } |
|
294 |
|
295 /* |
|
296 * Set drive password synchronously. not used. |
|
297 */ |
|
298 int FmOperationService::syncSetdDriverPassword( const QString &driverName, |
|
299 const QString &oldPassword, |
|
300 const QString &newPassword ) |
|
301 { |
|
302 Q_UNUSED( driverName ); |
|
303 Q_UNUSED( oldPassword ); |
|
304 Q_UNUSED( newPassword ); |
|
305 return FmErrNone; |
|
306 } |
|
307 |
|
308 /* |
|
309 * Rename synchronously. not used. |
|
310 */ |
|
311 int FmOperationService::syncRename( const QString &oldPath, const QString &newName ) |
|
312 { |
|
313 Q_UNUSED( oldPath ); |
|
314 Q_UNUSED( newName ); |
|
315 return FmErrNone; |
|
316 } |
|
317 |
|
318 /* |
|
319 * Launches the file in synchronous way. |
|
320 */ |
|
321 int FmOperationService::syncLaunchFileOpen( const QString &filePath ) |
|
322 { |
|
323 return FmUtils::launchFile( filePath ); |
|
324 } |
|
325 |
|
326 /* |
|
327 * Returns the backup handler. |
|
328 */ |
|
329 FmBackupRestoreHandler *FmOperationService::backupRestoreHandler() |
|
330 { |
|
331 if( !mBackupRestoreHandler ) { |
|
332 mBackupRestoreHandler = new FmBackupRestoreHandler( this ); |
|
333 mBackupRestoreHandler->setObjectName( "backupRestore" ) ; |
|
334 QMetaObject::connectSlotsByName( this ); |
|
335 } |
|
336 return mBackupRestoreHandler; |
|
337 } |
|
338 |
|
339 /* |
|
340 * Deletes the operation and set it to be 0. |
|
341 */ |
|
342 void FmOperationService::resetOperation() |
|
343 { |
|
344 if( mCurrentOperation ) { |
|
345 delete mCurrentOperation; |
|
346 mCurrentOperation = 0; |
|
347 } |
|
348 } |
|
349 |
|
350 /* |
|
351 * Connects \a operation's sinals to slots |
|
352 */ |
|
353 void FmOperationService::connectSignalsAndSlots( FmOperationBase *operation ) |
|
354 { |
|
355 |
|
356 connect( operation, SIGNAL( showNote( QString ) ), |
|
357 this, SLOT( on_operation_showNote( QString )), Qt::BlockingQueuedConnection ); |
|
358 connect( operation, SIGNAL( notifyError( int, QString ) ), |
|
359 this, SLOT( on_operation_notifyError( int, QString ) ) ); |
|
360 connect( operation, SIGNAL( notifyStart( bool, int ) ), |
|
361 this, SLOT( on_operation_notifyStart( bool, int ) ) ); |
|
362 connect( operation, SIGNAL( notifyProgress( int ) ), |
|
363 this, SLOT( on_operation_notifyProgress( int ) ) ); |
|
364 connect( operation, SIGNAL( notifyFinish() ), |
|
365 this, SLOT( on_operation_notifyFinish()) ); |
|
366 connect( operation, SIGNAL( notifyWaiting( bool ) ), |
|
367 this, SLOT( on_operation_notifyWaiting( bool )) ); |
|
368 |
|
369 } |
|
370 |
|
371 /* |
|
372 * Responds to mCurrentOperation's askForRename signal. |
|
373 * \a srcFile the source file. |
|
374 * \a destFile the new file name. |
|
375 */ |
|
376 void FmOperationService::on_operation_askForRename( const QString &srcFile, QString *destFile ) |
|
377 { |
|
378 mOperationResultProcesser->onAskForRename( |
|
379 mCurrentOperation, srcFile, destFile ); |
|
380 } |
|
381 |
|
382 /* |
|
383 * Responds to mCurrentOperation's askForReplace signal. |
|
384 * \a srcFile the source file. |
|
385 * \a destFile the target file. |
|
386 * \a isAccepted whether to replace the target file. |
|
387 */ |
|
388 void FmOperationService::on_operation_askForReplace( const QString &srcFile, const QString &destFile, bool *isAccepted ) |
|
389 { |
|
390 mOperationResultProcesser->onAskForReplace( |
|
391 mCurrentOperation, srcFile, destFile, isAccepted ); |
|
392 } |
|
393 |
|
394 /* |
|
395 * Responds to mCurrentOperation's showNote signal. |
|
396 * \a noteString the note content. |
|
397 */ |
|
398 void FmOperationService::on_operation_showNote( const char *noteString ) |
|
399 { |
|
400 mOperationResultProcesser->onShowNote( mCurrentOperation, noteString ); |
|
401 } |
|
402 |
|
403 /* |
|
404 * Responds to mCurrentOperation's showNote signal. |
|
405 * \a noteString the note content. |
|
406 */ |
|
407 void FmOperationService::on_operation_notifyWaiting( bool cancelable ) |
|
408 { |
|
409 mOperationResultProcesser->onNotifyWaiting( |
|
410 mCurrentOperation, cancelable ); |
|
411 emit notifyWaiting( mCurrentOperation, cancelable ); |
|
412 } |
|
413 |
|
414 /* |
|
415 * Responds to mCurrentOperation's notifyPreparing signal. |
|
416 * \a cancelable indicates whether the progress bar could be cancelled. |
|
417 */ |
|
418 void FmOperationService::on_operation_notifyPreparing( bool cancelable ) |
|
419 { |
|
420 mOperationResultProcesser->onNotifyPreparing( |
|
421 mCurrentOperation, cancelable ); |
|
422 emit notifyPreparing( mCurrentOperation, cancelable ); |
|
423 } |
|
424 |
|
425 /* |
|
426 * Responds to mCurrentOperation's notifyPreparing signal. |
|
427 * \a cancelable indicates whether the progress bar could be cancelled. |
|
428 * \maxSteps the length of progress bar. |
|
429 */ |
|
430 void FmOperationService::on_operation_notifyStart( bool cancelable, int maxSteps ) |
|
431 { |
|
432 mOperationResultProcesser->onNotifyStart( |
|
433 mCurrentOperation, cancelable, maxSteps ); |
|
434 emit notifyStart( mCurrentOperation, cancelable, maxSteps ); |
|
435 } |
|
436 |
|
437 /* |
|
438 * Responds to mCurrentOperation's notifyPreparing signal. |
|
439 * \a currentStep indicates the current length of progress bar. |
|
440 */ |
|
441 void FmOperationService::on_operation_notifyProgress( int currentStep ) |
|
442 { |
|
443 mOperationResultProcesser->onNotifyProgress( |
|
444 mCurrentOperation, currentStep ); |
|
445 emit notifyProgress( mCurrentOperation, currentStep ); |
|
446 } |
|
447 |
|
448 /* |
|
449 * Responds to mCurrentOperation's notifyFinish signal, indicate the |
|
450 * progress is over. |
|
451 */ |
|
452 void FmOperationService::on_operation_notifyFinish() |
|
453 { |
|
454 mOperationResultProcesser->onNotifyFinish( mCurrentOperation ); |
|
455 emit notifyFinish( mCurrentOperation ); |
|
456 resetOperation(); |
|
457 } |
|
458 |
|
459 /* |
|
460 * Responds to mCurrentOperation's notifyError signal. |
|
461 * \a error error id. |
|
462 * \a errString the error string. |
|
463 */ |
|
464 void FmOperationService::on_operation_notifyError(int error, QString errString ) |
|
465 { |
|
466 mOperationResultProcesser->onNotifyError( |
|
467 mCurrentOperation, error, errString ); |
|
468 emit notifyError( mCurrentOperation, error, errString ); |
|
469 resetOperation(); |
|
470 } |
|
471 |
|
472 /* |
|
473 * Responds to mCurrentOperation's driveSpaceChanged |
|
474 */ |
|
475 void FmOperationService::on_operation_driveSpaceChanged() |
|
476 { |
|
477 emit driveSpaceChanged( mCurrentOperation ); |
|
478 } |
|
479 |
|
480 /* |
|
481 * Responds to mBackupRestoreHandler's notifyPreparing |
|
482 * \a cancelable indicates whether it could be cancelled. |
|
483 */ |
|
484 void FmOperationService::on_backupRestore_notifyPreparing( bool cancelable ) |
|
485 { |
|
486 mOperationResultProcesser->onNotifyPreparing( |
|
487 mCurrentOperation, cancelable ); |
|
488 emit notifyPreparing( mCurrentOperation, cancelable ); |
|
489 } |
|
490 |
|
491 /* |
|
492 * Responds to mBackupRestoreHandler's notifyStart |
|
493 * \a cancelable indicates whether it could be cancelled. |
|
494 * \a maxSteps the lenth of progress bar. |
|
495 */ |
|
496 void FmOperationService::on_backupRestore_notifyStart( bool cancelable, int maxSteps ) |
|
497 { |
|
498 mOperationResultProcesser->onNotifyStart( |
|
499 mCurrentOperation, cancelable, maxSteps ); |
|
500 emit notifyStart( mCurrentOperation, cancelable, maxSteps ); |
|
501 } |
|
502 |
|
503 /* |
|
504 * Responds to mBackupRestoreHandler's notifyProgress |
|
505 * \a currentStep the current progress bar's step. |
|
506 */ |
|
507 void FmOperationService::on_backupRestore_notifyProgress( int currentStep ) |
|
508 { |
|
509 mOperationResultProcesser->onNotifyProgress( |
|
510 mCurrentOperation, currentStep ); |
|
511 emit notifyProgress( mCurrentOperation, currentStep ); |
|
512 } |
|
513 |
|
514 /* |
|
515 * Responds to mBackupRestoreHandler's notifyFinish |
|
516 */ |
|
517 void FmOperationService::on_backupRestore_notifyFinish() |
|
518 { |
|
519 mOperationResultProcesser->onNotifyFinish( mCurrentOperation ); |
|
520 emit notifyFinish( mCurrentOperation ); |
|
521 resetOperation(); |
|
522 } |
|
523 |
|
524 /* |
|
525 * Responds to mBackupRestoreHandler's notifyError |
|
526 * \a error the error id. |
|
527 * \a errString the error string. |
|
528 */ |
|
529 void FmOperationService::on_backupRestore_notifyError(int error, const QString &errString ) |
|
530 { |
|
531 mOperationResultProcesser->onNotifyError( |
|
532 mCurrentOperation, error, errString ); |
|
533 emit notifyError( mCurrentOperation, error, errString ); |
|
534 resetOperation(); |
|
535 } |
|
536 |
|
537 /* |
|
538 * Responds to mBackupRestoreHandler's notifyCanceled |
|
539 */ |
|
540 void FmOperationService::on_backupRestore_notifyCanceled() |
|
541 { |
|
542 mOperationResultProcesser->onNotifyError( |
|
543 mCurrentOperation, FmErrCancel, QString() ); |
|
544 emit notifyError( mCurrentOperation, FmErrCancel, QString() ); |
|
545 resetOperation(); |
|
546 } |
|
547 |
|
548 /// |
|
549 ///////////////////////////////////////////////////// |
|