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

// Definition of the CDiscoverer class

// 

//

/**

 @file

 @internalComponent

*/

#ifndef __DISCOVERER_H__

#define __DISCOVERER_H__

#include <e32base.h>

#include <f32file.h>

#include <e32property.h> // for RProperty

#include <domaindefs.h> // for TDmDomainState

#include "DiscovererObserver.h"	// The MDiscovererObserver class

#include "EComEntry.h"

#include "EComEntryBase.h"

#include "callback.h"

// Platsec path to binaries

_LIT(KSysBin,"\\sys\\bin\\");

// Platsec path to resources

_LIT(KResourcePlugins,"\\resource\\plugins\\");

_LIT(KDllExtension,".dll");

_LIT(KRscExtension,".rsc");

// Length of extension of file name.

//The language extension length including the "." is assumed to be 4 

const TInt KExtensionLength=4;

//Max lenth for plugin resource path

const TInt32 KEComPlugRSCPathMaxLen	=	50;

//class forward declare

class CEnvironmentChangeNotifier;

/**

	@internalComponent

	@since 7.0

	Responsible for Interface Implementation Collections,

	installed in the Interface Implementation Collection directories.

 */

class CDiscoverer : public CBase 

{

public:

/** Transition flag for Notification*/

	enum TNotificationFlag

	{

	/** A new plugin added or removed*/

	EPluginsModified,

	/**should do a rediscovery */

	EPluginsRediscover

	};

/** State declaration for CDiscoverer */	

	enum TDiscovererState

	{

	/** Undefined state */

	EDisc_Undefined,

	/** Initialize state */

	EDisc_NoPluginsDisc,

	/** Discover plugins on Ro Internal drive units */

	EDisc_CriticalPluginsDisc,

	/** All plugins are discovered.*/

	EDisc_AllPluginsDisc,

	/** Plugins added or removed, going to rediscover all plugins */

	EDisc_PluginsDirty

	};

/**

	@fn				NewL(MDiscovererObserver& aDiscovererObserver, RFs& aFs)

	Intended Usage	: Standardised safe construction which leaves nothing

					  on the cleanup stack.

	Error Condition	: Not enough memory available.	

	@leave  		KErrNoMemory

	@since			7.0

	@param			aDiscovererObserver A reference to the owning client 

					of the CDiscoverer

	@param			aFs A reference to a connected file server instance.

	@return			CDiscoverer* a pointer to the new class

	@pre 			None

	@post			CDiscoverer is fully constructed, and initialised.

 */

	static CDiscoverer* NewL(MDiscovererObserver& aDiscovererObserver, RFs& aFs);

/**

	@fn				~CDiscoverer()

	Intended Usage	: Standard default d'tor	

	Error Condition	: None	

	@since			7.0

	@pre 			CDiscoverer is fully constructed.

	@post			CDiscoverer is totally destroyed.

 */

	~CDiscoverer();

/**

	@fn				Resume()

	Intended Usage	: Re-enable the Discoverer to continue checking for new 

					  interface implementations. 

	Error Condition	: Where resume of the discoverer fails. KErrResumeFailed.

	@since			7.0

	@return			TInt The status of the operation. KErrNone or KErrResumeFailed.

	@pre 			CDiscoverer is fully constructed.

	@post			The operation of the discoverer has been resumed. Or where

					resumption failed, no change.

 */

	TInt Resume();

/**

	@fn				Suspend()

	Intended Usage	: Temporarily stop looking for new interface implementations.

	Error Condition	: Where suspension of the discoverer fails. KErrSuspendFailed.

	@since			7.0

	@return			TInt The status of the operation. KErrNone or KErrSuspendFailed.

	@pre 			CDiscoverer is fully constructed.

	@post			The operation of the discoverer has been suspended. Or where

					suspend failed, no change.

 */

	TInt Suspend();

/**

	@fn 			ProcessSSAEventL()

	Intended Usage	: It discovers the plugins on different Drive Units according to 

					the passing state. It will be used by CRegistrar to notify the 

					object of the system start-up state changes.

	@param 			aKnownState the start-up state passing in to CDiscoverer

	@pre			CDiscoverer is fully constructed

	@post			CDiscoverer is notified of the start-up state change

*/

