/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* ScrHelperUtil class provides the list of functionalities needed to store and retrieve the 

* SIS Registry Object in to and from the Software Component Registry respectively.

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#include <e32uid.h>

#include "scrhelperutil.h"

#include "log.h"

#include "scrdbconstants.h"

#include "sisregistryobject.h"

#include "sisregistrytoken.h"

#include "sisregistrypackage.h"

#include "hashcontainer.h"

#include "sisproperties.h"

#include "controllerinfo.h"

#include "sisregistrydependency.h"

#include "sisregistryfiledescription.h"

#include "sisregistryproperty.h"

#include "cleanuputils.h"

#include <usif/usifcommon.h>

#include <swi/sisregistrylog.h>

#include <scs/streamingarray.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "screntries_internal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

using namespace Swi;

// Store the SIS Registry Object details in to the Software Component Registry - SCR.

// The component object should have been fully constructed before calling this method.

void ScrHelperUtil::AddComponentL(Usif::RSoftwareComponentRegistry& aScrSession, Usif::TComponentId& aCompId, CSisRegistryObject& aObject, Usif::TScrComponentOperationType aOpType)

	{	

	WriteToScrL(aScrSession, aCompId, aObject, aOpType);

	////StopTimerAndWriteResultL(timer, _L8(" WriteToScrL "));

	// The default value of isRemovable is true in SCR - we change it only if needed

	if(aObject.iIsRemovable == EFalse)

		{

		aScrSession.SetIsComponentRemovableL(aCompId, aObject.IsRemovable());

		}

	aScrSession.SetVendorNameL(aCompId, *(aObject.iVendorLocalizedName), aObject.Language());

	if(KDefaultInstallType != aObject.InstallType())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompInstallType, aObject.InstallType());	

		}		

	if(KDefaultIsInRom != aObject.InRom())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompInRom, aObject.InRom());

		}		

	if(KDefaultIsDeletablePreInstalled != aObject.DeletablePreInstalled())	

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompDeletablePreinstalled, aObject.DeletablePreInstalled());

		}		

	if(KDefaultIsSigned != aObject.IsSigned())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompIsSigned, aObject.IsSigned());

		}		

	if(KDefaultTrustValue != aObject.Trust())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompTrust, aObject.Trust());

		}		

	if(KDefaultRemoveWithLastDependent != aObject.RemoveWithLastDependent())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompIsRemoveWithLastDependent, aObject.RemoveWithLastDependent());

		}

	aScrSession.SetComponentPropertyL(aCompId, KCompTrustTimeStamp, aObject.TrustTimeStamp().Int64());	

	if(KDefaultIsSignedBySuCert != aObject.IsSignedBySuCert())

		{

		aScrSession.SetComponentPropertyL(aCompId, KCompSignedBySuCert, aObject.IsSignedBySuCert());

		}		

	if(KDefaultIsDrmProtected != aObject.IsDrmProtected())

		{

		aScrSession.SetIsComponentDrmProtectedL(aCompId, aObject.IsDrmProtected());

		}

	if(KDefaultIsComponentHidden != aObject.IsHidden())

		{

		aScrSession.SetIsComponentHiddenL(aCompId, aObject.IsHidden());

		}

	ExternalizeSupplierPackageArrayL(aScrSession, aObject.Uid(), aObject.Name(), aObject.InstallType(), aObject.iDependencies);

	ExternalizeEmbeddedPackageArrayL(aScrSession, aCompId, aObject.iEmbeddedPackages);

	ExternalizePropertiesArrayL(aScrSession, aCompId, aObject.iProperties);

	ExternalizeFileDescriptionsArrayL(aScrSession, aCompId, aObject.FileDescriptions());

	WriteToScrL(aScrSession, aCompId, aObject.TrustStatus());

	ExternalizeChainIndexArrayL(aScrSession, aCompId, aObject.InstallChainIndicies());

	}

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, Usif::TComponentId& aCompId, CSisRegistryObject& aObject, Usif::TScrComponentOperationType aOpType)

	{

	// Add the component name, it's vendor name and the supporting language in to the SCR.

	RPointerArray<Usif::CLocalizableComponentInfo> componentInfo;

	CleanupResetAndDestroyPushL(componentInfo);

	TInt matchingLanguageCount = aObject.GetLocalizedPackageNamesArray().Count();

	Usif::CLocalizableComponentInfo* component;

	if( matchingLanguageCount > 0 )

		{

		for(TInt i=0;i<matchingLanguageCount;i++)

			{

			component = Usif::CLocalizableComponentInfo::NewLC((*(aObject.GetLocalizedPackageNamesArray()[i])), (*(aObject.GetLocalizedVendorNamesArray()[i])), (TLanguage)aObject.GetSupportedLanguageIdsArray()[i]);

			componentInfo.AppendL(component);

			CleanupStack::Pop(component);

			}

		}

	else

		{

		component = Usif::CLocalizableComponentInfo::NewLC(aObject.Name(), aObject.Vendor(), aObject.Language());

		componentInfo.AppendL(component);

		CleanupStack::Pop(component);

		}

	HBufC* compGlobalId = NULL;

	// For all SP and PP type packages, global Id is composed with package Uid and name.

	if (aObject.Index() > 0)

		{

		const TDesC& packageName = aObject.Name();

		compGlobalId = HBufC::NewLC(KCompUidSize + packageName.Size());

		TPtr ptr(compGlobalId->Des());

		ptr.AppendFormat(KPatchGlobalIdFormat, aObject.Uid().iUid, &(aObject.Name()));

		}

	// For all other non-SP and non-PP packages the global Id is simply the package Uid.		

	else

		{

		compGlobalId = HBufC::NewLC(KCompUidSize);

		TPtr ptr(compGlobalId->Des());

		ptr.AppendFormat(KGlobalIdFormat, aObject.Uid().iUid);

		}	

	aCompId = aScrSession.AddComponentL(componentInfo, KNativeSoftwareType, compGlobalId, aOpType);

	CleanupStack::PopAndDestroy(2, &componentInfo);

	// Write the SIS Registry Token details

	WriteToScrL(aScrSession, aCompId, static_cast<CSisRegistryToken&>(aObject));

	}

