// 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:
// Contains the implementation of the CDiscoverer class.
// 
//

/**
 @file
 @internalComponent
*/

#include <e32uid.h>
#include <startup.hrh> // for EStartupStateNonCritical and EStartupStateCritical
#include <bacntf.h>

#include <sacls.h>

#include "EComDebug.h"
#include "TestUtilities.h"	// For __FILE__LINE__
#include "Discoverer.h"
#include "DiscovererObserver.h"
#include "EComUidCodes.h"
#include "baspi.h"
#include "bautils.h"
#include "DriveInfo.h"
#include <ecom/ecomerrorcodes.h>
#include <saclscommon.h>


#define UNUSED_VAR(a) a = a


/** Interface Implementation Collection resource file search path */
_LIT(KEComResourceFileSearch,	"\\resource\\plugins\\*");

_LIT(KEComResourceFilePathAny,	"\\resource\\plugins\\");
_LIT(KEComResourceFolderPath,	"?:\\resource\\plugins\\"); 

// Relative to the Drive with a fixed path
_LIT(KEComSPIFilePath, "\\private\\10009D8F\\");

/** 
	Begin directory scanning after a delay of 1 Second
	Allowing multiple directory changes to be applied before
	beginning a scan.
 */
static const TInt32 KEComDefaultBeginScanPeriod	=	1000000;

