*     The source file of the file manager utilities on Symbian

#include "fmcommon.h"

#include <apgcli.h>

#include <sysutil.h>

#include <f32file.h>

#include <pathinfo.h>

#include <QDir>

#include <QFile>

#include <QRegExp>

#include <xqappmgr.h>

#include <XQConversions>

#include <shareui.h>

#include <hbglobal.h>

#include <hbdirectorynamelocalizer.h>

/*!

    query drive info and status for \a driveName

    return \a FmDriverInfo

*/

FmDriverInfo FmUtils::queryDriverInfo( const QString &driveName )

    if( driveName.isEmpty() ) {

        return FmDriverInfo( 0, 0, driveName, QString(), FmDriverInfo::EDriveNotPresent );

    drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    int volumeInfoErr( KErrNone );

    int driveInfoErr( KErrNone );

    int errorCode( KErrNone );

    volumeInfoErr = fs.Volume( volumeInfo, drive );

    errorCode = volumeInfoErr;

    TDriveInfo driveInfo;

    if( volumeInfoErr == KErrNone ) {

        driveInfo = volumeInfo.iDrive;

    } else {

        driveInfoErr = fs.Drive( driveInfo, drive );

        if( driveInfoErr != KErrNone ) {

            errorCode = driveInfoErr;

        }

    }

    if( volumeInfoErr == KErrNone || driveInfoErr == KErrNone ) {

        //TDriveInfo driveInfo = volumeInfo.iDrive;

        int err = DriveInfo::GetDriveStatus( fs, drive, drvStatus );

            if ( drvStatus & DriveInfo::EDriveUsbMemory )

                {

                state |= FmDriverInfo::EDriveUsbMemory;

                }

            if ( drvStatus & DriveInfo::EDriveRemote )

                {

                state |= FmDriverInfo::EDriveRemote;

                }

        // If memory card is not ready but type is present,

        // then check if it is reserved.

        if( err == KErrNone && volumeInfoErr == KErrNotReady &&

            driveInfo.iType != EMediaNotPresent )

            {

            // Check USB file transfer state

            TInt prop( ECoreAppUIsUSBFileTransferUninitialized );

            RProperty::Get(

                KPSUidCoreApplicationUIs,

                KCoreAppUIsUSBFileTransfer, prop );

            if ( prop == ECoreAppUIsUSBFileTransferActive )

                {

                errorCode = KErrInUse; // Reserved for file transfer

                }

            }

        if( err!= KErrNone )

            {

            errorCode = err;

            }

    // handle error code

    // volumeInfoErr will occur while drive is lock,corrupted...

    // driveInfoErr can not be promoted for locked, corrupted drive.

    // so we can not use driveInfoErr to justify EDriveAvailable

    switch( errorCode )

        // this drive could be used as it is not be locked, or corrupt.

        state |= FmDriverInfo::EDriveAvailable; 

    case KErrInUse:

        state |= FmDriverInfo::EDriveInUse;

        break;

    QString logString ( "FmUtils::queryDriverInfo_" + driveName + 

            "_volumeInfoErr:" + QString::number( volumeInfoErr ) +

            "_driveInfoErr:" + QString::number( driveInfoErr ) +

            "_errorCode:" + QString::number( errorCode ) + 

            "_driveSatus:" + QString::number( state ) );

    FM_LOG( logString );

    return FmDriverInfo( volumeInfo.iSize, volumeInfo.iFree, driveName, volumeName, state );

/*!

    remove drive password for \a driveName

    \a Pwd is original password.

*/

int FmUtils::removeDrivePwd( const QString &driveName,  const QString &Pwd )

    if( driveName.isEmpty() || Pwd.length() > FmMaxLengthofDrivePassword ) {

        return FmErrWrongParam;

    QString logString = "Drive name:" + driveName;

    FM_LOG( logString );

    FM_LOG( logString );

    drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    FM_LOG( logString );

    FM_LOG( logString );

    delete password16;

/*!

    Unlock drive \a driveName with provided password \a Pwd

*/

int FmUtils::unlockDrive( const QString &driveName,  const QString &Pwd )

    if( driveName.isEmpty() || Pwd.length() > FmMaxLengthofDrivePassword ) {

        return FmErrWrongParam;

    }

    QString logString = "Drive name:" + driveName;

    FM_LOG( logString );

    FM_LOG( logString );

	drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    FM_LOG( logString );

    FM_LOG( logString );

    delete password16;

/*!

    Check if \a pwd is the right password for drive \a driveName

*/

int FmUtils::checkDrivePwd( const QString &driveName, const QString &pwd )

    if( driveName.isEmpty() || pwd.length() > FmMaxLengthofDrivePassword ) {

        return FmErrWrongParam;

    }

    QString logString = "checkDrivePwd Drive name:" + driveName;

    FM_LOG( logString );

    return setDrivePwd( driveName, pwd, pwd );

/*!

    Set new password \a newPwd for drive \a driveName. \a oldPwd is old password

*/

int FmUtils::setDrivePwd( const QString &driveName, const QString &oldPwd, const QString &newPwd)

    if( driveName.isEmpty() || 

        oldPwd.length() > FmMaxLengthofDrivePassword || newPwd.length() > FmMaxLengthofDrivePassword  ) {

        return FmErrWrongParam;

    }

    QString logString = "setDrivePwd Drive name:" + driveName ;

    FM_LOG( logString );

	drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    FM_LOG( logString );

    FM_LOG( logString );

    delete newPassword16;

    delete oldPassword16;

/*!

    Set \a pwd as empty password

*/

    TBuf< FmMaxLengthofDrivePassword > nullPwd;

    nullPwd.FillZ( nullPwd.MaxLength() );

    nullPwd.Zero();

    pwd = XQConversions::s60DescToQString( nullPwd );

/*!

    Set drive volume for drive \a driveName

*/

int FmUtils::renameDrive( const QString &driveName, const QString &newVolumeName)

    if( driveName.isEmpty() ) {

        return FmErrWrongParam;

    }

    foreach( const QChar &ch, newVolumeName )

	drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    FM_LOG( logString );

/*!

    Eject drive \a driveName

*/

int FmUtils::ejectDrive( const QString &driveName )

    if( driveName.isEmpty() ) {

        return FmErrWrongParam;

    }

    FM_LOG( logString );

	drive = driveName[0].toUpper().toAscii() - 'A' + EDriveA;

    return FmErrNone;

}

/*!

    Check if drive \a driveName is accessable for user

*/

bool FmUtils::checkDriveAccessFilter( const QString &driveName )

{

    if( driveName.isEmpty() ) {

        return false;

    }

    FmDriverInfo driveInfo = queryDriverInfo( driveName );

    if( ( driveInfo.driveState()& FmDriverInfo::EDriveRam ) ||

        ( driveInfo.driveState()& FmDriverInfo::EDriveRom ) ) {

        return false;

    }

    return true;

/*!

    This function should be called to adjust path if user goto a drive.

    data folder will be append to C:\ becuase user could only view C:\data instead C:\ 

*/

QString FmUtils::checkDriveToFolderFilter( const QString &path )

    QString checkedPath = fillPathWithSplash( path );

    if( checkedPath.compare( Drive_C, Qt::CaseInsensitive ) == 0 ) {

        checkedPath += QString( "data" ) + QDir::separator();

        return checkedPath;

    }

    return path;

}

/*!

    This function should be called to adjust path if user back to up level path.

    If user is at C:\data then path level should be returned as C:\

    Becuase C:\data is root path for C drive 

*/

QString FmUtils::checkFolderToDriveFilter( const QString &path )

{

    QString logString;

    logString = QString( "checkFolderToDriveFilter: " ) + path;

    FM_LOG( logString );

    QString checkedPath = fillPathWithSplash( path );

    logString = QString( "checkFolderToDriveFilter_fillPathWithSplash: " ) + checkedPath;

    FM_LOG( logString );

    if( checkedPath.compare( Folder_C_Data, Qt::CaseInsensitive ) == 0 ) {

        FM_LOG( QString( " change from c:/data/ to C:/" ) );

        return Drive_C;

    return path;

/*!

    Check if \a path is accessable for user

*/

int FmUtils::isPathAccessabel( const QString &path )

    // Used to check if path is accessable, very important feature

    // and will return filemanager error.