	void ProcessSSAEventL(TStartupStateIdentifier aKnownState);

/** 

	@fn 			ProcessDNEventL()

	Intended Usage	:It will be used by one iRscDirNotifier in iRscDirNotifierList 

					to indicate that plugins have been removed or added(state is 

					EDisc_PluginsDirty) and to start a 

					re-discovery(when done, state is EDisc_AllPluginsDisc).

	@leave			KErrNoMemory

	@param			:aFlag the notification transition flag.

	@param			:aDriveUnit a drive which on the plugins has been changed and need to re-discovery

	@pre 			:CDiscoverer is fully constructed.

	@post			: state will be changed, and a re-discovery will happen 

					if the current state is EDisc_PluginsDirty. 

*/

	void ProcessDNEventL(TNotificationFlag aFlag, const TDriveUnit& aDriveUnit);

/**

	@fn 			State()

	Intended Usage	:Retrieve the object's current state.

	@return 		TDiscovererState the CDiscoverer's current state.

	@pre			CDiscoverer is fully constructed.

	@post 			the CDiscoverer's current state has been returned.

*/

	TDiscovererState State() const;

/** Set the iSwiChangeCallBack member

@param aCallBack new value for iSwiChangeCallBack

*/

	void SetSwiChangeCallBack(const TCallBackWithArg& aCallBack);

/** Set the iBurChangeCallBack member

@param aCallBack new value for iBurChangeCallBack

*/

	void SetBurChangeCallBack(const TCallBackWithArg& aCallBack);

private:

/**

	@internalComponent

	@fn				CDiscoverer(MDiscovererObserver& aDiscovererObserver, RFs& aFs)

	Intended Usage	: Standardised default c'tor	

	Error Condition	: None	

	@since			7.0

	@param			aDiscovererObserver A reference to the owning client 

					of the CDiscoverer

	@param			aFs A reference to an connected file server instance.

	@pre 			None

	@post			CDiscoverer is fully constructed

 */

	CDiscoverer(MDiscovererObserver& aDiscovererObserver, RFs& aFs);

/**

	@fn				ConstructL()

	Intended Usage	: Standardised 2nd, (Initialisation) phase of two phase construction.

	Error Condition	: Leaves with error code : usually KErrNoMemory.

	@leave  		KErrNoMemory.

	@since			7.0

	@return			void 

	@pre 			CDiscoverer is fully constructed.

	@post			CDiscoverer is fully initialised.

 */

	void ConstructL();

/**

	@fn				NotificationL(TInt aStatus)

	Intended Usage	: Called by the one object of iRscDirNotifierList when the 

					contents of the Interface Implementation directories

					has changed on a specified drive.

	Error Condition	: None	

	@leave			KErrNoMemory

	@since			7.0

	@param			aDriveUnit a drive which has changes.

	@return			ETrue to indicate the notifier should re-activate.

	@pre 			CDiscoverer is fully constructed.

	@post			CDiscoverer has been notified that a re-scan of the 

					plugin directories is required.

 */

	TBool NotificationL(TInt aStatus, const TDriveUnit& aDriveUnit);

/**

	@fn				SwiChangeNotificationL(TInt aSwiOperation)

	Intended Usage	: Called by iSwiChangeNotifier when it is notified of a

					SWI changed.

	Error Condition	: None	

	@since			9.2

	@param			aSwiOperation the SWI operation that is currently taking place

	@pre 			CDiscoverer is fully constructed.

	@post			CDiscoverer has been notified that a re-scan of the

					removable plugin directories is required and has stored current

					SWI operation.

 */

	void SwiChangeNotificationL(TInt aSwiOperation);

/**

	@fn				LanguageChangeNotificationL()

	Intended Usage	: Called by iLanguageChangeNotifier when it is notified of language

					downgrade path changed.

	Error Condition	: None	

	@since			9.3

	@pre 			CDiscoverer is fully constructed.

	@post			CDiscoverer has been notified that a rescan may be required

 */

	void LanguageChangeNotificationL();

