/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*     Zhiqiang Yang <zhiqiang.yang@nokia.com>

* 

* Description:

*     The source file of the file manager utilities

*/

#include "fmutils.h"

#include "fms60utils.h"

#include "fmcommon.h"

#include <QRegExp>

#include <coemain.h>

#include <driveinfo.h>

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

#include <f32file.h>

#include <apgcli.h>

#include <pathinfo.h>

#include <CDirectoryLocalizer.h>

#include <XQConversions>

#include <QStringList>

#include <QFileInfoList>

#include <QDir>

#include <QFile>

#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 ) {

        return QString();

    }

    return path.left( 3 );

}

QString FmUtils::getDriveLetterFromPath( const QString &path )

{

	if( path.length() <2 ) {

        return QString();

    }

    return path.left( 1 );

}

FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName )

{

    CCoeEnv *env = CCoeEnv::Static();

    RFs& fs = env->FsSession();

    TVolumeInfo volumeInfo;

    TInt drive = 0;

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

    quint32 state( 0 );

    int volumeInfoErr( KErrNone );

    int driveInfoErr( KErrNone );

    int errorCode( KErrNone );

    volumeInfoErr = fs.Volume( volumeInfo, drive );

    errorCode = volumeInfoErr;

    QString volumeName( (QChar*)( volumeInfo.iName.Des().Ptr() ), volumeInfo.iName.Length() );

    TDriveInfo driveInfo;

    if( volumeInfoErr == KErrNone ) {

        driveInfo = volumeInfo.iDrive;

    } else {

        driveInfoErr = fs.Drive( driveInfo, drive );

        if( driveInfoErr != KErrNone ) {

            errorCode = driveInfoErr;

        }

    }

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

        //TDriveInfo driveInfo = volumeInfo.iDrive;

        quint32 drvStatus( 0 );

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

        if( err == KErrNone ) {

            if ( ( drvStatus & DriveInfo::EDriveInternal ) &&

                 ( drvStatus & DriveInfo::EDriveExternallyMountable ) ){

                // Handle mass storage bits here

                state |= FmDriverInfo::EDriveMassStorage | FmDriverInfo::EDriveRemovable;

            }

            if ( drvStatus & DriveInfo::EDriveUsbMemory )

                {

                state |= FmDriverInfo::EDriveUsbMemory;

                }

            if ( drvStatus & DriveInfo::EDriveRom ){

                state |= FmDriverInfo::EDriveRom;  

            }

            if ( drvStatus & DriveInfo::EDriveRam ){

                state |= FmDriverInfo::EDriveRam;  

            }

            if ( driveInfo.iMediaAtt & KMediaAttFormattable ){

                state |= FmDriverInfo::EDriveFormattable;

            }

            if ( driveInfo.iMediaAtt & KMediaAttWriteProtected ){

                state |= FmDriverInfo::EDriveWriteProtected;

            }

            if ( driveInfo.iMediaAtt & KMediaAttHasPassword ){

                state |= FmDriverInfo::EDrivePasswordProtected;

            }    

            if ( driveInfo.iMediaAtt & KMediaAttLocked ){

                state |= FmDriverInfo::EDriveLocked;

            }

            if ( driveInfo.iDriveAtt & KDriveAttRemovable ){

                state |= FmDriverInfo::EDriveRemovable;

                if ( drvStatus & DriveInfo::EDriveSwEjectable ){

                    state |= FmDriverInfo::EDriveEjectable;

                }

            }

            if( driveInfo.iType == EMediaNotPresent ){

                state |= FmDriverInfo::EDriveNotPresent;    

            }

        }

        // 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 )

    {

    case KErrNone:

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

        state |= FmDriverInfo::EDriveAvailable; 

        break;

    case KErrLocked:

        state |= FmDriverInfo::EDriveLocked;

        break;

    case KErrCorrupt:

        state |= FmDriverInfo::EDriveCorrupted;

        break;

    case KErrInUse:

        state |= FmDriverInfo::EDriveInUse;

        break;

    default: // other errors

        state |= FmDriverInfo::EDriveNotPresent;

        break;

    }

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

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

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

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

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

    FmLogger::log( logString );

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

}

QString FmUtils::formatStorageSize( quint64 size )

{

	if ( size < 1000 ) {

		return QString::number( size ) + " B";

	} else if ( size < 1000 * 1000 ) {

		return QString::number( size / 1024.0, 'f', 2 ) + " KB";

	} else if ( size < 1000 * 1000 * 1000 ) {

		return QString::number( size / (1024.0 * 1024.0), 'f', 1 ) + " MB";

	} else {

	    return QString::number( size / ( 1024.0 * 1024.0 * 1024.0 ), 'f', 1 ) + " GB";	    

	}

}

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

