49 return QString(); |
50 return QString(); |
50 } |
51 } |
51 return path.left( 3 ); |
52 return path.left( 3 ); |
52 } |
53 } |
53 |
54 |
|
55 QString FmUtils::getDriveLetterFromPath( const QString &path ) |
|
56 { |
|
57 if( path.length() <2 ) { |
|
58 return QString(); |
|
59 } |
|
60 return path.left( 1 ); |
|
61 } |
|
62 |
54 FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName ) |
63 FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName ) |
55 { |
64 { |
56 CCoeEnv *env = CCoeEnv::Static(); |
65 CCoeEnv *env = CCoeEnv::Static(); |
57 RFs& fs = env->FsSession(); |
66 RFs& fs = env->FsSession(); |
58 |
67 |
59 TVolumeInfo volumeInfo; |
68 TVolumeInfo volumeInfo; |
60 TInt drive = 0; |
69 TInt drive = 0; |
61 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
70 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
62 |
71 |
63 fs.Volume( volumeInfo, drive ); |
72 quint32 state( 0 ); |
|
73 int err = fs.Volume( volumeInfo, drive ); |
64 QString volumeName( (QChar*)( volumeInfo.iName.Des().Ptr() ), volumeInfo.iName.Length() ); |
74 QString volumeName( (QChar*)( volumeInfo.iName.Des().Ptr() ), volumeInfo.iName.Length() ); |
65 |
75 |
66 return FmDriverInfo( volumeInfo.iSize, volumeInfo.iFree, driverName, volumeName ); |
76 if( err == KErrNone ) { |
|
77 TDriveInfo driveInfo = volumeInfo.iDrive; |
|
78 |
|
79 quint32 drvStatus( 0 ); |
|
80 err = DriveInfo::GetDriveStatus( fs, drive, drvStatus ); |
|
81 if( err == KErrNone ) { |
|
82 QString logString = driverName +':'+ QString::number( drvStatus); |
|
83 FmLogger::log(logString); |
|
84 |
|
85 if ( ( drvStatus & DriveInfo::EDriveInternal ) && |
|
86 ( drvStatus & DriveInfo::EDriveExternallyMountable ) ){ |
|
87 // Handle mass storage bits here |
|
88 |
|
89 state |= FmDriverInfo::EDriveMassStorage | FmDriverInfo::EDriveRemovable; |
|
90 } |
|
91 |
|
92 |
|
93 if ( drvStatus & DriveInfo::EDriveRom ){ |
|
94 state |= FmDriverInfo::EDriveRom; |
|
95 } |
|
96 |
|
97 if ( drvStatus & DriveInfo::EDriveRam ){ |
|
98 state |= FmDriverInfo::EDriveRam; |
|
99 } |
|
100 |
|
101 if ( driveInfo.iMediaAtt & KMediaAttFormattable ){ |
|
102 state |= FmDriverInfo::EDriveFormattable; |
|
103 } |
|
104 if ( driveInfo.iMediaAtt & KMediaAttWriteProtected ){ |
|
105 state |= FmDriverInfo::EDriveWriteProtected; |
|
106 } |
|
107 if ( driveInfo.iMediaAtt & KMediaAttHasPassword ){ |
|
108 state |= FmDriverInfo::EDrivePasswordProtected; |
|
109 } |
|
110 if ( driveInfo.iMediaAtt & KMediaAttLocked ){ |
|
111 state |= FmDriverInfo::EDriveLocked; |
|
112 } |
|
113 |
|
114 if ( driveInfo.iDriveAtt & KDriveAttRemovable ){ |
|
115 state |= FmDriverInfo::EDriveRemovable; |
|
116 |
|
117 if ( drvStatus & DriveInfo::EDriveSwEjectable ){ |
|
118 state |= FmDriverInfo::EDriveEjectable; |
|
119 } |
|
120 } |
|
121 |
|
122 if( driveInfo.iType == EMediaNotPresent ){ |
|
123 state |= FmDriverInfo::EDriveNotPresent; |
|
124 } |
|
125 } |
|
126 } |
|
127 //handle error code |
|
128 switch( err ) |
|
129 { |
|
130 case KErrNone: |
|
131 state |= FmDriverInfo::EDriveAvailable; |
|
132 break; |
|
133 case KErrLocked: |
|
134 state |= FmDriverInfo::EDriveLocked; |
|
135 break; |
|
136 case KErrCorrupt: |
|
137 state |= FmDriverInfo::EDriveCorrupted; |
|
138 break; |
|
139 default: // other errors |
|
140 state |= FmDriverInfo::EDriveNotPresent; |
|
141 break; |
|
142 } |
|
143 return FmDriverInfo( volumeInfo.iSize, volumeInfo.iFree, driverName, volumeName, state ); |
67 } |
144 } |
68 |
145 |
69 QString FmUtils::formatStorageSize( quint64 size ) |
146 QString FmUtils::formatStorageSize( quint64 size ) |
70 { |
147 { |
71 if ( size < 1000 ) { |
148 if ( size < 1000 ) { |
76 return QString::number( size / (1024.0 * 1024.0), 'f', 1 ) + " MB"; |
153 return QString::number( size / (1024.0 * 1024.0), 'f', 1 ) + " MB"; |
77 } else { |
154 } else { |
78 return QString::number( size / ( 1024.0 * 1024.0 * 1024.0 ), 'f', 1 ) + " GB"; |
155 return QString::number( size / ( 1024.0 * 1024.0 * 1024.0 ), 'f', 1 ) + " GB"; |
79 } |
156 } |
80 } |
157 } |
|
158 /* |
81 quint32 FmUtils::getDriverState( const QString &driverName ) |
159 quint32 FmUtils::getDriverState( const QString &driverName ) |
82 { |
160 { |
|
161 CCoeEnv *env = CCoeEnv::Static(); |
|
162 RFs& fs = env->FsSession(); |
|
163 |
|
164 TVolumeInfo volumeInfo; |
|
165 TInt drive = 0; |
|
166 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
|
167 |
83 quint32 state( 0 ); |
168 quint32 state( 0 ); |
84 CCoeEnv *env = CCoeEnv::Static(); |
169 int err = fs.Volume( volumeInfo, drive ); |
85 RFs& fs = env->FsSession(); |
170 QString volumeName( (QChar*)( volumeInfo.iName.Des().Ptr() ), volumeInfo.iName.Length() ); |
86 |
171 |
87 TVolumeInfo volumeInfo; |
172 //handle error code |
88 TInt drive = 0; |
|
89 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
|
90 |
|
91 int err = fs.Volume( volumeInfo, drive ); |
|
92 |
|
93 //handle error code |
|
94 if( err != KErrNone ) { |
173 if( err != KErrNone ) { |
95 state |= FmDriverInfo::EDriveNotPresent; |
174 state |= FmDriverInfo::EDriveNotPresent; |
96 } |
175 } |
97 if ( err == KErrLocked ) { |
176 if ( err == KErrLocked ) { |
98 state |= FmDriverInfo::EDriveLocked; |
177 state |= FmDriverInfo::EDriveLocked; |
204 logString = "Drive:" + QString::number( drive ); |
292 logString = "Drive:" + QString::number( drive ); |
205 FmLogger::log( logString ); |
293 FmLogger::log( logString ); |
206 logString = "Unlock drive error:" + QString::number( err ); |
294 logString = "Unlock drive error:" + QString::number( err ); |
207 FmLogger::log( logString ); |
295 FmLogger::log( logString ); |
208 |
296 |
209 return err; |
297 if( err == KErrNone ){ |
|
298 return FmErrNone; |
|
299 } |
|
300 else if( err == KErrAccessDenied ){ |
|
301 return FmErrAccessDenied; |
|
302 } |
|
303 else if( err == KErrAlreadyExists ){ |
|
304 return FmErrAlreadyExists; |
|
305 } |
|
306 else if( err == KErrNotSupported ){ |
|
307 return FmErrNotSupported; |
|
308 } |
|
309 else{ |
|
310 return FmErrUnKnown; |
|
311 } |
|
312 } |
|
313 |
|
314 int FmUtils::checkDrivePwd( const QString &driverName, const QString &pwd ) |
|
315 { |
|
316 QString logString = "checkDrivePwd Drive name:" + driverName; |
|
317 logString += " password:" + pwd; |
|
318 FmLogger::log( logString ); |
|
319 |
|
320 return setDrivePwd( driverName, pwd, pwd ); |
210 } |
321 } |
211 |
322 |
212 int FmUtils::setDrivePwd( const QString &driverName, const QString &oldPwd, const QString &newPwd) |
323 int FmUtils::setDrivePwd( const QString &driverName, const QString &oldPwd, const QString &newPwd) |
213 { |
324 { |
214 QString logString = "Drive name:" + driverName; |
325 QString logString = "setDrivePwd Drive name:" + driverName ; |
215 FmLogger::log( logString ); |
326 logString += " Old password:" + oldPwd; |
216 logString = "Old password:" + oldPwd; |
327 logString += " New password:" + newPwd; |
217 FmLogger::log( logString ); |
|
218 logString = "New password:" + newPwd; |
|
219 FmLogger::log( logString ); |
328 FmLogger::log( logString ); |
220 |
329 |
221 CCoeEnv *env = CCoeEnv::Static(); |
330 CCoeEnv *env = CCoeEnv::Static(); |
222 RFs& fs = env->FsSession(); |
331 RFs& fs = env->FsSession(); |
223 |
332 |
234 TPtr ptrOldPassword16( oldPassword16->Des() ); |
343 TPtr ptrOldPassword16( oldPassword16->Des() ); |
235 |
344 |
236 FmS60Utils::ConvertCharsToPwd( ptrNewPassword16, newPassword ); |
345 FmS60Utils::ConvertCharsToPwd( ptrNewPassword16, newPassword ); |
237 FmS60Utils::ConvertCharsToPwd( ptrOldPassword16, oldPassword ); |
346 FmS60Utils::ConvertCharsToPwd( ptrOldPassword16, oldPassword ); |
238 |
347 |
239 //oldPassword.FillZ(oldPassword.MaxLength()); |
|
240 //oldPassword.Zero(); |
|
241 //newPassword.Copy(_L8("A")); |
|
242 |
|
243 int err( fs.LockDrive( drive, oldPassword, newPassword, ETrue ) ); |
348 int err( fs.LockDrive( drive, oldPassword, newPassword, ETrue ) ); |
244 |
349 |
245 logString = "Drive:" + QString::number( drive ); |
350 logString = "Drive:" + QString::number( drive ); |
246 FmLogger::log( logString ); |
351 FmLogger::log( logString ); |
247 logString = "Password set error:" + QString::number( err ); |
352 logString = "Password set error:" + QString::number( err ); |
248 FmLogger::log( logString ); |
353 FmLogger::log( logString ); |
249 |
354 |
250 return err; |
355 if( err == KErrNone ){ |
|
356 return FmErrNone; |
|
357 } |
|
358 else if( err == KErrNotSupported ){ |
|
359 return FmErrNotSupported; |
|
360 } |
|
361 else{ |
|
362 return FmErrUnKnown; |
|
363 } |
251 } |
364 } |
252 |
365 |
253 void FmUtils::emptyPwd( QString &pwd ) |
366 void FmUtils::emptyPwd( QString &pwd ) |
254 { |
367 { |
255 TPtr des ( ( XQConversions::qStringToS60Desc( pwd ) )->Des() ); |
368 TPtr des ( ( XQConversions::qStringToS60Desc( pwd ) )->Des() ); |
271 int err( fs.SetVolumeLabel( newName, drive )); |
395 int err( fs.SetVolumeLabel( newName, drive )); |
272 |
396 |
273 QString logString = "Rename error:" + QString::number( err ); |
397 QString logString = "Rename error:" + QString::number( err ); |
274 FmLogger::log( logString ); |
398 FmLogger::log( logString ); |
275 |
399 |
276 return err; |
400 if( err == KErrNone ){ |
277 } |
401 return FmErrNone; |
278 |
402 } |
279 int FmUtils::ejectDrive( const QString &driverName ) |
403 else if( err == KErrNotReady ){ |
280 { |
404 return FmErrNotReady; |
281 CCoeEnv *env = CCoeEnv::Static(); |
405 } |
282 RFs& fs = env->FsSession(); |
406 else{ |
|
407 return FmErrUnKnown; |
|
408 } |
|
409 } |
|
410 |
|
411 void FmUtils::ejectDrive( const QString &driverName ) |
|
412 { |
|
413 QString logString = "FmUtils::ejectDrive start"; |
|
414 FmLogger::log( logString ); |
283 |
415 |
284 TInt drive = 0; |
416 TInt drive = 0; |
285 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
417 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
286 |
418 |
287 const int KDriveShift = 16; |
419 const int KDriveShift = 16; |
288 |
420 |
289 TFileName fileSystemName; |
421 // Let SysAp handle eject |
290 TInt err = fs.FileSystemName( fileSystemName, drive ); |
|
291 |
|
292 RProperty::Set( |
422 RProperty::Set( |
293 KPSUidCoreApplicationUIs, |
423 KPSUidCoreApplicationUIs, |
294 KCoreAppUIsMmcRemovedWithoutEject, |
424 KCoreAppUIsMmcRemovedWithoutEject, |
295 ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift ) |
425 ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift ) |
296 ); |
426 ); |
297 |
|
298 err = fs.DismountFileSystem( fileSystemName, drive ); |
|
299 |
|
300 if (err == KErrNone){ |
|
301 // remount the file system |
|
302 err = fs.MountFileSystem( fileSystemName, drive ); |
|
303 |
|
304 if (err == KErrInUse){ |
|
305 // try to remount after a while if locked |
|
306 User::After(1000000); |
|
307 err = fs.MountFileSystem( fileSystemName, drive ); |
|
308 } |
|
309 } |
|
310 |
|
311 return err; |
|
312 } |
|
313 |
|
314 int FmUtils::formatDrive( const QString &driverName ) |
|
315 { |
|
316 RFormat format; |
|
317 |
|
318 // CCoeEnv *env = CCoeEnv::Static(); |
|
319 // RFs& fs = env->FsSession(); |
|
320 |
|
321 RFs fs; |
|
322 int err = fs.Connect(); |
|
323 |
|
324 if( err != KErrNone ){ |
|
325 return FmErrTypeFormatFailed; |
|
326 } |
|
327 |
|
328 TInt drive = 0; |
|
329 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA; |
|
330 |
|
331 TDriveName formatDriveName( TDriveUnit( drive ).Name() ); |
|
332 |
|
333 int finalValue = 0; |
|
334 |
|
335 format.Close(); |
|
336 |
|
337 err = format.Open( |
|
338 fs, formatDriveName, EFullFormat | ESpecialFormat, finalValue ); |
|
339 |
|
340 QString logString = "Format open error:" + QString::number( err ); |
|
341 FmLogger::log( logString ); |
|
342 |
|
343 if( err == KErrLocked ){ |
|
344 err = fs.ErasePassword( drive ); |
|
345 |
|
346 logString = "ErasePassword error:" + QString::number( err ); |
|
347 FmLogger::log( logString ); |
|
348 |
|
349 if( err == KErrNone ){ |
|
350 err = format.Open( |
|
351 fs, formatDriveName, EFullFormat, finalValue ); |
|
352 |
|
353 logString = "Second format open error:" + QString::number( err ); |
|
354 FmLogger::log( logString ); |
|
355 } |
|
356 } |
|
357 |
|
358 if (err == KErrInUse){ |
|
359 TBool reallyFormat = ETrue; |
|
360 if (reallyFormat) |
|
361 { |
|
362 err = format.Open( |
|
363 fs, formatDriveName, EFullFormat | EForceFormat, finalValue ); |
|
364 |
|
365 logString = "Reallyformat open error:" + QString::number( err ); |
|
366 FmLogger::log( logString ); |
|
367 } |
|
368 } |
|
369 |
|
370 TFullName fsName; |
|
371 if ( err == KErrNone ) |
|
372 { |
|
373 err = fs.FileSystemName( fsName, drive ); |
|
374 |
|
375 logString = "FileSystemName error:" + QString::number( err ); |
|
376 FmLogger::log( logString ); |
|
377 |
|
378 if ( err == KErrNone && fsName.Length() > 0 ) |
|
379 { |
|
380 // Prevent SysAp shutting down applications |
|
381 RProperty::Set( |
|
382 KPSUidCoreApplicationUIs, |
|
383 KCoreAppUIsMmcRemovedWithoutEject, |
|
384 ECoreAppUIsEjectCommandUsed ); |
|
385 |
|
386 logString = "Prevent SysAp shutting down applications" ; |
|
387 FmLogger::log( logString ); |
|
388 } |
|
389 else |
|
390 { |
|
391 // Don't continue with format if there is no file system name |
|
392 // or file system name could not be obtained. |
|
393 err = KErrCancel; |
|
394 |
|
395 logString = "Format cancel:" + QString::number( err ); |
|
396 FmLogger::log( logString ); |
|
397 } |
|
398 } |
|
399 |
|
400 if( err == KErrNone && finalValue ){ |
|
401 |
|
402 while ( finalValue ){ |
|
403 logString = "Format tracks:" + QString::number( finalValue ); |
|
404 FmLogger::log( logString ); |
|
405 |
|
406 err = format.Next( finalValue ); |
|
407 |
|
408 if( err != KErrNone ){ |
|
409 logString = "Format error:" + QString::number( err ); |
|
410 FmLogger::log( logString ); |
|
411 break; |
|
412 } |
|
413 } |
|
414 } |
|
415 |
|
416 if( !finalValue || err != KErrNone ){ |
|
417 format.Close(); |
|
418 fs.Close(); |
|
419 |
|
420 createDefaultFolders( driverName ); |
|
421 } |
|
422 |
|
423 return FmErrNone; |
|
424 } |
427 } |
425 |
428 |
426 QString FmUtils::getFileType( const QString &filePath ) |
429 QString FmUtils::getFileType( const QString &filePath ) |
427 { |
430 { |
428 RApaLsSession apaSession; |
431 RApaLsSession apaSession; |
611 newFilePath = filePath.left( filePath.length() - 1 ); |
615 newFilePath = filePath.left( filePath.length() - 1 ); |
612 } |
616 } |
613 return newFilePath; |
617 return newFilePath; |
614 } |
618 } |
615 |
619 |
|
620 // used to filter drive which need be hide. |
616 bool FmUtils::checkDriveFilter( const QString &driveName ) |
621 bool FmUtils::checkDriveFilter( const QString &driveName ) |
617 { |
622 { |
618 if( driveName.contains( "D:" ) || driveName.contains( "Z:" ) ) { |
623 if( driveName.contains( "D:" ) || driveName.contains( "Z:" ) ) { |
619 return false; |
624 return false; |
620 } |
625 } |
621 return true; |
626 return true; |
622 } |
627 } |
623 |
628 |
624 QString FmUtils::checkDriveToFolderFilter( const QString &path ) |
629 QString FmUtils::checkDriveToFolderFilter( const QString &path ) |
625 { |
630 { |
|
631 /* |
626 QFileInfo fileInfo( path ); |
632 QFileInfo fileInfo( path ); |
627 if( !fileInfo.exists() ) { |
633 if( !fileInfo.exists() ) { |
628 return QString(); |
634 return QString(); |
629 } |
635 } |
630 |
636 */ |
631 QString checkedPath = fillPathWithSplash( path ); |
637 QString checkedPath = fillPathWithSplash( path ); |
632 if( checkedPath.compare( QString( "C:/"), Qt::CaseInsensitive ) == 0 ) { |
638 if( checkedPath.compare( QString( "C:/"), Qt::CaseInsensitive ) == 0 ) { |
633 checkedPath += QString( "data/" ); |
639 checkedPath += QString( "data/" ); |
634 return checkedPath; |
640 return checkedPath; |
635 } |
641 } |
655 |
661 |
656 } |
662 } |
657 |
663 |
658 bool FmUtils::isPathAccessabel( const QString &path ) |
664 bool FmUtils::isPathAccessabel( const QString &path ) |
659 { |
665 { |
|
666 FmLogger::log( QString( "isPathAccessabel:" ) + path ); |
|
667 if( path.length() <= 3 && !isDriveAvailable( path ) ) { //used to filter locked drive |
|
668 FmLogger::log( QString( "isPathAccessabel false: path is drive and not available" ) ); |
|
669 return false; |
|
670 } |
660 QFileInfo fileInfo( path ); |
671 QFileInfo fileInfo( path ); |
661 if( fileInfo.absoluteFilePath().contains( QString( Drive_C ), Qt::CaseInsensitive ) && |
672 if( fileInfo.absoluteFilePath().contains( QString( Drive_C ), Qt::CaseInsensitive ) && |
662 !fileInfo.absoluteFilePath().contains( QString( Folder_C_Data ), Qt::CaseInsensitive ) ) { |
673 !fileInfo.absoluteFilePath().contains( QString( Folder_C_Data ), Qt::CaseInsensitive ) ) { |
|
674 FmLogger::log( QString( "isPathAccessabel false: path contain C and not in data folder" ) ); |
663 return false; |
675 return false; |
664 } |
676 } |
665 if( fileInfo.absoluteFilePath().contains( QString( Drive_D ), Qt::CaseInsensitive ) ) { |
677 if( fileInfo.absoluteFilePath().contains( QString( Drive_D ), Qt::CaseInsensitive ) ) { |
|
678 FmLogger::log( QString( "isPathAccessabel false: path contain D" ) ); |
666 return false; |
679 return false; |
667 } |
680 } |
668 if( fileInfo.absoluteFilePath().contains( QString( Drive_Z ), Qt::CaseInsensitive ) ) { |
681 if( fileInfo.absoluteFilePath().contains( QString( Drive_Z ), Qt::CaseInsensitive ) ) { |
|
682 FmLogger::log( QString( "isPathAccessabel false: path contain Z" ) ); |
669 return false; |
683 return false; |
670 } |
684 } |
671 if( !fileInfo.exists() ) { |
685 if( !fileInfo.exists() ) { |
|
686 FmLogger::log( QString( "isPathAccessabel false: path not exist" ) ); |
672 return false; |
687 return false; |
673 } |
688 } |
|
689 FmLogger::log( QString( "isPathAccessabel true" ) ); |
674 return true; |
690 return true; |
675 } |
691 } |
676 |
692 |
|
693 // only used to check drive, when MMC is not inserted, also return false |
677 bool FmUtils::isDriveAvailable( const QString &path ) |
694 bool FmUtils::isDriveAvailable( const QString &path ) |
678 { |
695 { |
679 QFileInfo fileInfo( path ); |
696 FmLogger::log( QString( "isDriveAvailable:" ) + path ); |
680 if( !fileInfo.exists() ) { |
697 FmDriverInfo::DriveState driveState = queryDriverInfo( path ).driveState(); |
681 return false; |
698 if( ( driveState & FmDriverInfo::EDriveAvailable ) ) { |
682 } |
699 FmLogger::log( QString( "isDriveAvailable true" ) ); |
683 return true; |
700 return true; |
|
701 } |
|
702 FmLogger::log( QString( "isDriveAvailable false" ) ); |
|
703 return false; |
684 } |
704 } |
685 |
705 |
686 void FmUtils::getDriveList( QStringList &driveList, bool isHideUnAvailableDrive ) |
706 void FmUtils::getDriveList( QStringList &driveList, bool isHideUnAvailableDrive ) |
687 { |
707 { |
|
708 if( isHideUnAvailableDrive ) { |
|
709 FmLogger::log( QString( "getDriveList HideUnAvailableDrive_true" ) ); |
|
710 } else { |
|
711 FmLogger::log( QString( "getDriveList HideUnAvailableDrive_false" ) ); |
|
712 } |
688 QFileInfoList infoList = QDir::drives(); |
713 QFileInfoList infoList = QDir::drives(); |
689 |
714 |
690 foreach( QFileInfo fileInfo, infoList ) { |
715 foreach( QFileInfo fileInfo, infoList ) { |
691 QString driveName = fileInfo.absolutePath(); |
716 QString driveName = fileInfo.absolutePath(); |
692 if( checkDriveFilter( driveName ) ) { |
717 if( checkDriveFilter( driveName ) ) { |
760 |
785 |
761 delete request; |
786 delete request; |
762 return FmErrNone; |
787 return FmErrNone; |
763 } |
788 } |
764 |
789 |
765 void FmUtils::sendFiles( QList<QVariant> filePathList ) |
790 void FmUtils::sendFiles( QStringList &filePathList ) |
766 { |
791 { |
767 ShareUi shareui; |
792 ShareUi shareui; |
768 shareui.init( filePathList, false ); |
793 shareui.send( filePathList, false ); |
769 } |
794 } |
770 |
795 |
771 QString FmUtils::getBurConfigPath( QString appPath ) |
796 QString FmUtils::getBurConfigPath( QString appPath ) |
772 { |
797 { |
773 Q_UNUSED( appPath ); |
798 Q_UNUSED( appPath ); |
774 QString path( BURCONFIGFILE ); |
799 QString path( BURCONFIGFILE ); |
775 return path; |
800 return path; |
776 } |
801 } |
|
802 |
|
803 bool FmUtils::isPathEqual( const QString &pathFst, const QString &pathLast ) |
|
804 { |
|
805 QString fst( fillPathWithSplash( pathFst ) ); |
|
806 QString last( fillPathWithSplash( pathLast ) ); |
|
807 if( fst.compare( last, Qt::CaseInsensitive ) == 0 ) { |
|
808 return true; |
|
809 } |
|
810 return false; |
|
811 } |
|
812 |
|
813 bool FmUtils::isDefaultFolder( const QString &folderPath ) |
|
814 { |
|
815 TPtrC desFolderPath( XQConversions::qStringToS60Desc( folderPath )->Des() ); |
|
816 |
|
817 TInt pathType( PathInfo::PathType( desFolderPath ) ); |
|
818 switch( pathType ){ |
|
819 case PathInfo::ENotSystemPath:{ |
|
820 QString locString( Localize( folderPath ) ); |
|
821 if ( locString.isEmpty() ){ |
|
822 return false; |
|
823 } |
|
824 return true; |
|
825 } |
|
826 case PathInfo::EPhoneMemoryRootPath: // FALL THROUGH |
|
827 case PathInfo::EMemoryCardRootPath: // FALL THROUGH |
|
828 case PathInfo::ERomRootPath:{ |
|
829 return false; |
|
830 } |
|
831 // Accept other folders |
|
832 default:{ |
|
833 return true; |
|
834 } |
|
835 } |
|
836 } |
|
837 |
|
838 QString FmUtils::Localize( const QString &path ) |
|
839 { |
|
840 QString locPath = formatPath( path ); |
|
841 |
|
842 TPtrC desPath( XQConversions::qStringToS60Desc( locPath )->Des() ); |
|
843 CDirectoryLocalizer *localizer = CDirectoryLocalizer::NewL(); |
|
844 |
|
845 localizer->SetFullPath( desPath ); |
|
846 if( localizer->IsLocalized() ){ |
|
847 return XQConversions::s60DescToQString( localizer->LocalizedName() ); |
|
848 } |
|
849 |
|
850 return QString(); |
|
851 } |
|
852 |
|
853 QString FmUtils::formatPath( const QString &path ) |
|
854 { |
|
855 QString formatPath = path; |
|
856 QRegExp regExp( "/" ); |
|
857 formatPath.replace( regExp, "\\" ); |
|
858 |
|
859 if( path.right( 1 )!= "\\"){ |
|
860 formatPath.append( "\\" ); |
|
861 } |
|
862 return formatPath; |
|
863 } |