// 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);

	}