{

    QString logString = "Drive name:" + driverName;

    FmLogger::log( logString );

    logString = "Password:" + Pwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

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

    HBufC* password16 = XQConversions::qStringToS60Desc( Pwd );

    TMediaPassword password;   

    TPtr ptrPassword16( password16->Des() );  

    FmS60Utils::ConvertCharsToPwd( ptrPassword16, password );

    int err( fs.ClearPassword( drive, password ) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Clear password error:" + QString::number( err );

    FmLogger::log( logString );

    if( err == KErrNone ){

        return FmErrNone;   

    }

    else if( err == KErrAccessDenied ){

        return FmErrAccessDenied;

    }

    else{

        return FmErrUnKnown;

    }

}

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

{

    QString logString = "Drive name:" + driverName;

    FmLogger::log( logString );

    logString = "Password:" + Pwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

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

    HBufC* password16 = XQConversions::qStringToS60Desc( Pwd );

    TMediaPassword password;   

    TPtr ptrPassword16( password16->Des() );  

    FmS60Utils::ConvertCharsToPwd( ptrPassword16, password );

    int err( fs.UnlockDrive( drive, password, ETrue) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Unlock drive error:" + QString::number( err );

    FmLogger::log( logString );

    if( err == KErrNone ){

        return FmErrNone;   

    }

    else if( err == KErrAccessDenied ){

        return FmErrAccessDenied;

    }

    else if( err == KErrAlreadyExists ){

        return FmErrAlreadyExists;

    }

    else if( err == KErrNotSupported ){

        return FmErrNotSupported;

    }

    else{

        return FmErrUnKnown;

    }

}

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

{

    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)

{

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

    logString += " Old password:" + oldPwd;

    logString += " New password:" + newPwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

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

    HBufC* newPassword16 = XQConversions::qStringToS60Desc( newPwd);

    HBufC* oldPassword16 = XQConversions::qStringToS60Desc( oldPwd );

    TMediaPassword oldPassword;

    TMediaPassword newPassword;

    TPtr ptrNewPassword16( newPassword16->Des() );

    TPtr ptrOldPassword16( oldPassword16->Des() );

    FmS60Utils::ConvertCharsToPwd( ptrNewPassword16, newPassword );

    FmS60Utils::ConvertCharsToPwd( ptrOldPassword16, oldPassword );

    int err( fs.LockDrive( drive, oldPassword, newPassword, ETrue ) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Password set error:" + QString::number( err );

    FmLogger::log( logString );

    if( err == KErrNone ){

        return FmErrNone;   

    }

    else if( err == KErrNotSupported ){

        return FmErrNotSupported;

    }

    else{

        return FmErrUnKnown;

    }

}

void FmUtils::emptyPwd( QString &pwd )

{

    TPtr des ( ( XQConversions::qStringToS60Desc( pwd ) )->Des() );

    des.FillZ( des.MaxLength() );

    des.Zero();

    pwd = XQConversions::s60DescToQString( des );

}

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

{

    foreach( const QChar &ch, newVolumeName )

    {

        bool a = ch.isSpace();

        bool b = ch.isLetterOrNumber();

        // If not alphadigit or space, return error

        if( !ch.isLetterOrNumber() && !ch.isSpace() )

        {

            return FmErrBadName;

        }   

    }

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

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

    TPtr newName ( ( XQConversions::qStringToS60Desc( newVolumeName ) )->Des() );

    int err( fs.SetVolumeLabel( newName, drive ));

    QString logString = "Rename error:" + QString::number( err );

    FmLogger::log( logString );

    if( err == KErrNone ){

        return FmErrNone;   

    }

    else if( err == KErrNotReady ){

        return FmErrNotReady;

    }

    else{

        return FmErrUnKnown;

    }

}

void FmUtils::ejectDrive( const QString &driverName )

{

    QString logString = "FmUtils::ejectDrive start";

    FmLogger::log( logString );

    TInt drive = 0;

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

    const int KDriveShift = 16;

    // Let SysAp handle eject

    RProperty::Set(

        KPSUidCoreApplicationUIs,

        KCoreAppUIsMmcRemovedWithoutEject,

        ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift )

        );

}

QString FmUtils::getFileType( const QString &filePath  )

{

    RApaLsSession apaSession;

    TDataType dataType;

    TUid appUid;

    TBuf<128> mimeTypeBuf;

    int err = apaSession.Connect();

    if ( err == KErrNone ){   

        err = apaSession.AppForDocument( XQConversions::qStringToS60Desc( filePath )->Des(), 

                                         appUid, dataType );

        if( err == KErrNone ){

            mimeTypeBuf.Copy(dataType.Des8());

        }  

    }

    apaSession.Close();

    return XQConversions::s60DescToQString( mimeTypeBuf );

}

quint64 FmUtils::getDriveDetailsResult( const QString &folderPath, const QString &extension )

{

    int err;

    RFs fs;

    err = fs.Connect();

    QString string( formatPath( folderPath ) );

    TPtrC desFolderPath( XQConversions::qStringToS60Desc( string )->Des() );

    TPtrC ptrExtension( XQConversions::qStringToS60Desc( extension )->Des() );

    CDir* results = 0;

    TParse parse;

    quint64 size = 0;

    const TInt pathlength = ptrExtension.Length() + desFolderPath.Length();

    if ( pathlength > KMaxFileName ){

        err = KErrNotFound;   

    }

    else{

        err = fs.Parse( ptrExtension, desFolderPath, parse );

        err = fs.GetDir( parse.FullName(), KEntryAttMaskSupported|KEntryAttAllowUid, 

            ESortNone, results );

        TDesC des = parse.FullName();

        if (err == KErrNotFound)

            {

            return 0;

            }

    }

    if ( results ){

        CleanupStack::PushL(results);

        // Go through all files in the list and tell subclass

        TFileName file;

        const TInt count = results->Count();

        for( TInt i=0; i<count; ++i ){

            const TEntry& entry = (*results)[i];

            file = desFolderPath;

            file += entry.iName;

            size += entry.iSize;          

        }

        CleanupStack::PopAndDestroy(results);

    }

    fs.Close();

    return size;  

}

bool FmUtils::isDriveC( const QString &driverName )

{

    TInt drive = 0;

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

    if( drive == EDriveC ){

        return true;

    }

    else{

        return false;

    }

}

bool FmUtils::isDrive( const QString &path )

{

   bool ret( false );

   if( path.length() <= 3 && path.length() >=2 ) {

       ret = true;

   }

   return ret;   

}

void FmUtils::createDefaultFolders( const QString &driverName )

{

    int err;

    TInt drive = 0;

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