/*

* Copyright (c) 2006-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: CMMCScBkupDriveAndOperationTypeManager implementation

*     

*

*/

#include "CMMCScBkupDriveAndOperationTypeManager.h"

// User includes

#include "MMCScBkupLogger.h"

#ifdef RD_MULTIPLE_DRIVE

#include "BkupEngine.hrh"

#include <driveinfo.h>

#include <coemain.h>

#endif // RD_MULTIPLE_DRIVE

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

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

// CMMCScBkupDriveAndOperationTypeManager::CMMCScBkupDriveAndOperationTypeManager()

// 

// C++ constructor.

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

CMMCScBkupDriveAndOperationTypeManager::CMMCScBkupDriveAndOperationTypeManager()

    {

    iCalculatedDriveList.SetMax();

    }

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

// CMMCScBkupDriveAndOperationTypeManager::CMMCScBkupDriveAndOperationTypeManager()

// 

// C++ destructor.

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

EXPORT_C CMMCScBkupDriveAndOperationTypeManager::~CMMCScBkupDriveAndOperationTypeManager()

    {

    iEntries.Close();

    }

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

// CMMCScBkupDriveAndOperationTypeManager::ConstructL()

// 

// 

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

void CMMCScBkupDriveAndOperationTypeManager::ConstructL( TResourceReader& aReader )

    {

#ifdef RD_MULTIPLE_DRIVE

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

    // Get all user visible drives

    TInt numDrives( 0 );

    TDriveList drvList;

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(

        fs, drvList, numDrives ) );

    TInt drvListLen( drvList.Length() );

    TMMCScBkupDriveAndOperationType op;

    TInt count( aReader.ReadInt8() );

    // Get default system drive

    TInt sysDrive( 0 );

    User::LeaveIfError( DriveInfo::GetDefaultDrive(

        DriveInfo::EDefaultSystem, sysDrive ) );

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

        {

        TUint drvCategories( aReader.ReadUint8() );

        TMMCScBkupOwnerDataType dataType(

            static_cast< TMMCScBkupOwnerDataType >( aReader.ReadUint8() ) );

        if ( drvCategories & EBkupDeviceMemories )

            {

            // Default system drive is always backed up when

            // device memories are defined

            op.SetDrive( static_cast< TDriveNumber >( sysDrive ) );

            op.SetDataType( dataType );

            iEntries.AppendL( op );

            iCalculatedDriveList[ op.Drive() ] = ETrue;

            }

        for ( TInt j( 0 ); j < drvListLen; ++j )

            {

            if ( sysDrive != j && drvList[ j ] )

                {

                // Check for other drives

                TBool append( EFalse );

                TUint drvStatus( 0 );

                User::LeaveIfError( DriveInfo::GetDriveStatus(

                    fs, j, drvStatus ) );

                if ( ( drvCategories & EBkupDeviceMemories ) &&

                    ( drvStatus & DriveInfo::EDriveInternal ) &&

                    !( drvStatus & DriveInfo::EDriveExternallyMountable ) &&

                    !( drvStatus & DriveInfo::EDriveReadOnly ) )

                    {

                    append = ETrue; // Allow additional device memory

                    }

                else if ( ( drvCategories & EBkupInternalMassStorages ) &&

                    ( drvStatus & DriveInfo::EDriveInternal ) &&

                    ( drvStatus & DriveInfo::EDriveExternallyMountable ) )

                    {

                    append = ETrue; // Allow internal mass storage

                    }

                else if ( ( drvCategories & EBkupExternalMassStorages ) &&

                    ( drvStatus & DriveInfo::EDriveRemovable ) )

                    {

                    append = ETrue; // Allow external mass storage

                    }

                if ( append )

                    {

                    op.SetDrive(  static_cast< TDriveNumber >( j ) );

                    op.SetDataType( dataType );

                    iEntries.AppendL( op );

                    iCalculatedDriveList[ op.Drive() ] = ETrue;

                    }

                }

            }

        }

#else // RD_MULTIPLE_DRIVE

    TMMCScBkupDriveAndOperationType op;

    const TInt count = aReader.ReadInt8();

    //

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

        {

        op.SetDrive( static_cast< TDriveNumber >( aReader.ReadInt8() ) );

        op.SetDataType( static_cast< TMMCScBkupOwnerDataType >( aReader.ReadInt8() ) );

        //

        iEntries.AppendL( op );

        //

        iCalculatedDriveList[ op.Drive() ] = ETrue;

        }

#endif // RD_MULTIPLE_DRIVE

    }

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

// CMMCScBkupDriveAndOperationTypeManager::NewL()

// 

//

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

EXPORT_C CMMCScBkupDriveAndOperationTypeManager* CMMCScBkupDriveAndOperationTypeManager::NewL( TResourceReader& aReader )

    {

    CMMCScBkupDriveAndOperationTypeManager* self = new(ELeave) CMMCScBkupDriveAndOperationTypeManager();

    CleanupStack::PushL( self );

    self->ConstructL( aReader );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMMCScBkupDriveAndOperationTypeManager::Count()

// 

//

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

TInt CMMCScBkupDriveAndOperationTypeManager::Count() const

    {

    return iEntries.Count();

    }

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

// CMMCScBkupDriveAndOperationTypeManager::At()

// 

//

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

const TMMCScBkupDriveAndOperationType& CMMCScBkupDriveAndOperationTypeManager::At( TInt aIndex ) const

    {

    return iEntries[ aIndex ];

    }

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

// CMMCScBkupDriveAndOperationTypeManager::IsDataTypeAllowedToAccessDrive()

// 

//

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

TBool CMMCScBkupDriveAndOperationTypeManager::IsDataTypeAllowedToAccessDrive( TDriveNumber aDrive, TMMCScBkupOwnerDataType aDataType ) const

    {

//    __LOG2("CMMCScBkupDriveAndOperationTypeManager::IsDataTypeAllowedToAccessDrive() - START - aDrive: %c, aDataType: %S", aDrive + 'A', &MMCScBkupLogger::DataType( aDataType ));

    TBool allowed = EFalse;

    //

    const TInt count = iEntries.Count();

    //

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

        {

        const TMMCScBkupDriveAndOperationType& entry = iEntries[ i ];

        //

        if ( entry.DataType() == aDataType )

            {

            // Check drive...

            if ( entry.Drive() == aDrive )

                {

                allowed = ETrue;

                break;

                }

            }

        }

    //

//    __LOG1("CMMCScBkupDriveAndOperationTypeManager::IsDataTypeAllowedToAccessDrive() - END - allowed: %d", allowed);

    return allowed;

    }