	// Methods used by the Incremental Directory Scanning mechanism

/**

	@fn				void RediscoveryScanDirectoryL()

	Intended Usage	: Perform a scan on the Interface Implementation 

					Collection directories on a specified drive.

	Error Condition	: Not enough memory available	

	@leave  		KErrNoMemory

	@since			7.0

	@param			:A drive on which the directory is scanned.

	@return			void

	@pre 			CDiscoverer is fully constructed.

	@post			The scan of the Interface Implementation Collection 

					directories has processed on a specified drive.

 */

	void RediscoveryScanDirectoryL(const TDriveUnit& aDriveUnit);

/**

	@fn				void ScanDirectoryCancel()

	Intended Usage	: Cancel any scan of the Interface Implementation Collection 

					directories in progress.

	Error Condition	: None	

	@since			7.0

	@return			void 

	@pre 			CDiscoverer is fully constructed.

	@post			The re-scan of the Interface Implementation 

					Collection directories has beed aborted.

 */

	void ScanDirectoryCancel();

/**

	@fn				CompleteNotificationProcessing()

	Intended Usage	: Signal that the directory change notification has

					 been fully processed on all drives.

	Error Condition	: None	

	@since			7.0

	@pre 			CDiscoverer is fully constructed.

	@post			An asynchronous re-scan of the Interface Implementation 

					Collection directories is complete.

 */

	void CompleteNotificationProcessing();

/**

	@fn				ValidateEntryL(const TEntry& aEntry, const TDriveName& aDriveName, CPluginBase*& aEntryToFill,TBool aIsRO)

	Intended Usage	: Verify that a Interface Implementation Collection directories entry is valid

					discovery.

	Error Condition	: No memory

	@leave  		KErrNoMemory

	@since			9.1

	@param			aEntry	A directory entry for an Interface Implementation Collection.

	@param			aDriveName	The drive containing this entry

	@param			aEntryToFill A newly created directory entry with the 

					filename updated to include the full path.

	@param			aIsRO	Indicates whether current drive is Read Only

	@pre 			CDiscoverer is fully constructed, 

					aEntry, aPath and aEntryToFill are all valid references.

	@post			aEntryToFill is created and valid, with the full path and filename as its name entry.

 */

	void ValidateEntryL(const TEntry& aEntry, const TDriveName& aDriveName, CPluginBase*& aEntryToFill, TBool aIsRO);

/**

	@fn				ValidateEntryL(RResourceArchive& aRscArchive,CPluginBase*& aEntryToFill);

	Intended Usage	: Verify that a Interface Implementation Collection directories entry is valid

					discovery.

	Error Condition	: No memory

	@leave  		KErrNoMemory

	@since			9.1

	@param			aRscArchive A referernce to the resource archive

	@param			aEntryToFill A newly created directory entry with the 

					filename updated to include the full path.

	@pre 			CDiscoverer is fully constructed, 

	@post			aEntryToFill is created and valid, with the full path and filename as its name entry.

 */

	void ValidateEntryL(RResourceArchive& aRscArchive, CPluginBase*& aEntryToFill);

/**

	@fn				ProcessEntryL(const TDriveName& aDrive,CPluginBase*& aEntry, TBool aAnyDllDiscovered)

	Intended Usage	: Verify that a Interface Implementation Collection directories entry is valid

					discovery.

	Error Condition	: Depends on the observer implementation.	

	@leave  		Depends on the observer implementation. (@see CRegistrar).

	@since			9.1

	@param			aDrive the drive name containing this entry

	@param			aEntry	A directory entry for an Interface Implementation Collection.

	@param			aAnyDllDiscovered a flag to tell if any Dll is discovered in the drive.

	@pre 			CDiscoverer is fully constructed.

	@post			The directory entry has been processed by the observer.

 */

	void ProcessEntryL(const TDriveName& aDrive, CPluginBase*& aEntry, TBool aAnyDllDiscovered);

/**

	@fn				DriveMountedL(TDriveUnit aDrive)

	Intended Usage	: Signal a drive is available.

	Error Condition	: Depends on the observer implementation.	

	@leave  		Depends on the observer implementation. @see CRegistrar.

	@since			7.0

	@param			aDrive	The drive to be noted as available.

	@return			void. 

	@pre 			CDiscoverer is fully constructed.

	@post			The drive mount has been signalled to the observer.

 */