// __________________________________________________________________________
//
CDiscoverer::CSwiChangeNotifier* CDiscoverer::CSwiChangeNotifier::NewL(CDiscoverer& aDiscoverer)
	{
	CSwiChangeNotifier* self = new(ELeave) CSwiChangeNotifier(aDiscoverer);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CDiscoverer::CSwiChangeNotifier::CSwiChangeNotifier(CDiscoverer& aDiscoverer)
: CActive(CActive::EPriorityHigh), iDiscoverer(aDiscoverer)
	{
	// Safe because it cannot fail
	CActiveScheduler::Add(this);
	}

void CDiscoverer::CSwiChangeNotifier::ConstructL()
	{
	// Attach to SWI property
	User::LeaveIfError(
        iProperty.Attach(KUidSystemCategory, KSAUidSoftwareInstallKeyValue));
	}

CDiscoverer::CSwiChangeNotifier::~CSwiChangeNotifier()
	{
	Cancel();
	iProperty.Close();
	}

void CDiscoverer::CSwiChangeNotifier::DoCancel()
	{
	iProperty.Cancel();	// Cancel SWI change notifications
	}

void CDiscoverer::CSwiChangeNotifier::Subscribe()
	{
	if(!IsActive())
		{
		iProperty.Subscribe(iStatus);
		SetActive();
		}
	}

void CDiscoverer::CSwiChangeNotifier::RunL()
	{
	Subscribe();
	
	TInt swiProperty;
	User::LeaveIfError(
        iProperty.Get(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, swiProperty));

	// Do a discovery each time an install, uninstall or restore is completed.
	iDiscoverer.SwiChangeNotificationL(swiProperty);	
	}

TInt CDiscoverer::CSwiChangeNotifier::RunError(TInt /*aError*/)
	{
	//If unable to read the SWI P&S variable set the 
	//discoverers SWI state to ESASwiNone as this will return
	//EComs back to its default behaviour
	TRAP_IGNORE(iDiscoverer.SwiChangeNotificationL(ESASwisNone));	
	return KErrNone; //avoid CActiveScheduler panic
	}

// __________________________________________________________________________
//
/*
	The notification object which watches the Interface Implementation 
	Collection directories for any changes on specific drive.
	When its RunL method is called, it notifies its owning CDiscoverer class
	object to re-scan of the Interface Implementation Collection directories.
*/
CDiscoverer::CDirChangeNotifier::CDirChangeNotifier(CDiscoverer& aDiscoverer, RFs& aFs, const TDriveUnit& aDriveUnit)
: CActive(CActive::EPriorityHigh), iDiscoverer(aDiscoverer), iFs(aFs),iDriveUnit(aDriveUnit)
	{
	
	iNotificationFilePath.Append(iDriveUnit.Name());
	iNotificationFilePath.Append(KEComResourceFilePathAny);
	// Safe because it cannot fail
	CActiveScheduler::Add(this);
	}

CDiscoverer::CDirChangeNotifier::~CDirChangeNotifier()
	{
	Cancel();
	}

void CDiscoverer::CDirChangeNotifier::DoCancel()
	{
	iFs.NotifyChangeCancel(iStatus);	// Cancel change notifications
	}

void CDiscoverer::CDirChangeNotifier::Activate()
	{
	if(!IsActive())
		{
		iStatus = KRequestPending;
		SetActive();
		iFs.NotifyChange(ENotifyEntry, iStatus, iNotificationFilePath); 
		}
	}

void CDiscoverer::CDirChangeNotifier::RunL()
	{
	RECORD_START_NOTIFIER_RUNL_TIMER_RESULT(iDriveUnit)
	// Signal the notification
	// If iStatus.Int() is not KErrNone
	// then reactivation will not occur
	if(iDiscoverer.NotificationL(iStatus.Int(), iDriveUnit))
		Activate();
	RECORD_END_NOTIFIER_RUNL_TIMER_RESULT(iDriveUnit)
	}

TInt CDiscoverer::CDirChangeNotifier::RunError(TInt aError)
	{
	// Entered most likely because of an error condition during file system
    // rescanning and plugin registration that could not be handled locally. 
    // As indexes in the registry are updated after each registration and the
	// tree of registrations is updated at the end for some scan use-cases there
	// is a chance that the registration tree and the indexes can get out of 
    // sync when a leave occurs. 
    // The code is not present to handle a recovery so the best policy 
    // is to panic the server and have it restart on next use.
    // We can't trap leaves in RunL() and continue as we can not be sure the 
    // registry is in sync. The registry and discovery code would need to be 
    // totally reviewed and reworked if panic's were not acceptable. So far they 
    // have allowed error conditions found in the field to be reported as 
    // incidents allowing us to idenitify and resovle the underlying causes.
	__ECOM_LOG1("ECOM: PANIC in CDiscoverer::CDirChangeNotifier::RunError(), error= %d", aError);
	User::Panic(KEComServerPanicCategory, EEComPanic_CDiscoverer_CDirChangeNotifier_RunError);
	return KErrNone;   // dummy return to stop warnings on missing return
	}

// __________________________________________________________________________
//
/*
	The timer Active object for providing plugin directory scanning on rediscovery events. 
	The processing of notification will be performed only on drive(s) that has notification event(s)
	triggered on it.
	It uses data member iPendingDriveList to hold all pending drive nums, and executes only once. 
	It is activated by the CDirChangeNotifier's notification call. 
	The default priority is idle time execution only.
*/
CDiscoverer::CIdleScanningTimer* CDiscoverer::CIdleScanningTimer::NewL(CDiscoverer& aDiscoverer)
	{
	CIdleScanningTimer* self = new(ELeave) CIdleScanningTimer(aDiscoverer);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
CDiscoverer::CIdleScanningTimer::CIdleScanningTimer(CDiscoverer& aDiscoverer)
: CTimer(CActive::EPriorityIdle), iDiscoverer(aDiscoverer), iPendingDriveList(2)
	{
	// Safe because it cannot fail
	CActiveScheduler::Add(this);
	}

void CDiscoverer::CIdleScanningTimer::ConstructL()
	{
	CTimer::ConstructL();
	}

CDiscoverer::CIdleScanningTimer::~CIdleScanningTimer()
	{
	Cancel();
	iPendingDriveList.Close();
	}

void CDiscoverer::CIdleScanningTimer::DoCancel()
	{
	// Call the base class to ensure the timer is cancelled
	CTimer::DoCancel();

	iDiscoverer.ScanDirectoryCancel();
	}

void CDiscoverer::CIdleScanningTimer::RunL()
//	When the object activates on a specfic drive, this is method is called
//  and delegates to the CDiscoverer to scan the Interface Implementation 
//	Collection directories
//
	{
	// Only carry out a rediscovery if SWI is not in progress
	if(!iDiscoverer.SwiOperationInProgress()) 
		{
		RECORD_START_TIMER_RUNL_TIMER_RESULT
		// Do scan on all pending drives stored in iPendingDriveList array
		TInt length = iPendingDriveList.Count();
		for(TInt count = 0; count < length; ++count)
			{
			iDiscoverer.RediscoveryScanDirectoryL(TDriveUnit(iPendingDriveList[count]));
			}
	
		// Signal the observer that the scans have been completed successfully.
		iDiscoverer.iDiscovererObserver.DiscoveriesComplete(ETrue, EPluginProcessingTypeAll);
		// Reset pending drive list when finishes scan.
		iPendingDriveList.Reset();
		// Reset the state of discoverer as all notifications processed.
		iDiscoverer.CompleteNotificationProcessing();
		RECORD_END_TIMER_RUNL_TIMER_RESULT
		}
	}

TInt CDiscoverer::CIdleScanningTimer::RunError(TInt aError)
	{
	// Entered most likely because of an error condition during file system
    // rescanning and plugin registration that could not be handled locally. 
    // As indexes in the registry are updated after each registration and the
	// tree of registrations is updated at the end for some scan use-cases there
	// is a chance that the registration tree and the indexes can get out of 
    // sync when a leave occurs. 
    // The code is not present to handle a recovery so the best policy 
    // is to panic the server and have it restart on next use.
    // We can't trap leaves in RunL() and continue as we can not be sure the 
    // registry is in sync. The registry and discovery code would need to be 
    // totally reviewed and reworked if panic's were not acceptable. So far they 
    // have allowed error conditions found in the field to be reported as 
    // incidents allowing us to idenitify and resovle the underlying causes.
	__ECOM_LOG1("ECOM: PANIC in CDiscoverer::CIdleScanningTimer::RunError(), error = %d", aError);
	User::Panic(KEComServerPanicCategory, EEComPanic_CDiscoverer_CIdleScanningTimer_RunError);
	return KErrNone;	// dummy return to stop warnings on mising return
	}
	
void CDiscoverer::CIdleScanningTimer::RestartScanPeriod()
	{
	if (!iSuspended)
		{
		Cancel();
		After(KEComDefaultBeginScanPeriod);
		}
	}
	
void CDiscoverer::CIdleScanningTimer::Suspend()
	{
	Cancel();
	iSuspended = ETrue;
	}
	
void CDiscoverer::CIdleScanningTimer::Resume()
	{
	iSuspended = EFalse;
	if(IsAnyNotificationProcessingPending())
		{
		RestartScanPeriod();
		}
	}
// __________________________________________________________________________
//
/*
		CDirScanner implements incremental scanning of the Interface Implementation 
		Collection directory 
		on behalf of the CDiscoverer.
		It's methods are called in response to the timer task execution,
		thereby requiring the incremental scheduling.
*/
CDiscoverer::CDirScanner* CDiscoverer::CDirScanner::NewL(CDiscoverer& aDiscoverer, RFs& aFs)
	{
	CDirScanner* self = new(ELeave)CDirScanner(aDiscoverer,aFs);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

void CDiscoverer::CDirScanner::ConstructL()
	{
	}

CDiscoverer::CDirScanner::CDirScanner(CDiscoverer& aDiscoverer, RFs& aFs)
: CBase(), iDiscoverer(aDiscoverer), iFs(aFs)
	{
	}

CDiscoverer::CDirScanner::~CDirScanner()
// D'tor
	{
	}
	

void CDiscoverer::CDirScanner::ScanDriveL(const TDriveUnit& aDrive,  TBool aIsRO)
	{
	RECORD_START_REDISCOVERYSCANDIRECTORY_RESULT(aDrive)
	TDriveName driveName(aDrive.Name());
	TBool scanDirectoryForPlugins = ETrue;
	TBool found = EFalse;

	
	// If RO then attempt to discover plugins from SPI file
	if(aIsRO)
		{
		TFileName spiFilePath;
		spiFilePath.Append(driveName);
		spiFilePath.Append(KEComSPIFilePath);
		
		TEntry entry;
		//check if the path exists
		if (iFs.Entry(spiFilePath,entry)==KErrNone)
			{
			TParse spiPath;
			spiPath.Set(spiFilePath, NULL, NULL);
			// Discover plugins from SPI
			found = DoScanSpiFileL(spiPath);
			}
		scanDirectoryForPlugins = !found;
		}
 
 	// scan directory for plugins if not already discovered from SPI file. SPI applies to RO.
 	if(scanDirectoryForPlugins)
 		{
 	
		// Find plugins via resoure files
		TUidType rscUidType(KNullUid,KUidInterfaceImplementationCollectionInfo,KNullUid);
		TBool foundRsc = DoScanDriveL(aDrive, rscUidType, aIsRO);
		found = found || foundRsc; 
 		}

	if (!found)
		{
		iDiscoverer.DriveUnmountedL(aDrive);
		}
	RECORD_END_REDISCOVERYSCANDIRECTORY_RESULT(aDrive)
	}

TBool CDiscoverer::CDirScanner::DoScanSpiFileL(const TParse& aSpiPath)
{
	iDiscoverer.DriveMountedL(aSpiPath.Drive());

	RResourceArchive resourceArchive;
	//ECom server should continue if OpenL leaves because no spi exists 
	TRAPD(err,resourceArchive.OpenL(iFs, aSpiPath.DriveAndPath(),_L("ecom")));
	if(err==KErrNotFound || err==KErrPathNotFound)
		return EFalse;
	User::LeaveIfError(err);
	CleanupClosePushL(resourceArchive);
	// check SPI file type. On failure do not scan archives
	if(resourceArchive.Type() != KEcomSpiFileTypeUid)
		{
		CleanupStack::PopAndDestroy(&resourceArchive);
		return EFalse;
		}
	
	CPluginBase* entryBase=NULL;
	TBool resourceExistsIndicator = EFalse;
	while(!resourceArchive.End())
		{
		TRAPD(error,iDiscoverer.ValidateEntryL(resourceArchive,entryBase));
		CleanupStack::PushL(entryBase);
		if (error==KErrNoMemory)
			User::LeaveNoMemory();
		if (error==KErrNone)
			{
			// When SPI is on no DAT file exists,and also RO Internal drive is not rediscovered. 
			//Therefore this RO Internal drive is always at its initial discovery. No Dll
			// is ever discovered before. Always pass EFalse to ProcessEntryL method.
			iDiscoverer.ProcessEntryL(aSpiPath.Drive(),entryBase, EFalse);
			// set to indicate at least 1 resource exists
			resourceExistsIndicator = ETrue;	
			}
		else
			{
			__ECOM_TRACE1("ECOM: CDiscoverer::DoScanSpiFileL(). Fail Validate: %S\n.",&aSpiPath.FullName());
			}	
		CleanupStack::PopAndDestroy(entryBase);
		entryBase=NULL;
		}
	CleanupStack::PopAndDestroy(&resourceArchive);
	return resourceExistsIndicator;
}

TBool CDiscoverer::CDirScanner::DoScanDriveL(const TDriveUnit& aDrive, const TUidType& aUidType, TBool aIsRO)
	{	
	RDir dir;
	
	TDriveName driveName(aDrive.Name());
	TParse searchDir;
	User::LeaveIfError(searchDir.Set(KEComResourceFileSearch,NULL,&driveName));

	// Match the directory list UID's to a Polymorphic DLL UID and Interface
	// Implementation Collection UID.
	// Resource files are sorted by UID. However, since these files have same UID,
	// they are actually sorted by their names (alphanumerically).

  	TInt error = dir.Open(iFs, searchDir.FullName(), aUidType);
 
	if(error == KErrNone)
		{
		// Have found the plugin directory
		CleanupClosePushL(dir);
		
		TFileName* lastRscNameBuf = new TFileName;
		
		if (!lastRscNameBuf) 
		{
			CleanupStack::PopAndDestroy(&dir); 
			return EFalse;
		}
		CleanupStack::PushL(lastRscNameBuf);
		
		TEntryArray *dirEntriesArray = new TEntryArray;
	 
		if (!dirEntriesArray) 
		{
			CleanupStack::PopAndDestroy(lastRscNameBuf); 
			CleanupStack::PopAndDestroy(&dir); 
			return EFalse;
		}
		CleanupStack::PushL(dirEntriesArray);
				
		
		TPtrC lastRscName(KNullDesC);
		
		// Iterate through the directory reading multiple entries at a 
		// time
		TInt count = 0;
		TInt readError = KErrNone;
		CPluginBase* entryBase=NULL;

 		iDiscoverer.DriveMountedL(aDrive);
		TBool anyDllRegistered = iDiscoverer.IsAnyDllRegisteredWithDriveL(aDrive);
 
	 

		while (readError != KErrEof)  
			{
		
 			// Read the next set of entries
 			readError =	dir.Read(*dirEntriesArray);
 				
			if ((readError != KErrNone) &&  (readError != KErrEof))
				{
				User::Leave(readError);	
				}
			else 
				{
 				// for KErrEof, dirEntriesArray still has items to process 
				count = dirEntriesArray->Count();
 				// Ok use the entries to populate the file list
				for(TInt i = 0; i < count; ++i)
					{
 
 					// Compare current file name against previous one ignoring extension. If it is same
					// then there is no need to process it.
					TPtrC currName = (*dirEntriesArray)[i].iName.Left((*dirEntriesArray)[i].iName.Length()-KExtensionLength);
					if (lastRscName.Compare(currName) == 0)
						{
						continue;
						}
					else if (i < (count - 1))
						{
						lastRscName.Set(currName);
						}
					else
						{
						lastRscNameBuf->Copy(currName);
						lastRscName.Set(*lastRscNameBuf);
						}
						
 
					// Obtain a copy of the current directory entry
					TRAP(error,iDiscoverer.ValidateEntryL((*dirEntriesArray)[i], driveName, entryBase, aIsRO));			
					CleanupStack::PushL(entryBase);		
 
					if (error==KErrNoMemory) 
						User::LeaveNoMemory();
				
					if (error==KErrNone)
						{
						iDiscoverer.ProcessEntryL(driveName,entryBase,anyDllRegistered);
 						}
					else
						{
						__ECOM_TRACE1("ECOM: CDiscoverer::DoScanDriveL(). Fail Validate entry: %S\n.",&(*dirEntriesArray)[i].iName);
						}		
				    CleanupStack::PopAndDestroy(entryBase);
					entryBase=NULL;
					}
				}
			}
 		CleanupStack::PopAndDestroy(dirEntriesArray); 
		CleanupStack::PopAndDestroy(lastRscNameBuf); 
		CleanupStack::PopAndDestroy(&dir); 
		return ETrue; 
		}

	return EFalse;
	}

void CDiscoverer::CDirScanner::DiscoverPluginsL(TBool aDiscoverReadOnlyDrives)
	{
	// iterator which returns only the drives need to be scanned.
	TEComCachedDriveInfoIterator iter(*iDiscoverer.iCachedDriveInfo);

	// Iterate from highest drive letter (Z:) towards lowest drive letter (A:).
	for (iter.Last(); iter.InRange(); iter.Prev())
		{
		if (iter.DriveIsReadOnlyInternal() == aDiscoverReadOnlyDrives)
			{
			ScanDriveL(iter.DriveUnit(), aDiscoverReadOnlyDrives);
			}
		}
	}
	

// __________________________________________________________________________
//
/*
	Responsible for identifying new Interface Implementation Collections,
	installed in the Interface Implementation Collection directories.
*/

CDiscoverer* CDiscoverer::NewL(MDiscovererObserver& aDiscovererObserver, RFs& aFs)
	{
	CDiscoverer* self = new(ELeave) CDiscoverer(aDiscovererObserver, aFs);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

// Default d'tor

CDiscoverer::~CDiscoverer()
	{
	// Cancel any scanning behaviour or notifications
	if(iDirScanner != NULL)
		{
		// Left in the middle of a scan
		// So clear up
		delete iDirScanner;
		iDirScanner = NULL;
		// Signal the observer that the scan has 
		// not been completed successfully.
		iDiscovererObserver.DiscoveriesComplete(EFalse, EPluginProcessingTypeAll);
		}
	Suspend();
	iDrivesDiscovered.Reset();
	delete iSwiChangeNotifier;
	delete iScanningTimer;
	delete iLanguageChangeNotifier;
	delete iCachedDriveInfo;
	iRscDirNotifierList.ResetAndDestroy();

	}

// Default c'tor
CDiscoverer::CDiscoverer(MDiscovererObserver& aDiscovererObserver, RFs& aFs)
: CBase(),   iSwiChangeDiscoveryPending(EFalse), iLanguageChangeDiscoveryPending(EFalse),
  iState(EDisc_Undefined), iDiscovererObserver(aDiscovererObserver), iFs(aFs)
	{
	// Do nothing here
	}

void CDiscoverer::ConstructL()
	{
	iCachedDriveInfo = CEComCachedDriveInfo::NewL(iFs);
	
	// Construct the Interface Implementation Collection
	// directory change notifier list
	// and the scan step control object.

	CDirChangeNotifier *dirChangeNotifierPtr;

	// iterator which returns only the drives need to be scanned.
	TEComCachedDriveInfoIterator iter(*iCachedDriveInfo);

	for (iter.First(); iter.InRange(); iter.Next())
		{
		//Don't need to monitor read-only drives. They don't change.
		if ( !iter.DriveIsReadOnlyInternal() )
			{				
			dirChangeNotifierPtr = new(ELeave)CDirChangeNotifier(*this,iFs,iter.DriveUnit());
		
			CleanupStack::PushL(dirChangeNotifierPtr);				
			iRscDirNotifierList.AppendL(dirChangeNotifierPtr);
			CleanupStack::Pop();
			}
		}
	iSwiChangeNotifier = CSwiChangeNotifier::NewL(*this);

	iScanningTimer = CIdleScanningTimer::NewL(*this);

	//Create the language change notifier and install the callback function
	const TCallBack myCallBackFunction(&CDiscoverer::LocaleChangedL, this);
	iLanguageChangeNotifier = CEnvironmentChangeNotifier::NewL(CActive::EPriorityStandard, myCallBackFunction);
	
	iDirScanner = CDirScanner::NewL(*this,iFs);	

	InitialiseEvent();	
	}


TInt CDiscoverer::Resume()
	{
	// Reactivate the scanning timer if not NULL
	if (iScanningTimer != NULL)
		{
		iScanningTimer->Resume();
		}
	
	TCallBackState cbData = ECallBackState_EventEnd;
	iBurChangeCallBack.CallBack(ECallBackId_BurEvent, &cbData);

	/*
	iLanguageChangeNotifier is not activated because it is not cancelled during CDiscoverer::Suspend().
	It is not suspended because a language change should not occur whilst a backup/restore operation
	is taking place.
	*/

	return KErrNone;
	}


TInt CDiscoverer::Suspend()
	{
	// Suspend the scanning timer if not NULL
	if (iScanningTimer != NULL)
		{
		iScanningTimer->Suspend();
		}

	TCallBackState cbData = ECallBackState_EventStart;
	iBurChangeCallBack.CallBack(ECallBackId_BurEvent, &cbData);

	/*
	iLanguageChangeNotifier is not cancelled because a language change should not occur
	whilst a backup/restore operation is taking place.
	*/

	return KErrNone;
	}


TBool CDiscoverer::NotificationL(TInt aStatus, const TDriveUnit& aDriveUnit)
	{

	TBool okToContinue = ETrue;
	if(aStatus != KErrNone)
		{
		// Big trouble with the notification
		// Tell our observer
		// Notifications will cease if EFalse is returned!!!!
		okToContinue = iDiscovererObserver.NotifiedWithErrorCode(aStatus);	
		}
	else
		{
		//call ProcessDNEventL() to indicate Plugins have been added or removed on a specfic drive,
		// then do the state transition and to start a re-discovery .
		ProcessDNEventL(EPluginsModified,aDriveUnit );
		ProcessDNEventL(EPluginsRediscover, aDriveUnit);
		}
	return okToContinue;
	}

void CDiscoverer::SwiChangeNotificationL(TInt aSwiOperation)
	{
	// Store the current SWI operation, ignore operation status
	iSwiOperation = aSwiOperation & KSASwisOperationMask;
	
	TCallBackState cbData = SwiOperationInProgress() ? ECallBackState_EventStart : ECallBackState_EventEnd;
	iSwiChangeCallBack.CallBack(ECallBackId_SwiEvent, &cbData);

	// Test no SWI operation in progress
	if(!SwiOperationInProgress())
		{
		TBool rediscoveryPending = EFalse;
		if(!iSwiChangeDiscoveryPending)
			{		 
			// for each removable drive call ProcessDNEventL() to do the state transition and to start
			// a re-discovery for that drive.
			TInt count = iDrivesDiscovered.Count();		
			for(TInt i=0; i < count; i++)
				{
				TDriveUnit drvUnit(iDrivesDiscovered[i]);
				if(iCachedDriveInfo->DriveIsRemovableL(drvUnit))
					{
					rediscoveryPending = ETrue;
					ProcessDNEventL(EPluginsModified, drvUnit );
					ProcessDNEventL(EPluginsRediscover, drvUnit);
					iSwiChangeDiscoveryPending = ETrue;
					}
				}
			}
		
		//If there are no removable drives to be scanned check if there are any
		//pending notifications that couldn't be processed during SWI
		if(!rediscoveryPending && iScanningTimer->IsAnyNotificationProcessingPending())
			{
			// Activate timer if there is any notification processing pending
			iScanningTimer->RestartScanPeriod();
			}
		}
	}

TBool CDiscoverer::SwiOperationInProgress()
	{
	return (iSwiOperation != ESASwisNone);
	}

void CDiscoverer::LanguageChangeNotificationL()
	{
	if (!iLanguageChangeDiscoveryPending)
		{
		// for each drive call ProcessDNEventL() to do the state transition and to start
		// a re-discovery for that drive.
		TInt count = iDrivesDiscovered.Count();
		for(TInt i=0; i < count; i++)
			{
			ProcessDNEventL(EPluginsModified, iDrivesDiscovered[i] );
			ProcessDNEventL(EPluginsRediscover, iDrivesDiscovered[i]);
			}
		iLanguageChangeDiscoveryPending = ETrue;
		}
	}
void CDiscoverer::RediscoveryScanDirectoryL(const TDriveUnit& aDriveUnit) 
	{
	TBool doScan = EFalse;
	if(iDrivesDiscovered.Find(aDriveUnit) != KErrNotFound)
		{
		// If the drive has plugins on it previously, do ScanDriveL on any notifications.
		doScan = ETrue;
		}
	else // Otherwise the drive doesn't contain any plugin before, do further check.
		{
		TBuf<KEComPlugRSCPathMaxLen> pluginsDirPath(KEComResourceFolderPath);
		pluginsDirPath[0] = ('A' + TInt(aDriveUnit));
		TEntry entry;
		if(iFs.Entry(pluginsDirPath,entry) == KErrNone)
			{
			// Now it has plugins folder on it, do ScanDriveL.
			doScan = ETrue;
			}
		// If it still doesn't have plugins folder on it, skip unnecessary scanning.
		// NOTE: other returned error code could be KErrPathNotFound, KErrNotReady etc.
		//  As long as no plugin has been found, always skip scanning on this drive.
		}
	
	// Performs scanning according to above checks.
	if(doScan)
		{
		// Signal the observer that a scan has commenced.
		iDiscovererObserver.DiscoveriesBegin();	
		
		iDirScanner->ScanDriveL(aDriveUnit, iCachedDriveInfo->DriveIsReadOnlyInternalL(aDriveUnit));
		
		// Signal the observer that the scan has 
		// been completed successfully.
		iDiscovererObserver.SetDiscoveryFlagL(aDriveUnit);
		}
	}

void CDiscoverer::ScanDirectoryCancel()
	{
	if(iDirScanner != NULL)
		{
		// Signal the observer that the scan has 
		// been completed un-successfully.
		iDiscovererObserver.DiscoveriesComplete(EFalse, EPluginProcessingTypeAll);
		}
	}


void CDiscoverer::CompleteNotificationProcessing()
	{
	iState = EDisc_AllPluginsDisc;
	iSwiChangeDiscoveryPending = EFalse;
	iLanguageChangeDiscoveryPending = EFalse;
	}


void CDiscoverer::ValidateEntryL(const TEntry& aEntry, const TDriveName& aDriveName, CPluginBase*& aEntryToFill, TBool aIsRO)
   	{
	aEntryToFill=CSecurePlugin::NewL(iFs,aEntry,aDriveName, aIsRO);
  	}

void CDiscoverer::ValidateEntryL(RResourceArchive& aRscArchive,CPluginBase*& aEntryToFill)
   	{
    aEntryToFill = CSpiPlugin::NewL(aRscArchive);
	}
  	

void CDiscoverer::ProcessEntryL(const TDriveName& aDrive,CPluginBase*& aEntry, TBool aAnyDllDiscovered)
	{
	iDiscovererObserver.RegisterDiscoveryL(aDrive,aEntry,aAnyDllDiscovered);
	}
	
void CDiscoverer::DriveMountedL(TDriveUnit aDrive)
	{
	TInt index = iDrivesDiscovered.Find(aDrive);
	if(index == KErrNotFound)
		{
		User::LeaveIfError(iDrivesDiscovered.Append(aDrive));
		iDiscovererObserver.DriveReinstatedL(aDrive);	// Wasn't there before
		}
	}
	
TBool CDiscoverer::IsAnyDllRegisteredWithDriveL(const TDriveUnit aDrive)const
	{
	return 	iDiscovererObserver.IsAnyDllRegisteredWithDriveL(aDrive);
	}

void CDiscoverer::DriveUnmountedL(TDriveUnit aDrive)
	{
	TInt index = iDrivesDiscovered.Find(aDrive);
	if(index != KErrNotFound)
		{
		iDrivesDiscovered.Remove(index);
		iDiscovererObserver.DriveRemovedL(aDrive);		// Was there before
		}
	}
	
CDiscoverer::TDiscovererState CDiscoverer::State() const
	{
	return iState;
	}

	
void CDiscoverer::ProcessSSAEventL(TStartupStateIdentifier aKnownState)
	{

	if(iState == EDisc_NoPluginsDisc && aKnownState == EStartupStateCriticalStatic)
		{
		__ECOM_TRACE("ECOM: CDiscoverer::ProcessSSAEventL():EStartupStateCriticalStatic is reached,discover the RO Internal drives only.");

		// Signal the observer that the scanning is started
		iDiscovererObserver.DiscoveriesBegin();
		
		//scan the RO drives
	    iDirScanner->DiscoverPluginsL(ETrue);

		//change the state
		iState = EDisc_CriticalPluginsDisc;

		// Signal the observer that the scan has 
		// been completed successfully.
		iDiscovererObserver.DiscoveriesComplete(ETrue, EPluginProcessingTypeCriticalOnly);
		}
	else if(iState == EDisc_CriticalPluginsDisc && aKnownState == EStartupStateNonCritical)
		{
		__ECOM_TRACE("ECOM: CDiscoverer::ProcessSSAEventL():EStartupStateNonCritical is reached,discover the Non RO Internal drives.");

		// Signal the observer that the scanning is started
		iDiscovererObserver.DiscoveriesBegin();
		
		//scan the non-ro drives
		iDirScanner->DiscoverPluginsL(EFalse);
	
		//change the state
		iState = EDisc_AllPluginsDisc;
		
		// Signal the observer that the scan has 
		// been completed successfully.
		iDiscovererObserver.DiscoveriesComplete(ETrue, EPluginProcessingTypeNonCriticalOnly);

	
		StartNotifiers();		
		}
	else if(iState == EDisc_NoPluginsDisc && aKnownState == EStartupStateNonCritical)
		{
		__ECOM_TRACE("ECOM: CDiscoverer::ProcessSSAEventL():EStartupStateNonCritical is reached all at once,discover all the drives.");

		// Signal the observer that the scanning is started
		iDiscovererObserver.DiscoveriesBegin();
		
		//scan a specified the drives
		iDirScanner->DiscoverPluginsL(ETrue);
		iDirScanner->DiscoverPluginsL(EFalse);

		//change the state
		iState = EDisc_AllPluginsDisc;
		
		// Signal the observer that the scan has 
		// been completed successfully.
		iDiscovererObserver.DiscoveriesComplete(ETrue, EPluginProcessingTypeAll);

		StartNotifiers();
		}
	}
	
void CDiscoverer::StartNotifiers()
	{
		
	for(TInt i = 0; i<iRscDirNotifierList.Count(); i++)
		{
		if (iRscDirNotifierList[i] != NULL)
		iRscDirNotifierList[i]->Activate();
		}
	iSwiChangeNotifier->Subscribe();
	iLanguageChangeNotifier->Start();
	}
	
void CDiscoverer::ProcessDNEventL(TNotificationFlag aFlag, const TDriveUnit& aDriveUnit)
	{
	if(iState == EDisc_AllPluginsDisc && aFlag == EPluginsModified)
		{
		iState = EDisc_PluginsDirty;
		return;	
		}
	if(iState == EDisc_PluginsDirty && aFlag == EPluginsRediscover)
		{
		// Add drive number to the pending drive list and activate timer.
		iScanningTimer->AddDriveL(aDriveUnit);
		iScanningTimer->RestartScanPeriod();
		}
	}
	
void CDiscoverer::SetSwiChangeCallBack(const TCallBackWithArg& aCallBack)
	{
	iSwiChangeCallBack = aCallBack;
	}

void CDiscoverer::SetBurChangeCallBack(const TCallBackWithArg& aCallBack)
	{
	iBurChangeCallBack = aCallBack;
	}

void CDiscoverer::InitialiseEvent()
	{
	iState = EDisc_NoPluginsDisc;
	}
TInt CDiscoverer::LocaleChangedL(TAny* aPtr)
	{
	CDiscoverer* thisLocaleManager = (CDiscoverer *) aPtr ;
	
	if(!thisLocaleManager->iLanguageChangeNotifier)	
		{
	    __ECOM_TRACE("ECOM: LocaleChangedL: Bad Change Notification");
		return KErrGeneral;
		}

 	TInt stat = thisLocaleManager->iLanguageChangeNotifier->Change();
	if((stat & EChangesLocale) && (!thisLocaleManager->iLanguageChangeDiscoveryPending))
	   	{
	   	//
	   	// System Locale data has been updated 
	   	// if the downgrade path has changed we 
		// re-scan resource files for all drives and get the right language.
		TBool isLanguageChanged;
		thisLocaleManager->iDiscovererObserver.LanguageChangedL(isLanguageChanged);
		if(isLanguageChanged)
			{
			thisLocaleManager->LanguageChangeNotificationL();
			}
	   	}
	 return KErrNone;
	}