/*

* Copyright (c) 2002-2008 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:

*

* Description:  Utility class to provide common functionalities internally.

*

*/

#include <coemain.h>

#include <bautils.h>

#include <AknIconArray.h>

#include <eikenv.h>

#include <AknsUtils.h>

#include <gulicon.h>

#include <fbs.h>

#include <rsfwmountman.h>

#include <driveinfo.h>

#include <StringLoader.h>

#include <commondialogs.rsg>

#include "AknCFDUtility.h"

#include <AknUtils.h>

_LIT(KFreeFormate, "%.1f");

const TInt KListBoxEntryMaxLength( KMaxFileName + 32 );

const TInt KFreeLen = 10; 

const TInt KNoIndex = -1;

const TInt KHundredNum = 100;

const TInt KThousandNum = 1024;

const TInt KMegaNum = 1024*1024;

const TInt KGigaNum = 1024*1024*1024;

// ======== MEMBER FUNCTIONS ========

#pragma message("TODO: CFDUtilityDUMMY is still not updated identical to CFDUtility")

// ---------------------------------------------------------------------------

// AknCFDUtility::DriveInfoL

// aDriveInfo.iDriveStatus is set according the error code given by RFs

// functions. Drive status differs slightly from RFs error codes. This is

// because CFD functionality does need most of the error codes. Few drive

// status codes are sufficient. This should simplify CFD error handling.

// ---------------------------------------------------------------------------

//

