--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/pluginfw/Framework/frame/DriveInfo.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,360 @@
+// 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;
+	}