/*

* 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 <XQConversions>

#include <QStringList>

#include <QFileInfoList>

#include <QDir>

#include <QFile>

#include <xqaiwrequest.h>

#include <xqappmgr.h>

#include <shareuidialog.h>

#define BURCONFIGFILE  "z:/private/2002BCC0/burconfig.xml"

QString FmUtils::getDriveNameFromPath( const QString &path )

{

    if( path.length() <3 ) {

        return QString();

    }

    return path.left( 3 );

}

FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName )

{

}

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";	    

	}

}

quint32 FmUtils::getDriverState( const QString &driverName )

{    

    CCoeEnv *env = CCoeEnv::Static();

	if( err != KErrNone ) {

            state |= FmDriverInfo::EDriveNotPresent;

	}

	if ( err == KErrLocked ) {

            state |= FmDriverInfo::EDriveLocked;

	}

    TDriveInfo driveInfo = volumeInfo.iDrive;

    quint32 drvStatus( 0 );

    DriveInfo::GetDriveStatus( fs, drive, drvStatus );

    QString logString = driverName +':'+ QString::number( drvStatus);

    FmLogger::log(logString);

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

         ( drvStatus & DriveInfo::EDriveExternallyMountable ) ){

        // Handle mass storage bits here

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

    }

    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;    

    }

    return state;

}

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

}

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

}

int FmUtils::setDrivePwd( const QString &driverName, const QString &oldPwd, const QString &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 );

}

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)

{

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

}

{

    TInt drive = 0;

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

    const int KDriveShift = 16;

    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();

    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{