FCL/sf/app/files: comparison filemanager/src/inc/fmutils

equal deleted inserted replaced

-:b9588eb601eb
+:e28107efca85
 #include <QStringList>
 #include <QFileInfoList>
 #include <QDir>
 #include <QFile>
+#include <hbglobal.h>
 #include <xqaiwrequest.h>
 #include <xqappmgr.h>
 #include <shareui.h>
 #define BURCONFIGFILE  "z:/private/2002BCC0/burconfig.xml"
 QString FmUtils::getDriveNameFromPath( const QString &path )
 {
-if( path.length() <3 ) {
+// fillPathWithSplash make sure path length will be at least 3 if it is not empty.
+QString checkedPath( fillPathWithSplash( path ) );
+if( checkedPath.length() < 3 ) {
 return QString();
 }
-return path.left( 3 );
+return checkedPath.left( 3 );
 }
 QString FmUtils::getDriveLetterFromPath( const QString &path )
 {
 	if( path.length() <2 ) {
 return path.left( 1 );
 }
 FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName )
 {
+if( driverName.isEmpty() ) {
+return FmDriverInfo( 0, 0, driverName, QString(), FmDriverInfo::EDriveNotPresent );
+}
 CCoeEnv *env = CCoeEnv::Static();
 RFs& fs = env->FsSession();
 TVolumeInfo volumeInfo;
 TInt drive = 0;
 	}
 }
 int FmUtils::removeDrivePwd( const QString &driverName,  const QString &Pwd )
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 QString logString = "Drive name:" + driverName;
 FmLogger::log( logString );
 logString = "Password:" + Pwd;
 FmLogger::log( logString );
 }
 }
 int FmUtils::unlockDrive( const QString &driverName,  const QString &Pwd )
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 QString logString = "Drive name:" + driverName;
 FmLogger::log( logString );
 logString = "Password:" + Pwd;
 FmLogger::log( logString );
 }
 }
 int FmUtils::checkDrivePwd( const QString &driverName, const QString &pwd )
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 QString logString = "checkDrivePwd Drive name:" + driverName;
 logString += " password:" + pwd;
 FmLogger::log( logString );
 return setDrivePwd( driverName, pwd, pwd );
 }
 int FmUtils::setDrivePwd( const QString &driverName, const QString &oldPwd, const QString &newPwd)
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 QString logString = "setDrivePwd Drive name:" + driverName ;
 logString += " Old password:" + oldPwd;
 logString += " New password:" + newPwd;
 FmLogger::log( logString );
 pwd = XQConversions::s60DescToQString( des );
 }
 int FmUtils::renameDrive( const QString &driverName, const QString &newVolumeName)
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 foreach( const QChar &ch, newVolumeName )
 {
 bool a = ch.isSpace();
 bool b = ch.isLetterOrNumber();
 // If not alphadigit or space, return error
 else{
 return FmErrUnKnown;
 }
 }
-void FmUtils::ejectDrive( const QString &driverName )
+int FmUtils::ejectDrive( const QString &driverName )
 {
+if( driverName.isEmpty() ) {
+return FmErrWrongParam;
+}
 QString logString = "FmUtils::ejectDrive start";
 FmLogger::log( logString );
 TInt drive = 0;
 	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;
 RProperty::Set(
 KPSUidCoreApplicationUIs,
 KCoreAppUIsMmcRemovedWithoutEject,
 ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift )
 );
+return FmErrNone;
 }
 QString FmUtils::getFileType( const QString &filePath  )
 {
 RApaLsSession apaSession;
 return size;
 }
 bool FmUtils::isDriveC( const QString &driverName )
 {
+if( driverName.isEmpty() ) {
+return false;
+}
 TInt drive = 0;
 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;
 if( drive == EDriveC ){
 return true;
 }
 return ret;
 }
 void FmUtils::createDefaultFolders( const QString &driverName )
 {
+if( driverName.isEmpty() ) {
+return;
+}
 int err;
 TInt drive = 0;
 drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;
 CleanupStack::PopAndDestroy( array );
 }
 QString FmUtils::fillPathWithSplash( const QString &filePath )
 {
-QString newFilePath( filePath );
+	QString newFilePath;
 if( filePath.isEmpty() ) {
 return newFilePath;
 }
-if( filePath.at( filePath.length()-1 ) != QChar( '/' ) ){
+foreach( QChar ch, filePath ) {
-newFilePath.append( QChar( '/' ) );
+if( ch == QChar('\\') || ch == QChar('/') ) {
-}
+			newFilePath.append( QDir::separator() );
+} else {
+newFilePath.append( ch );
+}
+}
+if( newFilePath.right( 1 )!= QDir::separator() ){
+newFilePath.append( QDir::separator() );
+}
 return newFilePath;
 }
 QString FmUtils::removePathSplash( const QString &filePath )
 {
 newFilePath = filePath.left( filePath.length() - 1 );
 }
 return newFilePath;
 }