	void DriveMountedL(TDriveUnit aDrive);

/**

	@fn				DriveUnmountedL(TDriveUnit aDrive)

	Intended Usage	: Signal a drive is unavailable.

	Error Condition	: Leaves with an error code

	@leave			KErrNoMemory

	@since			7.0

	@param			aDrive	The drive to be noted as unavailable.

	@pre 			CDiscoverer is fully constructed.

	@post			The drive dismount has been signalled to the observer.

 */

	void DriveUnmountedL(TDriveUnit aDrive);

/**

	@fn 			StartNotifiers()

	Intended Usage	: start the iRscDirNotifierList and iSwiChangeNotifier when EDisc_AllPlugins

					state is reached.

	@pre 			: CDiscoverer is fully constructed. and iRscDirNotifierList and iSwiChangeNotifier

					are fully constructed.

	@post			: iRscDirNotifierList Activate and iSwiChangeNotifier Subscribe methods are called.

*/

	void StartNotifiers();

/** 

	@fn 			InitialiseEvent()

	Intended Usage	: called during the CDiscoverer's construction 

					to change the state.

	@pre			: non

	@post			: State is changed from EDisc_Undefined to EDisc_NoPluginsDisc.

*/		

	void InitialiseEvent();

/**

	@fn				IsAnyDllRegisteredWithDriveL(const TDriveUnit aDrive)

	Intended Usage	: Find if any Dll is registered in the drive.

	@param 			: aDrive the identifier of the drive to find if any Dll is registered.

	@return			: ETrue if any Dll is registered in the drive unit, otherwise EFalse.

	@pre 			: CDiscoverer is fully constructed.

	@post 			: If any Dll registered info will be returned.

*/	

	TBool IsAnyDllRegisteredWithDriveL(const TDriveUnit aDrive)const ;	

/**

	@fn				SwiOperationInProgress()

	Intended Usage	: Determine if any SWI operation is currently in progress

	@return			: ETrue if any SWI operation is in progress otherwise EFalse.

	@pre 			: CDiscoverer is fully constructed.

	@post 			: None

*/	

	TBool SwiOperationInProgress() ;

/**

	@fn				LocaleChangedL(TAny*)

	Intended Usage	: Callback function to be attached to an instance of CEnvironmentChangeNotifier to 

					  rebuild registry data. Note that this has to be a static member function.

	@param 			: A parameter to be passed usually with a "this" pointer so that while the function

					  remaining a static function it can access all the member data anyway.

	@return			: ETrue if language downgrade path is changed, otherwise EFalse.

	@pre 			: CDiscoverer is fully constructed.

	@post 			: Call LanguageChangeNotificationL method to rescan resource files.

*/		

	static TInt LocaleChangedL(TAny*) ;

// Attributes

private:

	// Define the helper classes which handle the 

	// notification processing.

	class CDirChangeNotifier;

	typedef RPointerArray<CDirChangeNotifier> RDirChangeNotifierPointerArray;

	// Handles notifications of changes to plugin resources directory on list of drives.

	RDirChangeNotifierPointerArray iRscDirNotifierList;

	class CSwiChangeNotifier;

	// Handles notifications of changes to SWI

	CSwiChangeNotifier* iSwiChangeNotifier;

	// Indicates whether a discovery due to SWI changes is pending

	TBool iSwiChangeDiscoveryPending;

	//Handle notifications of changes to environment (including language switch)

	CEnvironmentChangeNotifier* iLanguageChangeNotifier	;

	// Stores the current SWI operation

	TInt iSwiOperation;

	// Indicates whether a discovery due to language changes is pending

	TBool iLanguageChangeDiscoveryPending;

	// the current state of CDiscoverer

	TDiscovererState iState;

	class CIdleScanningTimer;

	// A single timer, processes all pending notifications.

	CIdleScanningTimer* iScanningTimer;

	class CDirScanner;

	/** 

		The internal Interface Implementation Collection 

		identifier and registration handler  

	 */

	CDirScanner* iDirScanner;

