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

 // Implementation of the registrar class

 // 

 //

 /**

  @internalComponent

  @file 

 */

 #include <barsc2.h> // CResourceFile

 #include <barsread2.h> // RResourceReader

 #include <bautils.h>

 #include <e32uid.h>

 #include <startup.hrh> // for EStartupStateNonCritical

 #include "ecompanics.h"

 #include "EComDebug.h"

 #include <ecom/ecom.h>

 #include <ecom/ecomerrorcodes.h>

 #include <ecom/ecomresolverparams.h>

 #include "TestUtilities.h"	// For __FILE__LINE__

 #include "Registrar.h"

 #include "Discoverer.h"

 #include "BackupNotifier.h"

 #include "RegistryData.h"

 #include "EComUidCodes.h"

 #include "RegistrarObserver.h"

 #include "DriveInfo.h"

 #include "ParseImplementationData.h"

 #include "EComInternalErrorCodes.h"

 const TInt KMinBuffAllocSize = 1;

 #define UNUSED_VAR(a) a = a

 CRegistrar* CRegistrar::NewL(CRegistryData& aRegistry, MRegistrarObserver& aRegistrarObserver, RFs& aFs)

 	{

 	CRegistrar* self = new(ELeave) CRegistrar(aRegistry,aRegistrarObserver,aFs);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 // Default d'tor

 CRegistrar::~CRegistrar()

 	{

 	delete iBackupNotifier;

 	delete iDiscoverer;

 	delete iCachedDriveInfo;

 	}

 // Default c'tor

 CRegistrar::CRegistrar(CRegistryData& aRegistry, MRegistrarObserver& aRegistrarObserver, RFs& aFs)

 : CBase(), iRegistry(aRegistry), iRegistrarObserver(aRegistrarObserver), iFs(aFs), iState(EReg_Undefined)

 	{

 	}

 void CRegistrar::ConstructL()

 	{

 	iCachedDriveInfo = CEComCachedDriveInfo::NewL(iFs);

 	// Instantiate the discoverer

 	iDiscoverer = CDiscoverer::NewL(*this, iFs);

 	InitialiseEvent();

 	}

 TInt CRegistrar::Disable(TUid aImplementationUid)

 	{

 	return iRegistry.SetEnabledState(aImplementationUid, EFalse);

 	}

 TInt CRegistrar::Enable(TUid aImplementationUid)

 	{

 	return iRegistry.SetEnabledState(aImplementationUid, ETrue);

 	}

 TInt CRegistrar::Resume()

 	{

 	return iDiscoverer->Resume();

 	}

 TInt CRegistrar::Suspend()

 	{

 	return iDiscoverer->Suspend();

 	}

 void CRegistrar::DriveRemovedL(TDriveUnit aDrive)

 	{

 	iRegistry.TemporaryUninstallL(aDrive);

 	}

 void CRegistrar::DriveReinstatedL(TDriveUnit aDrive)

 	{

 	iRegistry.UndoTemporaryUninstallL(aDrive);

 	}

 TBool CRegistrar::IsAnyDllRegisteredWithDriveL(const TDriveUnit aDrive)const

 	{

 	return iRegistry.IsAnyDllRegisteredWithDriveL(aDrive);

 	}

 void CRegistrar::RegisterDiscoveryL(const TDriveName& aDrive,CPluginBase*& aDirEntry, TBool aAnyDllDiscovered)

 	{

 	TBool found = EFalse;

 	TBool update = EFalse;

 	TInt  registryDriveIndex = KErrNotFound;

 	// Find the appropriate drive entry

 	TChar driveLetter = User::UpperCase(aDrive[0]) - 'A';

 	TDriveUnit driveUnit = EDriveA + driveLetter;

 	CRegistryData::CDriveData* drive =NULL;

 	// Get the drive data in the registry.

 	registryDriveIndex = iRegistry.FindDriveL(driveUnit, drive);

 	if(registryDriveIndex == KErrNotFound)

 		{

 		User::Leave(KEComErrDriveNotFound);

 		}

 	// Get the registry to return enough data so that the Add and Update routines

 	// can be optimised to avoid rescanning the registry data.

 	// This means that registryDriveIndex MUST remain valid until after

 	// the ParseRegistrationDataL call below.

 	// IsRegisteredWithDate will be called if the this drive is NOT

 	// under its initial discovery. If any Dll is discovered in the drive, then

 	// this drive is NOT in its initial discovery.

 	// In read-only drive with SPI enable, aAnyDllDiscovered will be always false. 

 	// If language downgrade path has been changed, IsRegisteredWithDate will be

 	// called to check whether current localised file need to be updated. 

 	if((aAnyDllDiscovered) || (iRegistry.HasLanguageChanged()))

 		{

 		found = iRegistry.IsRegisteredWithDate(aDirEntry->iDllThirdUid, aDirEntry->iDllModifiedTime, update, drive);

 		}

 	if(!found || update || iRegistry.HasLanguageChanged())

 		{

 		if(found && !update && iRegistry.HasLanguageChanged())

 			{

 			// If we got here because the language has changed

 			// ensure the existing registry data is updated rather than a new entry added

 			update = ETrue;

 			}

 		ParseRegistrationDataL(aDirEntry,driveUnit, update, registryDriveIndex, drive);

 		}

 	}

 void CRegistrar::DiscoveriesBegin()

 	{

 	// We are about to receive registrations so inform the registry that its index

 	// is about to be invalid

 	iRegistry.DiscoveriesBeginning();

 	}

 void CRegistrar::DiscoveriesComplete(TBool aSuccessful, TPluginProcessingTypeIdentifier aProcessingType)

 	{

 	TBool doesRegChanged = EFalse;

 	// Successfully completed, if registry data has been changed, update 

 	TRAPD(error,iRegistry.DiscoveriesCompleteL(aSuccessful, aProcessingType,doesRegChanged));

     UNUSED_VAR(error);

 	// Notify if the registry data has been changed.

 	if(doesRegChanged)

 		{

 	// Notify that we have updated the registry

 		iRegistrarObserver.Notification(KErrNone);

 		}

 	}

 void CRegistrar::SetDiscoveryFlagL(const TDriveUnit& aDriveUnit)

 	{

 	//set the drive flag to indicate it has changes.

 	iRegistry.SetDiscoveryFlagL(aDriveUnit);

 	}

 TBool CRegistrar::NotifiedWithErrorCode(TInt aError)

 	{

 	// Test the safe error codes

 	return (aError == KErrNotReady ||		// Drive removed?

 			aError == KErrPathNotFound);	// Directory deleted?

 	}

 void CRegistrar::ParseRegistrationDataL(CPluginBase*& aEntry,

 										const TDriveUnit& aDrive, 

 										TBool aUpdate, 

 										TInt aRegistryDriveIndex,

 										CRegistryData::CDriveData* aDriveData)

 	{

 	// Ok we intend installing this item so 

 	// create the Interface Implementation Collection entry first

 	CRegistryData::CDllData* dll = CRegistryData::CDllData::NewLC(*(aEntry->iDllName),aEntry->iDllModifiedTime,aEntry->iDllSecondUid,aEntry->iDllThirdUid,aDriveData);

 #ifdef ECOM_TRACE

 	static int counter = 0; counter++;

 	TFileName fullFileName(aDrive.Name());

 	fullFileName.Append(_L("\\sys\\bin\\"));

 	fullFileName.Append(*(aEntry->iDllName));

 	__ECOM_TRACE2("ECOM: Plugin discovered (%04d) %S", counter, &fullFileName);

 #endif

 	// update resource ext info

 	HBufC* resourceExt = aEntry->RscFileExt();

 	if(resourceExt)

 		dll->SetResourceExtL(*resourceExt);

 	// Don't automatically leave during the parse of the implementation

 	// collection's registration data.

 	// If we did then there would be a cascade of leaves which stop the 

 	// entire registration process for all discoveries remaining on the list.

 	// Check to see if there is a problem specifically with the registration data

 	// OR if its a general problem. In the latter case leave.

 	TInt error=KErrNone;

 	TRAP(error, ParseL(aEntry,*dll));

 	if (error==KErrNoMemory)

 		User::LeaveNoMemory();

 	if(error == KErrNone)

 		{

 		if(aUpdate)

 			{	

 			iRegistry.UpdateDllDataL(aDrive, aRegistryDriveIndex, dll);

 			}

 		else

 			{	

 			iRegistry.AddDllDataL(aDrive, aRegistryDriveIndex, dll);

 			}

 		// Remove dll from CleanupStack as ownership has been passed in one of

 		// the two functions above

 		CleanupStack::Pop(dll);

 		}

 	else

 		{

 		// This interface implementation collection 

 		// cannot be registered correctly.

 		CleanupStack::PopAndDestroy(dll);

 		}

 	}

 void CRegistrar::GetResourceFormatVersionL(RResourceReader& aReader, TInt& aResourceFormatVersion)

 	{

 	aResourceFormatVersion = 1;

 	TUid dllUid(KNullUid);

 	TUid uid = {aReader.ReadInt32L()};

 	if(uid==KUidEComResourceFormatV2)

 		{

 		aResourceFormatVersion = 2;

 		dllUid.iUid = aReader.ReadInt32L();

 		}

 	else if(uid==KUidEComResourceFormatV3)

 		{

 		aResourceFormatVersion = 3;

 		dllUid.iUid = aReader.ReadInt32L();

 		}		

 	else

 		dllUid = uid;

 	}

 void CRegistrar::ParseL(CPluginBase*& aEntry,CRegistryData::CDllData& aDll)

 	{

 // Read the resource file starting at offset:0 section size:0

 	CResourceFile* regFile =aEntry->RscFile();

 //	Note : There may be an issue here with resource reading when the 

 //  file is not in the ROM. The solution would be to call

 //	regFile.ConfirmSignatureL(regFile.SignatureL());

 //	However for 6.2 interface implementation collections will ALL

 //	be within the ROM. and future development will move to an

 //	XML parsed solution @ build time.

 //	IF this situation changes, place the fix here.

  	RResourceReader theReader;

  	theReader.OpenLC(regFile, KMinBuffAllocSize);

 	TInt resourceFormatVersion = 0;

 	GetResourceFormatVersionL(theReader,resourceFormatVersion);

 	TDriveUnit drive(aDll.iParent->iDrive);

 	TBool romBased = iCachedDriveInfo->DriveIsReadOnlyInternalL(drive);

 	const TInt numInterfaces = theReader.ReadInt16L();

 	if (resourceFormatVersion == 3 && numInterfaces > KMaxInterfacesInResV3)

 		{

 		User::Leave(KErrNotSupported);

 		}

 	for(TInt iface = 0; iface < numInterfaces; ++iface)

 		{

 		// Read the interface uid

 		const TUid interfaceUid = {theReader.ReadInt32L()};

 		CRegistryData::CInterfaceData* interfaceList = CRegistryData::CInterfaceData::NewLC(interfaceUid,&aDll);

 		aDll.AddL(interfaceList);

 		CleanupStack::Pop(interfaceList);		// Now owned by aDll

 		const TInt numImplementations = theReader.ReadInt16L();

 		if (resourceFormatVersion == 3 && numImplementations > KMaxImplementationsForEachInterfacesInResV3)

 			{

 			User::Leave(KErrNotSupported);

 			}

 		for(TInt index = 0; index < numImplementations; ++index)

 			{

 			TUid implementationUid;

 			TInt versionNo;

 			TInt infoFormat;

 			TBool romOnly;

 			RExtendedInterfacesArray* extendedInterfaces = NULL;

 			HBufC* name = NULL;

 			HBufC8* defaultData = NULL;

 			HBufC8* opaqueData = NULL;

 			CParseImplementationData* parseImplementationData = CParseImplementationData::NewLC(resourceFormatVersion);

 			parseImplementationData->ParseL(theReader,

 											infoFormat,

 											implementationUid,

 											versionNo,

 									   	  	name,

 									      	defaultData,

 									      	opaqueData,

 									      	extendedInterfaces,

 									      	romOnly);

 			CleanupStack::PopAndDestroy(parseImplementationData);									      	

 			CleanupStack::PushL(TCleanupItem(CloseAndDeleteArray, extendedInterfaces));

 			CleanupStack::PushL(name);

 			CleanupStack::PushL(defaultData);

 			CleanupStack::PushL(opaqueData);

 			if (romOnly && !(romBased))

 				{

 				// pop and destroy opaquedata, defaultdata,name and extendedInterfaces

 				CleanupStack::PopAndDestroy(4,extendedInterfaces); 

 				}

 			else

 				{

 				CRegistryData::CImplementationData* implData = CRegistryData::CImplementationData::NewL(interfaceList,

 																										implementationUid, 

 																				 						versionNo, 

 																				 						name, 

 																						 				defaultData,

 																										opaqueData,

 																					 					drive,

 																					 					romOnly,

 																				 						romBased,

 																				 						extendedInterfaces);

 				CleanupStack::Pop(4,extendedInterfaces); // opaqueData,defaultData,name,extendedInterfaces owned by implData

 				CleanupStack::PushL(implData);

 				interfaceList->AddL(implData);	// Now owned by interfaceList	

 				CleanupStack::Pop(implData);

 				}

 			}

 		}

 	CleanupStack::PopAndDestroy(&theReader);		

 	}

 CRegistrar::TRegistrarState CRegistrar::State()const

 	{

 	return iState;

 	}

 void CRegistrar::ProcessSSAEventL(TStartupStateIdentifier aKnownState)

 	{

 	iDiscoverer->ProcessSSAEventL(aKnownState); 

 	if(aKnownState == EStartupStateNonCritical && iState == EReg_StartupInProgess)

 		{

 		__ECOM_TRACE("ECOM: CRegistrar::ProcessSSAEventL(): EStartupStateNonCritical is reached.");

 		iState = EReg_StartupComplete;

 		iBackupNotifier = CBackupNotifier::NewL(*this);

 		}

 	}

 void CRegistrar::InitialiseEvent()

 	{

 	iState = EReg_StartupInProgess;

 	}

 void CRegistrar::LanguageChangedL(TBool& aLanguageChanged)

 	{

 	iRegistry.LanguageChangedL(aLanguageChanged);

 	}

 void CRegistrar::InstallSwiEventCallBack(const TCallBackWithArg& aCallBack)

 	{

 	iDiscoverer->SetSwiChangeCallBack(aCallBack);

 	}

 void CRegistrar::InstallBurEventCallBack(const TCallBackWithArg& aCallBack)

 	{

 	iDiscoverer->SetBurChangeCallBack(aCallBack);

 	}