-// used to filter drive which need be hide.
+// filter un-accessable drive
-bool FmUtils::checkDriveFilter( const QString &driveName )
+bool FmUtils::checkDriveAccessFilter( const QString &driveName )
 {
-if( driveName.contains( "D:" ) || driveName.contains( "Z:" ) ) {
+if( driveName.isEmpty() ) {
+return false;
+}
+FmDriverInfo driveInfo = queryDriverInfo( driveName );
+if( ( driveInfo.driveState()& FmDriverInfo::EDriveRam ) ||
+( driveInfo.driveState()& FmDriverInfo::EDriveRom ) ) {
 return false;
 }
 return true;
 }
 if( !fileInfo.exists() ) {
 return QString();
 }
 */
 QString checkedPath = fillPathWithSplash( path );
-if( checkedPath.compare( QString( "C:/"), Qt::CaseInsensitive ) == 0 ) {
+if( checkedPath.compare( Drive_C, Qt::CaseInsensitive ) == 0 ) {
-checkedPath += QString( "data/" );
+checkedPath += QString( "data" ) + QDir::separator();
 return checkedPath;
 }
 return path;
 }
 QString checkedPath = fillPathWithSplash( path );
 logString = QString( "checkFolderToDriveFilter_fillPathWithSplash: " ) + checkedPath;
 FmLogger::log( logString );
-if( checkedPath.compare( QString( "C:/data/"), Qt::CaseInsensitive ) == 0 ) {
+if( checkedPath.compare( Folder_C_Data, Qt::CaseInsensitive ) == 0 ) {
 FmLogger::log( QString( " change from c:/data/ to C:/" ) );
-return QString( "C:/" );
+return Drive_C;
 }
 return path;
 }
-bool FmUtils::isPathAccessabel( const QString &path )
+int FmUtils::isPathAccessabel( const QString &path )
 {
+// Used to check if path is accessable, very important feature
+	// and will return filemanager error.
 FmLogger::log( QString( "isPathAccessabel:" ) + path );
+if( path.isEmpty() ) {
+return FmErrPathNotExist;
+}
 if( path.length() <= 3 && !isDriveAvailable( path ) ) { //used to filter locked drive
 FmLogger::log( QString( "isPathAccessabel false: path is drive and not available" ) );
-return false;
+return FmErrDriveNotAvailable;
 }
 QFileInfo fileInfo( path );
-if( fileInfo.absoluteFilePath().contains( QString( Drive_C ), Qt::CaseInsensitive ) &&
+if( fileInfo.absoluteFilePath().contains( Drive_C, Qt::CaseInsensitive ) &&
-!fileInfo.absoluteFilePath().contains( QString( Folder_C_Data ), Qt::CaseInsensitive ) ) {
+!fileInfo.absoluteFilePath().contains( Folder_C_Data, Qt::CaseInsensitive ) ) {
 FmLogger::log( QString( "isPathAccessabel false: path contain C and not in data folder" ) );
-return false;
+return FmErrPathDenied;
 }
-if( fileInfo.absoluteFilePath().contains( QString( Drive_D ), Qt::CaseInsensitive ) ) {
+if( !checkDriveAccessFilter( FmUtils::getDriveNameFromPath( fileInfo.absoluteFilePath() ) ) ){
-FmLogger::log( QString( "isPathAccessabel false: path contain D" ) );
+return FmErrDriveDenied;
-return false;
-}
-if( fileInfo.absoluteFilePath().contains( QString( Drive_Z ), Qt::CaseInsensitive ) ) {
-FmLogger::log( QString( "isPathAccessabel false: path contain Z" ) );
-return false;
 }
 if( !fileInfo.exists() ) {
 FmLogger::log( QString( "isPathAccessabel false: path not exist" ) );
-return false;
+return FmErrPathNotExist;
 }
-FmLogger::log( QString( "isPathAccessabel true" ) );
+FmLogger::log( QString( "isPathAccessabel FmErrNone" ) );
-return true;
+return FmErrNone;
 }
 // only used to check drive, when MMC is not inserted, also return false
 bool FmUtils::isDriveAvailable( const QString &path )
 {
 FmLogger::log( QString( "isDriveAvailable:" ) + path );
+if( path.isEmpty() ) {
+return false;
+}
 FmDriverInfo::DriveState driveState = queryDriverInfo( path ).driveState();
 if( ( driveState & FmDriverInfo::EDriveAvailable ) ) {
 FmLogger::log( QString( "isDriveAvailable true" ) );
 return true;
 }
 }
 QFileInfoList infoList = QDir::drives();
 foreach( QFileInfo fileInfo, infoList ) {
 QString driveName = fileInfo.absolutePath();
-if( checkDriveFilter( driveName ) ) {
+if( checkDriveAccessFilter( driveName ) ) {
 if( !isHideUnAvailableDrive ) {
 driveList.append( driveName );
 }
 else if ( isDriveAvailable( driveName ) ) {
 driveList.append( driveName );
 }
 QString FmUtils::fillDriveVolume( QString driveName, bool isFillWithDefaultVolume )
 {
 QString ret;
+if( driveName.isEmpty() ) {
+return ret;
+}
 QString tempDriveName = fillPathWithSplash( driveName );
-ret = removePathSplash( driveName );
+QString checkedDriveName( removePathSplash( driveName ) );
 FmDriverInfo driverInfo = FmUtils::queryDriverInfo( tempDriveName );
 QString volumeName = driverInfo.volumeName();
 if( volumeName.isEmpty() && isFillWithDefaultVolume ){
 FmDriverInfo::DriveState driveState = queryDriverInfo( tempDriveName ).driveState();
 if( driveState & FmDriverInfo::EDriveAvailable ){
 if( driveState & FmDriverInfo::EDriveRemovable ) {
 if( driveState & FmDriverInfo::EDriveMassStorage ) {
-volumeName.append( QObject::tr( "Mass Storage" ) );
+// Mass Storage
+ret = hbTrId( "txt_fmgr_dblist_1_mass_storage" ).arg( checkedDriveName );
 } else if( driveState & FmDriverInfo::EDriveUsbMemory ) {
-volumeName.append( QObject::tr( "Usb Memory" ) );
+// USB Memory
+ret = hbTrId( "txt_fmgr_dblist_1_usb_memory" ).arg( checkedDriveName );
 } else{
-volumeName.append( QObject::tr( "Memory Card" ) );
+// Memory Card
+ret = hbTrId( "txt_fmgr_dblist_1_memory_card" ).arg( checkedDriveName );
 }
 } else{
-volumeName.append( QObject::tr( "Phone Memory" ) );
+// phone memory
-}
+ret = hbTrId( "txt_fmgr_dblist_1_device_memory" ).arg( checkedDriveName );
 }
 }
+}
-ret += QString( " " ) + volumeName;
+if( ret.isEmpty() ) {
+// set ret as volumeName
+// txt_fmgr_dblist_1_2 is not correct, can not use.
+ret = hbTrId( "%1 %2" ).arg( checkedDriveName ).arg( volumeName );
+}
 return ret;
 }
 int FmUtils::launchFile( const QString &filePath )
 {
 QFile file( filePath );
+if( !file.exists() ) {
+return false;
+}
 XQApplicationManager mAiwMgr;
 XQAiwRequest *request = mAiwMgr.create(file);
 if ( request == 0 ) {
 // No handlers for the URI
 return FmErrUnKnown;
 return QString();
 }
 QString FmUtils::formatPath( const QString &path  )
 {
-QString formatPath = path;
+QString formatPath;
-QRegExp regExp( "/" );
+	foreach( QChar ch, path ) {
-formatPath.replace( regExp, "\\" );
+		if( ch == QChar('\\') || ch == QChar('/') ) {
+			formatPath.append( QDir::separator() );
-if( path.right( 1 )!= "\\"){
+		} else {
-formatPath.append( "\\" );
+			formatPath.append( ch );
+		}
+}
+if( formatPath.right( 1 ) != QDir::separator() ){
+formatPath.append( QDir::separator() );
 }
 return formatPath;
 }
 int FmUtils::getMaxFileNameLength()
 {
 return KMaxFileName;
 }
 bool FmUtils::checkMaxPathLength( const QString& path )
 {
 if( path.length() > KMaxPath ) {
 return false;
 }
 return true;
 }
 bool FmUtils::checkFolderFileName( const QString& name )
 {
 if( name.endsWith( QChar('.'),  Qt::CaseInsensitive ) ) {
 return false;
 }
 if( name.length() > KMaxFileName ) {
 return false;
 }
 return true;
 }
+bool FmUtils::checkNewFolderOrFile( const QString &path, QString &errString )
+{
+QFileInfo fileInfo( path );
+bool ret( true );
+if (!FmUtils::checkFolderFileName( fileInfo.fileName() ) ) {
+errString = hbTrId( "Invalid file or folder name!" );
+ret = false;
+} else if( !FmUtils::checkMaxPathLength( path ) ) {
+errString = hbTrId( "the path you specified is too long!" );
+ret = false;
+} else if (fileInfo.exists()) {
+errString = hbTrId( "%1 already exist!" ).arg( fileInfo.fileName() );
+ret = false;
+}
+return ret;
+}

branch	GCC_SURGE
changeset 31	e28107efca85
parent 30	6e96d2143d46
child 35	060d0b1ab845