TInt AknCFDUtility::DriveInfoL( const TDriveNumber aDriveNumber,

                            TCFDDriveInfo& aDriveInfo)

    {

    TInt error;

    TFullName fsName;

    TDriveInfo driveInfo;

    TVolumeInfo volumeInfo;

    aDriveInfo.iVolumeLabel.Des().Zero();

    aDriveInfo.iDriveNumber = aDriveNumber;

    aDriveInfo.iDiskSpace = KDiskSpaceNotAvailable;

    aDriveInfo.iMediaType = EMediaNotPresent;

    aDriveInfo.iDriveStatus = EDriveOK;

    //iConnectionState: KMountStronglyConnected, KMountNotConnected

    aDriveInfo.iConnectionState = NULL;

    aDriveInfo.iStatus = NULL;

    RFs& fs = CCoeEnv::Static()->FsSession();

    _LIT( KFat, "Fat" );

    // Check drive's media status

    error = DriveInfo::GetDriveStatus( fs, aDriveNumber, aDriveInfo.iStatus );

    if( error )

        {

        aDriveInfo.iStatus = DriveInfo::EDriveCorrupt;

        return error;

        }

    // Check if the drive is already mounted

    error = fs.FileSystemName( fsName, aDriveNumber );

    if( error )

        {

        aDriveInfo.iDriveStatus = EDriveNotReady;

        return error;

        }

    // check if MMC already mounted

    if( fsName.Length() == 0 )

        {

        // MMC drive isnt mounted at present, so try it now....

        error = fs.MountFileSystem( KFat, aDriveInfo.iDriveNumber );

        // If it's a locked MMC and the password is already known it'll be

        // unlocked automatically when it's mounted., otherwise the mount will

        // return with KErrLocked.....

        switch( error )

            {

            case KErrNone:

                {

                // OK to continue...

                break;

                }

            case KErrLocked:

                {

                aDriveInfo.iDriveStatus = EDriveLocked;

                return error;                

                }

            default:

                {

                aDriveInfo.iDriveStatus = EDriveNotReady;

                return error;

               }

            }

        }

    error = fs.Drive( driveInfo, aDriveNumber );

    if( error )

        {

        aDriveInfo.iDriveStatus = EDriveNotReady;

        return error;

        }

    aDriveInfo.iMediaType = driveInfo.iType;

    // MMC is in slot

    if( driveInfo.iMediaAtt & KMediaAttLocked )

        {

        aDriveInfo.iDriveStatus = EDriveLocked;

        return error;

        }

    if( driveInfo.iDriveAtt & KDriveAttRemote )

        {

        // Initialize volumeInfo.

        error = fs.Volume( volumeInfo, aDriveNumber );

        volumeInfo.iName.Des().Zero();

        if ( !error )

            {            

            TPtr ptr = volumeInfo.iName.Des();

            // Get remote drive name, RFs::Volume() can only got the name

            // which is less than 11, so use GetDriveName to got the name.

            error = fs.GetDriveName( aDriveNumber, ptr );

            }

        }

    else

        {

        error = fs.Volume( volumeInfo, aDriveNumber );

        }

    if( error )

        {

        aDriveInfo.iDriveStatus = EDriveNotReady;

        return error;

        }

#pragma message("TODO: Disk space checking for remote drives might need different implementation (CRsfwMountMan?).")

    TInt64 free( volumeInfo.iFree );

    aDriveInfo.iDiskSpace = free;

    aDriveInfo.iVolumeLabel = volumeInfo.iName;

    // If type is remote drive and aConnectionState is required

    if( driveInfo.iDriveAtt & KDriveAttRemote )

        {

        TChar driveLetter;

        fs.DriveToChar( aDriveNumber, driveLetter );

           // This statement migth cause leave.. to be solved

        CRsfwMountMan* mountMgr = CRsfwMountMan::NewL( 0, NULL );

        TRsfwMountInfo mountInfo;

        error = mountMgr->GetMountInfo( driveLetter, mountInfo );

        delete mountMgr;

        aDriveInfo.iConnectionState = mountInfo.iMountStatus.iConnectionState;

        if( error ||

            mountInfo.iMountStatus.iConnectionState != KMountStronglyConnected )

            {

            aDriveInfo.iDriveStatus = EDriveNotReady;

            return error;

            }

        }

    return error;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::DriveStatusL

// ---------------------------------------------------------------------------

//

TCFDDriveStatus AknCFDUtility::DriveStatusL( const TDriveNumber aDriveNumber )

    {

#pragma message("TODO: Find out the actual functions needed for checking drive status - this might be too heavy checking.")

    RFs& fs = CCoeEnv::Static()->FsSession();

    _LIT( KFat, "Fat" );

    // Check if the drive is already mounted

    TFullName fsName;

    TInt error( fs.FileSystemName( fsName, aDriveNumber ) );

    if( error )

        {

        return EDriveNotReady;

        }

    // check if MMC already mounted

    if( fsName.Length() == 0 )

        {

        // MMC drive isnt mounted at present, so try it now....

        error = fs.MountFileSystem( KFat, aDriveNumber );

        // If it's a locked MMC and the password is already known it'll be

        // unlocked automatically when it's mounted., otherwise the mount will

        // return with KErrLocked.....

        switch( error )

            {

            case KErrNone:

                {

                // OK to continue...

                break;

                }

            case KErrLocked:

                {

                return EDriveLocked;

                }

            default:

                {

                return EDriveNotReady;

                }

            }

        }

    TDriveInfo driveInfo;

    error = fs.Drive( driveInfo, aDriveNumber );

    if( error )

        {

        return EDriveNotReady;

        }

    // MMC is in slot

    if( driveInfo.iMediaAtt & KMediaAttLocked )

        {

        return EDriveLocked;

        }

    TVolumeInfo volumeInfo;

    error = fs.Volume( volumeInfo, aDriveNumber );

    if( error )

        {

        return EDriveNotReady;

        }

    // If type is remote drive and aConnectionState is required

    if( driveInfo.iDriveAtt & KDriveAttRemote )

        {

        TChar driveLetter;

        fs.DriveToChar( aDriveNumber, driveLetter );

        // This statement migth cause leave.. to be solved

        CRsfwMountMan* mountMgr = CRsfwMountMan::NewL( 0, NULL );

        TRsfwMountInfo mountInfo;

        error = mountMgr->GetMountInfo( driveLetter, mountInfo );

        delete mountMgr;

        if( error ||

            mountInfo.iMountStatus.iConnectionState != KMountStronglyConnected )

            {

            return EDriveNotReady;

            }

        }

    return EDriveOK;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::DriveNumber

// ---------------------------------------------------------------------------

//

TInt AknCFDUtility::DriveNumber( const TDesC& aPath )

    {

    TDriveUnit unit( aPath );

    return TInt( unit );

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::DirectoryCount

// ---------------------------------------------------------------------------

//

TInt AknCFDUtility::DirectoryCount( const TDesC& aPath )

    {

    TInt pathLength( aPath.Length() );

    if( pathLength == 0 )

        {

        return 0;

        }

    TInt directoryCount( 0 );

    TUint character( 0 );

    for( TInt index( 0 ); index < pathLength; index++ )

        {

        // Find backslash characters from path

        character = aPath[ index ];

        if( character == '\\' )

            {

            directoryCount++;

            }

        }

    // If the path doesn't end to a backslash

    if( character != '\\' )

        {

        // Add folder count with one

        // e.g. "Nokia\Images" would return 1 folder but it should

        // return 2, like "Nokia\Images\" does

        directoryCount++;

        }

    return directoryCount;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AddTrailingBackslash

// ---------------------------------------------------------------------------

//

TInt AknCFDUtility::AddTrailingBackslash( TDes& aPath )

    {

    TInt descriptorLength( aPath.Length() );

    if( descriptorLength == 0 )

        {

        return KErrBadDescriptor;

        }

    // Check if path ends to a backslash

    if( aPath[ descriptorLength - 1 ] == '\\' )

        {

        return KErrNone;

        }

    // Check that descriptor has space for one character

    if( aPath.MaxLength() == descriptorLength )

        {

        return KErrOverflow;

        }

    aPath.Append( TChar( '\\' ) );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::RemoveTrailingBackslash

// ---------------------------------------------------------------------------

//

TInt AknCFDUtility::RemoveTrailingBackslash( TDes& aPath )

    {

    TInt descriptorLength( aPath.Length() );

    if( descriptorLength == 0 )

        {

        return KErrBadDescriptor;

        }

    // Check if path already ends to a backslash

    if( aPath[ descriptorLength - 1 ] == '\\' )

        {

        aPath.Delete( descriptorLength - 1, 1 );

        }

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AllocateIfValidL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::AllocateIfValidL( HBufC*& aDestination, const TDesC& aSource )

    {

    if( aSource.Length() )

        {

        delete aDestination;

        aDestination = NULL;

        aDestination = aSource.AllocL();

        }

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AllocateOrNullL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::AllocateOrNullL( HBufC*& aDestination, const TDesC& aSource )

    {

    delete aDestination;

    aDestination = NULL;

    if( aSource.Length() )

        {

        aDestination = aSource.AllocL();

        }

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AllocateIfNullL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::AllocateIfNullL( HBufC*& aDestination, const TDesC& aSource )

    {

    if( !aDestination )

        {

        AllocateOrNullL( aDestination, aSource );

        }

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AppendImageToArrayL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::AppendImageToArrayL(

    CEikonEnv& /*aEnv*/, CAknIconArray& aArray,

    const TDesC& aBitmapFile, TInt aBitmapId, TInt aMaskId )

    {

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    AknIconUtils::CreateIconLC(

            bitmap, mask, aBitmapFile, aBitmapId, aMaskId );

    CleanupStack::PushL( bitmap );

    CleanupStack::PushL( mask );

    // Ownership is transferred to CGulIcon

    CGulIcon* icon = CGulIcon::NewL( bitmap, mask );

    CleanupStack::Pop( 2 ); // mask, bitmap

    CleanupStack::PushL( icon );

    aArray.AppendL( icon ); // Ownership is transferred to CAknIconArray

    CleanupStack::Pop( icon ); // icon

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::AppendSkinnedImageToArrayL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::AppendSkinnedImageToArrayL( CEikonEnv& /*aEnv*/,

                                             CAknIconArray& aArray,

                                             MAknsSkinInstance* aSkin,

                                             const TAknsItemID& aItemID,

                                             const TDesC& aBitmapFile,

                                             TInt aBitmapId,

                                             TInt aMaskId,

                                             TBool aColorIcon)

    {        

    TRgb defaultColour( KRgbBlack );

    CFbsBitmap* bitmap = NULL;

    CFbsBitmap* mask = NULL;

    if( aColorIcon )      

        {

        AknsUtils::GetCachedColor( aSkin, defaultColour, 

                                KAknsIIDQsnIconColors, 

                                EAknsCIQsnIconColorsCG13 );

        AknsUtils::CreateColorIconLC( aSkin, aItemID, 

                                KAknsIIDQsnIconColors, 

                                EAknsCIQsnIconColorsCG13, bitmap, mask, 

                                aBitmapFile, aBitmapId, aMaskId, 

                                defaultColour );

        // Ownership is transferred to CGulIcon

        CGulIcon* icon = CGulIcon::NewL( bitmap, mask );

        CleanupStack::Pop( 2 ); // mask, bitmap

        CleanupStack::PushL( icon );

        aArray.AppendL( icon ); // Ownership is transferred to CAknIconArray

        CleanupStack::Pop( icon ); // icon 	

        }

    else

        {

        AknsUtils::CreateIconL( aSkin, aItemID, bitmap, mask, aBitmapFile,

                                aBitmapId, aMaskId );

        CleanupStack::PushL( bitmap );

        CleanupStack::PushL( mask );

        // Ownership is transferred to CGulIcon

        CGulIcon* icon = CGulIcon::NewL( bitmap, mask );

        CleanupStack::Pop( 2 ); // mask, bitmap

        CleanupStack::PushL( icon );

        aArray.AppendL( icon ); // Ownership is transferred to CAknIconArray

        CleanupStack::Pop( icon ); // icon 	

        }

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::DirectoriesOnly

// ---------------------------------------------------------------------------

//

TBool AknCFDUtility::DirectoriesOnly( TCommonDialogType aType )

    {

    if ( aType == ECFDDialogTypeMove ||

        aType == ECFDDialogTypeSave ||

        aType == ECFDDialogTypeBrowse  ||

        aType == ECFDDialogTypeCopy )

        {

        return ETrue;

        }

    return EFalse;

    }

// ---------------------------------------------------------------------------

// AknCFDUtility::ReadDynamicDrivesL

// ---------------------------------------------------------------------------

//

void AknCFDUtility::ReadDynamicDrivesL(

    CDesCArrayFlat& aRootPathArray, TInt aIncludedMedias )

    {

#ifdef _DEBUG

    CDesCArray* mediaTypeStrings = new (ELeave) CDesCArrayFlat(10);

    CleanupStack::PushL( mediaTypeStrings );

    // TMediaType enumeration as string representation for debugging.

    mediaTypeStrings->AppendL( _L( "EMediaNotPresent" ) );

    mediaTypeStrings->AppendL( _L( "EMediaUnknown" ) );

    mediaTypeStrings->AppendL( _L( "EMediaFloppy" ) );

    mediaTypeStrings->AppendL( _L( "EMediaHardDisk" ));

    mediaTypeStrings->AppendL( _L( "EMediaCdRom" ));

    mediaTypeStrings->AppendL( _L( "EMediaRam" ));

    mediaTypeStrings->AppendL( _L( "EMediaFlash" ));

    mediaTypeStrings->AppendL( _L( "EMediaRom"  ));

    mediaTypeStrings->AppendL( _L( "EMediaRemote" ));

    mediaTypeStrings->AppendL( _L( "EMediaNANDFlash" ));

    _LOG( "[CFDUtility] Drive info: " );

#endif // _DEBUG

    // Get list of drives dynamically (move this to CFDUtility?)

    RFs& fs = CCoeEnv::Static()->FsSession();

    TDriveList driveList;

    CRsfwMountMan* mountMgr = CRsfwMountMan::NewL( 0, NULL );

    CleanupStack::PushL( mountMgr );

    mountMgr->GetRemoteMountListL( driveList );

    CleanupStack::PopAndDestroy( mountMgr );

    _LOG1( "[CFDUtility] driveList:%S", &driveList );