mirror of
https://github.com/openharmony/ability_ability_runtime.git
synced 2026-08-24 12:43:16 -04:00
XKK
517 lines
19 KiB
C++
517 lines
19 KiB
C++
/*
|
|
* Copyright (c) 2024 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "js_runtime_lite.h"
|
|
|
|
#include <regex>
|
|
|
|
#include "bundle_mgr_interface.h"
|
|
#include "hilog_tag_wrapper.h"
|
|
#include "iservice_registry.h"
|
|
#include "js_environment.h"
|
|
#include "js_module_reader.h"
|
|
#include "js_worker.h"
|
|
#include "ohos_js_env_logger.h"
|
|
#include "ohos_js_environment_impl.h"
|
|
#include "parameters.h"
|
|
#include "system_ability_definition.h"
|
|
#include "native_engine/native_create_env.h"
|
|
|
|
using Extractor = OHOS::AbilityBase::Extractor;
|
|
using ExtractorUtil = OHOS::AbilityBase::ExtractorUtil;
|
|
|
|
namespace OHOS {
|
|
namespace AbilityRuntime {
|
|
namespace {
|
|
constexpr int64_t DEFAULT_GC_POOL_SIZE = 0x10000000; // 256MB
|
|
constexpr size_t MAX_ENV_COUNT = 16;
|
|
const std::string SANDBOX_ARK_PROIFILE_PATH = "/data/storage/ark-profile";
|
|
const std::string PACKAGE_NAME = "packageName";
|
|
const std::string BUNDLE_NAME = "bundleName";
|
|
const std::string MODULE_NAME = "moduleName";
|
|
const std::string VERSION = "version";
|
|
const std::string ENTRY_PATH = "entryPath";
|
|
const std::string IS_SO = "isSO";
|
|
const std::string DEPENDENCY_ALIAS = "dependencyAlias";
|
|
int32_t PrintVmLog(int32_t, int32_t, const char*, const char*, const char* message)
|
|
{
|
|
TAG_LOGI(AAFwkTag::JSRUNTIME, "ArkLog: %{public}s", message);
|
|
return 0;
|
|
}
|
|
}
|
|
JsRuntimeLite::JsRuntimeLite()
|
|
{}
|
|
|
|
JsRuntimeLite::~JsRuntimeLite()
|
|
{
|
|
std::lock_guard<std::mutex> lock(envMutex_);
|
|
for (auto it : envMap_) {
|
|
it.second.reset();
|
|
it.second = nullptr;
|
|
}
|
|
envMap_.clear();
|
|
threadIds_.clear();
|
|
}
|
|
|
|
JsRuntimeLite& JsRuntimeLite::GetInstance()
|
|
{
|
|
static JsRuntimeLite jsRuntimeLite;
|
|
return jsRuntimeLite;
|
|
}
|
|
|
|
napi_status CreateNapiEnv(napi_env *env)
|
|
{
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "Called");
|
|
if (env == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "Invalid arg");
|
|
return napi_status::napi_invalid_arg;
|
|
}
|
|
auto options = JsRuntimeLite::GetInstance().GetChildOptions();
|
|
if (options == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null options");
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
std::shared_ptr<OHOS::JsEnv::JsEnvironment> jsEnv = nullptr;
|
|
auto errCode = JsRuntimeLite::GetInstance().CreateJsEnv(*options, jsEnv);
|
|
if (errCode != napi_status::napi_ok) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "CreateJsEnv failed");
|
|
return errCode;
|
|
}
|
|
*env = reinterpret_cast<napi_env>(jsEnv->GetNativeEngine());
|
|
if (env == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null env");
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
return JsRuntimeLite::GetInstance().Init(*options, *env);
|
|
}
|
|
|
|
napi_status DestroyNapiEnv(napi_env *env)
|
|
{
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "Called");
|
|
if (env == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "Invalid arg");
|
|
return napi_status::napi_invalid_arg;
|
|
}
|
|
auto errCode = JsRuntimeLite::GetInstance().RemoveJsEnv(*env);
|
|
if (errCode == napi_status::napi_ok) {
|
|
*env = nullptr;
|
|
}
|
|
return errCode;
|
|
}
|
|
|
|
void JsRuntimeLite::InitJsRuntimeLite(const Options& options)
|
|
{
|
|
if (options.isUnique) {
|
|
return;
|
|
}
|
|
GetInstance().SetChildOptions(options);
|
|
NativeCreateEnv::RegCreateNapiEnvCallback(CreateNapiEnv);
|
|
NativeCreateEnv::RegDestroyNapiEnvCallback(DestroyNapiEnv);
|
|
}
|
|
|
|
napi_status JsRuntimeLite::CreateJsEnv(const Options& options, std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "called");
|
|
panda::RuntimeOption pandaOption;
|
|
int arkProperties = OHOS::system::GetIntParameter<int>("persist.ark.properties", -1);
|
|
std::string bundleName = OHOS::system::GetParameter("persist.ark.arkbundlename", "");
|
|
std::string memConfigProperty = OHOS::system::GetParameter("persist.ark.mem_config_property", "");
|
|
size_t gcThreadNum = OHOS::system::GetUintParameter<size_t>("persist.ark.gcthreads", 7);
|
|
size_t longPauseTime = OHOS::system::GetUintParameter<size_t>("persist.ark.longpausetime", 40);
|
|
pandaOption.SetArkProperties(arkProperties);
|
|
pandaOption.SetArkBundleName(bundleName);
|
|
pandaOption.SetMemConfigProperty(memConfigProperty);
|
|
pandaOption.SetGcThreadNum(gcThreadNum);
|
|
pandaOption.SetLongPauseTime(longPauseTime);
|
|
TAG_LOGI(AAFwkTag::JSRUNTIME, "ark properties = %{public}d bundlename = %{public}s",
|
|
arkProperties, bundleName.c_str());
|
|
pandaOption.SetGcType(panda::RuntimeOption::GC_TYPE::GEN_GC);
|
|
pandaOption.SetGcPoolSize(DEFAULT_GC_POOL_SIZE);
|
|
pandaOption.SetLogLevel(panda::RuntimeOption::LOG_LEVEL::FOLLOW);
|
|
pandaOption.SetLogBufPrint(PrintVmLog);
|
|
|
|
bool asmInterpreterEnabled = OHOS::system::GetBoolParameter("persist.ark.asminterpreter", true);
|
|
std::string asmOpcodeDisableRange = OHOS::system::GetParameter("persist.ark.asmopcodedisablerange", "");
|
|
pandaOption.SetEnableAsmInterpreter(asmInterpreterEnabled);
|
|
pandaOption.SetAsmOpcodeDisableRange(asmOpcodeDisableRange);
|
|
pandaOption.SetEnableJIT(options.jitEnabled);
|
|
|
|
bool useAbilityRuntime = (options.isStageModel) || (options.isTestFramework);
|
|
if (useAbilityRuntime) {
|
|
bool aotEnabled = OHOS::system::GetBoolParameter("persist.ark.aot", true);
|
|
pandaOption.SetEnableAOT(aotEnabled);
|
|
pandaOption.SetProfileDir(SANDBOX_ARK_PROIFILE_PATH);
|
|
}
|
|
|
|
OHOSJsEnvLogger::RegisterJsEnvLogger();
|
|
// options eventRunner is nullptr
|
|
jsEnv = std::make_shared<JsEnv::JsEnvironment>(std::make_unique<OHOSJsEnvironmentImpl>(options.eventRunner));
|
|
if (jsEnv == nullptr || !jsEnv->Initialize(pandaOption, static_cast<void*>(this))
|
|
|| jsEnv->GetNativeEngine() == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "Initialize js environment failed");
|
|
return napi_status::napi_ok;
|
|
}
|
|
jsEnv->GetNativeEngine()->MarkNativeThread();
|
|
return AddEnv(reinterpret_cast<napi_env>(jsEnv->GetNativeEngine()), jsEnv);
|
|
}
|
|
|
|
napi_status JsRuntimeLite::Init(const Options& options, napi_env env)
|
|
{
|
|
auto jsEnv = GetJsEnv(env);
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
|
|
auto vm = GetEcmaVm(jsEnv);
|
|
if (!vm) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null vm");
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
|
|
bool isModular = false;
|
|
if (!options.preload) {
|
|
LoadAotFile(options, jsEnv);
|
|
panda::JSNApi::SetBundle(vm, options.isBundle);
|
|
panda::JSNApi::SetBundleName(vm, options.bundleName);
|
|
panda::JSNApi::SetHostResolveBufferTracker(
|
|
vm, JsModuleReader(options.bundleName, options.hapPath, options.isUnique));
|
|
isModular = !panda::JSNApi::IsBundle(vm);
|
|
panda::JSNApi::SetSearchHapPathTracker(
|
|
vm, [options](const std::string moduleName, std::string &hapPath) -> bool {
|
|
if (options.hapModulePath.find(moduleName) == options.hapModulePath.end()) {
|
|
return false;
|
|
}
|
|
hapPath = options.hapModulePath.find(moduleName)->second;
|
|
return true;
|
|
});
|
|
std::map<std::string, std::vector<std::vector<std::string>>> pkgContextInfoMap;
|
|
std::map<std::string, std::string> pkgAliasMap;
|
|
GetPkgContextInfoListMap(options.pkgContextInfoJsonStringMap, pkgContextInfoMap, pkgAliasMap);
|
|
panda::JSNApi::SetpkgContextInfoList(vm, pkgContextInfoMap);
|
|
panda::JSNApi::SetPkgAliasList(vm, pkgAliasMap);
|
|
panda::JSNApi::SetPkgNameList(vm, options.packageNameList);
|
|
}
|
|
|
|
if (!preloaded_) {
|
|
InitConsoleModule(jsEnv);
|
|
}
|
|
|
|
if (!options.preload) {
|
|
if (!options.isUnique) {
|
|
InitTimerModule(jsEnv);
|
|
}
|
|
InitWorkerModule(options, jsEnv);
|
|
SetModuleLoadChecker(options.moduleCheckerDelegate, jsEnv);
|
|
SetRequestAotCallback(jsEnv);
|
|
|
|
if (!InitLoop(jsEnv)) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "Init loop failed");
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
}
|
|
|
|
preloaded_ = options.preload;
|
|
return napi_status::napi_ok;
|
|
}
|
|
|
|
napi_status JsRuntimeLite::AddEnv(napi_env env, std::shared_ptr<JsEnv::JsEnvironment> jsEnv)
|
|
{
|
|
std::lock_guard<std::mutex> lock(envMutex_);
|
|
pid_t threadId = gettid();
|
|
if (threadIds_.find(threadId) != threadIds_.end()) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "already created");
|
|
return napi_status::napi_create_ark_runtime_only_one_env_per_thread;
|
|
}
|
|
if (envMap_.size() >= MAX_ENV_COUNT) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "envMap size exceed upperLimits");
|
|
return napi_status::napi_create_ark_runtime_too_many_envs;
|
|
}
|
|
threadIds_.insert(threadId);
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "add threadId %{public}d", threadId);
|
|
auto it = envMap_.find(env);
|
|
if (it == envMap_.end()) {
|
|
envMap_[env] = jsEnv;
|
|
return napi_status::napi_ok;
|
|
}
|
|
return napi_status::napi_generic_failure;
|
|
}
|
|
|
|
napi_status JsRuntimeLite::RemoveJsEnv(napi_env env)
|
|
{
|
|
std::lock_guard<std::mutex> lock(envMutex_);
|
|
pid_t threadId = gettid();
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "remove threadId %{public}d", threadId);
|
|
threadIds_.erase(threadId);
|
|
auto it = envMap_.find(env);
|
|
if (it != envMap_.end()) {
|
|
it->second.reset();
|
|
it->second = nullptr;
|
|
envMap_.erase(env);
|
|
return napi_status::napi_ok;
|
|
}
|
|
return napi_status::napi_destroy_ark_runtime_env_not_exist;
|
|
}
|
|
|
|
panda::ecmascript::EcmaVM* JsRuntimeLite::GetEcmaVm(const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv) const
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return nullptr;
|
|
}
|
|
return jsEnv->GetVM();
|
|
}
|
|
|
|
std::shared_ptr<JsEnv::JsEnvironment> JsRuntimeLite::GetJsEnv(napi_env env)
|
|
{
|
|
std::lock_guard<std::mutex> lock(envMutex_);
|
|
auto jsEnv = envMap_.find(env);
|
|
if (jsEnv != envMap_.end()) {
|
|
return jsEnv->second;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void JsRuntimeLite::LoadAotFile(const Options& options, const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
auto vm = GetEcmaVm(jsEnv);
|
|
if (!vm || options.hapPath.empty()) {
|
|
return;
|
|
}
|
|
|
|
bool newCreate = false;
|
|
std::string loadPath = ExtractorUtil::GetLoadFilePath(options.hapPath);
|
|
std::shared_ptr<Extractor> extractor = ExtractorUtil::GetExtractor(loadPath, newCreate, true);
|
|
if (extractor != nullptr && newCreate) {
|
|
panda::JSNApi::LoadAotFile(vm, options.moduleName);
|
|
}
|
|
}
|
|
|
|
void JsRuntimeLite::InitConsoleModule(const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return;
|
|
}
|
|
jsEnv->InitConsoleModule();
|
|
}
|
|
|
|
void JsRuntimeLite::InitTimerModule(const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return;
|
|
}
|
|
jsEnv->InitTimerModule();
|
|
}
|
|
|
|
void JsRuntimeLite::SetModuleLoadChecker(const std::shared_ptr<ModuleCheckerDelegate>& moduleCheckerDelegate,
|
|
const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return;
|
|
}
|
|
jsEnv->SetModuleLoadChecker(moduleCheckerDelegate);
|
|
}
|
|
|
|
void JsRuntimeLite::SetRequestAotCallback(const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return;
|
|
}
|
|
auto callback = [](const std::string& bundleName, const std::string& moduleName, int32_t triggerMode) -> int32_t {
|
|
auto systemAbilityMgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
|
|
if (systemAbilityMgr == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "get Samgr failed");
|
|
return ERR_INVALID_VALUE;
|
|
}
|
|
|
|
auto remoteObj = systemAbilityMgr->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
|
|
if (remoteObj == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null remoteObj");
|
|
return ERR_INVALID_VALUE;
|
|
}
|
|
|
|
auto bundleMgr = iface_cast<AppExecFwk::IBundleMgr>(remoteObj);
|
|
if (bundleMgr == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "get bms failed");
|
|
return ERR_INVALID_VALUE;
|
|
}
|
|
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME,
|
|
"Reset compile status, bundleName: %{public}s, moduleName: %{public}s, triggerMode: %{public}d",
|
|
bundleName.c_str(), moduleName.c_str(), triggerMode);
|
|
return bundleMgr->ResetAOTCompileStatus(bundleName, moduleName, triggerMode);
|
|
};
|
|
|
|
jsEnv->SetRequestAotCallback(callback);
|
|
}
|
|
|
|
bool JsRuntimeLite::InitLoop(const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return false;
|
|
}
|
|
return jsEnv->InitLoop();
|
|
}
|
|
|
|
void JsRuntimeLite::InitWorkerModule(const Options& options, const std::shared_ptr<JsEnv::JsEnvironment>& jsEnv)
|
|
{
|
|
if (jsEnv == nullptr) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "null jsEnv");
|
|
return;
|
|
}
|
|
|
|
std::shared_ptr<JsEnv::WorkerInfo> workerInfo = std::make_shared<JsEnv::WorkerInfo>();
|
|
workerInfo->codePath = options.codePath;
|
|
workerInfo->isDebugVersion = options.isDebugVersion;
|
|
workerInfo->isBundle = options.isBundle;
|
|
workerInfo->packagePathStr = options.packagePathStr;
|
|
workerInfo->assetBasePathStr = options.assetBasePathStr;
|
|
workerInfo->hapPath = options.hapPath;
|
|
workerInfo->isStageModel = options.isStageModel;
|
|
workerInfo->moduleName = options.moduleName;
|
|
if (options.isJsFramework) {
|
|
SetJsFramework();
|
|
}
|
|
jsEnv->InitWorkerModule(workerInfo);
|
|
}
|
|
|
|
void JsRuntimeLite::SetChildOptions(const Options& options)
|
|
{
|
|
std::lock_guard<std::mutex> lock(childOptionsMutex_);
|
|
if (childOptions_ == nullptr) {
|
|
childOptions_ = std::make_shared<Options>();
|
|
}
|
|
childOptions_->lang = options.lang;
|
|
childOptions_->bundleName = options.bundleName;
|
|
childOptions_->moduleName = options.moduleName;
|
|
childOptions_->codePath = options.codePath;
|
|
childOptions_->bundleCodeDir = options.bundleCodeDir;
|
|
childOptions_->hapPath = options.hapPath;
|
|
childOptions_->arkNativeFilePath = options.arkNativeFilePath;
|
|
childOptions_->hapModulePath = options.hapModulePath;
|
|
childOptions_->loadAce = options.loadAce;
|
|
childOptions_->preload = options.preload;
|
|
childOptions_->isBundle = options.isBundle;
|
|
childOptions_->isDebugVersion = options.isDebugVersion;
|
|
childOptions_->isJsFramework = options.isJsFramework;
|
|
childOptions_->isStageModel = options.isStageModel;
|
|
childOptions_->isTestFramework = options.isTestFramework;
|
|
childOptions_->uid = options.uid;
|
|
childOptions_->isUnique = options.isUnique;
|
|
childOptions_->moduleCheckerDelegate = options.moduleCheckerDelegate;
|
|
childOptions_->apiTargetVersion = options.apiTargetVersion;
|
|
childOptions_->packagePathStr = options.packagePathStr;
|
|
childOptions_->assetBasePathStr = options.assetBasePathStr;
|
|
childOptions_->jitEnabled = options.jitEnabled;
|
|
childOptions_->pkgContextInfoJsonStringMap = options.pkgContextInfoJsonStringMap;
|
|
childOptions_->packageNameList = options.packageNameList;
|
|
}
|
|
|
|
std::shared_ptr<Options> JsRuntimeLite::GetChildOptions()
|
|
{
|
|
std::lock_guard<std::mutex> lock(childOptionsMutex_);
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "called");
|
|
return childOptions_;
|
|
}
|
|
|
|
void JsRuntimeLite::GetPkgContextInfoListMap(const std::map<std::string, std::string> &contextInfoMap,
|
|
std::map<std::string, std::vector<std::vector<std::string>>> &pkgContextInfoMap,
|
|
std::map<std::string, std::string> &pkgAliasMap)
|
|
{
|
|
for (auto it = contextInfoMap.begin(); it != contextInfoMap.end(); it++) {
|
|
std::vector<std::vector<std::string>> pkgContextInfoList;
|
|
std::string filePath = it->second;
|
|
bool newCreate = false;
|
|
std::shared_ptr<Extractor> extractor = ExtractorUtil::GetExtractor(
|
|
ExtractorUtil::GetLoadFilePath(filePath), newCreate, false);
|
|
if (!extractor) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "moduleName: %{public}s load hapPath failed", it->first.c_str());
|
|
continue;
|
|
}
|
|
std::unique_ptr<uint8_t[]> data;
|
|
size_t dataLen = 0;
|
|
if (!extractor->ExtractToBufByName("pkgContextInfo.json", data, dataLen)) {
|
|
TAG_LOGD(AAFwkTag::JSRUNTIME, "moduleName: %{public}s get pkgContextInfo failed", it->first.c_str());
|
|
continue;
|
|
}
|
|
auto jsonObject = nlohmann::json::parse(data.get(), data.get() + dataLen, nullptr, false);
|
|
if (jsonObject.is_discarded()) {
|
|
TAG_LOGE(AAFwkTag::JSRUNTIME, "moduleName: %{public}s parse json error", it->first.c_str());
|
|
continue;
|
|
}
|
|
ParsePkgContextInfoJson(jsonObject, pkgContextInfoList, pkgAliasMap);
|
|
TAG_LOGI(AAFwkTag::JSRUNTIME, "moduleName: %{public}s parse json success", it->first.c_str());
|
|
pkgContextInfoMap[it->first] = pkgContextInfoList;
|
|
}
|
|
}
|
|
|
|
void JsRuntimeLite::ParsePkgContextInfoJson(nlohmann::json &jsonObject,
|
|
std::vector<std::vector<std::string>> &pkgContextInfoList, std::map<std::string, std::string> &pkgAliasMap)
|
|
{
|
|
for (nlohmann::json::iterator jsonIt = jsonObject.begin(); jsonIt != jsonObject.end(); jsonIt++) {
|
|
std::vector<std::string> items;
|
|
items.emplace_back(jsonIt.key());
|
|
nlohmann::json itemObject = jsonIt.value();
|
|
std::string pkgName = "";
|
|
items.emplace_back(PACKAGE_NAME);
|
|
if (itemObject[PACKAGE_NAME].is_null() || !itemObject[PACKAGE_NAME].is_string()) {
|
|
items.emplace_back(pkgName);
|
|
} else {
|
|
pkgName = itemObject[PACKAGE_NAME].get<std::string>();
|
|
items.emplace_back(pkgName);
|
|
}
|
|
|
|
ParsePkgContextInfoJsonString(itemObject, BUNDLE_NAME, items);
|
|
ParsePkgContextInfoJsonString(itemObject, MODULE_NAME, items);
|
|
ParsePkgContextInfoJsonString(itemObject, VERSION, items);
|
|
ParsePkgContextInfoJsonString(itemObject, ENTRY_PATH, items);
|
|
items.emplace_back(IS_SO);
|
|
if (itemObject[IS_SO].is_null() || !itemObject[IS_SO].is_boolean()) {
|
|
items.emplace_back("false");
|
|
} else {
|
|
bool isSo = itemObject[IS_SO].get<bool>();
|
|
if (isSo) {
|
|
items.emplace_back("true");
|
|
} else {
|
|
items.emplace_back("false");
|
|
}
|
|
}
|
|
if (!itemObject[DEPENDENCY_ALIAS].is_null() && itemObject[DEPENDENCY_ALIAS].is_string()) {
|
|
std::string pkgAlias = itemObject[DEPENDENCY_ALIAS].get<std::string>();
|
|
if (!pkgAlias.empty()) {
|
|
pkgAliasMap[pkgAlias] = pkgName;
|
|
}
|
|
}
|
|
pkgContextInfoList.emplace_back(items);
|
|
}
|
|
}
|
|
|
|
void JsRuntimeLite::ParsePkgContextInfoJsonString(
|
|
const nlohmann::json &itemObject, const std::string &key, std::vector<std::string> &items)
|
|
{
|
|
items.emplace_back(key);
|
|
if (itemObject[key].is_null() || !itemObject[key].is_string()) {
|
|
items.emplace_back("");
|
|
} else {
|
|
items.emplace_back(itemObject[key].get<std::string>());
|
|
}
|
|
}
|
|
} // namespace AbilityRuntime
|
|
} // namespace OHOS
|