	/** A reference to the owning client of the CDiscoverer */

	MDiscovererObserver& iDiscovererObserver;

	/** A reference to the connected file server instance */

	RFs& iFs;

	/** The list of existing drives */

	RArray<TUint> iDrivesDiscovered;

	/** cached info of drives A to Z */

	CEComCachedDriveInfo* iCachedDriveInfo;

	TCallBackWithArg iSwiChangeCallBack;

	TCallBackWithArg iBurChangeCallBack;

	// List the internal classes as friends

	friend class CSwiChangeNotifier;

	friend class CDirChangeNotifier;

	friend class CIdleScanningTimer;

	friend class CDirScanner;

	// And the Test bed state accessor

	friend class TDiscoverer_StateAccessor;

};

// __________________________________________________________________________

//

/**

The notification object which uses P&S to monitor SWI KSAUidSoftwareInstallKey 

for changes. When SWI is present in the device/ROM this attribute publishes the

current state of a software install or uninstall.

When its RunL method is called and depending on the install/uninstall state it 

notifies its owning CDiscoverer class object to re-scan removable drives.

@internalComponent

*/

class CDiscoverer::CSwiChangeNotifier : public CActive

	{

public:

	/**

		@fn				NewL(CDiscoverer& aDiscoverer)

		Intended Usage	: Standardised safe construction which leaves nothing

						  on the cleanup stack.

		Error Condition	: Not enough memory available.	

		@leave  			KErrNoMemory

		@since			9.2

		@param			aDiscoverer A reference to the owning CDiscoverer

		@return			CSwiChangeNotifier* a pointer to the new class

		@pre 			None

		@post			CSwiChangeNotifier is fully constructed, and initialised.

	 */	

	static CSwiChangeNotifier* NewL(CDiscoverer& aDiscoverer);

	/**

		@fn				virtual ~CSwiChangeNotifier()

		Intended Usage	: Standard default d'tor	

		Error Condition	: None	

		@since			9.2

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier is totally destroyed

	 */

	virtual ~CSwiChangeNotifier();

	/**

		@fn				Subscribe()

		Intended Usage	: Subscribes with P&S for change notifications for the 

                          SWI KSAUidSoftwareInstallKey property

		Error Condition	: None	

		@since			9.2

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier is active on the current scheduler.

	 */

	void Subscribe();

private:

	/**

		@fn				CSwiChangeNotifier(CDiscoverer& aDiscoverer)

		Intended Usage	: Standardised default c'tor	

		Error Condition	: None	

		@since			9.2

		@param			aDiscoverer A reference to its owning class instance.

		@pre 			None

		@post			CSwiChangeNotifier is fully constructed

	 */

	CSwiChangeNotifier(CDiscoverer& aDiscoverer);

	/**

		@fn				RunL()

		Intended Usage	: When the object activates, this is method is called

						and notifies the CDiscoverer to re-scan the 

						removable drives.. 

		Error Condition	: Not enough memory available to complete the scan.

		@leave  			KErrNoMemory

		@since			9.2

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier notifications are subscribed and plugins on

						removable drives have been rediscovered..

	 */

	void RunL();

	/**

		@fn				void ConstructL()

		Intended Usage	: Standardised 2nd, (Initialisation) phase of two phase construction.

		Error Condition	: Leaves with error code : usually KErrNoMemory.

		@leave  			KErrNoMemory.

		@since			9.2

		@return			void 

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier is fully initialised.

	 */

	void ConstructL();

	/**

		@fn				DoCancel()

		Intended Usage	: The cancel action called by CActive::Cancel(). 

		Error Condition	: None	

		@since			9.2

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier notifications are cancelled and

						it is no longer active on the current scheduler.

	 */

	void DoCancel();

	/**

		@fn				RunError(TInt aError)

		Intended Usage	: Called by the notifier RunL leaving.

		@since			9.2

		@param			aError The error code that the RunL left with.

		@return			TInt KErrNone. 

		@pre 			CSwiChangeNotifier is fully constructed.

		@post			CSwiChangeNotifier is returned to a

						sensible active state.

	 */

	TInt RunError(TInt aError);

private:

	/** A reference to its owning class instance */

	CDiscoverer& iDiscoverer;	

	/** Handle allowing access to P&S properties */

	RProperty iProperty;

	/** Friend class to enable access to private members for testing. */

	friend class TDiscoverer_StateAccessor;

	};

