Mercurial Mercurial > oss > FCL > sf > mw > appinstall / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
secureswitools/swisistools/source/rscparser/dirparse.cpp
changeset 75 2d2d25361590
parent 55 ac7f90a6ff4c
equal deleted inserted replaced
69:b18a4bf55ddb 75:2d2d25361590 
   282 /**
 
   282 /**
 
   283  * Creates Class TAppAttribute for XML Parsing
 
   283  * Creates Class TAppAttribute for XML Parsing
 
   284  */
 
   284  */
 
   285 
   285 
   286 void CreateAppProperty(XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo& aAppProperty, 
   286 void CreateAppProperty(XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo& aAppProperty, 
   287 								const std::wstring& aStrValue, const int aLocale,
 
   287 								const std::string& aStrValue, const int aLocale,
 
   288 								const int aServiceUid, const bool aIsStr8Bit )
 
   288 								const int aServiceUid, const bool aIsStr8Bit )
 
   289 {
 
   289 {
 
   290 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppProperty componentproperty;
 
   290 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TAppProperty componentproperty;
 
   291 
   291 
   292 	componentproperty.iName = DbConstants::CompOpaqueData;
 
   292 	componentproperty.iName = DbConstants::CompOpaqueData;
 
   302 /**
 
   302 /**
 
   303  * Creates Class TOpaqueDataType for XML Parsing
 
   303  * Creates Class TOpaqueDataType for XML Parsing
 
   304  */
 
   304  */
 
   305 
   305 
   306 void CreateOpaqueDataType(XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo& aAppOpaqueData, 
   306 void CreateOpaqueDataType(XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo& aAppOpaqueData, 
   307 								const std::wstring& aStrValue, const int aLocale, const int aServUid)
 
   307 								const std::string& aStrValue, const int aLocale, const int aServUid)
 
   308 {
 
   308 {
 
   309 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType componentData;
 
   309 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo::TOpaqueDataType componentData;
 
   310 
   310 
   311 	componentData.iLocale = aLocale;
 
   311 	componentData.iLocale = aLocale;
 
   312 	componentData.iServiceUid = aServUid;
 
   312 	componentData.iServiceUid = aServUid;
 
   313 
   313 
   314 	/* 
   314 	 componentData.iOpaqueData = aStrValue;
 
   315 	 * Under LINUX : The OpaqueData which is read from the resource file will be in UTF-16 format contained
 
   315 	 componentData.iIsBinary = true;
 
   316 	 *               in a std::wstring. So, we need to convert it back to UTF-32 format which is the format
 
       
   317 	 *               of LINUX specific std::wstring.
 
       
   318      * 
       
   319 	 * Under WINDOWS : Nothing needs to be done and this is taken care of by XercesStringToWString()
 
       
   320 	 *				   which is platform specific.	
       
   321 	 */
 
       
   322 	 componentData.iOpaqueData = XercesStringToWString(reinterpret_cast<const XMLCh*>(aStrValue.c_str()));
 
       
   323 	 aAppOpaqueData.iOpaqueDataType.push_back(componentData);
 
   316 	 aAppOpaqueData.iOpaqueDataType.push_back(componentData);
 
   324 }
 
   317 }
 
   325 
   318 
   326 /**
 
   319 /**
 
   327  * Get the path of Database "scr.db"
 
   320  * Get the path of Database "scr.db"
 
   404 
   397 
   405 
   398 
   406 void CreateApplicationRegistrationInfoL(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, 
   399 void CreateApplicationRegistrationInfoL(XmlDetails::TScrPreProvisionDetail::TComponent& aComponent, 
   407 												const CAppInfoReader* aAppInfoReader)
 
   400 												const CAppInfoReader* aAppInfoReader)
 
   408 {
 
   401 {
 
   409 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo atemp;
 
   402 	XmlDetails::TScrPreProvisionDetail::TApplicationRegistrationInfo iApplicationRegistrationInfo;
 
   410 
   403 
   411 	Ptr16* iAppBinaryFullName = aAppInfoReader->AppBinaryFullName();
 
   404 	Ptr16* iAppBinaryFullName = aAppInfoReader->AppBinaryFullName();
 
   412 	std::wstring sStr = DbConstants::CompAppFile;
 
   405 	std::wstring sAppAttributeName = DbConstants::CompAppFile;
 
   413 	std::wstring sStr1 = Ptr16ToWstring(iAppBinaryFullName);
 
   406 	std::wstring sAppAttributeValue = Ptr16ToWstring(iAppBinaryFullName);
 
   414 	CreateAppAttribute(atemp,sStr,sStr1,false,false);
 
   407 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,false,false);
 
   415 
   408 
   416 	TUidType iAppBinaryUidType = aAppInfoReader->AppBinaryUidType();;
 
   409 	TUidType iAppBinaryUidType = aAppInfoReader->AppBinaryUidType();;
 
   417 	sStr = DbConstants::CompAppUid;
 
   410 	sAppAttributeName = DbConstants::CompAppUid;
 
   418 	TUid Uid = iAppBinaryUidType[2];
 
   411 	TUid Uid = iAppBinaryUidType[2];
 
   419 	sStr1 = Utils::IntegerToWideString(Uid.GetUid());
 
   412 	sAppAttributeValue = Utils::IntegerToWideString(Uid.GetUid());
 
   420 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   413 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   421 
   414 
   422 	sStr = DbConstants::CompTypeId;
 
   415 	sAppAttributeName = DbConstants::CompTypeId;
 
   423 	TInt TypeId = -1367772926;
 
   416 	TInt TypeId = -1367772926;
 
   424 	sStr1 = Utils::IntegerToWideString(TypeId);
 
   417 	sAppAttributeValue = Utils::IntegerToWideString(TypeId);
 
   425 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   418 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   426 
   419 
   427 	TAppCapability iCapability;
 
   420 	TAppCapability iCapability;
 
   428 	aAppInfoReader->Capability(iCapability);
 
   421 	aAppInfoReader->Capability(iCapability);
 
   429 
   422 
   430  	sStr = DbConstants::CompAttributes;
 
   423  	sAppAttributeName = DbConstants::CompAttributes;
 
   431 	sStr1 = Utils::IntegerToWideString(iCapability.iAttributes);
 
   424 	sAppAttributeValue = Utils::IntegerToWideString(iCapability.iAttributes);
 
   432 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   425 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   433 
   426 
   434 	sStr = DbConstants::CompHidden;
 
   427 	sAppAttributeName = DbConstants::CompHidden;
 
   435 	sStr1 = Utils::IntegerToWideString(iCapability.iAppIsHidden);
 
   428 	sAppAttributeValue = Utils::IntegerToWideString(iCapability.iAppIsHidden);
 
   436 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   429 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   437 
   430 
   438 	sStr = DbConstants::CompEmbeddable;
 
   431 	sAppAttributeName = DbConstants::CompEmbeddable;
 
   439 	sStr1 = Utils::IntegerToWideString(iCapability.iEmbeddability);
 
   432 	sAppAttributeValue = Utils::IntegerToWideString(iCapability.iEmbeddability);
 
   440 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   433 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   441 
   434 
   442 	sStr = DbConstants::CompNewfile;
 
   435 	sAppAttributeName = DbConstants::CompNewfile;
 
   443 	sStr1 = Utils::IntegerToWideString(iCapability.iSupportsNewFile);
 
   436 	sAppAttributeValue = Utils::IntegerToWideString(iCapability.iSupportsNewFile);
 
   444 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   437 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   445 
   438 
   446 	sStr = DbConstants::CompLaunch;
 
   439 	sAppAttributeName = DbConstants::CompLaunch;
 
   447 	sStr1 = Utils::IntegerToWideString(iCapability.iLaunchInBackground);
 
   440 	sAppAttributeValue = Utils::IntegerToWideString(iCapability.iLaunchInBackground);
 
   448 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   441 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   449 
   442 
   450 	sStr = DbConstants::CompGroupName;
 
   443 	sAppAttributeName = DbConstants::CompGroupName;
 
   451 	if(iCapability.iGroupName)
 
   444 	if(iCapability.iGroupName)
 
   452 		sStr1 = Ptr16ToWstring(iCapability.iGroupName);
 
   445 		sAppAttributeValue = Ptr16ToWstring(iCapability.iGroupName);
 
   453 	else
 
   446 	else
 
   454 		sStr1=L'\0';
 
   447 		sAppAttributeValue=L'\0';
 
   455 	CreateAppAttribute(atemp,sStr,sStr1,false,false);
 
   448 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,false,false);
 
   456 
   449 
   457 	TUint iDefaultScreenNumber = aAppInfoReader->DefaultScreenNumber();
 
   450 	TUint iDefaultScreenNumber = aAppInfoReader->DefaultScreenNumber();
 
   458 	sStr = DbConstants::CompDefaultScreenNumber;
 
   451 	sAppAttributeName = DbConstants::CompDefaultScreenNumber;
 
   459 	sStr1 = Utils::IntegerToWideString(iDefaultScreenNumber);
 
   452 	sAppAttributeValue = Utils::IntegerToWideString(iDefaultScreenNumber);
 
   460 	CreateAppAttribute(atemp,sStr,sStr1,true,false);
 
   453 	CreateAppAttribute(iApplicationRegistrationInfo,sAppAttributeName,sAppAttributeValue,true,false);
 
   461 
   454 
   462 	std::vector<Ptr16*>* ownedFileArray = aAppInfoReader->OwnedFiles();
 
   455 	std::vector<Ptr16*>* ownedFileArray = aAppInfoReader->OwnedFiles();
 
       
   456 	std::wstring sFileName;
 
   463 	if(ownedFileArray)
 
   457 	if(ownedFileArray)
 
   464 	{
 
   458 	{
 
   465 		for(TInt ii = 0; ii<ownedFileArray->size(); ii++)
 
   459 		for(TInt ii = 0; ii<ownedFileArray->size(); ii++)
 
   466 		{
 
   460 		{
 
   467 			Ptr16 *temp = ownedFileArray->at(ii);
 
   461 			Ptr16 *temp = ownedFileArray->at(ii);
 
   468 			if(temp)
 
   462 			if(temp)
 
   469 				sStr = Ptr16ToWstring(temp);
 
   463 				sFileName = Ptr16ToWstring(temp);
 
   470 			else
 
   464 			else
 
   471 				sStr=L'\0';
 
   465 				sFileName = L'\0';
 
   472 			atemp.iFileOwnershipInfo.push_back(sStr);
 
   466 			iApplicationRegistrationInfo.iFileOwnershipInfo.push_back(sFileName);
 
   473 		}
 
   467 		}
 
   474 	}
 
   468 	}
 
   475 
   469 
       
   470 	std::string sOpaqueData;
 
   476 	TInt iIndexOfFirstOpenService;
 
   471 	TInt iIndexOfFirstOpenService;
 
   477 	std::vector<TAppServiceInfo*>* iServiceArray = aAppInfoReader->ServiceArray(iIndexOfFirstOpenService);
 
   472 	std::vector<TAppServiceInfo*>* iServiceArray = aAppInfoReader->ServiceArray(iIndexOfFirstOpenService);
 
   478 	if(iServiceArray)
 
   473 	if(iServiceArray)
 
   479 	{
 
   474 	{
 
   480 		for(TInt i = 0; i<iServiceArray->size(); i++)
 
   475 		for(TInt i = 0; i<iServiceArray->size(); i++)
 
   481 		{
 
   476 		{
 
   482 			TAppServiceInfo* temp = iServiceArray->at(i);
 
   477 			TAppServiceInfo* temp = iServiceArray->at(i);
 
   483 			TUid iUid = temp->GetUid();
 
   478 			TUid iUid = temp->GetUid();
 
   484 			std::vector<TDataTypeWithPriority*> iData = temp->GetDataType();
 
   479 			std::vector<TDataTypeWithPriority*> iData = temp->GetDataType();
 
   485 			CreateAppServiceInfo(atemp,iUid,iData);
 
   480 			CreateAppServiceInfo(iApplicationRegistrationInfo,iUid,iData);
 
   486 
   481 
   487 			int servUid = iUid.GetUid();
 
   482 			int servUid = iUid.GetUid();
 
   488 			std::vector<CAppLocalOpaqueDataInfo*> opaqueDataArray = aAppInfoReader->GetOpaqueDataArray();
 
   483 			std::vector<CAppLocalOpaqueDataInfo*> opaqueDataArray = aAppInfoReader->GetOpaqueDataArray();
 
   489 			for(TInt i = 0; i<opaqueDataArray.size(); i++)
 
   484 			for(TInt i = 0; i<opaqueDataArray.size(); i++)
 
   490 			{
 
   485 			{
 
   492 			
   487 			
   493 				TUint32 serviceUid = tp->GetServiceUid();
 
   488 				TUint32 serviceUid = tp->GetServiceUid();
 
   494 				if(servUid == serviceUid)
 
   489 				if(servUid == serviceUid)
 
   495 				{
 
   490 				{
 
   496 					Ptr8*	opaqueData = tp->GetOpaqueData();
 
   491 					Ptr8*	opaqueData = tp->GetOpaqueData();
 
       
   492 
   497 					if(opaqueData)
 
   493 					if(opaqueData)
 
   498 						sStr1 = Ptr8ToWstring(opaqueData);
 
   494 						sOpaqueData.assign(opaqueData->GetPtr(), opaqueData->GetPtr()+opaqueData->GetLength());
 
   499 					else
 
   495 					else
 
   500 						sStr1=L'\0';
 
   496 						sOpaqueData = '\0';
 
   501 				
       
   502 					TInt locale = tp->GetLocale();
 
   497 					TInt locale = tp->GetLocale();
 
   503 					CreateOpaqueDataType(atemp,sStr1,locale,serviceUid);
 
   498 					CreateOpaqueDataType(iApplicationRegistrationInfo,sOpaqueData,locale,serviceUid);
 
   504 				}
 
   499 				}
 
   505 			}
 
   500 			}
 
   506 		}
 
   501 		}
 
   507 	}
 
   502 	}
 
   508 
   503 
   509 	std::vector<CAppLocalizableInfo*> aAppLocalizable = aAppInfoReader->LocalizableInfo();
 
   504 	std::vector<CAppLocalizableInfo*> aAppLocalizable = aAppInfoReader->LocalizableInfo();
 
   510 
   505 
   511 	for(TInt i = 0; i<aAppLocalizable.size(); i++)
 
   506 	for(TInt i = 0; i<aAppLocalizable.size(); i++)
 
   512 	{
 
   507 	{
 
   513 		CAppLocalizableInfo* tp = aAppLocalizable.at(i);
 
   508 		CAppLocalizableInfo* tp = aAppLocalizable.at(i);
 
   514 		CreateLocalizableInfoL(atemp,tp);
 
   509 		CreateLocalizableInfoL(iApplicationRegistrationInfo,tp);
 
   515 	}
 
   510 	}
 
   516 
   511 
   517 	std::vector<CAppLocalOpaqueDataInfo*> opaqueDataArray = aAppInfoReader->GetOpaqueDataArray();
 
   512 	std::vector<CAppLocalOpaqueDataInfo*> opaqueDataArray = aAppInfoReader->GetOpaqueDataArray();
 
   518 	for(TInt i = 0; i<opaqueDataArray.size(); i++)
 
   513 	for(TInt i = 0; i<opaqueDataArray.size(); i++)
 
   519 	{
 
   514 	{
 
   521 
   516 
   522 		TUint32 serviceUid = tp->GetServiceUid();
 
   517 		TUint32 serviceUid = tp->GetServiceUid();
 
   523 		if(0 == serviceUid)
 
   518 		if(0 == serviceUid)
 
   524 		{
 
   519 		{
 
   525 			Ptr8* 	opaqueData = tp->GetOpaqueData();
 
   520 			Ptr8* 	opaqueData = tp->GetOpaqueData();
 
       
   521 
   526 			if(opaqueData)
 
   522 			if(opaqueData)
 
   527 				sStr1 = Ptr8ToWstring(opaqueData);
 
   523 				sOpaqueData.assign(opaqueData->GetPtr(), opaqueData->GetPtr()+opaqueData->GetLength());
 
   528 			else
 
   524 			else
 
   529 				sStr1=L'\0';
 
   525 				sOpaqueData='\0';
 
   530 		
   526 			
   531 			TInt locale = tp->GetLocale();
 
   527 			TInt locale = tp->GetLocale();
 
   532 			CreateOpaqueDataType(atemp,sStr1,locale,serviceUid);
 
   528 			CreateOpaqueDataType(iApplicationRegistrationInfo,sOpaqueData,locale,serviceUid);
 
   533 		}
 
   529 		}
 
   534 	}
 
   530 	}
 
   535 
   531 
   536 	aComponent.iApplicationRegistrationInfo.push_back(atemp);
 
   532 	aComponent.iApplicationRegistrationInfo.push_back(iApplicationRegistrationInfo);
 
   537 }
 
   533 }
 
   538 
   534 
   539 
   535 
   540 /**
 
   536 /**
 
   541  * Get the path of Localizefile.
 
   537  * Get the path of Localizefile.
FCL/sf/mw/appinstall