/*
* 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:  Drive info storage
*
*/


// INCLUDE FILES
#include <coreapplicationuisdomainpskeys.h>
#include "TFileManagerDriveInfo.h"
#include "CFileManagerEngine.h"
#include "FileManagerDebug.h"
#include "CFileManagerCommonDefinitions.h"
#include "CFileManagerFeatureManager.h"
#ifdef RD_MULTIPLE_DRIVE
#include <driveinfo.h>
#endif // RD_MULTIPLE_DRIVE

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

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::TFileManagerDriveInfo
// -----------------------------------------------------------------------------
//
EXPORT_C TFileManagerDriveInfo::TFileManagerDriveInfo()
    {
    Reset();
    }

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::TFileManagerDriveInfo
// -----------------------------------------------------------------------------
//
EXPORT_C void TFileManagerDriveInfo::Reset()
    {
    iName.Zero();
    iCapacity = 0;
    iSpaceFree = 0;
    iUid = 0;
    iDrive = 0;
    iState = 0;
    }

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::GetInfoL
// -----------------------------------------------------------------------------
//
void TFileManagerDriveInfo::GetInfoL(
        const CFileManagerEngine& aEngine, const TInt aDrive )
    {
    FUNC_LOG

    INFO_LOG1( "TFileManagerDriveInfo::GetInfoL - aDrive %d", aDrive )

    Reset();
    iDrive = aDrive;

    RFs& fs( aEngine.Fs() );
    CheckMountL( fs, aDrive );
    TInt err( FillStateFromVolumeInfo( fs, aDrive ) );
    if ( err == KErrInUse )
        {
        iState |= EDriveInUse;
        }
    else if ( err == KErrCorrupt )
        {
        iState |= EDrivePresent | EDriveCorrupted;
        }
    else if ( err == KErrLocked )
        {
        iState |= EDrivePresent | EDriveLocked | EDriveFormatted |
            EDrivePasswordProtected | EDriveLockable;
        }
    else if ( err == KErrNone )
        {
        if ( iState & EDriveRemote )
            {
            if ( aEngine.IsRemoteDriveConnected( aDrive ) )
                {
                iState |= EDriveConnected;
                }
            }

#ifndef RD_FILE_MANAGER_BACKUP
        if ( iState & EDriveRemovable )
            {
            if ( aEngine.BackupFileExistsL( aDrive ) )
                {
                iState |= EDriveBackupped;
                }
            }
#endif // RD_FILE_MANAGER_BACKUP

        }

    INFO_LOG3( "TFileManagerDriveInfo::GetInfoL - aDrive %d, err %d, iState 0x%x",
        aDrive, err, iState )

    if ( aEngine.FeatureManager().IsEmbedded() )
        {
        // Disable format in embedded mode, because it messes up 
        // operations since embedded apps are closed.
        iState &= ~EDriveFormattable;
        }
    }

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::CheckMountL()
// -----------------------------------------------------------------------------
// 
void TFileManagerDriveInfo::CheckMountL(
        RFs& aFs, const TInt aDrive ) const
    {
    FUNC_LOG

    HBufC* fullname = HBufC::NewLC( KMaxFullName );
    TPtr name( fullname->Des() );
    TInt err( aFs.FileSystemName( name, aDrive ) );
    if ( err == KErrNone && !name.Length() )
        {
        // Drive isn't mounted at present, so try it now....
        // Returns KErrLocked, if locked and the password
        // is not in store
        err = aFs.MountFileSystem( KFmgrFatFSName, aDrive );
        }
    CleanupStack::PopAndDestroy( fullname );

    LOG_IF_ERROR1( err, "TFileManagerDriveInfo::CheckMountL-err=%d", err )
    }

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::FillStateFromDriveInfo()
// -----------------------------------------------------------------------------
// 
TInt TFileManagerDriveInfo::FillStateFromDriveInfo(
#ifdef RD_MULTIPLE_DRIVE
        RFs& aFs,
#else // RD_MULTIPLE_DRIVE
        RFs& /*aFs*/,
#endif // RD_MULTIPLE_DRIVE
        const TInt aDrive,
        const TDriveInfo& aDrvInfo )
    {
    FUNC_LOG

    TInt ret( KErrNone );

#ifdef RD_MULTIPLE_DRIVE
    TUint drvStatus( 0 );
    TInt err( DriveInfo::GetDriveStatus( aFs, aDrive, drvStatus ) );
    if ( err != KErrNone )
        {
        ERROR_LOG2( "TFileManagerDriveInfo::FillStateFromDriveInfo - aDrive %d, Status err %d",
            aDrive, err )
        }
    INFO_LOG2( "TFileManagerDriveInfo::FillStateFromDriveInfo - Media type %d, drvStatus 0x%x",
        aDrvInfo.iType, drvStatus )
    if ( aDrvInfo.iType != EMediaNotPresent && ( drvStatus & DriveInfo::EDriveInUse ) )
        {
        ret = KErrInUse; // Drive is reserved for exclusive usage like file transfer
        }
    if ( ( drvStatus & DriveInfo::EDriveInternal ) &&
        ( drvStatus & DriveInfo::EDriveExternallyMountable ) )
        {
        // Handle mass storage bits here
        iState |= EDriveMassStorage | EDriveRemovable;
        if ( aDrvInfo.iMediaAtt & KMediaAttFormattable )
            {
            iState |= EDriveFormattable;
            }
        if ( aDrvInfo.iMediaAtt & KMediaAttLocked )
            {
            // Locking internal drives is not supported
            iState |= EDriveCorrupted;
            ret = KErrCorrupt;
            }
        return ret;
        }
    if ( drvStatus & DriveInfo::EDriveUsbMemory )
        {
        iState |= EDriveUsbMemory;
        }
#endif // RD_MULTIPLE_DRIVE

    // Setup flags from drive info
    if ( aDrvInfo.iMediaAtt & KMediaAttWriteProtected )
        {
        iState |= EDriveWriteProtected;
        }
    if ( aDrvInfo.iMediaAtt & KMediaAttLocked )
        {
        iState |= EDriveLocked;
        ret = KErrLocked;
        }
    if ( aDrvInfo.iMediaAtt & KMediaAttFormattable )
        {
        iState |= EDriveFormattable;
        }
    if ( aDrvInfo.iMediaAtt & KMediaAttLockable )
        {
        iState |= EDriveLockable;
        }
    if ( aDrvInfo.iMediaAtt & KMediaAttHasPassword )
        {
        iState |= EDrivePasswordProtected;
        }
    if ( ( aDrvInfo.iDriveAtt & KDriveAttRemovable ) ||
        aDrive == KFmgrMemoryCardDrive )
        {
        iState |= EDriveRemovable;
#ifdef RD_MULTIPLE_DRIVE
        if ( drvStatus & DriveInfo::EDriveSwEjectable )
            {
            iState |= EDriveEjectable;
            }
#else // RD_MULTIPLE_DRIVE
        // Eject is possible for external memory cards
        if ( !( aDrvInfo.iDriveAtt & KDriveAttInternal ) ||
            aDrive == KFmgrMemoryCardDrive )
            {
            iState |= EDriveEjectable;
            }
#endif // RD_MULTIPLE_DRIVE
        }
    if ( aDrvInfo.iDriveAtt & KDriveAttRemote )
        {
        iState |= EDriveRemote;
        }

    return ret;
    }