// __________________________________________________________________________

//

/**

	@internalComponent

	@since 7.0

	The notification object which watches the Interface Implementation Collection directories for

	any changes.

	When its RunL method is called, it notifies its owning CDiscoverer class

	object to re-scan the Interface Implementation Collection directories.

 */

class CDiscoverer::CDirChangeNotifier : public CActive

	{

public:

	/**

		@fn				CDirChangeNotifier(CDiscoverer& aDiscoverer, RFs& aFs, const TDesC& aNotificationFilePath)

		Intended Usage	: Standardised default c'tor	

		Error Condition	: None	

		@since			7.0

		@param			aDiscoverer A reference to its owning class instance.

		@param			aFs A reference to a connected file server instance.

		@param			aNotificationFilePath A reference to the file path that is to be watched.

		@param			aDriveUnit A drive which the notification object watches for.

		@pre 			None

		@post			CDirChangeNotifier is fully constructed

	 */

	CDirChangeNotifier(CDiscoverer& aDiscoverer, RFs& aFs,const TDriveUnit& aDriveUnit);

	/**

		@fn				virtual ~CDirChangeNotifier()

		Intended Usage	: Standard default d'tor	

		Error Condition	: None	

		@since			7.0

		@pre 			CDirChangeNotifier is fully constructed.

		@post			CDirChangeNotifier is totally destroyed

	 */

	virtual ~CDirChangeNotifier();

	/**

		@fn				Activate()

		Intended Usage	: Activate the notifier and attach it to the File 

						session to watch the appropriate Interface Implementation Collection directories. 

		Error Condition	: None	

		@since			7.0

		@pre 			CDirChangeNotifier is fully constructed.

		@post			CDirChangeNotifier is active on the current scheduler.

	 */

	void Activate();

private:

	/**

		@fn				RunL()

		Intended Usage	: When the object activates, this is method is called

						and notifies the CDiscoverer to re-scan the 

						Interface Implementation Collection	directories. 

		Error Condition	: Not enough memory available to complete the scan.

		@leave  		KErrNoMemory

		@since			7.0

		@pre 			CDirChangeNotifier is fully constructed.

		@post			CDirChangeNotifier notifications are cancelled and

						it is no longer active on the current scheduler.

	 */

	void RunL();

	/**

		@fn				DoCancel()

		Intended Usage	: The cancel action called by CActive::Cancel(). 

		Error Condition	: None	

		@since			7.0

		@pre 			CDirChangeNotifier is fully constructed.

		@post			CDirChangeNotifier notifications are cancelled and

						it is no longer active on the current scheduler.

	 */

	void DoCancel();

	/**

		@fn				RunError(TInt aError)

		Intended Usage	: Called by the notifier RunL leaving.

		@since			7.0

		@param			aError The error code that the RunL left with.

		@return			TInt KErrNone. 

		@pre 			CDirChangeNotifier is fully constructed.

		@post			CDirChangeNotifier is returned to a

						sensible active state.

	 */

	TInt RunError(TInt aError);

private:

	/** A reference to its owning class instance */

	CDiscoverer& iDiscoverer;	

	/** A reference to a connected file server instance */

	RFs&	iFs;

	/** The file path for a specific drivethat we are interested in.*/

	//const TDesC& iNotificationFilePath;

	typedef TBuf<KEComPlugRSCPathMaxLen> TResourcePathName;

	TResourcePathName iNotificationFilePath;

	/** A drive which the notification object watches for.*/

	TDriveUnit iDriveUnit;

	/** Friend class to enable access to private members for testing. */

	friend class TDiscoverer_StateAccessor;

	};

/**

	@since 7.0	

	The timer Active object for providing incremental plugin directory scanning. 

	Note that task execution is dependant upon the task priority

	The default priority is idle time execution only.

	This object controls the yielding of time to other processes by having a low priority

	but requesting immediate reactivation, after each incremental part of the directory scan.

	It is launched by the CDirChangeNotifier's notification call.

 */