// Store the SIS Registry Token details in to the SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, Usif::TComponentId& aCompId, CSisRegistryToken& aToken)

	{

	// First write the SIS Registry Package details

	WriteToScrL(aScrSession, aCompId, static_cast<CSisRegistryPackage&>(aToken));

	// Format the version to text and store in the SCR.

	TBuf<KSmlBufferSize> versionString(KEmptyString);	

	VersionToString(aToken.Version(), versionString);

	aScrSession.SetComponentVersionL(aCompId, versionString);

	// iDrives will be automatically populated by SCR

	ExternalizeSidArrayL(aScrSession, aCompId, aToken.Sids());

	ExternalizeControllerArrayL(aScrSession, aCompId, aToken.ControllerInfo());

	if (aToken.Language() != ELangEnglish)

		{

		// ROM stubs are typically set to English so save a few bytes in the database and a DB operation

		// for files installed as English

		aScrSession.SetComponentPropertyL(aCompId, KCompLanguage, static_cast<TInt32>(aToken.Language()));

		}

	if (aToken.SelectedDrive() != 0)

		{

		// ROM stubs are set to drive 0 - this optimisation avoids adding a custom property for these

		aScrSession.SetComponentPropertyL(aCompId, KCompSelectedDrive, static_cast<TInt32>(aToken.SelectedDrive()));

		}

	}

// Store the SIS Registry Package details in to the SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, Usif::TComponentId& aCompId, CSisRegistryPackage& aPackage)

	{

	// Store the Unique Vendor Name as a custom property

	aScrSession.SetComponentPropertyL(aCompId, KCompUniqueVendorName, *(aPackage.iVendorName));

	aScrSession.SetComponentPropertyL(aCompId, KCompUid, static_cast<TInt32>(aPackage.iUid.iUid));

	// The index is the Index of the component being installed. Always it will be 0 for SA type packages and

	// the index will start incrementing for each SP we install on top the base (SA) package.

	if (aPackage.Index() != KDefaultComponentIndex)

		aScrSession.SetComponentPropertyL(aCompId, KCompIndex, aPackage.Index());	

	}

// Store the array of package's SID details in to the SCR.

void ScrHelperUtil::ExternalizeSidArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, const RArray<TUid>& aSids)

	{

	TBuf<KSmlBufferSize> compSid(KEmptyString);

	TInt sidCount = aSids.Count();

	if(KDefaultSidCount != sidCount)

		aScrSession.SetComponentPropertyL(aCompId, KCompSidCount, sidCount);

	if(sidCount > 0)

		aScrSession.SetComponentPropertyL(aCompId, KCompSidsPresent, 1);

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

		{

		compSid.Format(KCompSidFormat, index);

		aScrSession.SetComponentPropertyL(aCompId, compSid, static_cast<TUint>(aSids[index].iUid));

		}

	}

// Store the array of controllers in to the SCR.

