diff -r 5cc91383ab1e -r 7333d7932ef7 installationservices/swcomponentregistry/source/client/scrclient.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swcomponentregistry/source/client/scrclient.cpp	Tue Aug 31 15:21:33 2010 +0300
@@ -0,0 +1,728 @@
+/*
+* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
+* 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: 
+* RSoftwareComponentRegistry implementation. See class and function 
+* declarations for more detail.
+*
+*/
+
+
+#include "scr.h"
+#include "scrclient.inl"
+#include "scrcommon.h"
+#include "usiflog.h"
+#include "scr_internal.h"
+#include <e32cmn.h>
+#include <scs/streamingarray.h>
+#include <scs/scscommon.h>
+#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+#include "screntries_internal.h"
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+
+using namespace Usif;
+
+TInt RSoftwareComponentRegistry::SendSyncMessage(TInt aFunction, const TIpcArgs& aArgs) const
+	{
+	return CallSessionFunction(aFunction, aArgs);
+	}
+
+EXPORT_C RSoftwareComponentRegistry::RSoftwareComponentRegistry()
+	:	RScsClientBase()
+	{
+	// empty
+	}
+
+EXPORT_C TInt RSoftwareComponentRegistry::Connect()
+	{
+	DEBUG_PRINTF2(_L("Connecting to %S."), &KSoftwareComponentRegistryName);
+	TVersion version = ScrServerVersion();
+	TUidType scrFullUid = ScrServerImageFullUid();
+	
+	return RScsClientBase::Connect(KSoftwareComponentRegistryName(), version, KScrServerImageName(), scrFullUid);
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::Close()
+	{
+	DEBUG_PRINTF2(_L("Closing connection to %S."), &KSoftwareComponentRegistryName);
+	RScsClientBase::Close();
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::CreateTransactionL()
+	{
+	DEBUG_PRINTF(_L("Sending Create Transaction request."));
+	User::LeaveIfError(CallSessionFunction(ECreateTransaction));
+	}
+		
+EXPORT_C void RSoftwareComponentRegistry::RollbackTransactionL()
+	{
+	DEBUG_PRINTF(_L("Sending Rollback Transaction request."));
+	User::LeaveIfError(CallSessionFunction(ERollbackTransaction));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::CommitTransactionL()
+	{
+	DEBUG_PRINTF(_L("Sending Commit Transaction request."));
+	User::LeaveIfError(CallSessionFunction(ECommitTransaction));
+	}
+
+
+EXPORT_C TComponentId RSoftwareComponentRegistry::AddComponentL(const TDesC& aName, const TDesC& aVendor, const TDesC& aUniqueSwTypeName, const TDesC* aGlobalId, TScrComponentOperationType aCompOpType)
+	{
+	DEBUG_PRINTF3(_L("Sending add a new component ('%S','%S') request."), &aName, &aVendor);
+
+	CLocalizableComponentInfo *cmpInfo = CLocalizableComponentInfo::NewLC(aName, aVendor, KNonLocalized);
+	RPointerArray<CLocalizableComponentInfo> cmpInfoList;
+	cmpInfoList.AppendL(cmpInfo);
+	CleanupStack::Pop(cmpInfo);
+	CleanupResetAndDestroyPushL(cmpInfoList);
+	TComponentId compId = AddComponentL(cmpInfoList, aUniqueSwTypeName, aGlobalId, aCompOpType);
+	CleanupStack::PopAndDestroy(&cmpInfoList);
+	return compId;
+	}
+
+EXPORT_C TComponentId RSoftwareComponentRegistry::AddComponentL(const RPointerArray<CLocalizableComponentInfo>& aComponentInfo, const TDesC& aUniqueSwTypeName, const TDesC* aGlobalId, TScrComponentOperationType aCompOpType)
+	{
+	if(!aComponentInfo.Count())
+		{
+		DEBUG_PRINTF(_L("The localizables component info array is empty!."));
+		User::Leave(KErrArgument);
+		}
+	DEBUG_PRINTF(_L("Sending add a new component request with a set of localizable names."));
+	
+	TComponentId compId = static_cast<TComponentId>(aCompOpType);
+	// compId variable carries the component operation type to the SCR server.
+	// On return, it will contain the actual component Id value.
+	TPckg<TComponentId> compIdPckg(compId);
+	HBufC8* arrayBuf = ExternalizePointersArrayLC(aComponentInfo);
+	const TDesC *globalId = aGlobalId ? aGlobalId : &KNullDesC();
+	TIpcArgs args(&aUniqueSwTypeName, arrayBuf, globalId, &compIdPckg);
+	User::LeaveIfError(CallSessionFunction(EAddComponent, args));
+	CleanupStack::PopAndDestroy(arrayBuf);
+	return compId;
+	}
+
+template <class C>
+void RSoftwareComponentRegistry::SendDependencyArgsL(TInt aFunction, const C& aSupplierId, const CGlobalComponentId& aDependantGlobalCompId)
+	{
+	RBuf8 suppVerCompId;
+	suppVerCompId.CleanupClosePushL();
+	ExternalizeObjectL(&aSupplierId, suppVerCompId);
+		
+	RBuf8 depGlobalId;
+	depGlobalId.CleanupClosePushL();
+	ExternalizeObjectL(&aDependantGlobalCompId, depGlobalId);
+	// Send the software type of the dependant component seperately in order to apply custom security check properly on the server side.
+	TIpcArgs args(&aDependantGlobalCompId.SoftwareTypeName(),&suppVerCompId, &depGlobalId);
+	User::LeaveIfError(CallSessionFunction(aFunction, args));
+	CleanupStack::PopAndDestroy(2, &suppVerCompId); // suppVerCompId, depGlobalId
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::AddComponentDependencyL(const CVersionedComponentId& aSupplierVerCompId, const CGlobalComponentId& aDependantGlobalCompId)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to add a new dependency between two components (%S depends on %S)."), &aDependantGlobalCompId.GlobalIdName(), &aSupplierVerCompId.GlobalId().GlobalIdName());
+	SendDependencyArgsL(EAddComponentDependency, aSupplierVerCompId, aDependantGlobalCompId);
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentPropertyL(TComponentId aComponentId, const TDesC& aName, const TDesC8& aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the binary property(%S) of the component(%d)."), &aName, aComponentId);
+	TIpcArgs args(aComponentId, &aName, &aValue);
+	User::LeaveIfError(CallSessionFunction(ESetComponentBinaryProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentPropertyL(TComponentId aComponentId, const TDesC& aName, const TDesC& aValue, TLanguage aLocale)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to set the string property(%S,%S) of the component(%d)."), &aName, &aValue, aComponentId);
+	TIpcArgs args(aComponentId, &aName, &aValue, aLocale);
+	User::LeaveIfError(CallSessionFunction(ESetComponentLocalizableProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentPropertyL(TComponentId aComponentId, const TDesC& aName, TInt64 aValue)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to set the numeric property(%S,%Ld) of the component(%d)."), &aName, aValue, aComponentId);
+	TIpcArgs args(aComponentId, &aName, I64HIGH(aValue), I64LOW(aValue));
+	User::LeaveIfError(CallSessionFunction(ESetComponentNumericProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::RegisterComponentFileL(TComponentId aComponentId, const TDesC& aFileName, TBool aConsiderForInstalledDrives /*= ETrue*/ )
+	{
+	DEBUG_PRINTF4(_L("Sending a request to register the file(%S) for the component(%d). ConsiderFilesInDriveList:%d"), &aFileName, aComponentId, aConsiderForInstalledDrives);
+	TIpcArgs args(aComponentId, &aFileName, aConsiderForInstalledDrives);
+	User::LeaveIfError(CallSessionFunction(ERegisterComponentFile, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetFilePropertyL(TComponentId aComponentId, const TDesC& aFileName, const TDesC& aPropName, const TDesC8& aPropValue)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to set the string property(%S) of the file(%S) of the component(%d)."), &aPropName, &aFileName, aComponentId);
+	TIpcArgs args(aComponentId, &aFileName, &aPropName, &aPropValue);
+	User::LeaveIfError(CallSessionFunction(ESetFileStringProperty, args));
+	}
+EXPORT_C void RSoftwareComponentRegistry::SetFilePropertyL(TComponentId aComponentId, const TDesC& aFileName, const TDesC& aPropName, TInt aPropValue)
+	{
+	DEBUG_PRINTF5(_L("Sending a request to set the numeric property(%S,%d) of the file(%S) of the component(%d)."), &aPropName, aPropValue, &aFileName, aComponentId);
+	TIpcArgs args(aComponentId, &aFileName, &aPropName, aPropValue);
+	User::LeaveIfError(CallSessionFunction(ESetFileNumericProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentNameL(TComponentId aComponentId, const TDesC& aName, TLanguage aLocale)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to update the name(%S,%d) of the component(%d)."), &aName, aLocale, aComponentId);
+	TIpcArgs args(aComponentId, &aName, aLocale);
+	User::LeaveIfError(CallSessionFunction(ESetComponentName, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetVendorNameL(TComponentId aComponentId, const TDesC& aVendor, TLanguage aLocale)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to update the vendor(%S,%d) of the component(%d)."), &aVendor, aLocale, aComponentId);
+	TIpcArgs args(aComponentId, &aVendor, aLocale);
+	User::LeaveIfError(CallSessionFunction(ESetComponentVendor, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentVersionL(TComponentId aComponentId, const TDesC& aVersion)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the version(%S) of the component(%d)."), &aVersion, aComponentId);
+	TIpcArgs args(aComponentId, &aVersion);
+	User::LeaveIfError(CallSessionFunction(ESetComponentVersion, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentRemovableL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the removable attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentRemovable, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentDrmProtectedL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the DRM protected attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentDrmProtected, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentHiddenL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the hidden attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentHidden, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentKnownRevokedL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the known-revoked attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentKnownRevoked, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentOriginVerifiedL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the origin-verified attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentOriginVerified, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetComponentSizeL(TComponentId aComponentId, TInt64 aComponentSizeInBytes)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the install-time size (%Ld) of the component(%d)."), aComponentSizeInBytes, aComponentId);
+	TIpcArgs args(aComponentId, I64HIGH(aComponentSizeInBytes), I64LOW(aComponentSizeInBytes));
+	User::LeaveIfError(CallSessionFunction(ESetComponentSize, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteComponentPropertyL(TComponentId aComponentId, const TDesC& aPropName)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to delete the property(%S) of the component(%d)."), &aPropName, aComponentId);
+	TIpcArgs args(aComponentId, &aPropName);
+	User::LeaveIfError(CallSessionFunction(EDeleteComponentProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteFilePropertyL(TComponentId aComponentId, const TDesC& aFileName, const TDesC& aPropName)
+	{
+	DEBUG_PRINTF4(_L("Sending a request to delete the property(%S) of the file(%S) of the component(%d)."), &aPropName, &aFileName, aComponentId);
+	TIpcArgs args(aComponentId, &aFileName, &aPropName);
+	User::LeaveIfError(CallSessionFunction(EDeleteFileProperty, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::UnregisterComponentFileL(TComponentId aComponentId, const TDesC& aFileName)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to deregister the file(%S) for the component(%d)."), &aFileName, aComponentId);
+	TIpcArgs args(aComponentId, &aFileName);
+	User::LeaveIfError(CallSessionFunction(EUnregisterComponentFile, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteComponentL(TComponentId aComponentId)
+	{
+	DEBUG_PRINTF2(_L("Sending a request to delete the component(%d)."), aComponentId);
+	TIpcArgs args(aComponentId);
+	User::LeaveIfError(CallSessionFunction(EDeleteComponent, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteComponentDependencyL(const CGlobalComponentId& aSupplierGlobalCompId, const CGlobalComponentId& aDependantGlobalCompId)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to delete an existing dependency between two components (%S depends on %S)."), &aDependantGlobalCompId.GlobalIdName(), &aSupplierGlobalCompId.GlobalIdName());
+	SendDependencyArgsL(EDeleteComponentDependency, aSupplierGlobalCompId, aDependantGlobalCompId);
+	}
+
+EXPORT_C TBool RSoftwareComponentRegistry::GetComponentL(TComponentId aComponentId, CComponentEntry& aEntry, TLanguage aLocale) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the entry of the component(%d)."), aComponentId);
+	TIpcArgs args(aComponentId, aLocale);
+	TInt argNum = 2; // size descriptor will be added to this slot
+	return GetObjectL(*this, aEntry, EGetSingleComponentSize, EGetSingleComponentData, argNum, args);
+	}
+	
+EXPORT_C void RSoftwareComponentRegistry::GetComponentLocalizedInfoL(TComponentId aComponentId, RPointerArray<CLocalizableComponentInfo>& aCompLocalizedInfoArray) const
+    {
+    DEBUG_PRINTF2(_L("Sending a request to retrieve the localized entry of the component(%d)."), aComponentId);
+    TIpcArgs args(aComponentId);
+    TInt argNum = 1; // size descriptor will be added to this slot
+    GetObjectArrayL(*this, EGetLocalizedComponentSize, EGetLocalizedComponentData, argNum, args, aCompLocalizedInfoArray);
+    }
+
+EXPORT_C void RSoftwareComponentRegistry::GetComponentIdsL(RArray<TComponentId>& aComponentIdList, CComponentFilter* aFilter) const
+	{
+	RBuf8 buf;
+	buf.CleanupClosePushL();
+	ExternalizeObjectL(aFilter, buf);
+	
+	TIpcArgs args(&buf);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EGetComponentIdListSize, EGetComponentIdListData, argNum, args, aComponentIdList);
+	CleanupStack::PopAndDestroy(&buf);
+	}
+
+EXPORT_C TComponentId RSoftwareComponentRegistry::GetComponentIdL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName) const
+	{
+	DEBUG_PRINTF3(_L("Sending a request to retrieve the local component Id of a global component id (%S,%S)."), &aGlobalIdName, &aUniqueSwTypeName);
+	
+	TComponentId compId;
+	TPckg<TComponentId> compIdPckg(compId);
+		
+	TIpcArgs args(&aGlobalIdName, &aUniqueSwTypeName, &compIdPckg);
+	User::LeaveIfError(CallSessionFunction(EGetLocalComponentId, args));
+	
+	return compId;
+	}
+
+EXPORT_C CComponentEntry* RSoftwareComponentRegistry::GetComponentL(const TDesC& aGlobalIdName, const TDesC& aUniqueSwTypeName, TLanguage aLocale) const
+	{
+	DEBUG_PRINTF3(_L("Sending a request with the global id(%S,%S) to retrieve the entry of the component."), &aGlobalIdName, &aUniqueSwTypeName);
+
+	TIpcArgs args(&aGlobalIdName, &aUniqueSwTypeName, aLocale);
+	TInt argNum = 3; // size descriptor will be added to this slot
+	return GetObjectL<CComponentEntry>(*this, EGetComponentWithGlobalIdSize, EGetComponentWithGlobalIdData, argNum, args);	
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetSupplierComponentsL(const CGlobalComponentId& aDependantGlobalId, RPointerArray<CVersionedComponentId>& aSupplierList) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the supplier list of a dependant component (%S)."), &aDependantGlobalId.GlobalIdName());
+	
+	RBuf8 depGlobalId;
+	depGlobalId.CleanupClosePushL();
+	ExternalizeObjectL(&aDependantGlobalId, depGlobalId);
+	
+	TIpcArgs args(&depGlobalId);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EGetSupplierComponentsSize, EGetSupplierComponentsData, argNum, args, aSupplierList);
+	CleanupStack::PopAndDestroy(&depGlobalId);
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetDependantComponentsL(const CGlobalComponentId& aSupplierGlobalId, RPointerArray<CVersionedComponentId>& aDependantList) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the dependant list of a supplier component (%S)."), &aSupplierGlobalId.GlobalIdName());
+	
+	RBuf8 supGlobalId;
+	supGlobalId.CleanupClosePushL();
+	ExternalizeObjectL(&aSupplierGlobalId, supGlobalId);
+	
+	TIpcArgs args(&supGlobalId);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EGetDependantComponentsSize, EGetDependantComponentsData, argNum, args, aDependantList);
+	CleanupStack::PopAndDestroy(&supGlobalId);
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetFilePropertiesL(TComponentId aComponentId, const TDesC& aFileName, RPointerArray<CPropertyEntry>& aProperties) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the properties of the file(%S)."), &aFileName);
+	TIpcArgs args(aComponentId, &aFileName);
+	TInt argNum = 2;
+	GetObjectArrayL(*this, EGetFilePropertiesSize, EGetFilePropertiesData, argNum, args, aProperties);
+	}
+
+EXPORT_C CPropertyEntry* RSoftwareComponentRegistry::GetFilePropertyL(TComponentId aComponentId, const TDesC& aFileName, const TDesC& aPropertyName) const
+	{
+	DEBUG_PRINTF3(_L("Sending a request to retrieve the property(%S) of the file(%S)."), &aPropertyName, &aFileName);
+	TIpcArgs args(aComponentId, &aFileName, &aPropertyName);
+	TInt argNum = 3;
+	return GetObjectL<CPropertyEntry>(*this, EGetSingleFilePropertySize, EGetSingleFilePropertyData, argNum, args);
+	}
+
+EXPORT_C TUint RSoftwareComponentRegistry::GetComponentFilesCountL(TComponentId aComponentId) const
+	{
+	TUint registeredFilesNum;
+	TPckg<TUint> resPckg(registeredFilesNum);
+	TIpcArgs args(aComponentId, &resPckg);
+	User::LeaveIfError(CallSessionFunction(EGetComponentFilesCount, args));
+	return registeredFilesNum;	
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetComponentsL(const TDesC& aFileName, RArray<TComponentId>& aComponents) const
+	{
+	TIpcArgs args(&aFileName);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EGetFileComponentsSize, EGetFileComponentsData, argNum, args, aComponents);
+	}
+
+EXPORT_C CPropertyEntry* RSoftwareComponentRegistry::GetComponentPropertyL(TComponentId aComponentId, const TDesC& aPropertyName, TLanguage aLocale) const
+	{
+	TIpcArgs args(aComponentId, &aPropertyName, aLocale);
+	TInt argNum = 3;
+	return GetObjectL<CPropertyEntry>(*this, EGetComponentSinglePropertySize, EGetComponentSinglePropertyData, argNum, args);
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetComponentPropertiesL(TComponentId aComponentId, RPointerArray<CPropertyEntry>& aProperties, TLanguage aLocale) const
+	{
+	TIpcArgs args(aComponentId, aLocale);
+	TInt argNum = 2;
+	GetObjectArrayL(*this, EGetComponentPropertiesSize, EGetComponentPropertiesData, argNum, args, aProperties);
+	}
+
+EXPORT_C TBool RSoftwareComponentRegistry::IsMediaPresentL(TComponentId aComponentId) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the media presence status of component (%d)."), aComponentId);
+	TBool result;
+	TPckg<TBool> isMediaPresent(result);
+	User::LeaveIfError(CallSessionFunction(EGetIsMediaPresent, TIpcArgs(aComponentId, &isMediaPresent)));	
+
+	DEBUG_PRINTF3(_L("Received media presence status of component (%d) - result is %d."), aComponentId, result);
+	return result;
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetScomoStateL(TComponentId aComponentId, TScomoState aScomoState) const
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the scomo state (%d) of component(%d) at install time."), aScomoState, aComponentId);
+	TIpcArgs args(aComponentId, aScomoState);
+	User::LeaveIfError(CallSessionFunction(ESetScomoState, args));
+	}
+
+EXPORT_C TUid RSoftwareComponentRegistry::GetPluginUidL(const TDesC& aMimeType) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the list of plugins for mime types %S."), &aMimeType);
+	TUint32 uidNum(0);
+	TPckg<TUint32> uidDes(uidNum);
+	TIpcArgs args(&aMimeType, &uidDes);
+	User::LeaveIfError(CallSessionFunction(EGetPluginUidWithMimeType, args));
+	TUid pluginUid = TUid::Uid(uidNum);
+	return pluginUid;
+	}
+
+EXPORT_C TUid RSoftwareComponentRegistry::GetPluginUidL(TComponentId aComponentId) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to retrieve the list of plugins for the component(%d)."), aComponentId);
+	TUint32 uidNum(0);
+	TPckg<TUint32> uidDes(uidNum);
+	TIpcArgs args(aComponentId, &uidDes);
+	User::LeaveIfError(CallSessionFunction(EGetPluginUidWithComponentId, args));
+	TUid pluginUid = TUid::Uid(uidNum);
+	return pluginUid;
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::AddSoftwareTypeL(const CSoftwareTypeRegInfo& aSwTypeRegInfo)
+	{
+	if(!aSwTypeRegInfo.MimeTypes().Count())
+	    {
+	    DEBUG_PRINTF(_L("MIME types list cannot be empty!"));
+	    User::Leave(KErrArgument);
+	    }
+	
+	RBuf8 buf;
+	buf.CleanupClosePushL();
+	ExternalizeRefObjectL(aSwTypeRegInfo, buf);
+	      
+	TIpcArgs swTypeArgs(&buf);
+	User::LeaveIfError(CallSessionFunction(EAddSoftwareType, swTypeArgs));
+ 
+	CleanupStack::PopAndDestroy();//buf, reginfo
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteSoftwareTypeL(const TDesC& aUniqueSwTypeName, RPointerArray<HBufC>& aDeletedMimeTypes)
+	{
+	DEBUG_PRINTF2(_L("Sending a request to delete the software type (%S)."), &aUniqueSwTypeName);
+	TIpcArgs args(&aUniqueSwTypeName);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EDeleteSoftwareType, EGetDeletedMimeTypes, argNum, args, aDeletedMimeTypes);
+	// Please note that EDeleteSoftwareType IPC function returns the size of the deleted MIME types list.
+	}
+
+EXPORT_C TBool RSoftwareComponentRegistry::IsComponentOrphanedL(TComponentId aComponentId)
+	{
+	DEBUG_PRINTF2(_L("Sending a request to get whether the component (%d) is orphaned."), aComponentId);
+	TBool result;
+	TPckg<TBool> isComponentOrphaned(result);
+	User::LeaveIfError(CallSessionFunction(EGetIsComponentOrphaned, TIpcArgs(aComponentId, &isComponentOrphaned)));	
+	return result;
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::RetrieveLogEntriesL(RPointerArray<CScrLogEntry>& aLogEntries, const TDesC* aUniqueSwTypeName) const
+	{
+	DEBUG_PRINTF(_L("Sending a request to retrieve log entries."));
+	// Retrieve the RFs and RFile handles from the server
+	TInt fsh;          	 // File server handle (RFs - session)
+	TPckgBuf<TInt> fh;   // File handle (RFile - subsession)
+			
+	fsh = CallSessionFunction(EGetLogFileHandle, TIpcArgs(&fh));   // pointer to fh in slot 0
+	User::LeaveIfError(fsh);
+		
+	// Adopt the file using the returned handles
+	RFile logFile;
+	User::LeaveIfError(logFile.AdoptFromServer(fsh, fh()));
+	CleanupClosePushL(logFile);
+	
+	RFileReadStream logStream(logFile);		 
+	CleanupClosePushL(logStream);
+	(void)logStream.ReadInt32L(); // skip the major version of the log file
+	(void)logStream.ReadInt32L(); // skip the minor version of the log file
+	TInt logCount = logStream.ReadInt32L();
+	
+	CScrLogEntry *log = NULL;
+	
+	for (TInt i = 0; i < logCount; ++i)
+		{
+		log = CScrLogEntry::NewLC(logStream);
+		if(aUniqueSwTypeName && aUniqueSwTypeName->CompareF(log->SoftwareTypeName()))
+			{ // if unique sw type name is given and the log doesn't belong to that sw type, continue.
+			CleanupStack::PopAndDestroy(log);
+			continue;
+			}
+		// Otherwise, append the log into the log entries list
+		aLogEntries.AppendL(log);			
+		CleanupStack::Pop(log); // Ownership is transferred 					
+		} // for
+	
+	CleanupStack::PopAndDestroy(2, &logFile); // logFile, logStream
+	}
+
+TInt GetNextNumberFromVersionL(TLex& aVersion)
+	{
+	TInt number = KErrNotFound;
+	if(aVersion.Eos())
+		return number; // if the end of string has already been reached, return KErrNotFound.
+	
+	TChar c = aVersion.Peek(); // show the next character
+	
+	while(c != 0 && c != '.')
+		{ // Go forward until coming across a dot or reaching the end of the string
+		aVersion.Inc();
+		c = aVersion.Peek();	
+		}
+	
+	if(!aVersion.TokenLength())
+		{// unexpected format
+		DEBUG_PRINTF(_L8("Version token length is unexpectedly zero."));
+		User::Leave(KErrArgument);
+		}
+	
+	// Get the token and convert it to a decimal number
+	TInt err = TLex(aVersion.MarkedToken()).Val(number);
+	if(KErrNone != err)
+		{
+		if(KErrGeneral == err)
+			{ // Convert KErrGeneral (if nun-numeric chars exist in the token) to KErrArgument
+			err = KErrArgument;
+			}
+		User::Leave(err);
+		}
+			
+	if(c != 0)
+		{ // if it is not the end of the string
+		aVersion.Inc(); // Increment to get over the last dot
+		aVersion.Mark(); // and mark the extraction position
+		}
+	return number;
+	}
+
+EXPORT_C TInt RSoftwareComponentRegistry::CompareVersionsL(const TDesC& aVersionLeft, const TDesC& aVersionRight)
+	{
+	DEBUG_PRINTF3(_L("Comparing version left (%S) to version right (%S)."), &aVersionLeft, &aVersionRight);
+	__ASSERT_ALWAYS(aVersionLeft.Length()>0 && aVersionRight.Length()>0, User::Leave(KErrArgument));
+	
+	if(!aVersionLeft.Compare(aVersionRight))
+		return 0; // if the version strings are identical, simply return zero (means equality)
+	
+	TLex lVer(aVersionLeft);
+	TLex rVer(aVersionRight);
+	
+	TInt lNum = GetNextNumberFromVersionL(lVer);
+	TInt rNum = GetNextNumberFromVersionL(rVer);
+	
+	while(lNum != KErrNotFound && rNum != KErrNotFound)
+		{
+		TInt diff = lNum - rNum;
+		if(diff != 0)
+			return diff;
+		
+		lNum = GetNextNumberFromVersionL(lVer);
+		rNum = GetNextNumberFromVersionL(rVer);
+		}
+	
+	TInt lVal (0);
+	TInt rVal (0);
+	
+	// The following two while-loops are used to consider trailing zeros.
+	// Theoritically, 1.2.0 is equal to 1.2, however, 1.2.0.1 is greater than 1.2.
+	// In order to handle these conditions the extra parts of the version are sum up
+	// to see whether it is greater than zero.
+	while(lNum != KErrNotFound)
+		{
+		lVal += lNum;
+		lNum = GetNextNumberFromVersionL(lVer);
+		}
+	
+	while(rNum != KErrNotFound)
+		{
+		rVal += rNum;
+		rNum = GetNextNumberFromVersionL(rVer);
+		}
+	
+	return (lVal - rVal);
+	}
+
+EXPORT_C TBool RSoftwareComponentRegistry::IsComponentOnReadOnlyDriveL(TComponentId aComponentId) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to determine if the component (%d) is on read-only drive."), aComponentId);
+	
+	TBool result;
+	TPckg<TBool> isOnReadOnlyDrive(result);
+	User::LeaveIfError(CallSessionFunction(EGetIsComponentOnReadOnlyDrive, TIpcArgs(aComponentId, &isOnReadOnlyDrive)));	
+	return result;
+	}
+
+EXPORT_C TBool RSoftwareComponentRegistry::IsComponentPresentL(TComponentId aComponentId) const
+	{
+	DEBUG_PRINTF2(_L("Sending a request to determine if the component(%d) is fully present."), aComponentId);	
+	TBool result;
+	TPckg<TBool> isCompPresent(result);
+	User::LeaveIfError(CallSessionFunction(EGetIsComponentPresent, TIpcArgs(aComponentId, &isCompPresent)));	
+	return result;
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::SetIsComponentPresentL(TComponentId aComponentId, TBool aValue)
+	{
+	DEBUG_PRINTF3(_L("Sending a request to set the CompPresence attribute(%d) of the component(%d)."), aValue, aComponentId);
+	TIpcArgs args(aComponentId, aValue);
+	User::LeaveIfError(CallSessionFunction(ESetIsComponentPresent, args));
+	}
+
+EXPORT_C void RSoftwareComponentRegistry::GetComponentSupportedLocalesListL(TComponentId aComponentId,RArray<TLanguage>& aMatchingSupportedLanguages) const
+	{
+	TIpcArgs args(aComponentId);
+	TInt argNum = 1;
+	GetObjectArrayL(*this, EGetComponentSupportedLocalesListSize, EGetComponentSupportedLocalesListData, argNum, args, aMatchingSupportedLanguages);
+	}
+
+
+EXPORT_C void RSoftwareComponentRegistry::AddApplicationEntryL(const TComponentId aComponentId, const CApplicationRegistrationData& aApplicationRegistrationData) 
+    {
+    DEBUG_PRINTF2(_L("Sending a request to add an application to be associated with component (%d) from SCR"), aComponentId);
+
+    if(aApplicationRegistrationData.AppUid() == KNullUid || !((aApplicationRegistrationData.AppFile()).CompareF(KNullDesC())) ) 
+        {
+        DEBUG_PRINTF(_L8("AppUid is zero or the App filename is absent. In either of the above cases values cannot be inserted into the db"));
+        User::Leave(KErrArgument);
+        }    
+    RBuf8 buf;
+    buf.CleanupClosePushL();
+    ExternalizeObjectL(&aApplicationRegistrationData, buf);
+      
+    TIpcArgs args(aComponentId, &buf);
+    User::LeaveIfError(CallSessionFunction(EAddApplicationEntry, args));
+    CleanupStack::PopAndDestroy(&buf);
+    }
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteApplicationEntriesL(TComponentId aComponentId) 
+    {
+    TIpcArgs args(aComponentId);
+    DEBUG_PRINTF2(_L("Sending a request to delete the applications associated with component (%d) from SCR"), aComponentId);
+    User::LeaveIfError(CallSessionFunction(EDeleteApplicationEntries, args));
+    }
+
+EXPORT_C void RSoftwareComponentRegistry::DeleteApplicationEntryL(TUid aApplicationUid) 
+    {
+    TIpcArgs args(aApplicationUid.iUid);
+    DEBUG_PRINTF2(_L("Sending a request to delete an application 0x%x from SCR" ), aApplicationUid.iUid);
+    User::LeaveIfError(CallSessionFunction(EDeleteApplicationEntry, args));
+    }
+
+EXPORT_C TComponentId RSoftwareComponentRegistry::GetComponentIdForAppL(TUid aAppUid) const
+    {
+    DEBUG_PRINTF2(_L("Sending a request to retrieve the component id for AppUid(%d)."), aAppUid);
+    TPckg<TUid> appUidPckg(aAppUid);
+    TComponentId compId;
+    TPckg<TComponentId> compIdPckg(compId);
+    TIpcArgs args(&appUidPckg, &compIdPckg);
+    User::LeaveIfError(CallSessionFunction(EGetComponentIdForApp, args));
+    return compId;
+    }
+
+EXPORT_C void RSoftwareComponentRegistry::GetAppUidsForComponentL(TComponentId aCompId, RArray<TUid>& aAppUids) const
+    {
+    DEBUG_PRINTF2(_L("Sending a request to retrieve the list of apps associated with component(%d)."), aCompId);
+    TIpcArgs args(aCompId);
+    TInt argNum = 1; // size descriptor will be added to this slot
+    GetObjectArrayL(*this, EGetAppUidsForComponentSize, EGetAppUidsForComponentData, argNum, args, aAppUids);    
+    }
+
+EXPORT_C void RSoftwareComponentRegistry::GetApplicationLaunchersL(RPointerArray<CLauncherExecutable>& aLaunchers) const
+	{
+    DEBUG_PRINTF(_L("Getting the list of applicaiton launchers."));
+    TIpcArgs args;
+    TInt argNum = 1;
+    GetObjectArrayL(*this, EGetApplicationLaunchersSize, EGetApplicationLaunchersData, argNum, args, aLaunchers);
+	}
+
+/*
+ * RScrInternalClient Implementation.
+ */
+EXPORT_C RScrInternalClient::RScrInternalClient()
+    :   RScsClientBase()
+    {
+    // empty
+    }
+
+EXPORT_C TInt RScrInternalClient::Connect()
+    {
+    DEBUG_PRINTF2(_L("Connecting to %S using the internal client(RScrInternalClient)."), &KSoftwareComponentRegistryName);
+    TVersion version = ScrServerVersion();
+    TUidType scrFullUid = ScrServerImageFullUid();
+    
+    return RScsClientBase::Connect(KSoftwareComponentRegistryName(), version, KScrServerImageName(), scrFullUid);
+    }
+
+EXPORT_C void RScrInternalClient::Close()
+    {
+    DEBUG_PRINTF2(_L("Closing connection to %S using the internal client(RScrInternalClient)."), &KSoftwareComponentRegistryName);
+    RScsClientBase::Close();
+    }
+
+
+EXPORT_C TUid RScrInternalClient::GenerateNewAppUidL() const
+    {
+    DEBUG_PRINTF(_L("Sending a request to generate a new Application Uid for non native applications."));
+
+    TUid newUid = TUid::Null();
+    TPckg<TUid> appUidPckg(newUid);
+    
+    TIpcArgs args(&appUidPckg);
+    User::LeaveIfError(CallSessionFunction(EGenerateNonNativeAppUid, args));
+    return newUid;
+    }
+