class CDiscoverer::CIdleScanningTimer : public CTimer

	{

public:

	/**

		@fn				NewL(CDiscoverer& aDiscoverer)

		Intended Usage	: Standardised safe construction which leaves nothing

						  on the cleanup stack.

		Error Condition	: Not enough memory available.	

		@leave  		KErrNoMemory

		@since			7.0

		@param			aDiscoverer A reference to the owning CDiscoverer

		@return			CIdleScanningTimer* a pointer to the new class

		@pre 			None

		@post			CIdleScanningTimer is fully constructed, and initialised.

	 */	

	static CIdleScanningTimer* NewL(CDiscoverer& aDiscoverer);

	/**

		@fn				virtual ~CIdleScanningTimer()

		Intended Usage	: Standard default d'tor	

		Error Condition	: None	

		@since			7.0

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is totally destroyed

	 */

	virtual ~CIdleScanningTimer();

	/** 

		@fn				AddDriveL(TDriveUnit aDrive)

		Intended Usage	: Add a drive for processing notification

		Error Condition	: None	

		@leave  		System wide error codes.

		@param			aDrive The drive to be added.

		@post			The drive number added into pending list only if it has not been added before

	 */

	inline void AddDriveL(const TDriveUnit aDrive)

		{

		if(iPendingDriveList.Find(aDrive) == KErrNotFound)

			{

			iPendingDriveList.AppendL(aDrive);

			}

		}

	/**

		@fn				IsAnyNotificationProcessingPending()

		Intended Usage	: To check if there is any notification waiting to be processed.

		@return			TBool A flag indicating if there is any pending notification to be processed

	 */	

	inline TBool IsAnyNotificationProcessingPending()

		{

		if(iPendingDriveList.Count())

			return ETrue;

		return EFalse;

		}

	/**

		@fn				RestartScanPeriod()

		Intended Usage	: Called to restart the scanning period.

		Error Condition	: None	

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is activated and will process pending drives list, if the timer has not been suspended

	 */

	void RestartScanPeriod();

	/**

		@fn				Suspend()

		Intended Usage	: Called to suspend the scanning timer, disabling the scanning from being restarted.

		Error Condition	: None	

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is set as suspended. No re-discovery will take place.

	 */

	void Suspend();

	/**

		@fn				Resume()

		Intended Usage	: Called to resume the scanning timer, and enable scanning to be restarted.

		Error Condition	: None	

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is set as resumed. Re-discovery will take place.

	 */

	void Resume();

private:

	/**

		@fn				CIdleScanningTimer(CDiscoverer& aDiscoverer)

		Intended Usage	: Standardised default c'tor made explicit to avoid unintentional

						conversion construction by the compiler.	

		Error Condition	: None	

		@since			7.0

		@param			aDiscoverer A reference to its owning class instance.

		@pre 			None

		@post			CIdleScanningTimer is fully constructed

	 */

	explicit CIdleScanningTimer(CDiscoverer& aDiscoverer);

	/**

		@fn				void ConstructL()

		Intended Usage	: Standardised 2nd, (Initialisation) phase of two phase construction.

		Error Condition	: Leaves with error code : usually KErrNoMemory.

		@leave  		KErrNoMemory.

		@since			7.0

		@return			void 

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is fully initialised.

	 */

	void ConstructL();

	/**

		@fn				DoCancel()

		Intended Usage	: The cancel action called by CActive::Cancel(). 

		Error Condition	: None	

		@since			7.0

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is no longer active on the current scheduler.

	 */

	void DoCancel();

	/**

		@fn				RunL()

		Intended Usage	: When the object activates, this method calls

						the CDiscoverer to continue the incremental scan 

						of the Interface Implementation Collection directories. 

		Error Condition	: Not enough memory available to add to complete the scan.

		@leave  		KErrNoMemory

		@since			7.0

		@pre 			CIdleScanningTimer is fully constructed.

		@post			The Interface Implementation Collection directories Scan has completed another step and the

						CIdleScanningTimer has been re-activated for the next step

						OR The Interface Implementation Collection directories Scan is complete and the 

						CDirChangeNotifier has been re-activated.

	 */

	void RunL();

	/**

		@fn				RunError(TInt aError)

		Intended Usage	: Called when the directory change

						notification processing failed by leaving.

		@since			7.0

		@param			aError The error code that the RunL left with.

		@return			TInt KErrNone. 

		@pre 			CIdleScanningTimer is fully constructed.

		@post			CIdleScanningTimer is non-active.

	 */

	TInt RunError(TInt aError);

private:

	/** A reference to its owning class instance */

	CDiscoverer& iDiscoverer;	

	/** 

		An array of drives to be processed.

	*/

	RArray<TUint> iPendingDriveList;

	/**

		A flag to indicate if the timer is suspended or not.

	*/

	TBool iSuspended;

	// List the internal classes as friends

	// the Test bed state accessor

	friend class TDiscoverer_StateAccessor;

	};