void ScrHelperUtil::ExternalizeControllerArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, const RPointerArray<CControllerInfo>& aControllerInfoArray)

	{

	TInt controllerCount = aControllerInfoArray.Count();

	if(KDefaultControllerCount != controllerCount)

		aScrSession.SetComponentPropertyL(aCompId, KCompControllerCount, controllerCount);

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

		{

		WriteToScrL(aScrSession, aCompId, *(aControllerInfoArray[index]), index);

		}

	}

// Store the controller's details in to the SCR.	

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, CControllerInfo& aControllerInfo, TInt aIndex)

	{

	TBuf<KBigBufferSize> propertyName(KEmptyString);

	TBuf<KSmlBufferSize> propertyValue(KEmptyString);	

	propertyName.Format(KVersionNameFormat, aIndex);	

	TVersion controllerVersion = aControllerInfo.Version();

	if (controllerVersion.iMajor != KDefaultVersionMajor || controllerVersion.iMinor != KDefaultVersionMinor || 

		controllerVersion.iBuild != KDefaultVersionBuild)

		{

		VersionToString(controllerVersion, propertyValue);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, propertyValue);

		}

	// Multiple PU controllers on top of an SA will lead the offset values to be incremented by one for	each PU.	

	if (aControllerInfo.iOffset != 0)

		{

		// Most applications are SA's that have not been upgraded so use a default value of 0

		propertyName.Format(KOffsetNameFormat, aIndex);	

		aScrSession.SetComponentPropertyL(aCompId, propertyName, aControllerInfo.iOffset);

		}

	WriteToScrL(aScrSession, aCompId, *(aControllerInfo.iHashContainer), aIndex);	

	}

 // Store the controller's hash details in to the SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, CHashContainer& aHashContainer, TInt aIndex)

	{

	TBuf<KBigBufferSize> propertyName(KEmptyString);

	propertyName.Format(KHashAlgorithmNameFormat, aIndex);

	if (aHashContainer.Algorithm() != CMessageDigest::ESHA1)

		aScrSession.SetComponentPropertyL(aCompId, propertyName, static_cast<TInt32>(aHashContainer.Algorithm()));

	propertyName.Format(KHashDataNameFormat, aIndex);

	aScrSession.SetComponentPropertyL(aCompId, propertyName, aHashContainer.Data());

	}

// Store the array of supplier package dependency details in to the SCR.

// Supplier packages are the packages on which the current package is depending on.

void ScrHelperUtil::ExternalizeSupplierPackageArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const TUid& aCompUid, const TDesC& aCompName, Sis::TInstallType aInstallType, RPointerArray<CSisRegistryDependency>& aDependentPackageArray)

	{

	for (TInt index = 0; index < aDependentPackageArray.Count(); ++index)

		{

		WriteToScrL(aScrSession, aCompUid, aCompName, aInstallType, *(aDependentPackageArray[index]));			

		}

	}

// Store the details of one of the dependency package of given component in to SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const TUid& aCompUid, const TDesC& aCompName, Sis::TInstallType aInstallType, CSisRegistryDependency& aRegistryDependency)

	{	

	TBuf <KCompUidSize> supplierGlobalIdString;

	TBuf<KSmlBufferSize> fromVersionString(KEmptyString);

	TBuf<KSmlBufferSize> toVersionString(KEmptyString);

	// Get the dependent details.	

	HBufC* dependentGlobalIdString = FormatGlobalIdLC(aCompUid, aCompName, aInstallType);

	// Get the supplier details.

	supplierGlobalIdString.AppendFormat(KGlobalIdFormat, aRegistryDependency.iUid.iUid);

	VersionToString(aRegistryDependency.iFromVersion, fromVersionString);

	VersionToString(aRegistryDependency.iToVersion, toVersionString);

	// Create the component global id for both dependent and supplier.

	Usif::CGlobalComponentId* supplierGlobalId = Usif::CGlobalComponentId::NewLC(supplierGlobalIdString, Usif::KSoftwareTypeNative);

	Usif::CGlobalComponentId* dependentGlobalId = Usif::CGlobalComponentId::NewLC(*dependentGlobalIdString, Usif::KSoftwareTypeNative);

	// Create the versioned component Id for supplier.

	Usif::CVersionedComponentId* supplierVersionedCompId = Usif::CVersionedComponentId::NewLC(*supplierGlobalId, &fromVersionString, &toVersionString);

	// Add the dependency details in to SCR.

	TRAPD(err, aScrSession.AddComponentDependencyL(*supplierVersionedCompId, *dependentGlobalId));

	// Since SWI allows multiple equal dependencies, we ignore KErrAlreadyExists

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	CleanupStack::PopAndDestroy(4, dependentGlobalIdString);

	}

