// 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.

 	 */

 	void ConstructL();

 	/**

 		@fn				DoScanDriveL(const TDriveUnit aDrive, const TUidType aUidType)

 		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			9.0

 		@param			aDrive The drive to scan.

 		@param			aUidType The uid type to be searched for.

 		@param			aIsRO Indicates whether the current drive is read Only.

 		@pre 			CDirScanner is fully constructed.

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

 	 */

 	TBool DoScanDriveL(const TDriveUnit& aDrive, const TUidType& aUidType, TBool aIsRO);

 	/**

 		@fn				DoScanSpiFileL(const TParse aSpiPath)

 		Intended Usage	: Helper method for StartScanL.

 						Scan a SPI file 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			9.0

 		@param			aSpiPath The SPI file to scan.

 		@pre 			CDirScanner is fully constructed.

 		@post			Another drive's Interface Implementation Collection has been scanned from an SPI file.

 	 */

 	TBool DoScanSpiFileL(const TParse& aSpiPath);

 // Attributes / Properties

 private:

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

 	CDiscoverer& iDiscoverer;	

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

 	RFs&	iFs;

 	/** The Full Interface Implementation Collection Directory path */

 	// List the internal classes as friends

 	// the Test bed state accessor

 	friend class TDiscoverer_StateAccessor;

 };  // CDirScanner

 #endif // __DISCOVERER_H__