• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hap_module_info.h"
17 
18 #include "bundle_constants.h"
19 #include "json_util.h"
20 #include "message_parcel.h"
21 #include "nlohmann/json.hpp"
22 #include "parcel_macro.h"
23 #include "string_ex.h"
24 
25 namespace OHOS {
26 namespace AppExecFwk {
27 namespace {
28 const std::string HAP_MODULE_INFO_NAME = "name";
29 const std::string HAP_MODULE_INFO_PACKAGE = "package";
30 const std::string HAP_MODULE_INFO_DESCRIPTION = "description";
31 const std::string HAP_MODULE_INFO_DESCRIPTION_ID = "descriptionId";
32 const std::string HAP_MODULE_INFO_ICON_PATH = "iconPath";
33 const std::string HAP_MODULE_INFO_ICON_ID = "iconId";
34 const std::string HAP_MODULE_INFO_LABEL = "label";
35 const std::string HAP_MODULE_INFO_LABEL_ID = "labelId";
36 const std::string HAP_MODULE_INFO_BACKGROUND_IMG = "backgroundImg";
37 const std::string HAP_MODULE_INFO_MAIN_ABILITY = "mainAbility";
38 const std::string HAP_MODULE_INFO_SRC_PATH = "srcPath";
39 const std::string HAP_MODULE_INFO_HASH_VALUE = "hashValue";
40 const std::string HAP_MODULE_INFO_SUPPORTED_MODES = "supportedModes";
41 const std::string HAP_MODULE_INFO_REQ_CAPABILITIES = "reqCapabilities";
42 const std::string HAP_MODULE_INFO_DEVICE_TYPES = "deviceTypes";
43 const std::string HAP_MODULE_INFO_ABILITY_INFOS = "abilityInfos";
44 const std::string HAP_MODULE_INFO_COLOR_MODE = "colorMode";
45 const std::string HAP_MODULE_INFO_MAIN_ELEMENTNAME = "mainElementName";
46 const std::string HAP_MODULE_INFO_PAGES = "pages";
47 const std::string HAP_MODULE_INFO_PROCESS = "process";
48 const std::string HAP_MODULE_INFO_RESOURCE_PATH = "resourcePath";
49 const std::string HAP_MODULE_INFO_SRC_ENTRANCE = "srcEntrance";
50 const std::string HAP_MODULE_INFO_UI_SYNTAX = "uiSyntax";
51 const std::string HAP_MODULE_INFO_VIRTUAL_MACHINE = "virtualMachine";
52 const std::string HAP_MODULE_INFO_DELIVERY_WITH_INSTALL = "deliveryWithInstall";
53 const std::string HAP_MODULE_INFO_INSTALLATION_FREE = "installationFree";
54 const std::string HAP_MODULE_INFO_IS_MODULE_JSON = "isModuleJson";
55 const std::string HAP_MODULE_INFO_IS_STAGE_BASED_MODEL = "isStageBasedModel";
56 const std::string HAP_MODULE_INFO_IS_REMOVABLE = "isRemovable";
57 const std::string HAP_MODULE_INFO_MODULE_TYPE = "moduleType";
58 const std::string HAP_MODULE_INFO_EXTENSION_INFOS = "extensionInfos";
59 const std::string HAP_MODULE_INFO_META_DATA = "metadata";
60 const std::string HAP_MODULE_INFO_DEPENDENCIES = "dependencies";
61 const std::string HAP_MODULE_INFO_UPGRADE_FLAG = "upgradeFlag";
62 const std::string HAP_MODULE_INFO_HAP_PATH = "hapPath";
63 const std::string HAP_MODULE_INFO_COMPILE_MODE = "compileMode";
64 const std::string HAP_MODULE_INFO_HQF_INFO = "hqfInfo";
65 const std::string HAP_MODULE_INFO_IS_LIB_ISOLATED = "isLibIsolated";
66 const std::string HAP_MODULE_INFO_NATIVE_LIBRARY_PATH = "nativeLibraryPath";
67 const std::string HAP_MODULE_INFO_CPU_ABI = "cpuAbi";
68 const std::string HAP_MODULE_INFO_MODULE_SOURCE_DIR = "moduleSourceDir";
69 const std::string HAP_OVERLAY_MODULE_INFO = "overlayModuleInfos";
70 const std::string HAP_MODULE_INFO_PRELOADS = "preloads";
71 const std::string PRELOAD_ITEM_MODULE_NAME = "moduleName";
72 const std::string HAP_MODULE_INFO_VERSION_CODE = "versionCode";
73 const std::string HAP_MODULE_INFO_PROXY_DATAS = "proxyDatas";
74 const std::string PROXY_DATA_URI = "uri";
75 const std::string PROXY_DATA_REQUIRED_READ_PERMISSION = "requiredReadPermission";
76 const std::string PROXY_DATA_REQUIRED_WRITE_PERMISSION = "requiredWritePermission";
77 const std::string PROXY_DATA_METADATA = "metadata";
78 const std::string HAP_MODULE_INFO_BUILD_HASH = "buildHash";
79 const std::string HAP_MODULE_INFO_ISOLATION_MODE = "isolationMode";
80 const std::string HAP_MODULE_INFO_AOT_COMPILE_STATUS = "aotCompileStatus";
81 const std::string HAP_MODULE_INFO_COMPRESS_NATIVE_LIBS = "compressNativeLibs";
82 const std::string HAP_MODULE_INFO_NATIVE_LIBRARY_FILE_NAMES = "nativeLibraryFileNames";
83 const std::string HAP_MODULE_INFO_FILE_CONTEXT_MENU = "fileContextMenu";
84 const size_t MODULE_CAPACITY = 10240; // 10K
85 }
86 
ReadFromParcel(Parcel & parcel)87 bool PreloadItem::ReadFromParcel(Parcel &parcel)
88 {
89     moduleName = Str16ToStr8(parcel.ReadString16());
90     return true;
91 }
92 
Marshalling(Parcel & parcel) const93 bool PreloadItem::Marshalling(Parcel &parcel) const
94 {
95     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
96     return true;
97 }
98 
Unmarshalling(Parcel & parcel)99 PreloadItem *PreloadItem::Unmarshalling(Parcel &parcel)
100 {
101     PreloadItem *info = new (std::nothrow) PreloadItem();
102     if (info && !info->ReadFromParcel(parcel)) {
103         APP_LOGW("read from parcel failed");
104         delete info;
105         info = nullptr;
106     }
107     return info;
108 }
109 
to_json(nlohmann::json & jsonObject,const PreloadItem & preloadItem)110 void to_json(nlohmann::json &jsonObject, const PreloadItem &preloadItem)
111 {
112     jsonObject = nlohmann::json {
113         {PRELOAD_ITEM_MODULE_NAME, preloadItem.moduleName}
114     };
115 }
116 
from_json(const nlohmann::json & jsonObject,PreloadItem & preloadItem)117 void from_json(const nlohmann::json &jsonObject, PreloadItem &preloadItem)
118 {
119     const auto &jsonObjectEnd = jsonObject.end();
120     int32_t parseResult = ERR_OK;
121     GetValueIfFindKey<std::string>(jsonObject,
122         jsonObjectEnd,
123         PRELOAD_ITEM_MODULE_NAME,
124         preloadItem.moduleName,
125         JsonType::STRING,
126         false,
127         parseResult,
128         ArrayType::NOT_ARRAY);
129     if (parseResult != ERR_OK) {
130         APP_LOGE("read PreloadItem from database error, error code : %{public}d", parseResult);
131     }
132 }
133 
ReadFromParcel(Parcel & parcel)134 bool Dependency::ReadFromParcel(Parcel &parcel)
135 {
136     bundleName = Str16ToStr8(parcel.ReadString16());
137     moduleName = Str16ToStr8(parcel.ReadString16());
138     versionCode = parcel.ReadInt32();
139     return true;
140 }
141 
Marshalling(Parcel & parcel) const142 bool Dependency::Marshalling(Parcel &parcel) const
143 {
144     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
145     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
146     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, versionCode);
147     return true;
148 }
149 
Unmarshalling(Parcel & parcel)150 Dependency *Dependency::Unmarshalling(Parcel &parcel)
151 {
152     Dependency *dependency = new (std::nothrow) Dependency();
153     if (dependency && !dependency->ReadFromParcel(parcel)) {
154         APP_LOGW("read from parcel failed");
155         delete dependency;
156         dependency = nullptr;
157     }
158     return dependency;
159 }
160 
to_json(nlohmann::json & jsonObject,const Dependency & dependency)161 void to_json(nlohmann::json &jsonObject, const Dependency &dependency)
162 {
163     jsonObject = nlohmann::json {
164         {Constants::BUNDLE_NAME, dependency.bundleName},
165         {Constants::MODULE_NAME, dependency.moduleName},
166         {HAP_MODULE_INFO_VERSION_CODE, dependency.versionCode}
167     };
168 }
169 
from_json(const nlohmann::json & jsonObject,Dependency & dependency)170 void from_json(const nlohmann::json &jsonObject, Dependency &dependency)
171 {
172     const auto &jsonObjectEnd = jsonObject.end();
173     int32_t parseResult = ERR_OK;
174     GetValueIfFindKey<std::string>(jsonObject,
175         jsonObjectEnd,
176         Constants::BUNDLE_NAME,
177         dependency.bundleName,
178         JsonType::STRING,
179         false,
180         parseResult,
181         ArrayType::NOT_ARRAY);
182     GetValueIfFindKey<std::string>(jsonObject,
183         jsonObjectEnd,
184         Constants::MODULE_NAME,
185         dependency.moduleName,
186         JsonType::STRING,
187         false,
188         parseResult,
189         ArrayType::NOT_ARRAY);
190     GetValueIfFindKey<int>(jsonObject,
191         jsonObjectEnd,
192         HAP_MODULE_INFO_VERSION_CODE,
193         dependency.versionCode,
194         JsonType::NUMBER,
195         false,
196         parseResult,
197         ArrayType::NOT_ARRAY);
198     if (parseResult != ERR_OK) {
199         APP_LOGE("read Dependency error, error code : %{public}d", parseResult);
200     }
201 }
202 
ReadFromParcel(Parcel & parcel)203 bool ProxyData::ReadFromParcel(Parcel &parcel)
204 {
205     uri = Str16ToStr8(parcel.ReadString16());
206     requiredReadPermission = Str16ToStr8(parcel.ReadString16());
207     requiredWritePermission = Str16ToStr8(parcel.ReadString16());
208     std::unique_ptr<Metadata> data(parcel.ReadParcelable<Metadata>());
209     if (!data) {
210         APP_LOGE("ReadParcelable<Metadata> failed");
211         return false;
212     }
213     metadata = *data;
214     return true;
215 }
216 
Marshalling(Parcel & parcel) const217 bool ProxyData::Marshalling(Parcel &parcel) const
218 {
219     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri));
220     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(requiredReadPermission));
221     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(requiredWritePermission));
222     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &metadata);
223     return true;
224 }
225 
Unmarshalling(Parcel & parcel)226 ProxyData *ProxyData::Unmarshalling(Parcel &parcel)
227 {
228     ProxyData *info = new (std::nothrow) ProxyData();
229     if (info && !info->ReadFromParcel(parcel)) {
230         APP_LOGW("read from parcel failed");
231         delete info;
232         info = nullptr;
233     }
234     return info;
235 }
236 
to_json(nlohmann::json & jsonObject,const ProxyData & proxyData)237 void to_json(nlohmann::json &jsonObject, const ProxyData &proxyData)
238 {
239     jsonObject = nlohmann::json {
240         {PROXY_DATA_URI, proxyData.uri},
241         {PROXY_DATA_REQUIRED_READ_PERMISSION, proxyData.requiredReadPermission},
242         {PROXY_DATA_REQUIRED_WRITE_PERMISSION, proxyData.requiredWritePermission},
243         {PROXY_DATA_METADATA, proxyData.metadata}
244     };
245 }
246 
from_json(const nlohmann::json & jsonObject,ProxyData & proxyData)247 void from_json(const nlohmann::json &jsonObject, ProxyData &proxyData)
248 {
249     const auto &jsonObjectEnd = jsonObject.end();
250     int32_t parseResult = ERR_OK;
251     GetValueIfFindKey<std::string>(jsonObject,
252         jsonObjectEnd,
253         PROXY_DATA_URI,
254         proxyData.uri,
255         JsonType::STRING,
256         false,
257         parseResult,
258         ArrayType::NOT_ARRAY);
259     GetValueIfFindKey<std::string>(jsonObject,
260         jsonObjectEnd,
261         PROXY_DATA_REQUIRED_READ_PERMISSION,
262         proxyData.requiredReadPermission,
263         JsonType::STRING,
264         false,
265         parseResult,
266         ArrayType::NOT_ARRAY);
267     GetValueIfFindKey<std::string>(jsonObject,
268         jsonObjectEnd,
269         PROXY_DATA_REQUIRED_WRITE_PERMISSION,
270         proxyData.requiredWritePermission,
271         JsonType::STRING,
272         false,
273         parseResult,
274         ArrayType::NOT_ARRAY);
275     GetValueIfFindKey<Metadata>(jsonObject,
276         jsonObjectEnd,
277         PROXY_DATA_METADATA,
278         proxyData.metadata,
279         JsonType::OBJECT,
280         false,
281         parseResult,
282         ArrayType::NOT_ARRAY);
283     if (parseResult != ERR_OK) {
284         APP_LOGE("read ProxyData from database error, error code : %{public}d", parseResult);
285     }
286 }
287 
ReadFromParcel(Parcel & parcel)288 bool HapModuleInfo::ReadFromParcel(Parcel &parcel)
289 {
290     int32_t abilityInfosSize;
291     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilityInfosSize);
292     CONTAINER_SECURITY_VERIFY(parcel, abilityInfosSize, &abilityInfos);
293     for (auto i = 0; i < abilityInfosSize; i++) {
294         std::unique_ptr<AbilityInfo> abilityInfo(parcel.ReadParcelable<AbilityInfo>());
295         if (!abilityInfo) {
296             APP_LOGE("ReadParcelable<AbilityInfo> failed");
297             return false;
298         }
299         abilityInfos.emplace_back(*abilityInfo);
300     }
301 
302     int32_t extensionInfosSize;
303     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extensionInfosSize);
304     CONTAINER_SECURITY_VERIFY(parcel, extensionInfosSize, &extensionInfos);
305     for (auto i = 0; i < extensionInfosSize; i++) {
306         std::unique_ptr<ExtensionAbilityInfo> extensionAbilityInfo(parcel.ReadParcelable<ExtensionAbilityInfo>());
307         if (!extensionAbilityInfo) {
308             APP_LOGE("ReadParcelable<ExtensionAbilityInfo> failed");
309             return false;
310         }
311         extensionInfos.emplace_back(*extensionAbilityInfo);
312     }
313 
314     name = Str16ToStr8(parcel.ReadString16());
315     package = Str16ToStr8(parcel.ReadString16());
316     moduleName = Str16ToStr8(parcel.ReadString16());
317     description = Str16ToStr8(parcel.ReadString16());
318     descriptionId = parcel.ReadInt32();
319     iconPath = Str16ToStr8(parcel.ReadString16());
320     iconId = parcel.ReadInt32();
321     label = Str16ToStr8(parcel.ReadString16());
322     labelId = parcel.ReadInt32();
323     backgroundImg = Str16ToStr8(parcel.ReadString16());
324     mainAbility = Str16ToStr8(parcel.ReadString16());
325     srcPath = Str16ToStr8(parcel.ReadString16());
326     hashValue = Str16ToStr8(parcel.ReadString16());
327     hapPath = Str16ToStr8(parcel.ReadString16());
328     supportedModes = parcel.ReadInt32();
329 
330     int32_t reqCapabilitiesSize;
331     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqCapabilitiesSize);
332     CONTAINER_SECURITY_VERIFY(parcel, reqCapabilitiesSize, &reqCapabilities);
333     for (auto i = 0; i < reqCapabilitiesSize; i++) {
334         reqCapabilities.emplace_back(Str16ToStr8(parcel.ReadString16()));
335     }
336 
337     int32_t deviceTypesSize;
338     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceTypesSize);
339     CONTAINER_SECURITY_VERIFY(parcel, deviceTypesSize, &deviceTypes);
340     for (auto i = 0; i < deviceTypesSize; i++) {
341         deviceTypes.emplace_back(Str16ToStr8(parcel.ReadString16()));
342     }
343 
344     int32_t dependenciesSize;
345     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, dependenciesSize);
346     CONTAINER_SECURITY_VERIFY(parcel, dependenciesSize, &dependencies);
347     for (auto i = 0; i < dependenciesSize; i++) {
348         std::unique_ptr<Dependency> dependency(parcel.ReadParcelable<Dependency>());
349         if (!dependency) {
350             APP_LOGE("ReadParcelable<Dependency> failed");
351             return false;
352         }
353         dependencies.emplace_back(*dependency);
354     }
355 
356     colorMode = static_cast<ModuleColorMode>(parcel.ReadInt32());
357     bundleName = Str16ToStr8(parcel.ReadString16());
358     mainElementName = Str16ToStr8(parcel.ReadString16());
359     pages = Str16ToStr8(parcel.ReadString16());
360     process = Str16ToStr8(parcel.ReadString16());
361     resourcePath = Str16ToStr8(parcel.ReadString16());
362     srcEntrance = Str16ToStr8(parcel.ReadString16());
363     uiSyntax = Str16ToStr8(parcel.ReadString16());
364     virtualMachine = Str16ToStr8(parcel.ReadString16());
365     deliveryWithInstall = parcel.ReadBool();
366     installationFree = parcel.ReadBool();
367     isModuleJson = parcel.ReadBool();
368     isStageBasedModel = parcel.ReadBool();
369 
370     int32_t isRemovableSize;
371     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, isRemovableSize);
372     CONTAINER_SECURITY_VERIFY(parcel, isRemovableSize, &isRemovable);
373     for (auto i = 0; i < isRemovableSize; i++) {
374         std::string key = Str16ToStr8(parcel.ReadString16());
375         bool isRemove = parcel.ReadBool();
376         isRemovable[key] = isRemove;
377     }
378     moduleType = static_cast<ModuleType>(parcel.ReadInt32());
379 
380     int32_t metadataSize;
381     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadataSize);
382     CONTAINER_SECURITY_VERIFY(parcel, metadataSize, &metadata);
383     for (int32_t i = 0; i < metadataSize; ++i) {
384         std::unique_ptr<Metadata> meta(parcel.ReadParcelable<Metadata>());
385         if (!meta) {
386             APP_LOGE("ReadParcelable<Metadata> failed");
387             return false;
388         }
389         metadata.emplace_back(*meta);
390     }
391 
392     upgradeFlag = parcel.ReadInt32();
393     compileMode = static_cast<CompileMode>(parcel.ReadInt32());
394     std::unique_ptr<HqfInfo> hqfInfoPtr(parcel.ReadParcelable<HqfInfo>());
395     if (hqfInfoPtr == nullptr) {
396         APP_LOGE("ReadParcelable<HqfInfo> failed");
397         return false;
398     }
399     hqfInfo = *hqfInfoPtr;
400     isLibIsolated = parcel.ReadBool();
401     nativeLibraryPath = Str16ToStr8(parcel.ReadString16());
402     cpuAbi = Str16ToStr8(parcel.ReadString16());
403     moduleSourceDir = Str16ToStr8(parcel.ReadString16());
404 
405     int32_t overlayModuleInfosSize;
406     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayModuleInfosSize);
407     CONTAINER_SECURITY_VERIFY(parcel, overlayModuleInfosSize, &overlayModuleInfos);
408     for (auto i = 0; i < overlayModuleInfosSize; i++) {
409         std::unique_ptr<OverlayModuleInfo> overlayModuleInfo(parcel.ReadParcelable<OverlayModuleInfo>());
410         if (!overlayModuleInfo) {
411             APP_LOGE("ReadParcelable<OverlayModuleInfo> failed");
412             return false;
413         }
414         overlayModuleInfos.emplace_back(*overlayModuleInfo);
415     }
416 
417     int32_t preloadsSize;
418     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, preloadsSize);
419     CONTAINER_SECURITY_VERIFY(parcel, preloadsSize, &preloads);
420     for (int32_t i = 0; i < preloadsSize; ++i) {
421         std::unique_ptr<PreloadItem> preload(parcel.ReadParcelable<PreloadItem>());
422         if (!preload) {
423             APP_LOGE("ReadParcelable<PreloadItem> failed");
424             return false;
425         }
426         preloads.emplace_back(*preload);
427     }
428     int32_t proxyDatasSize;
429     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, proxyDatasSize);
430     CONTAINER_SECURITY_VERIFY(parcel, proxyDatasSize, &proxyDatas);
431     for (int32_t i = 0; i < proxyDatasSize; ++i) {
432         std::unique_ptr<ProxyData> proxyData(parcel.ReadParcelable<ProxyData>());
433         if (!proxyData) {
434             APP_LOGE("ReadParcelable<ProxyData> failed");
435             return false;
436         }
437         proxyDatas.emplace_back(*proxyData);
438     }
439     buildHash = Str16ToStr8(parcel.ReadString16());
440     isolationMode = static_cast<IsolationMode>(parcel.ReadInt32());
441     aotCompileStatus = static_cast<AOTCompileStatus>(parcel.ReadInt32());
442     compressNativeLibs = parcel.ReadBool();
443     int32_t nativeLibraryFileNamesSize;
444     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, nativeLibraryFileNamesSize);
445     CONTAINER_SECURITY_VERIFY(parcel, nativeLibraryFileNamesSize, &nativeLibraryFileNames);
446     for (int32_t i = 0; i < nativeLibraryFileNamesSize; ++i) {
447         nativeLibraryFileNames.emplace_back(Str16ToStr8(parcel.ReadString16()));
448     }
449     fileContextMenu = Str16ToStr8(parcel.ReadString16());
450     return true;
451 }
452 
Unmarshalling(Parcel & parcel)453 HapModuleInfo *HapModuleInfo::Unmarshalling(Parcel &parcel)
454 {
455     HapModuleInfo *info = new (std::nothrow) HapModuleInfo();
456     if (info && !info->ReadFromParcel(parcel)) {
457         APP_LOGW("read from parcel failed");
458         delete info;
459         info = nullptr;
460     }
461     return info;
462 }
463 
Marshalling(Parcel & parcel) const464 bool HapModuleInfo::Marshalling(Parcel &parcel) const
465 {
466     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilityInfos.size());
467     for (auto &abilityInfo : abilityInfos) {
468         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &abilityInfo);
469     }
470 
471     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extensionInfos.size());
472     for (auto &extensionInfo : extensionInfos) {
473         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &extensionInfo);
474     }
475 
476     CHECK_PARCEL_CAPACITY(parcel, MODULE_CAPACITY);
477     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
478     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(package));
479     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
480     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
481     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, descriptionId);
482     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(iconPath));
483     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, iconId);
484     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
485     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, labelId);
486     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(backgroundImg));
487     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mainAbility));
488     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcPath));
489     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hashValue));
490     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapPath));
491     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportedModes);
492 
493     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqCapabilities.size());
494     for (auto &reqCapability : reqCapabilities) {
495         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(reqCapability));
496     }
497 
498     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceTypes.size());
499     for (auto &deviceType : deviceTypes) {
500         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(deviceType));
501     }
502 
503     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, dependencies.size());
504     for (auto &dependency : dependencies) {
505         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &dependency);
506     }
507 
508     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(colorMode));
509     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
510     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mainElementName));
511     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(pages));
512     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(process));
513     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(resourcePath));
514     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcEntrance));
515     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uiSyntax));
516     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(virtualMachine));
517     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, deliveryWithInstall);
518     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, installationFree);
519     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isModuleJson);
520     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isStageBasedModel);
521 
522     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, isRemovable.size());
523     for (auto &item : isRemovable) {
524         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(item.first));
525         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, item.second);
526     }
527 
528     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(moduleType));
529 
530     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadata.size());
531     for (auto &mete : metadata) {
532         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &mete);
533     }
534 
535     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, upgradeFlag);
536     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(compileMode));
537     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &hqfInfo);
538     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isLibIsolated);
539     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(nativeLibraryPath));
540     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(cpuAbi));
541     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleSourceDir));
542     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayModuleInfos.size());
543     for (auto &overlayModuleInfo : overlayModuleInfos) {
544         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &overlayModuleInfo);
545     }
546 
547     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, preloads.size());
548     for (auto &item : preloads) {
549         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &item);
550     }
551     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, proxyDatas.size());
552     for (auto &item : proxyDatas) {
553         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &item);
554     }
555     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(buildHash));
556     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(isolationMode));
557     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(aotCompileStatus));
558     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, compressNativeLibs);
559     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, nativeLibraryFileNames.size());
560     for (auto &fileName : nativeLibraryFileNames) {
561         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(fileName));
562     }
563     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(fileContextMenu));
564     return true;
565 }
566 
to_json(nlohmann::json & jsonObject,const HapModuleInfo & hapModuleInfo)567 void to_json(nlohmann::json &jsonObject, const HapModuleInfo &hapModuleInfo)
568 {
569     jsonObject = nlohmann::json {
570         {HAP_MODULE_INFO_NAME, hapModuleInfo.name},
571         {HAP_MODULE_INFO_PACKAGE, hapModuleInfo.package},
572         {Constants::MODULE_NAME, hapModuleInfo.moduleName},
573         {HAP_MODULE_INFO_DESCRIPTION, hapModuleInfo.description},
574         {HAP_MODULE_INFO_DESCRIPTION_ID, hapModuleInfo.descriptionId},
575         {HAP_MODULE_INFO_ICON_PATH, hapModuleInfo.iconPath},
576         {HAP_MODULE_INFO_ICON_ID, hapModuleInfo.iconId},
577         {HAP_MODULE_INFO_LABEL, hapModuleInfo.label},
578         {HAP_MODULE_INFO_LABEL_ID, hapModuleInfo.labelId},
579         {HAP_MODULE_INFO_BACKGROUND_IMG, hapModuleInfo.backgroundImg},
580         {HAP_MODULE_INFO_MAIN_ABILITY, hapModuleInfo.mainAbility},
581         {HAP_MODULE_INFO_SRC_PATH, hapModuleInfo.srcPath},
582         {HAP_MODULE_INFO_HASH_VALUE, hapModuleInfo.hashValue},
583         {HAP_MODULE_INFO_HAP_PATH, hapModuleInfo.hapPath},
584         {HAP_MODULE_INFO_SUPPORTED_MODES, hapModuleInfo.supportedModes},
585         {HAP_MODULE_INFO_REQ_CAPABILITIES, hapModuleInfo.reqCapabilities},
586         {HAP_MODULE_INFO_DEVICE_TYPES, hapModuleInfo.deviceTypes},
587         {HAP_MODULE_INFO_ABILITY_INFOS, hapModuleInfo.abilityInfos},
588         {HAP_MODULE_INFO_COLOR_MODE, hapModuleInfo.colorMode},
589         {Constants::BUNDLE_NAME, hapModuleInfo.bundleName},
590         {HAP_MODULE_INFO_MAIN_ELEMENTNAME, hapModuleInfo.mainElementName},
591         {HAP_MODULE_INFO_PAGES, hapModuleInfo.pages},
592         {HAP_MODULE_INFO_PROCESS, hapModuleInfo.process},
593         {HAP_MODULE_INFO_RESOURCE_PATH, hapModuleInfo.resourcePath},
594         {HAP_MODULE_INFO_SRC_ENTRANCE, hapModuleInfo.srcEntrance},
595         {HAP_MODULE_INFO_UI_SYNTAX, hapModuleInfo.uiSyntax},
596         {HAP_MODULE_INFO_VIRTUAL_MACHINE, hapModuleInfo.virtualMachine},
597         {HAP_MODULE_INFO_DELIVERY_WITH_INSTALL, hapModuleInfo.deliveryWithInstall},
598         {HAP_MODULE_INFO_INSTALLATION_FREE, hapModuleInfo.installationFree},
599         {HAP_MODULE_INFO_IS_MODULE_JSON, hapModuleInfo.isModuleJson},
600         {HAP_MODULE_INFO_IS_STAGE_BASED_MODEL, hapModuleInfo.isStageBasedModel},
601         {HAP_MODULE_INFO_IS_REMOVABLE, hapModuleInfo.isRemovable},
602         {HAP_MODULE_INFO_UPGRADE_FLAG, hapModuleInfo.upgradeFlag},
603         {HAP_MODULE_INFO_MODULE_TYPE, hapModuleInfo.moduleType},
604         {HAP_MODULE_INFO_EXTENSION_INFOS, hapModuleInfo.extensionInfos},
605         {HAP_MODULE_INFO_META_DATA, hapModuleInfo.metadata},
606         {HAP_MODULE_INFO_DEPENDENCIES, hapModuleInfo.dependencies},
607         {HAP_MODULE_INFO_COMPILE_MODE, hapModuleInfo.compileMode},
608         {HAP_MODULE_INFO_HQF_INFO, hapModuleInfo.hqfInfo},
609         {HAP_MODULE_INFO_IS_LIB_ISOLATED, hapModuleInfo.isLibIsolated},
610         {HAP_MODULE_INFO_NATIVE_LIBRARY_PATH, hapModuleInfo.nativeLibraryPath},
611         {HAP_MODULE_INFO_CPU_ABI, hapModuleInfo.cpuAbi},
612         {HAP_MODULE_INFO_MODULE_SOURCE_DIR, hapModuleInfo.moduleSourceDir},
613         {HAP_OVERLAY_MODULE_INFO, hapModuleInfo.overlayModuleInfos},
614         {HAP_MODULE_INFO_PRELOADS, hapModuleInfo.preloads},
615         {HAP_MODULE_INFO_PROXY_DATAS, hapModuleInfo.proxyDatas},
616         {HAP_MODULE_INFO_BUILD_HASH, hapModuleInfo.buildHash},
617         {HAP_MODULE_INFO_ISOLATION_MODE, hapModuleInfo.isolationMode},
618         {HAP_MODULE_INFO_AOT_COMPILE_STATUS, hapModuleInfo.aotCompileStatus},
619         {HAP_MODULE_INFO_COMPRESS_NATIVE_LIBS, hapModuleInfo.compressNativeLibs},
620         {HAP_MODULE_INFO_NATIVE_LIBRARY_FILE_NAMES, hapModuleInfo.nativeLibraryFileNames},
621         {HAP_MODULE_INFO_FILE_CONTEXT_MENU, hapModuleInfo.fileContextMenu}
622     };
623 }
624 
from_json(const nlohmann::json & jsonObject,HapModuleInfo & hapModuleInfo)625 void from_json(const nlohmann::json &jsonObject, HapModuleInfo &hapModuleInfo)
626 {
627     const auto &jsonObjectEnd = jsonObject.end();
628     int32_t parseResult = ERR_OK;
629     GetValueIfFindKey<std::string>(jsonObject,
630         jsonObjectEnd,
631         HAP_MODULE_INFO_NAME,
632         hapModuleInfo.name,
633         JsonType::STRING,
634         false,
635         parseResult,
636         ArrayType::NOT_ARRAY);
637     GetValueIfFindKey<std::string>(jsonObject,
638         jsonObjectEnd,
639         HAP_MODULE_INFO_PACKAGE,
640         hapModuleInfo.package,
641         JsonType::STRING,
642         false,
643         parseResult,
644         ArrayType::NOT_ARRAY);
645     GetValueIfFindKey<std::string>(jsonObject,
646         jsonObjectEnd,
647         Constants::MODULE_NAME,
648         hapModuleInfo.moduleName,
649         JsonType::STRING,
650         false,
651         parseResult,
652         ArrayType::NOT_ARRAY);
653     GetValueIfFindKey<std::string>(jsonObject,
654         jsonObjectEnd,
655         HAP_MODULE_INFO_DESCRIPTION,
656         hapModuleInfo.description,
657         JsonType::STRING,
658         false,
659         parseResult,
660         ArrayType::NOT_ARRAY);
661     GetValueIfFindKey<int>(jsonObject,
662         jsonObjectEnd,
663         HAP_MODULE_INFO_DESCRIPTION_ID,
664         hapModuleInfo.descriptionId,
665         JsonType::NUMBER,
666         false,
667         parseResult,
668         ArrayType::NOT_ARRAY);
669     GetValueIfFindKey<std::string>(jsonObject,
670         jsonObjectEnd,
671         HAP_MODULE_INFO_ICON_PATH,
672         hapModuleInfo.iconPath,
673         JsonType::STRING,
674         false,
675         parseResult,
676         ArrayType::NOT_ARRAY);
677     GetValueIfFindKey<int>(jsonObject,
678         jsonObjectEnd,
679         HAP_MODULE_INFO_ICON_ID,
680         hapModuleInfo.iconId,
681         JsonType::NUMBER,
682         false,
683         parseResult,
684         ArrayType::NOT_ARRAY);
685     GetValueIfFindKey<std::string>(jsonObject,
686         jsonObjectEnd,
687         HAP_MODULE_INFO_LABEL,
688         hapModuleInfo.label,
689         JsonType::STRING,
690         false,
691         parseResult,
692         ArrayType::NOT_ARRAY);
693     GetValueIfFindKey<int>(jsonObject,
694         jsonObjectEnd,
695         HAP_MODULE_INFO_LABEL_ID,
696         hapModuleInfo.labelId,
697         JsonType::NUMBER,
698         false,
699         parseResult,
700         ArrayType::NOT_ARRAY);
701     GetValueIfFindKey<std::string>(jsonObject,
702         jsonObjectEnd,
703         HAP_MODULE_INFO_BACKGROUND_IMG,
704         hapModuleInfo.backgroundImg,
705         JsonType::STRING,
706         false,
707         parseResult,
708         ArrayType::NOT_ARRAY);
709     GetValueIfFindKey<std::string>(jsonObject,
710         jsonObjectEnd,
711         HAP_MODULE_INFO_MAIN_ABILITY,
712         hapModuleInfo.mainAbility,
713         JsonType::STRING,
714         false,
715         parseResult,
716         ArrayType::NOT_ARRAY);
717     GetValueIfFindKey<std::string>(jsonObject,
718         jsonObjectEnd,
719         HAP_MODULE_INFO_SRC_PATH,
720         hapModuleInfo.srcPath,
721         JsonType::STRING,
722         false,
723         parseResult,
724         ArrayType::NOT_ARRAY);
725     GetValueIfFindKey<std::string>(jsonObject,
726         jsonObjectEnd,
727         HAP_MODULE_INFO_HASH_VALUE,
728         hapModuleInfo.hashValue,
729         JsonType::STRING,
730         false,
731         parseResult,
732         ArrayType::NOT_ARRAY);
733     GetValueIfFindKey<std::string>(jsonObject,
734         jsonObjectEnd,
735         HAP_MODULE_INFO_HAP_PATH,
736         hapModuleInfo.hapPath,
737         JsonType::STRING,
738         false,
739         parseResult,
740         ArrayType::NOT_ARRAY);
741     GetValueIfFindKey<int>(jsonObject,
742         jsonObjectEnd,
743         HAP_MODULE_INFO_SUPPORTED_MODES,
744         hapModuleInfo.supportedModes,
745         JsonType::NUMBER,
746         false,
747         parseResult,
748         ArrayType::NOT_ARRAY);
749     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
750         jsonObjectEnd,
751         HAP_MODULE_INFO_REQ_CAPABILITIES,
752         hapModuleInfo.reqCapabilities,
753         JsonType::ARRAY,
754         false,
755         parseResult,
756         ArrayType::STRING);
757     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
758         jsonObjectEnd,
759         HAP_MODULE_INFO_DEVICE_TYPES,
760         hapModuleInfo.deviceTypes,
761         JsonType::ARRAY,
762         false,
763         parseResult,
764         ArrayType::STRING);
765     GetValueIfFindKey<std::vector<AbilityInfo>>(jsonObject,
766         jsonObjectEnd,
767         HAP_MODULE_INFO_ABILITY_INFOS,
768         hapModuleInfo.abilityInfos,
769         JsonType::ARRAY,
770         false,
771         parseResult,
772         ArrayType::OBJECT);
773     GetValueIfFindKey<ModuleColorMode>(jsonObject,
774         jsonObjectEnd,
775         HAP_MODULE_INFO_COLOR_MODE,
776         hapModuleInfo.colorMode,
777         JsonType::NUMBER,
778         false,
779         parseResult,
780         ArrayType::NOT_ARRAY);
781     GetValueIfFindKey<std::string>(jsonObject,
782         jsonObjectEnd,
783         Constants::BUNDLE_NAME,
784         hapModuleInfo.bundleName,
785         JsonType::STRING,
786         false,
787         parseResult,
788         ArrayType::NOT_ARRAY);
789     GetValueIfFindKey<std::string>(jsonObject,
790         jsonObjectEnd,
791         HAP_MODULE_INFO_MAIN_ELEMENTNAME,
792         hapModuleInfo.mainElementName,
793         JsonType::STRING,
794         false,
795         parseResult,
796         ArrayType::NOT_ARRAY);
797     GetValueIfFindKey<std::string>(jsonObject,
798         jsonObjectEnd,
799         HAP_MODULE_INFO_PAGES,
800         hapModuleInfo.pages,
801         JsonType::STRING,
802         false,
803         parseResult,
804         ArrayType::NOT_ARRAY);
805     GetValueIfFindKey<std::string>(jsonObject,
806         jsonObjectEnd,
807         HAP_MODULE_INFO_PROCESS,
808         hapModuleInfo.process,
809         JsonType::STRING,
810         false,
811         parseResult,
812         ArrayType::NOT_ARRAY);
813     GetValueIfFindKey<std::string>(jsonObject,
814         jsonObjectEnd,
815         HAP_MODULE_INFO_RESOURCE_PATH,
816         hapModuleInfo.resourcePath,
817         JsonType::STRING,
818         false,
819         parseResult,
820         ArrayType::NOT_ARRAY);
821     GetValueIfFindKey<std::string>(jsonObject,
822         jsonObjectEnd,
823         HAP_MODULE_INFO_SRC_ENTRANCE,
824         hapModuleInfo.srcEntrance,
825         JsonType::STRING,
826         false,
827         parseResult,
828         ArrayType::NOT_ARRAY);
829     GetValueIfFindKey<std::string>(jsonObject,
830         jsonObjectEnd,
831         HAP_MODULE_INFO_UI_SYNTAX,
832         hapModuleInfo.uiSyntax,
833         JsonType::STRING,
834         false,
835         parseResult,
836         ArrayType::NOT_ARRAY);
837     GetValueIfFindKey<std::string>(jsonObject,
838         jsonObjectEnd,
839         HAP_MODULE_INFO_VIRTUAL_MACHINE,
840         hapModuleInfo.virtualMachine,
841         JsonType::STRING,
842         false,
843         parseResult,
844         ArrayType::NOT_ARRAY);
845     GetValueIfFindKey<bool>(jsonObject,
846         jsonObjectEnd,
847         HAP_MODULE_INFO_DELIVERY_WITH_INSTALL,
848         hapModuleInfo.deliveryWithInstall,
849         JsonType::BOOLEAN,
850         false,
851         parseResult,
852         ArrayType::NOT_ARRAY);
853     GetValueIfFindKey<bool>(jsonObject,
854         jsonObjectEnd,
855         HAP_MODULE_INFO_INSTALLATION_FREE,
856         hapModuleInfo.installationFree,
857         JsonType::BOOLEAN,
858         false,
859         parseResult,
860         ArrayType::NOT_ARRAY);
861     GetValueIfFindKey<bool>(jsonObject,
862         jsonObjectEnd,
863         HAP_MODULE_INFO_IS_MODULE_JSON,
864         hapModuleInfo.isModuleJson,
865         JsonType::BOOLEAN,
866         false,
867         parseResult,
868         ArrayType::NOT_ARRAY);
869     GetValueIfFindKey<bool>(jsonObject,
870         jsonObjectEnd,
871         HAP_MODULE_INFO_IS_STAGE_BASED_MODEL,
872         hapModuleInfo.isStageBasedModel,
873         JsonType::BOOLEAN,
874         false,
875         parseResult,
876         ArrayType::NOT_ARRAY);
877     GetValueIfFindKey<std::map<std::string, bool>>(jsonObject,
878         jsonObjectEnd,
879         HAP_MODULE_INFO_IS_REMOVABLE,
880         hapModuleInfo.isRemovable,
881         JsonType::OBJECT,
882         false,
883         parseResult,
884         ArrayType::NOT_ARRAY);
885     GetValueIfFindKey<int32_t>(jsonObject,
886         jsonObjectEnd,
887         HAP_MODULE_INFO_UPGRADE_FLAG,
888         hapModuleInfo.upgradeFlag,
889         JsonType::NUMBER,
890         false,
891         parseResult,
892         ArrayType::NOT_ARRAY);
893     GetValueIfFindKey<ModuleType>(jsonObject,
894         jsonObjectEnd,
895         HAP_MODULE_INFO_MODULE_TYPE,
896         hapModuleInfo.moduleType,
897         JsonType::NUMBER,
898         false,
899         parseResult,
900         ArrayType::NOT_ARRAY);
901     GetValueIfFindKey<std::vector<ExtensionAbilityInfo>>(jsonObject,
902         jsonObjectEnd,
903         HAP_MODULE_INFO_EXTENSION_INFOS,
904         hapModuleInfo.extensionInfos,
905         JsonType::ARRAY,
906         false,
907         parseResult,
908         ArrayType::OBJECT);
909     GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
910         jsonObjectEnd,
911         HAP_MODULE_INFO_META_DATA,
912         hapModuleInfo.metadata,
913         JsonType::ARRAY,
914         false,
915         parseResult,
916         ArrayType::OBJECT);
917     GetValueIfFindKey<std::vector<Dependency>>(jsonObject,
918         jsonObjectEnd,
919         HAP_MODULE_INFO_DEPENDENCIES,
920         hapModuleInfo.dependencies,
921         JsonType::ARRAY,
922         false,
923         parseResult,
924         ArrayType::OBJECT);
925     GetValueIfFindKey<CompileMode>(jsonObject,
926         jsonObjectEnd,
927         HAP_MODULE_INFO_COMPILE_MODE,
928         hapModuleInfo.compileMode,
929         JsonType::NUMBER,
930         false,
931         parseResult,
932         ArrayType::NOT_ARRAY);
933     GetValueIfFindKey<HqfInfo>(jsonObject,
934         jsonObjectEnd,
935         HAP_MODULE_INFO_HQF_INFO,
936         hapModuleInfo.hqfInfo,
937         JsonType::OBJECT,
938         false,
939         parseResult,
940         ArrayType::NOT_ARRAY);
941     GetValueIfFindKey<bool>(jsonObject,
942         jsonObjectEnd,
943         HAP_MODULE_INFO_IS_LIB_ISOLATED,
944         hapModuleInfo.isLibIsolated,
945         JsonType::BOOLEAN,
946         false,
947         parseResult,
948         ArrayType::NOT_ARRAY);
949     GetValueIfFindKey<std::string>(jsonObject,
950         jsonObjectEnd,
951         HAP_MODULE_INFO_NATIVE_LIBRARY_PATH,
952         hapModuleInfo.nativeLibraryPath,
953         JsonType::STRING,
954         false,
955         parseResult,
956         ArrayType::NOT_ARRAY);
957     GetValueIfFindKey<std::string>(jsonObject,
958         jsonObjectEnd,
959         HAP_MODULE_INFO_CPU_ABI,
960         hapModuleInfo.cpuAbi,
961         JsonType::STRING,
962         false,
963         parseResult,
964         ArrayType::NOT_ARRAY);
965     GetValueIfFindKey<std::string>(jsonObject,
966         jsonObjectEnd,
967         HAP_MODULE_INFO_MODULE_SOURCE_DIR,
968         hapModuleInfo.moduleSourceDir,
969         JsonType::STRING,
970         false,
971         parseResult,
972         ArrayType::NOT_ARRAY);
973     GetValueIfFindKey<std::vector<OverlayModuleInfo>>(jsonObject,
974         jsonObjectEnd,
975         HAP_OVERLAY_MODULE_INFO,
976         hapModuleInfo.overlayModuleInfos,
977         JsonType::ARRAY,
978         false,
979         parseResult,
980         ArrayType::OBJECT);
981     GetValueIfFindKey<std::vector<PreloadItem>>(jsonObject,
982         jsonObjectEnd,
983         HAP_MODULE_INFO_PRELOADS,
984         hapModuleInfo.preloads,
985         JsonType::ARRAY,
986         false,
987         parseResult,
988         ArrayType::OBJECT);
989     GetValueIfFindKey<std::vector<ProxyData>>(jsonObject,
990         jsonObjectEnd,
991         HAP_MODULE_INFO_PROXY_DATAS,
992         hapModuleInfo.proxyDatas,
993         JsonType::ARRAY,
994         false,
995         parseResult,
996         ArrayType::OBJECT);
997     GetValueIfFindKey<std::string>(jsonObject,
998         jsonObjectEnd,
999         HAP_MODULE_INFO_BUILD_HASH,
1000         hapModuleInfo.buildHash,
1001         JsonType::STRING,
1002         false,
1003         parseResult,
1004         ArrayType::NOT_ARRAY);
1005     GetValueIfFindKey<IsolationMode>(jsonObject,
1006         jsonObjectEnd,
1007         HAP_MODULE_INFO_ISOLATION_MODE,
1008         hapModuleInfo.isolationMode,
1009         JsonType::NUMBER,
1010         false,
1011         parseResult,
1012         ArrayType::NOT_ARRAY);
1013     GetValueIfFindKey<AOTCompileStatus>(jsonObject,
1014         jsonObjectEnd,
1015         HAP_MODULE_INFO_AOT_COMPILE_STATUS,
1016         hapModuleInfo.aotCompileStatus,
1017         JsonType::NUMBER,
1018         false,
1019         parseResult,
1020         ArrayType::NOT_ARRAY);
1021     GetValueIfFindKey<bool>(jsonObject,
1022         jsonObjectEnd,
1023         HAP_MODULE_INFO_COMPRESS_NATIVE_LIBS,
1024         hapModuleInfo.compressNativeLibs,
1025         JsonType::BOOLEAN,
1026         false,
1027         parseResult,
1028         ArrayType::NOT_ARRAY);
1029     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1030         jsonObjectEnd,
1031         HAP_MODULE_INFO_NATIVE_LIBRARY_FILE_NAMES,
1032         hapModuleInfo.nativeLibraryFileNames,
1033         JsonType::ARRAY,
1034         false,
1035         parseResult,
1036         ArrayType::STRING);
1037     GetValueIfFindKey<std::string>(jsonObject,
1038         jsonObjectEnd,
1039         HAP_MODULE_INFO_FILE_CONTEXT_MENU,
1040         hapModuleInfo.fileContextMenu,
1041         JsonType::STRING,
1042         false,
1043         parseResult,
1044         ArrayType::NOT_ARRAY);
1045     if (parseResult != ERR_OK) {
1046         APP_LOGW("HapModuleInfo from_json error, error code : %{public}d", parseResult);
1047     }
1048 }
1049 }  // namespace AppExecFwk
1050 }  // namespace OHOS
1051