// Store details of the array of embedded packages of the given component in to SCR.

void ScrHelperUtil::ExternalizeEmbeddedPackageArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, RPointerArray<CSisRegistryPackage>& aEmbeddedPackageArray)

	{

	TInt embeddedPackageCount = aEmbeddedPackageArray.Count();

	if(KDefaultEmbeddedPackageCount != embeddedPackageCount)

		aScrSession.SetComponentPropertyL(aCompId, KCompEmbeddedPackageCount, embeddedPackageCount);

	if(embeddedPackageCount > 0)

		aScrSession.SetComponentPropertyL(aCompId, KCompEmbeddedPackagePresent, 1);

	TBuf<KBigBufferSize> propertyName(KEmptyString);	

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

		{

		CSisRegistryPackage* package = aEmbeddedPackageArray[index];

		// Store the package details

		propertyName.Format(KCompEmbeddedPackageUid, index);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, package->Uid().iUid);

		propertyName.Format(KCompEmbeddedPackageName, index);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, package->Name());

		propertyName.Format(KCompEmbeddedPackageVendor, index);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, package->Vendor());

		propertyName.Format(KCompEmbeddedPackageIndex, index);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, package->Index());

		}

	}

// Store the details of one of the embedded package of the given component in to SCR.

void ScrHelperUtil::ExternalizePropertiesArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, RPointerArray<CSisRegistryProperty>& aRegistryPropertyArray)

	{

	TInt compPropertyCount = aRegistryPropertyArray.Count();

	if(KDefaultCompPropertyCount != compPropertyCount)

		aScrSession.SetComponentPropertyL(aCompId, KCompPropertyCount, compPropertyCount);

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

		{

		WriteToScrL(aScrSession, aCompId, *(aRegistryPropertyArray[index]), index);		

		}		

	}

// Store the SIS Registry property in to SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, CSisRegistryProperty& aRegistryProperty, TInt aIndex)

	{

	TBuf<KBigBufferSize> propertyName(KEmptyString);

	propertyName.Format(KCompPropertyKey, aIndex);

	aScrSession.SetComponentPropertyL(aCompId, propertyName, aRegistryProperty.iKey);

	propertyName.Format(KCompPropertyValue, aIndex);

	aScrSession.SetComponentPropertyL(aCompId, propertyName, aRegistryProperty.iValue);	

	}

TInt CompareDescriptors(const TPtrC &aLhs, const TPtrC& aRhs)

	{

	return aLhs.CompareF(aRhs);

	}	

// Store the array of owned file's details in to the SCR.

// Wild carded files are stored as part of component custom property group. Where as the normal files are stored 

// as part of files property group. The wild carded files are used only in stub files and they are used only during

// checking for eclipse validation during ROM upgrade. The wild carded files won't give file ownership information.

void ScrHelperUtil::ExternalizeFileDescriptionsArrayL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, RPointerArray<CSisRegistryFileDescription>& aFileDescriptionArray)

	{

	// As SCR won't support the wildcard characters on file names, if the file name has wildcard characters, 

	// dont' store them as part file properties. Rather, store them as component custom properties only.

	TInt wildCardFileCount = 0;

	TInt executableFileIndex = 0;

	TInt64 componentSize = 0;

	// Since SCR does not check for duplicate entries, and they may occur in SWI, we filter them here

	// The file names are stored in a temporary array and compared with while iterating over file descriptions. Duplicates are skipped

	// Cannot use CDesC16ArrayFlat as it is in BAFL which the TCB sisregistryserver cannot link to

	RArray<TPtrC> filenamesArray;

	CleanupClosePushL(filenamesArray);

	TInt fileDescriptionsCount = aFileDescriptionArray.Count();

	TLinearOrder<TPtrC> descriptorsComparator(&CompareDescriptors);

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

		{

		const TDesC& fileTarget = aFileDescriptionArray[index]->Target();

		TPtrC fileTargetPtr(fileTarget);

		if (filenamesArray.SpecificFindInOrder(fileTargetPtr, descriptorsComparator, EArrayFindMode_First) != KErrNotFound)

			continue; // Skip duplicates

		if (IsWildcardFile(fileTarget))

			{

			// Calls the method with ETrue if it's wild carded file.

			WriteToScrL(aScrSession, aCompId, *(aFileDescriptionArray[index]), ETrue, wildCardFileCount, -1);

			++wildCardFileCount;

			}

		else

			{

			// If the file's SID value is not zero (only for EXEs)

			if (aFileDescriptionArray[index]->Sid().iUid != 0)

				{

				WriteToScrL(aScrSession, aCompId, *(aFileDescriptionArray[index]), EFalse, -1, executableFileIndex);

				++executableFileIndex;

				}

			else

				{

				WriteToScrL(aScrSession, aCompId, *(aFileDescriptionArray[index]), EFalse, -1, -1);

				}			

			// Get the each file size and accumulate it to get the whole component size.

			componentSize += aFileDescriptionArray[index]->UncompressedLength();

			}

		}

	if (KDefaultWildCardFileCount != wildCardFileCount)

		aScrSession.SetComponentPropertyL(aCompId, KCompWildCardFileCount, wildCardFileCount);

	if (0 != componentSize) // For ROM components, the typical size is 0 which is also the default value at the SCR

		aScrSession.SetComponentSizeL(aCompId, componentSize);

	CleanupStack::PopAndDestroy(&filenamesArray);

	}