// -----------------------------------------------------------------------------
// TFileManagerDriveInfo::FillStateFromVolumeInfo()
// -----------------------------------------------------------------------------
// 
TInt TFileManagerDriveInfo::FillStateFromVolumeInfo(
        RFs& aFs, const TInt aDrive )
    {
    FUNC_LOG

    TVolumeInfo volInfo;
    TInt ret( aFs.Volume( volInfo, aDrive ) );
    LOG_IF_ERROR1( ret,
        "TFileManagerDriveInfo::FillStateFromVolumeInfo - Volume err %d", ret );
    if ( ret == KErrNone )
        {
        // Get all information from volume info
        TInt maxLen( Min( volInfo.iName.Length(), KMaxVolumeName ) );

        iName = volInfo.iName.Left( maxLen );
        iUid = volInfo.iUniqueID;
        iCapacity = volInfo.iSize;
        iSpaceFree = volInfo.iFree;

        iState |= EDrivePresent;

        if ( volInfo.iSize )
            {
            iState |= EDriveFormatted;
            }

        ret = FillStateFromDriveInfo( aFs, aDrive, volInfo.iDrive );
        }
    else
        {
        // Get all information from drive info
        TDriveInfo& drvInfo( volInfo.iDrive );
        TInt err( aFs.Drive( drvInfo, aDrive ) );
        LOG_IF_ERROR1( err,
            "TFileManagerDriveInfo::FillStateFromVolumeInfo - Drive err %d", err );
        if ( err == KErrNone )
            {
            err = FillStateFromDriveInfo( aFs, aDrive, drvInfo );

            // If memory card is not ready but type is present,
            // then check if it is reserved.
            if( err == KErrNone &&
               ret == KErrNotReady &&
               drvInfo.iType != EMediaNotPresent )
                {
                // Check USB file transfer state
                TInt prop( ECoreAppUIsUSBFileTransferUninitialized );
                RProperty::Get(
                    KPSUidCoreApplicationUIs,
                    KCoreAppUIsUSBFileTransfer, prop );
                if ( prop == ECoreAppUIsUSBFileTransferActive )
                    {
                    ret = KErrInUse; // Reserved for file transfer
                    }
                INFO_LOG2( "TFileManagerDriveInfo::FillStateFromVolumeInfo-prop=%d,ret=%d",
                    prop, ret )
                }
            }
        if ( err != KErrNone )
            {
            ret = err;
            }
        }

    LOG_IF_ERROR2( ret,
        "TFileManagerDriveInfo::FillStateFromVolumeInfo - aDrive %d, Ret %d",
        aDrive, ret )

    return ret;
    }

//  End of File