/*

* Copyright (c) 2002-2007 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:  Resolves different media types' drive letters

*

*/

// INCLUDE FILES

#include "CGflmDriveResolver.h"

#include "CGflmDriveItem.h"

#include "MGflmItemFilter.h"

#include "GflmUtils.h"

#include <f32file.h>

#ifdef RD_MULTIPLE_DRIVE

 #include <driveinfo.h>

#endif // RD_MULTIPLE_DRIVE

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

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

// CGflmDriveResolver::CGflmDriveResolver

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CGflmDriveResolver::CGflmDriveResolver( RFs& aFs ) :

        iFs( aFs )

    {

    }

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

// CGflmDriveResolver::NewL

// Two-phased constructor.

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

//

CGflmDriveResolver* CGflmDriveResolver::NewL( RFs& aFs )

    {

    CGflmDriveResolver* self = new ( ELeave ) CGflmDriveResolver( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGflmDriveResolver::ConstructL

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

//

void CGflmDriveResolver::ConstructL()

    {

    User::LeaveIfError( iCs.CreateLocal() );

    }

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

// CGflmDriveResolver::~CGflmDriveResolver

//

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

//

CGflmDriveResolver::~CGflmDriveResolver()

    {

    iDrives.ResetAndDestroy();

    iDrives.Close();

    iCs.Close();

    }

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

// CGflmDriveResolver::RefreshDrives()

//

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

//

TInt CGflmDriveResolver::RefreshDrives( MGflmItemFilter* aFilter )

    {

    iCs.Wait();

    TRAPD( ret, RefreshDrivesL( aFilter ) );

    LOG_IF_ERROR1(

        ret, "CGflmDriveResolver::RefreshDrives-ret=%d", ret )

    iCs.Signal();

    return ret;

    }

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

// CGflmDriveResolver::RefreshDrivesL()

//

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

//

void CGflmDriveResolver::RefreshDrivesL( MGflmItemFilter* aFilter )

    {

    TIMESTAMP( "GFLM refresh drives started: " )

    if ( !iRefreshed )

        {

        iDrives.ResetAndDestroy();

        TDriveList drives;

        User::LeaveIfError( iFs.DriveList( drives, KDriveAttAll ) );

        TInt count( drives.Length() );

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

            {

            if ( drives[ i ] )

                {

                AppendDriveL( i, aFilter );

                }

            }

        iRefreshed = ETrue;

        }

    TIMESTAMP( "GFLM refresh drives ended: " )

    }

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

// CGflmDriveResolver::DriveCount()

//

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

//

TInt CGflmDriveResolver::DriveCount() const

    {

    return iDrives.Count();

    }

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

// CGflmDriveResolver::DriveAt()

//

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

//

CGflmDriveItem* CGflmDriveResolver::DriveAt( const TInt aIndex ) const

    {

    return iDrives[ aIndex ];

    }

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

// CGflmDriveResolver::DriveFromPath()

//

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

//

CGflmDriveItem* CGflmDriveResolver::DriveFromPath( const TDesC& aPath ) const

    {

    TInt drv( 0 );

    if ( aPath.Length() &&

         RFs::CharToDrive( aPath[ 0 ], drv ) == KErrNone )

        {

        return DriveFromId( drv );

        }

    return NULL;

    }

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

// CGflmDriveResolver::ClearDrives()

//

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

//

void CGflmDriveResolver::ClearDrives()

    {

    iRefreshed = EFalse;

    }

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

// CGflmDriveResolver::IsRootPath()

//

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

//

TBool CGflmDriveResolver::IsRootPath( const TDesC& aPath ) const

    {

    TInt count( iDrives.Count() );

    TInt pathLen( aPath.Length() );

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

        {

        CGflmDriveItem* drvItem = iDrives[ i ];

        TPtrC root( drvItem->RootDirectory() );

        if ( pathLen == root.Length() && !root.CompareF( aPath ) )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CGflmDriveResolver::AppendDriveL()

//

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

//

void CGflmDriveResolver::AppendDriveL(

        const TInt aDrive, MGflmItemFilter* aFilter )

    {

    INFO_LOG1( "CGflmDriveResolver::AppendDriveL()-aDrive=%d", aDrive )

    TVolumeInfo volInfo;

    TInt err( iFs.Volume( volInfo, aDrive ) );

    LOG_IF_ERROR1( err, "CGflmDriveResolver::AppendDriveL()-err=%d", err )

    if ( err != KErrNone )

        {

        TInt err2( iFs.Drive( volInfo.iDrive, aDrive ) );

        LOG_IF_ERROR1( err2, "CGflmDriveResolver::AppendDriveL()-err2=%d", err )

        if ( err2 != KErrNone )

            {

            return;

            }

        }

    TDriveInfo& drvInfo( volInfo.iDrive );

    if ( drvInfo.iMediaAtt & KMediaAttLocked )

        {

        err = KErrLocked;

        }

    if ( drvInfo.iType == EMediaNotPresent )

        {

        err = KErrNotReady;

        }

    TUint drvStatus( 0 );

#ifdef RD_MULTIPLE_DRIVE

    TInt err3( DriveInfo::GetDriveStatus( iFs, aDrive, drvStatus ) );

    LOG_IF_ERROR1( err3, "CGflmDriveResolver::AppendDriveL()-err3=%d", err3 )

    if ( err3 != KErrNone )

        {

        // Supress error

        }

#endif // RD_MULTIPLE_DRIVE

    CGflmDriveItem* drvItem = CGflmDriveItem::NewLC(

        aDrive, volInfo, err, drvStatus );

    if ( drvInfo.iDriveAtt & KDriveAttRemote )

        {

        // Get remote drive name

        if ( iFs.GetDriveName( aDrive, iReadBuffer ) == KErrNone )

            {

            drvItem->SetLocalizedNameL( iReadBuffer );

            }

        }

    TBool allowed( ETrue );

    if ( aFilter )

        {

        allowed = aFilter->FilterItemL( drvItem, 0, NULL );

        }

    if ( allowed )

        {

        iDrives.AppendL( drvItem );

        CleanupStack::Pop( drvItem );

        }

    else

        {

        CleanupStack::PopAndDestroy( drvItem );

        }

    }

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

// CGflmDriveResolver::IsRemoteDrive()

//

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

//

TBool CGflmDriveResolver::IsRemoteDrive( const TDesC& aPath ) const

    {

    CGflmDriveItem* drv = DriveFromPath( aPath );

    if ( drv )

        {

        const TVolumeInfo& vol( drv->VolumeInfo() );

        if ( vol.iDrive.iDriveAtt & KDriveAttRemote )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CGflmDriveResolver::DriveFromId()

//

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

//

CGflmDriveItem* CGflmDriveResolver::DriveFromId( const TInt aDrive ) const

    {

    TInt count( iDrives.Count() );

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

        {

        CGflmDriveItem* drvItem = iDrives[ i ];

        if ( aDrive == drvItem->Drive() )

            {

            return drvItem;

            }

        }

    return NULL;

    }

//  End of File