// Store the owned files details in to the SCR.

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, CSisRegistryFileDescription& aFileDescription, 

								TBool aIsWildcardedFile, TInt aIndex, TInt aExecutableFileIndex)

	{	

	if (aIsWildcardedFile)

		{

		// SCR doesn't support the wildcard cahracters in file names.

		// So, store the object as a component custom property.

		TBuf<KBigBufferSize> propertyName(KEmptyString);

		propertyName.Format(KCompWildCardFile, aIndex);

		// For wild-carded files, all properties apart from the target are meaningless

		aScrSession.SetComponentPropertyL(aCompId, propertyName, aFileDescription.Target());				

		return;

		}

	// For normal file, store it using regular SCR file management APIs

	// Store the file name as component property to get the FileName related to a specific SID easily.

	// CSisRegistryPackage::iSids & CSisRegistryObject::iFileDescriptions are to be in sync. Otherwise, this mapping will fail.

	if (aExecutableFileIndex != -1) // Value will be -1 for non executables.

		{

		TBuf<KBigBufferSize> propertyName(KEmptyString);

		propertyName.Format(KCompSidFileNameFormat, aExecutableFileIndex);

		aScrSession.SetComponentPropertyL(aCompId, propertyName, aFileDescription.Target());		

		}

	TBool considerFileInDriveList = (aFileDescription.Operation() != Swi::Sis::EOpNull);

	// For OpNull, we shouldn't update the drive list, as the file does not actually exist, it is only registered for uninstall

	aScrSession.RegisterComponentFileL(aCompId, aFileDescription.Target(), considerFileInDriveList);

	if (aFileDescription.MimeType().Size() > 0)

		{

		RBuf8 mimeType8;

		mimeType8.CreateL(aFileDescription.MimeType().Size());

		CleanupClosePushL(mimeType8);

		mimeType8.Copy(aFileDescription.MimeType());

		aScrSession.SetFilePropertyL(aCompId, aFileDescription.Target(), KFileMimeType, mimeType8);

		CleanupStack::PopAndDestroy(&mimeType8);

		}

	if (aFileDescription.Operation() != Swi::Sis::EOpInstall)

		{

		aScrSession.SetFilePropertyL(aCompId, aFileDescription.Target(), KFileSisFileOperation, aFileDescription.Operation());

		}

	if (aFileDescription.OperationOptions())

		{

		aScrSession.SetFilePropertyL(aCompId, aFileDescription.Target(), KFileFileOperationOptions, aFileDescription.OperationOptions());

		}

	if (aFileDescription.Sid().iUid)

		{

		aScrSession.SetFilePropertyL(aCompId, aFileDescription.Target(), KFileSid, aFileDescription.Sid().iUid);		

		}

	WriteToScrL(aScrSession, aCompId, aFileDescription.Hash(), aFileDescription.Target());		

	}

void ScrHelperUtil::WriteToScrL(Usif::RSoftwareComponentRegistry& aScrSession, const Usif::TComponentId aCompId, const CHashContainer& aHashContainer, const TDesC& aFileName)

	{	

	if (aHashContainer.Algorithm() != CMessageDigest::ESHA1)

		{

		aScrSession.SetFilePropertyL(aCompId, aFileName, KFileHashAlgorithm, static_cast<TInt32>(aHashContainer.Algorithm()));

		}

	if (aHashContainer.Data().Length() > 0)

		{

		aScrSession.SetFilePropertyL(aCompId, aFileName, KFileHashData, aHashContainer.Data());