FCL/sf/mw/appinstall: comparison secureswitools/swisistools/source/dbmanager/dblayer.cpp

equal deleted inserted replaced

-:ae54820ef82c
+:245df5276b97
 #include "dblayer.h"
 #include "exception.h"
 #include "logs.h"
 #include "util.h"
 #include "symbiantypes.h"
+#include "../sisxlibrary/utility.h"
 #include <string>
 #include <vector>
 #include <algorithm>
 #include <sstream>
 typedef std::vector<XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppLocalizableInfo::TViewData>::const_iterator ViewDataIterator;
 typedef std::vector<XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppLocalizableInfo::TViewData::TViewDataAttributes>::const_iterator ViewDataAttributeIterator;
 typedef std::vector<XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppProperty>::const_iterator ApplicationPropertyIterator;
+#ifdef __LINUX__
+/*
+* Platform specific feature
+*
+* In WINDOWS : sizeof(wchar_t) = 2
+* In LINUX   : sizeof(wchar_t) = 4
+*/
+static utf16WString utf32WString2utf16WString(std::wstring aParameter)
+{
+	int strLen = aParameter.length();
+	const wchar_t * source = aParameter.c_str();
+	unsigned short int* buffer = new unsigned short int[strLen + 1];
+	// Using a temp variable in place of buffer as ConvertUTF32toUTF16 modifies the source pointer passed.
+	unsigned short int* temp = buffer;
+	ConvertUTF32toUTF16(&source, source + strLen, &temp,  temp + strLen, lenientConversion);
+	// Appending NUL to the converted buffer.
+	*temp = 0;
+	utf16WString utf16Ws;
+	utf16Ws.resize(strLen);
+	// The built-in basic_string template class copy operation
+	// truncates when a NUL is encountered when a c_str() is
+	// used to construct the required string.
+	// So, if aParameter is any hashable string having the
+	// syntax : swtypeName + L'\0' + someId then, we will end
+	// up returning only part of the converted UTF-16 string.
+	// Hence, we resort to the explicit copy operation with
+	// two bytes at a time.
+	while( strLen-- )
+	{
+		utf16Ws[ strLen ] = buffer[ strLen ];
+	}
+	delete[] buffer;
+	return utf16Ws;
+}
+#else
+// We need not do anything for WINDOWS, since the windows wstring
+// will already be in UTF-16 encoding.
+#define utf32WString2utf16WString(aParameter) (aParameter)
+#endif
 const int KMaxDrives=26;
 CDbLayer::CDbLayer(const std::string& aDllPath, const std::string& aSqlDbName)
 	{
 	iScrDbHandler = new CDbProcessor(aDllPath, aSqlDbName);
 	std::string insertMimeType("INSERT INTO MimeTypes(SoftwareTypeId,MimeType) VALUES(?,?);");
 	std::auto_ptr<CStatement> stmtMimeType(iScrDbHandler->PrepareStatement(insertMimeType));
 	for(ScrEnvIterator aScrEnvIterator = aScrEnvDetails.begin(); aScrEnvIterator != aScrEnvDetails.end(); ++aScrEnvIterator)
 		{
-		unsigned int swTypeId = Util::Crc32(aScrEnvIterator->iUniqueSoftwareTypeName.c_str(),aScrEnvIterator->iUniqueSoftwareTypeName.length()*2);
+		// To maintain the consistency of CRC value across the platforms(WINDOWS and LINUX), we are
+		// using UTF-16 string in CRC generation.
+		utf16WString utf16Ws = utf32WString2utf16WString(aScrEnvIterator->iUniqueSoftwareTypeName);
+		unsigned int swTypeId = Util::Crc32(utf16Ws.c_str(),aScrEnvIterator->iUniqueSoftwareTypeName.length()*2);
 		if (!aScrEnvIterator->iLauncherExecutable.empty())
 		{
 		stmtSwType->BindInt(1, swTypeId);
 		stmtSwType->BindInt(2, aScrEnvIterator->iSifPluginUid);
 		stmtSwType->BindStr(3, aScrEnvIterator->iLauncherExecutable);
 	{
 	LOGENTER("CDbLayer::AddComponentDetails()");
 	std::string insertComponents;
 	XmlDetails::TScrPreProvisionDetail::TComponentDetails
 		componentDetail = aComponent.iComponentDetails;
 	if (aComponent.iComponentDetails.iIsRomApplication)
 		{
 		LOGINFO("Is rom app");
 		return true;
 		}
 	LOGINFO("Not rom app");
-	unsigned int swTypeId = Util::Crc32(aSoftwareTypeName.c_str(),aSoftwareTypeName.length()*2);
+	// To maintain the consistency of CRC value across the platforms(WINDOWS and LINUX), we are
+	// using UTF-16 string in CRC generation.
+utf16WString utf16Ws = utf32WString2utf16WString(aSoftwareTypeName);
+	unsigned int swTypeId = Util::Crc32(utf16Ws.c_str(),aSoftwareTypeName.length()*2);
 	std::wstring strGlobalId = componentDetail.iGlobalId;
 	if(!strGlobalId.empty())
 		{
 		insertComponents = "INSERT INTO Components(SoftwareTypeId, SoftwareTypeName, Removable, Size, ScomoState, InstalledDrives, OriginVerified, Hidden, GlobalIdHash, GlobalId, Version, InstallTime) VALUES(?,?,?,?,?,?,?,?,?,?,?,?);";
 	std::wstring localTime = GetLocalTime();
 	if(!strGlobalId.empty())
 		{
 		std::wstring concatGlobalId = aSoftwareTypeName + L'\0' + strGlobalId;
-		unsigned int globalIdHash = Util::Crc32(concatGlobalId.c_str(),concatGlobalId.length()*2);
+		// To maintain the consistency of CRC value across the platforms(WINDOWS and LINUX), we are
+		// using UTF-16 string in CRC generation.
+		utf16WString utf16Ws = utf32WString2utf16WString(concatGlobalId);
+		unsigned int globalIdHash = Util::Crc32(utf16Ws.c_str(),concatGlobalId.length()*2);
 		stmtComponents->BindInt(9, globalIdHash);
 		stmtComponents->BindStr(10, concatGlobalId);
 		stmtComponents->BindStr(11, version);
 		stmtComponents->BindStr(12, localTime);
 		}
 			}
 		else
 			{
 			if(compPropIter->iIsStr8Bit)
 				{
-				std::string str = Util::wstring2string(compPropIter->iValue);
+				std::string str = wstring2string(compPropIter->iValue);
 				std::string decodedString = Util::Base64Decode(str);
-				stmtComponentProperty->BindBinary(4, str);
+				stmtComponentProperty->BindBinary(4, decodedString);
 				}
 			else
 				{
 				stmtComponentProperty->BindStr(4, compPropIter->iValue);
 				}
 	std::vector<XmlDetails::TScrPreProvisionDetail::TComponentDependency::TComponentDependencyDetail>::const_iterator compDepIter;
 	for(compDepIter = aComponentDependencyDetails.begin() ; compDepIter != aComponentDependencyDetails.end() ; ++compDepIter)
 		{
 		std::wstring concatGlobalId = dependantGlobalId + compDepIter->iSupplierId;
-		unsigned int globalIdHash = Util::Crc32(concatGlobalId.c_str(),concatGlobalId.length()*2);
+		// To maintain the consistency of CRC value across the platforms(WINDOWS and LINUX), we are
-		unsigned int dependantIdHash = Util::Crc32(dependantGlobalId.c_str(),dependantGlobalId.length()*2);
+		// using UTF-16 string in CRC generation.
-		unsigned int supplierIdHash = Util::Crc32(compDepIter->iSupplierId.c_str(),compDepIter->iSupplierId.length()*2);
+		utf16WString utf16Ws = utf32WString2utf16WString(concatGlobalId);
+		unsigned int globalIdHash = Util::Crc32(utf16Ws.c_str(),concatGlobalId.length()*2);
+		utf16Ws = utf32WString2utf16WString(dependantGlobalId);
+		unsigned int dependantIdHash = Util::Crc32(utf16Ws.c_str(),dependantGlobalId.length()*2);
+		utf16Ws = utf32WString2utf16WString(compDepIter->iSupplierId);
+		unsigned int supplierIdHash = Util::Crc32(utf16Ws.c_str(),compDepIter->iSupplierId.length()*2);
 		std::string insertComponentDeps("INSERT INTO ComponentDependencies(GlobalIdHash,DependantGlobalIdHash, SupplierGlobalIdHash, DependantGlobalId,SupplierGlobalId,VersionFrom,VersionTo) VALUES(?,?,?,?,?,?,?);");
 		std::auto_ptr<CStatement> stmtComponentDeps(iScrDbHandler->PrepareStatement(insertComponentDeps));
 		stmtComponentDeps->BindInt( 1 ,globalIdHash);
 		stmtComponentDeps->BindInt( 2 ,dependantIdHash);
 	std::string insertComponentFileDetails("INSERT INTO ComponentsFiles(ComponentId,LocationHash,Location) VALUES(?,?,?);");
 	std::auto_ptr<CStatement> stmtComponentFileDetails(iScrDbHandler->PrepareStatement(insertComponentFileDetails));
 	stmtComponentFileDetails->BindInt(1,aComponentId);
-	// size does not return the actual binary size of the object
 	int length = aLocation.length()*2 ;
 	// generate hash for location
 	std::wstring location = aLocation;
 	std::transform(	location.begin(), location.end(), location.begin(), tolower);
-	unsigned int hash = Util::Crc32(location.c_str(),length);
+	#ifdef __TOOLS2_LINUX__
+	// To maintain the consistency of the LocationHash value(essentially the CRC of
+	// Location string) across the WINDOWS and LINUX platforms, we reconstruct the
+	// location to have WINDOWS specific path.
+std::wstring::size_type idx = 0;
+while( (idx = location.find(L"//", idx)) != std::wstring::npos)
+{
+	 location.replace( idx, 2, L"\\\\" );
+}
+idx = 0;
+while( (idx = location.find(L"/", idx)) != std::wstring::npos)
+{
+	 location.replace( idx, 1, L"\\" );
+}
+	#endif
+	// To maintain the consistency of CRC value across the platforms(WINDOWS and LINUX), we are
+	// using UTF-16 string in CRC generation.
+	utf16WString utf16Ws = utf32WString2utf16WString(location);
+	unsigned int hash = Util::Crc32(utf16Ws.c_str(),length);
 	stmtComponentFileDetails->BindInt(2,hash);
 	stmtComponentFileDetails->BindStr(3,aLocation);
 	stmtComponentFileDetails->ExecuteStatement();
 	stmtComponentFileDetails->Reset();
 			int intValue = Util::WideCharToInteger(filePropIter->iValue.c_str());
 			stmtFileProperty->BindInt(3, intValue);
 			}
 		else
 			{
-			std::string str = Util::wstring2string(filePropIter->iValue);
+			std::string str = wstring2string(filePropIter->iValue);
 			std::string decodedString = Util::Base64Decode(str);
-			stmtFileProperty->BindBinary(3, str);
+			stmtFileProperty->BindBinary(3, decodedString);
 			stmtFileProperty->BindInt(4, 1);
 			}
 		stmtFileProperty->ExecuteStatement();
 		stmtFileProperty->Reset();
 	insertAppAttributes = "INSERT INTO AppRegistrationInfo(AppUid,ComponentId,AppFile,TypeId,Attributes,Hidden,Embeddable,Newfile,Launch,GroupName,DefaultScreenNumber) VALUES(?,?,?,?,?,?,?,?,?,?,?);";
 	std::auto_ptr<CStatement> stmtAppAttribute(iScrDbHandler->PrepareStatement(insertAppAttributes));
 	stmtAppAttribute->BindInt64(2, aComponentId);
+	//Assigning Default Values
+	TInt64 intVal = 0;
+	stmtAppAttribute->BindInt64(5, intVal); //Attributes
+	stmtAppAttribute->BindInt64(6, intVal); //Hidden
+	stmtAppAttribute->BindInt64(7, intVal); //Embeddable
+	stmtAppAttribute->BindInt64(8, intVal); //Newfile
+	stmtAppAttribute->BindInt64(9, intVal); //Launch
+	stmtAppAttribute->BindInt64(11, intVal); //DefaultScreenNumber
+	std::wstring strVal(L"");
+	stmtAppAttribute->BindStr(10, strVal); //GroupName
 	int appUid = 0;
 	std::string appfile;
 	for(ApplicationAttributeIterator applicationAttributeIter = aAppAttribute.begin(); applicationAttributeIter != aAppAttribute.end() ; ++applicationAttributeIter )
 		{
 		if (applicationAttributeIter->iName == L"AppUid")
 			insertDataType = "INSERT INTO DataType(ServiceId,Priority,Type) VALUES(?,?,?);";
 			std::auto_ptr<CStatement> stmtDataType(iScrDbHandler->PrepareStatement(insertDataType));
 			stmtDataType->BindInt64(1, serviceId);
 			stmtDataType->BindInt64(2, dataTypeIter->iPriority);
+			#ifdef __TOOLS2_LINUX__
+			stmtDataType->BindStr(3, dataTypeIter->iType, avoidSlashConversion);
+			#else
 			stmtDataType->BindStr(3, dataTypeIter->iType);
+			#endif
 			stmtDataType->ExecuteStatement();
 			stmtDataType->Reset();
 			}
 		}
 	std::string insertAppLocalizableInfo;
 	insertAppLocalizableInfo = "INSERT INTO LocalizableAppInfo(AppUid,ShortCaption,GroupName,Locale,CaptionAndIconId) VALUES(?,?,?,?,?);";
 	std::auto_ptr<CStatement> stmtAppLocalizableInfo(iScrDbHandler->PrepareStatement(insertAppLocalizableInfo));
+	//Assigning default value
+	TInt64 intVal = 0;
+	stmtAppLocalizableInfo->BindInt64(4, intVal); //Locale
+	std::wstring strVal(L"");
+	stmtAppLocalizableInfo->BindStr(2, strVal); //ShortCaption
+	stmtAppLocalizableInfo->BindStr(3, strVal); //GroupName
 	std::string insertCaptionAndIconInfo;
 	insertCaptionAndIconInfo = "INSERT INTO CaptionAndIconInfo(Caption,NumberOfIcons,IconFile) VALUES(?,?,?);";
 	std::auto_ptr<CStatement> stmtCaptionAndIconInfo(iScrDbHandler->PrepareStatement(insertCaptionAndIconInfo));
 	std::string insertCaptionAndIconInfo;
 	insertCaptionAndIconInfo = "INSERT INTO CaptionAndIconInfo(Caption,NumberOfIcons,IconFile) VALUES(?,?,?);";
 	std::auto_ptr<CStatement> stmtCaptionAndIconInfo(iScrDbHandler->PrepareStatement(insertCaptionAndIconInfo));
+	//Assigning Default Value
+	TInt64 intVal = 0;
+	stmtViewData->BindInt64(3, intVal); //ScreenMode
+	stmtCaptionAndIconInfo->BindInt64(2, intVal); //NumberOfIcons
+	std::wstring strVal(L"");
+	stmtCaptionAndIconInfo->BindStr(3, strVal); //IconFile
 	bool captionAndIconInfoPresent = 0;
 	//for every TViewData
 	stmtViewData->BindInt64(1, alocalAppInfoId);
 		stmtAppProperty->BindInt(4, appPropertyIter->iServiceUid);
 		stmtAppProperty->BindInt(5, appPropertyIter->iIntValue);
 		if(appPropertyIter->iIsStr8Bit)
 			{
-			stmtAppProperty->BindBinary(6, appPropertyIter->iStrValue);
+				std::string str = wstring2string(appPropertyIter->iStrValue);
+				std::string decodedString = Util::Base64Decode(str);
+				stmtAppProperty->BindBinary(6, decodedString);
 			}
 		else
 			{
 			stmtAppProperty->BindStr(6, appPropertyIter->iStrValue);
 			}

changeset 60	245df5276b97
parent 33	8110bf1194d1
child 67	3a625661d1ce