// Copyright (c) 2006-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:

//

// Description:

// Implementation for CEComCachedDriveInfo class

// 

//

/**

 @file

 @internalComponent

*/

#include <e32const.h>

#include <f32file.h>

#include <bsul/bsul.h>

#include <ecom/ecomerrorcodes.h>

#include "DriveInfo.h"

#include "EComPatchDataConstantv2.h"

#include "EComInternalErrorCodes.h"

const TInt KInvalidIndex = -1;

const TInt32 KInvalidDrvNumber = -1;

/** static member of CEComCachedDriveInfo */

TFixedArray<TEComDrvFlags, KMaxDrives> CEComCachedDriveInfo::iDriveAttr;

/** static member of CEComCachedDriveInfo */

TInt CEComCachedDriveInfo::iLastIndex = KInvalidIndex;

/** static member of CEComCachedDriveInfo */

TBool CEComCachedDriveInfo::iInitialized = EFalse;

/** Standard factory method to instantiate CEComCachedDriveInfo instances.

*/

CEComCachedDriveInfo* CEComCachedDriveInfo::NewL(RFs& aFs)

	{

	CEComCachedDriveInfo* self = new (ELeave) CEComCachedDriveInfo;

	CleanupStack::PushL(self);

	self->ConstructL(aFs, KDiscoveryDisabledDriveList);

	CleanupStack::Pop(self);

	return self;

	}

/** Constructor of CEComCachedDriveInfo. Nothing to do. */

CEComCachedDriveInfo::CEComCachedDriveInfo()

	{

	}

/** Standard two-phase construction to complete construction

of CEComCachedDriveInfo.

@param aFs reference to a connected RFs session.

@param aDiscoveryDisabledMask bits set indicate the drives contain no plug-ins

	and need not be scanned. There is a mechanism to allow licensees to

	specify this mask at ROM build time.

@leave KErrNoMemory if out of memory, or any of the other system wide errors.

*/

void CEComCachedDriveInfo::ConstructL(RFs& aFs, TUint32 aDiscoveryDisabledMask)

	{

	if (iInitialized)

		{

		return;

		}

	iLastIndex = KInvalidIndex;

	// Get list of installed drives. This info is not available from

	// BSUL::CCachedDriveInfo API's.

	TDriveList drvList;

	User::LeaveIfError( aFs.DriveList(drvList) );

	BSUL::CCachedDriveInfo* cachedDrvInfo = BSUL::CCachedDriveInfo::NewL(aFs);

	CleanupStack::PushL(cachedDrvInfo);

	// determine attributes of valid drives

	for (TInt i = EDriveA; i <= EDriveZ; i++)

		{

		if (drvList[i])

			{

			// drive exist

			TInt j = ++iLastIndex;

			iDriveAttr[j].iDrvNumber = i; 

			TDriveUnit drvUnit(i);

			if (cachedDrvInfo->IsReadOnlyInternalL(drvUnit))

				{

				iDriveAttr[j].iFlags = EEComDrvAttrReadOnlyInternal;

				// RO internal drive does not have any other attributes

				continue;

				}

			iDriveAttr[j].iFlags = 0; 

			// Check if drive is removable

			if (cachedDrvInfo->IsFlagSetOnDriveL(drvUnit, KDriveAttRemovable))

				{

				iDriveAttr[j].iFlags |= EEComDrvAttrRemovable;

				}

			// Check if drive is on ReadWrite drive

			if (! cachedDrvInfo->IsFlagSetOnDriveL(drvUnit, KDriveAttRom))

				{

				iDriveAttr[j].iFlags |= EEComDrvAttrWritable;

				}

			TUint32 drvBitMask = 1;

			drvBitMask <<= i;

			// Three conditions for discovery disable: disabled by licensees,

			// remote drives and substituted drives

			if ( (drvBitMask & aDiscoveryDisabledMask) ||

				 cachedDrvInfo->IsFlagSetOnDriveL(drvUnit, KDriveAttSubsted) ||

				 cachedDrvInfo->IsFlagSetOnDriveL(drvUnit, KDriveAttRemote) )

				{

				iDriveAttr[j].iFlags |= EEComDrvAttrNoDiscovery;

				}

			} // if drvList[i]

		} // for

	CleanupStack::PopAndDestroy(cachedDrvInfo);

	__ASSERT_DEBUG(iLastIndex >= 0, User::Invariant());

	for (TInt i = iLastIndex + 1; i < KMaxDrives; i++)

		{

		iDriveAttr[i].iDrvNumber = KInvalidDrvNumber; 

		}

	iInitialized = ETrue;

	}

