// 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;
	}