/**

	CDirScanner implements incremental scanning of the Interface Implementation 

	Collection directories on behalf of the CDiscoverer.

	Its methods are called in response to the timer task execution,

	thereby requiring the incremental scheduling.

 */ 

class CDiscoverer::CDirScanner : public CBase

	{

// Methods

public:

	/**

		@fn				CDirScanner(CDiscoverer& aDiscoverer, RFs& aFs)

		Intended Usage	: Standardised safe construction which leaves nothing

						  on the cleanup stack.

		Error Condition	: Not enough memory available.	

		@leave  		KErrNoMemory

		@since			7.0

		@param			aDiscoverer A reference to its owning class instance.

		@param			aFs A reference to a connected file server instance.

		@return			CDirScanner* a pointer to the new class

		@pre 			None

		@post			CDirScanner is fully constructed, and initialised.

	 */

	static CDirScanner* NewL(CDiscoverer& aDiscoverer, RFs& aFs);

	/**

		@fn				virtual ~CDirScanner()

		Intended Usage	: Standard default d'tor	

		Error Condition	: None	

		@since			7.0

		@pre 			CDirScanner is fully constructed.

		@post			CDirScanner is totally destroyed

	 */

	virtual ~CDirScanner();

	/**

		@fn				DiscoverPluginsL()

		Intended Usage	: Discover the plugins the specific drive units.

		@param			: aIsRO a flag to show if the Drive Units list is RO Internal or not.

		@pre 			: CDiscoverer is fully constructed.iDirScanner is fully constructed.

		@pre			: CDirScanner is fully constructed.

		@post			: the plugins on the specific Drive Units have been discovered.

	 */

	 void DiscoverPluginsL(TBool aDiscoverReadOnlyDrives);

	/**

		@fn				ScanDriveL(TDriveUnit aDrive)

		Intended Usage	: Helper method for StartScanL.

						Scan a drive for the Interface Implementation Collection directories

						and identify any Interface Implementation 

						Collections within that directory

						for addition to the registry. 

		Error Condition	: None	

		@leave  		KErrNoMemory

		@since			7.0

		@param			aDrive The drive to scan.

		@param			aIsRO A flag to tell if the drive unit is RO or Non-RO

		@pre 			CDirScanner is fully constructed.

		@post			Another drive's Interface Implementation Collection directories has been scanned,

	 */

	void ScanDriveL(const TDriveUnit& aDrive,  TBool aIsRO);

private:

	/**

		@fn				CDirScanner(CDiscoverer& aDiscoverer, RFs& aFs)

		Intended Usage	: Standardised default c'tor. 

		Error Condition	: None	

		@since			7.0

		@param			aDiscoverer A reference to its owning class instance.

		@param			aFs A reference to a connected file server instance.

		@pre 			None

		@post			CDirScanner is fully constructed

	 */

	CDirScanner(CDiscoverer& aDiscoverer, RFs& aFs);

	/**

		@fn				void ConstructL()

		Intended Usage	: Standardised 2nd, (Initialisation) phase of two phase construction.

		Error Condition	: Leaves with error code : usually KErrNoMemory.

		@leave  		KErrNoMemory.

		@since			7.0

		@return			void 

		@pre 			CDirScanner is fully constructed.

		@post			CDirScanner is fully initialised.