/** Is EEComDrvAttrReadOnlyInternal attribute set on the given drive?

@param aDrive the drive number

@return ETrue if drive is RO internal. EFalse means either no such drive or

	not RO internal.

@leave KEComErrDriveNotFound if aDrive is not supposed to be scanned,

	i.e. drive absent or disabled by licensees or subst or remote.

    Use TEComCachedDriveInfoIterator::SetPos instead if want to test drive

	attribute.

*/

TBool CEComCachedDriveInfo::DriveIsReadOnlyInternalL(const TInt aDrive) const

	{

	TEComCachedDriveInfoIterator iter(*this);

	if (! iter.SetPos(aDrive))

		{

		// This method is intended to be used on drives that are known

		// to be valid, e.g. drive extracted from the path of a discovered

		// DLL.

		User::Leave(KEComErrDriveNotFound);

		}

	return iter.DriveIsReadOnlyInternal();

	}

/** Test if the EEComDrvAttrRemovable attribute for the given drive is set.

@param aDrive the drive number

@return ETrue if drive is removable. EFalse means either no such drive or

	not removable.

@leave KEComErrDriveNotFound if aDrive is not supposed to be scanned,

	i.e. drive absent or disabled by licensees or subst or remote.

    Use TEComCachedDriveInfoIterator::SetPos instead if want to test drive

	is removable.

*/

TBool CEComCachedDriveInfo::DriveIsRemovableL(const TInt aDrive) const

	{

	TEComCachedDriveInfoIterator iter(*this);

	if (! iter.SetPos(aDrive))

		{

		// This method is intended to be used on drives that are known

		// to be valid, e.g. drive extracted from the path of a discovered

		// DLL.

		User::Leave(KEComErrDriveNotFound);

		}

	return iter.DriveIsRemovable();

	}

/** Test if the EEComDrvAttrWritable attribute for the given drive is set.

@param aDrive the drive number

@return ETrue if drive is writable. EFalse means either no such drive or

	drive not writable.

@leave KEComErrDriveNotFound if aDrive is not supposed to be scanned,

	i.e. drive absent or disabled by licensees or subst or remote.

    Use TEComCachedDriveInfoIterator::SetPos instead if want to test drive

	is removable.

*/

TBool CEComCachedDriveInfo::DriveIsWritableL(const TInt aDrive) const

	{

	TEComCachedDriveInfoIterator iter(*this);

	if (! iter.SetPos(aDrive))

		{

		// This method is intended to be used on drives that are known

		// to be valid, e.g. drive extracted from the path of a discovered

		// DLL.

		User::Leave(KEComErrDriveNotFound);

		}

	return iter.DriveIsWritable();

	}

// Implementation for TEComCachedDriveInfoIterator class

/** TEComCachedDriveInfoIterator Constructor

Note that the object is not yet in valid state. User must first call

First() or Last().

*/

TEComCachedDriveInfoIterator::TEComCachedDriveInfoIterator(const CEComCachedDriveInfo& aCachedDriveInfo)

	: iDriveAttr(aCachedDriveInfo.iDriveAttr)

	{

	iIndex = KInvalidIndex;

	}

/** Check if the drive is enabled for scanning and move index there if true.

@param aDrive the drive number of the drive to check.

@return ETrue the drive is enabled for scanning. Index is moved to that location.

	If drive not to be scanned, index is moved out of bound.

*/

