filemanager/src/filemanager/src/operationservice/fmoperationformat_s60.cpp
changeset 37 15bc28c9dd51
parent 16 ada7962b4308
child 46 d58987eac7e8
equal deleted inserted replaced
16:ada7962b4308 37:15bc28c9dd51
    24 
    24 
    25 #include <f32file.h>
    25 #include <f32file.h>
    26 #include <e32property.h>
    26 #include <e32property.h>
    27 #include <coreapplicationuisdomainpskeys.h>
    27 #include <coreapplicationuisdomainpskeys.h>
    28 
    28 
    29 FmOperationFormat::FmOperationFormat( QObject *parent, QString mDriverName ) : FmOperationBase( parent, FmOperationService::EOperationTypeFormat ),
    29 /* \fn  void driveSpaceChanged()
       
    30  * This signal is emitted when copy or move is completed, and used to update the drive size.
       
    31  */
       
    32 
       
    33 /*
       
    34  * Constructs a format operation with \a parent
       
    35  * \a mDriverName the drive to be formatted.
       
    36  */
       
    37 FmOperationFormat::FmOperationFormat( QObject *parent, const QString &mDriverName ) : FmOperationBase( parent, FmOperationService::EOperationTypeFormat ),
    30     mDriverName( mDriverName )
    38     mDriverName( mDriverName )
    31 {
    39 {
    32 }
    40     connect( this, SIGNAL( driveSpaceChanged() ),
       
    41             parent, SLOT( on_operation_driveSpaceChanged() ) );
       
    42 }
       
    43 
       
    44 /*
       
    45  * Destructs the operation.
       
    46  */
    33 FmOperationFormat::~FmOperationFormat()
    47 FmOperationFormat::~FmOperationFormat()
    34 {
    48 {
    35 }
    49 }
    36 
    50 
       
    51 /*
       
    52  * Returns the to be formatted drive name
       
    53  */
    37 QString FmOperationFormat::driverName()
    54 QString FmOperationFormat::driverName()
    38 {
    55 {
    39     return mDriverName;
    56     return mDriverName;
    40 }
    57 }
    41 
    58 
    42 int FmOperationFormat::start()
    59 /*
       
    60  * Starts to format.
       
    61  * \a isStopped not used
       
    62  */
       
    63 void FmOperationFormat::start( volatile bool */*isStopped*/ )
    43 { 
    64 { 
    44     QString logString = "FmOperationFormat::start";
    65     QString logString = "FmOperationFormat::start";
    45     FmLogger::log( logString );
    66     FM_LOG( logString );
    46     
    67     
    47     emit notifyPreparing( false );
    68     emit notifyPreparing( false );
    48     
    69     
    49     if( mDriverName.isEmpty() ) {
    70     if( mDriverName.isEmpty() ) {
    50         return FmErrWrongParam;
    71         emit notifyError( FmErrWrongParam, QString() );
       
    72         return;
    51     }
    73     }
    52     
    74     
    53     RFormat format;
    75     RFormat format;
    54     
    76     
    55     RFs fs;
    77     RFs fs;
    56     int err = fs.Connect();
    78     int err = fs.Connect();
    57     
    79     
    58     if( err != KErrNone ){
    80     if( err != KErrNone ){
    59         return FmErrTypeFormatFailed;
    81         emit notifyError( FmErrTypeFormatFailed, QString() );
       
    82         return;
    60     }
    83     }
    61 
    84 
    62     TInt drive = 0;
    85     TInt drive = 0;
    63     drive = mDriverName[0].toUpper().toAscii() - 'A' + EDriveA;
    86     drive = mDriverName[0].toUpper().toAscii() - 'A' + EDriveA;
    64 
    87 
    71     err = format.Open(
    94     err = format.Open(
    72         fs, formatDriveName, EFullFormat | ESpecialFormat, finalValue );
    95         fs, formatDriveName, EFullFormat | ESpecialFormat, finalValue );
    73     
    96     
    74     if( err == KErrNone ){
    97     if( err == KErrNone ){
    75         logString = "emit notifyStart";
    98         logString = "emit notifyStart";
    76         FmLogger::log( logString );
    99         FM_LOG( logString );
    77         mTotalSteps = finalValue;
   100         mTotalSteps = finalValue;
    78         emit notifyStart( false, finalValue );
   101         emit notifyStart( false, finalValue );
    79     }
   102     }
    80     
   103     
    81     logString = "Format open error:" + QString::number( err );
   104     logString = "Format open error:" + QString::number( err );
    82     FmLogger::log( logString );
   105     FM_LOG( logString );
    83     
   106     
    84     if( err == KErrLocked ){
   107     if( err == KErrLocked ){
    85         err = fs.ErasePassword( drive );
   108         err = fs.ErasePassword( drive );
    86         
   109         
    87         logString = "ErasePassword error:" + QString::number( err );
   110         logString = "ErasePassword error:" + QString::number( err );
    88         FmLogger::log( logString );
   111         FM_LOG( logString );
    89         
   112         
    90         if( err == KErrNone ){
   113         if( err == KErrNone ){
    91             err = format.Open(
   114             err = format.Open(
    92                fs, formatDriveName, EFullFormat, finalValue ); 
   115                fs, formatDriveName, EFullFormat, finalValue ); 
    93             
   116             
    94             if( err == KErrNone ){
   117             if( err == KErrNone ){
    95                 logString = "emit notifyStart";
   118                 logString = "emit notifyStart";
    96                 FmLogger::log( logString );
   119                 FM_LOG( logString );
    97                 mTotalSteps = finalValue;
   120                 mTotalSteps = finalValue;
    98                 emit notifyStart( false, finalValue );
   121                 emit notifyStart( false, finalValue );
    99             }           
   122             }           
   100             logString = "Second format open error:" + QString::number( err );
   123             logString = "Second format open error:" + QString::number( err );
   101             FmLogger::log( logString );
   124             FM_LOG( logString );
   102         }
   125         }
   103     }
   126     }
   104     
   127     
   105     if (err == KErrInUse){
   128     if (err == KErrInUse){
   106         TBool reallyFormat = ETrue;
   129         TBool reallyFormat = ETrue;
   108             err = format.Open(
   131             err = format.Open(
   109                     fs, formatDriveName, EFullFormat | EForceFormat, finalValue );
   132                     fs, formatDriveName, EFullFormat | EForceFormat, finalValue );
   110             
   133             
   111             if( err == KErrNone ){
   134             if( err == KErrNone ){
   112                 logString = "emit notifyStart";
   135                 logString = "emit notifyStart";
   113                 FmLogger::log( logString );
   136                 FM_LOG( logString );
   114                 mTotalSteps = finalValue;
   137                 mTotalSteps = finalValue;
   115                 emit notifyStart( false, finalValue );
   138                 emit notifyStart( false, finalValue );
   116             } 
   139             } 
   117             
   140             
   118             logString = "Reallyformat open error:" + QString::number( err );
   141             logString = "Reallyformat open error:" + QString::number( err );
   119             FmLogger::log( logString );
   142             FM_LOG( logString );
   120         }
   143         }
   121     }
   144     }
   122     
   145     
   123     TFullName fsName;
   146     TFullName fsName;
   124     if ( err == KErrNone )
   147     if ( err == KErrNone )
   125         {
   148         {
   126         err = fs.FileSystemName( fsName, drive  );
   149         err = fs.FileSystemName( fsName, drive  );
   127         
   150         
   128         logString = "FileSystemName error:" + QString::number( err );
   151         logString = "FileSystemName error:" + QString::number( err );
   129         FmLogger::log( logString );
   152         FM_LOG( logString );
   130 
   153 
   131         if ( err == KErrNone && fsName.Length() > 0 )
   154         if ( err == KErrNone && fsName.Length() > 0 )
   132             {
   155             {
   133             // Prevent SysAp shutting down applications
   156             // Prevent SysAp shutting down applications
   134             RProperty::Set(
   157             RProperty::Set(
   135                     KPSUidCoreApplicationUIs,
   158                     KPSUidCoreApplicationUIs,
   136                     KCoreAppUIsMmcRemovedWithoutEject,
   159                     KCoreAppUIsMmcRemovedWithoutEject,
   137                     ECoreAppUIsEjectCommandUsed );
   160                     ECoreAppUIsEjectCommandUsed );
   138             
   161             
   139             logString = "Prevent SysAp shutting down applications" ;
   162             logString = "Prevent SysAp shutting down applications" ;
   140             FmLogger::log( logString );
   163             FM_LOG( logString );
   141             }
   164             }
   142         else
   165         else
   143             {
   166             {
   144             // Don't continue with format if there is no file system name
   167             // Don't continue with format if there is no file system name
   145             // or file system name could not be obtained.
   168             // or file system name could not be obtained.
   146             err = KErrCancel;
   169             err = KErrCancel;
   147             
   170             
   148             logString = QString( "Format cancel" );
   171             logString = QString( "Format cancel" );
   149             FmLogger::log( logString );
   172             FM_LOG( logString );
   150             }
   173             }
   151         }
   174         }
   152     
   175     
   153     if( err == KErrNone &&  finalValue ){
   176     if( err == KErrNone &&  finalValue ){
   154     
   177     
   155         while ( finalValue ){        
   178         while ( finalValue ){        
   156             logString = "Format tracks:" + QString::number( finalValue );
   179             logString = "Format tracks:" + QString::number( finalValue );
   157             FmLogger::log( logString );
   180             FM_LOG( logString );
   158             err = format.Next( finalValue );
   181             err = format.Next( finalValue );
   159             
   182             
   160             if( err != KErrNone ){ 
   183             if( err != KErrNone ){ 
   161                 logString = "Format error:" + QString::number( err );
   184                 logString = "Format error:" + QString::number( err );
   162                 FmLogger::log( logString );
   185                 FM_LOG( logString );
   163                 break; 
   186                 break; 
   164             }
   187             }
   165             
   188             
   166             logString = "emit notifyProgress";
   189             logString = "emit notifyProgress";
   167             FmLogger::log( logString );
   190             FM_LOG( logString );
   168             emit notifyProgress( mTotalSteps - finalValue );
   191             emit notifyProgress( mTotalSteps - finalValue );
   169         }
   192         }
   170     }
   193     }
   171     
   194     
   172     if( !finalValue || err != KErrNone ){
   195     if( !finalValue || err != KErrNone ){
   175         
   198         
   176         FmUtils::createDefaultFolders( mDriverName );
   199         FmUtils::createDefaultFolders( mDriverName );
   177     }
   200     }
   178 
   201 
   179     if( err == KErrNone ){
   202     if( err == KErrNone ){
   180         return FmErrNone;
   203         emit notifyFinish();        
   181     }
   204     }
   182     else{
   205     else{
   183         return FmErrTypeFormatFailed;
   206         emit notifyError( FmErrTypeFormatFailed, QString() );
   184     }
   207     }
   185 }
   208     // refresh drive space no care if cancel, error or finished.
       
   209     // as filemanger cannot notify drive space changed
       
   210     // do not refresh path as QFileSystemModel will do auto-refresh
       
   211     emit driveSpaceChanged();    
       
   212     
       
   213 }