TBool TEComCachedDriveInfoIterator::SetPos(const TInt aDrive)

	{

	for (iIndex = CEComCachedDriveInfo::iLastIndex; iIndex >= 0; iIndex--)

		{

		if (iDriveAttr[iIndex].iDrvNumber == aDrive)

			{

		    if (0 == (iDriveAttr[iIndex].iFlags & EEComDrvAttrNoDiscovery))

				{

				return ETrue;

				}

			iIndex = KInvalidIndex;

			break;

			}

		}

	return EFalse;

	}

/** Position iterator at first valid drive so as to

iterate the drive list in increasing drive number order. */

void TEComCachedDriveInfoIterator::First(void)

	{

	for (iIndex = 0; iIndex <= CEComCachedDriveInfo::iLastIndex; iIndex++)

		{

		if (0 == (iDriveAttr[iIndex].iFlags & EEComDrvAttrNoDiscovery))

			{

			return;

			}

		}

	}

/** Position iterator at last valid drive so as to

iterate the drive list in decreasing drive number order. */

void TEComCachedDriveInfoIterator::Last(void)

	{

	for (iIndex = CEComCachedDriveInfo::iLastIndex; iIndex >=0; iIndex--)

		{

		if (0 == (iDriveAttr[iIndex].iFlags & EEComDrvAttrNoDiscovery))

			{

			return;

			}

		}

	}

/** To be used in for and while loops to check if iterator

has stepped through all posible drives. */

TBool TEComCachedDriveInfoIterator::InRange(void) const

	{

	return (iIndex >= 0 && iIndex <= CEComCachedDriveInfo::iLastIndex);

	}

/** Increment iterator to next valid drive. */

void TEComCachedDriveInfoIterator::Next(void)

	{

	if (InRange())

		{

		for (++iIndex; iIndex <= CEComCachedDriveInfo::iLastIndex; iIndex++)

			{

			if (0 == (iDriveAttr[iIndex].iFlags & EEComDrvAttrNoDiscovery))

				{

				return;

				}

			}

		}

	}

/** Decrement iterator to next valid drive. */

void TEComCachedDriveInfoIterator::Prev(void)

	{

	if (InRange())

		{

		for (--iIndex; iIndex >= 0; iIndex--)

			{

			if (0 == (iDriveAttr[iIndex].iFlags & EEComDrvAttrNoDiscovery))

				{

				return;

				}

			}

		}

	}

/**

@panic USER:133 from TFixedArray if iterator is out of bound.

*/

TDriveNumber TEComCachedDriveInfoIterator::DriveNumber(void) const

	{

	return static_cast<TDriveNumber>( iDriveAttr.At(iIndex).iDrvNumber );

	}

/**

@panic USER:133 from TFixedArray if iterator is out of bound.

*/

TDriveUnit TEComCachedDriveInfoIterator::DriveUnit(void) const

	{

	return TDriveUnit( DriveNumber() );

	}

/** Test if the EEComDrvAttrReadOnlyInternal attribute for the current

drive is set.

@panic USER:133 from TFixedArray if iterator is out of bound.

*/

TBool TEComCachedDriveInfoIterator::DriveIsReadOnlyInternal(void) const

	{

	if (EEComDrvAttrReadOnlyInternal & iDriveAttr.At(iIndex).iFlags)

		{

		return ETrue;

		}

	return EFalse;

	}

/** Test if the EEComDrvAttrRemovable attribute for the current

drive is set.

@panic USER:133 from TFixedArray if iterator is out of bound.

*/

TBool TEComCachedDriveInfoIterator::DriveIsRemovable(void) const

	{

	if (EEComDrvAttrRemovable & iDriveAttr.At(iIndex).iFlags)

		{

		return ETrue;

		}

	return EFalse;

	}

/** Test if the EEComDrvAttrWritable attribute for the current drive is set.

@return ETrue if drive is writable. EFalse means drive is not writable.

@panic USER:133 from TFixedArray if iterator is out of bound.

*/

TBool TEComCachedDriveInfoIterator::DriveIsWritable(void) const

	{

	if (EEComDrvAttrWritable & iDriveAttr.At(iIndex).iFlags)

		{

		return ETrue;

		}

	return EFalse;

	}