• 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_ATOMIC_SERVICE_MODULE_TYPE = "atomicServiceModuleType";
71 const std::string HAP_MODULE_INFO_PRELOADS = "preloads";
72 const std::string PRELOAD_ITEM_MODULE_NAME = "moduleName";
73 const std::string HAP_MODULE_INFO_VERSION_CODE = "versionCode";
74 const std::string HAP_MODULE_INFO_PROXY_DATAS = "proxyDatas";
75 const std::string PROXY_DATA_URI = "uri";
76 const std::string PROXY_DATA_REQUIRED_READ_PERMISSION = "requiredReadPermission";
77 const std::string PROXY_DATA_REQUIRED_WRITE_PERMISSION = "requiredWritePermission";
78 const std::string PROXY_DATA_METADATA = "metadata";
79 const std::string HAP_MODULE_INFO_BUILD_HASH = "buildHash";
80 const std::string HAP_MODULE_INFO_ISOLATION_MODE = "isolationMode";
81 const std::string HAP_MODULE_INFO_AOT_COMPILE_STATUS = "aotCompileStatus";
82 const std::string HAP_MODULE_INFO_COMPRESS_NATIVE_LIBS = "compressNativeLibs";
83 const std::string HAP_MODULE_INFO_NATIVE_LIBRARY_FILE_NAMES = "nativeLibraryFileNames";
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     atomicServiceModuleType = static_cast<AtomicServiceModuleType>(parcel.ReadInt32());
417 
418     int32_t preloadsSize;
419     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, preloadsSize);
420     CONTAINER_SECURITY_VERIFY(parcel, preloadsSize, &preloads);
421     for (int32_t i = 0; i < preloadsSize; ++i) {
422         std::unique_ptr<PreloadItem> preload(parcel.ReadParcelable<PreloadItem>());
423         if (!preload) {
424             APP_LOGE("ReadParcelable<PreloadItem> failed");
425             return false;
426         }
427         preloads.emplace_back(*preload);
428     }
429     int32_t proxyDatasSize;
430     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, proxyDatasSize);
431     CONTAINER_SECURITY_VERIFY(parcel, proxyDatasSize, &proxyDatas);
432     for (int32_t i = 0; i < proxyDatasSize; ++i) {
433         std::unique_ptr<ProxyData> proxyData(parcel.ReadParcelable<ProxyData>());
434         if (!proxyData) {
435             APP_LOGE("ReadParcelable<ProxyData> failed");
436             return false;
437         }
438         proxyDatas.emplace_back(*proxyData);
439     }
440     buildHash = Str16ToStr8(parcel.ReadString16());
441     isolationMode = static_cast<IsolationMode>(parcel.ReadInt32());
442     aotCompileStatus = static_cast<AOTCompileStatus>(parcel.ReadInt32());
443     compressNativeLibs = parcel.ReadBool();
444     int32_t nativeLibraryFileNamesSize;
445     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, nativeLibraryFileNamesSize);
446     for (int32_t i = 0; i < nativeLibraryFileNamesSize; ++i) {
447         nativeLibraryFileNames.emplace_back(Str16ToStr8(parcel.ReadString16()));
448     }
449     return true;
450 }
451 
Unmarshalling(Parcel & parcel)452 HapModuleInfo *HapModuleInfo::Unmarshalling(Parcel &parcel)
453 {
454     HapModuleInfo *info = new (std::nothrow) HapModuleInfo();
455     if (info && !info->ReadFromParcel(parcel)) {
456         APP_LOGW("read from parcel failed");
457         delete info;
458         info = nullptr;
459     }
460     return info;
461 }
462 
Marshalling(Parcel & parcel) const463 bool HapModuleInfo::Marshalling(Parcel &parcel) const
464 {
465     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilityInfos.size());
466     for (auto &abilityInfo : abilityInfos) {
467         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &abilityInfo);
468     }
469 
470     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extensionInfos.size());
471     for (auto &extensionInfo : extensionInfos) {
472         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &extensionInfo);
473     }
474 
475     CHECK_PARCEL_CAPACITY(parcel, MODULE_CAPACITY);
476     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
477     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(package));
478     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
479     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
480     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, descriptionId);
481     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(iconPath));
482     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, iconId);
483     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
484     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, labelId);
485     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(backgroundImg));
486     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mainAbility));
487     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcPath));
488     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hashValue));
489     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapPath));
490     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportedModes);
491 
492     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqCapabilities.size());
493     for (auto &reqCapability : reqCapabilities) {
494         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(reqCapability));
495     }
496 
497     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceTypes.size());
498     for (auto &deviceType : deviceTypes) {
499         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(deviceType));
500     }
501 
502     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, dependencies.size());
503     for (auto &dependency : dependencies) {
504         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &dependency);
505     }
506 
507     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(colorMode));
508     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
509     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mainElementName));
510     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(pages));
511     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(process));
512     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(resourcePath));
513     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcEntrance));
514     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uiSyntax));
515     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(virtualMachine));
516     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, deliveryWithInstall);
517     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, installationFree);
518     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isModuleJson);
519     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isStageBasedModel);
520 
521     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, isRemovable.size());
522     for (auto &item : isRemovable) {
523         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(item.first));
524         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, item.second);
525     }
526 
527     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(moduleType));
528 
529     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadata.size());
530     for (auto &mete : metadata) {
531         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &mete);
532     }
533 
534     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, upgradeFlag);
535     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(compileMode));
536     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &hqfInfo);
537     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isLibIsolated);
538     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(nativeLibraryPath));
539     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(cpuAbi));
540     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleSourceDir));
541     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayModuleInfos.size());
542     for (auto &overlayModuleInfo : overlayModuleInfos) {
543         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &overlayModuleInfo);
544     }
545     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(atomicServiceModuleType));
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     return true;
564 }
565 
to_json(nlohmann::json & jsonObject,const HapModuleInfo & hapModuleInfo)566 void to_json(nlohmann::json &jsonObject, const HapModuleInfo &hapModuleInfo)
567 {
568     jsonObject = nlohmann::json {
569         {HAP_MODULE_INFO_NAME, hapModuleInfo.name},
570         {HAP_MODULE_INFO_PACKAGE, hapModuleInfo.package},
571         {Constants::MODULE_NAME, hapModuleInfo.moduleName},
572         {HAP_MODULE_INFO_DESCRIPTION, hapModuleInfo.description},
573         {HAP_MODULE_INFO_DESCRIPTION_ID, hapModuleInfo.descriptionId},
574         {HAP_MODULE_INFO_ICON_PATH, hapModuleInfo.iconPath},
575         {HAP_MODULE_INFO_ICON_ID, hapModuleInfo.iconId},
576         {HAP_MODULE_INFO_LABEL, hapModuleInfo.label},
577         {HAP_MODULE_INFO_LABEL_ID, hapModuleInfo.labelId},
578         {HAP_MODULE_INFO_BACKGROUND_IMG, hapModuleInfo.backgroundImg},
579         {HAP_MODULE_INFO_MAIN_ABILITY, hapModuleInfo.mainAbility},
580         {HAP_MODULE_INFO_SRC_PATH, hapModuleInfo.srcPath},
581         {HAP_MODULE_INFO_HASH_VALUE, hapModuleInfo.hashValue},
582         {HAP_MODULE_INFO_HAP_PATH, hapModuleInfo.hapPath},
583         {HAP_MODULE_INFO_SUPPORTED_MODES, hapModuleInfo.supportedModes},
584         {HAP_MODULE_INFO_REQ_CAPABILITIES, hapModuleInfo.reqCapabilities},
585         {HAP_MODULE_INFO_DEVICE_TYPES, hapModuleInfo.deviceTypes},
586         {HAP_MODULE_INFO_ABILITY_INFOS, hapModuleInfo.abilityInfos},
587         {HAP_MODULE_INFO_COLOR_MODE, hapModuleInfo.colorMode},
588         {Constants::BUNDLE_NAME, hapModuleInfo.bundleName},
589         {HAP_MODULE_INFO_MAIN_ELEMENTNAME, hapModuleInfo.mainElementName},
590         {HAP_MODULE_INFO_PAGES, hapModuleInfo.pages},
591         {HAP_MODULE_INFO_PROCESS, hapModuleInfo.process},
592         {HAP_MODULE_INFO_RESOURCE_PATH, hapModuleInfo.resourcePath},
593         {HAP_MODULE_INFO_SRC_ENTRANCE, hapModuleInfo.srcEntrance},
594         {HAP_MODULE_INFO_UI_SYNTAX, hapModuleInfo.uiSyntax},
595         {HAP_MODULE_INFO_VIRTUAL_MACHINE, hapModuleInfo.virtualMachine},
596         {HAP_MODULE_INFO_DELIVERY_WITH_INSTALL, hapModuleInfo.deliveryWithInstall},
597         {HAP_MODULE_INFO_INSTALLATION_FREE, hapModuleInfo.installationFree},
598         {HAP_MODULE_INFO_IS_MODULE_JSON, hapModuleInfo.isModuleJson},
599         {HAP_MODULE_INFO_IS_STAGE_BASED_MODEL, hapModuleInfo.isStageBasedModel},
600         {HAP_MODULE_INFO_IS_REMOVABLE, hapModuleInfo.isRemovable},
601         {HAP_MODULE_INFO_UPGRADE_FLAG, hapModuleInfo.upgradeFlag},
602         {HAP_MODULE_INFO_MODULE_TYPE, hapModuleInfo.moduleType},
603         {HAP_MODULE_INFO_EXTENSION_INFOS, hapModuleInfo.extensionInfos},
604         {HAP_MODULE_INFO_META_DATA, hapModuleInfo.metadata},
605         {HAP_MODULE_INFO_DEPENDENCIES, hapModuleInfo.dependencies},
606         {HAP_MODULE_INFO_COMPILE_MODE, hapModuleInfo.compileMode},
607         {HAP_MODULE_INFO_HQF_INFO, hapModuleInfo.hqfInfo},
608         {HAP_MODULE_INFO_IS_LIB_ISOLATED, hapModuleInfo.isLibIsolated},
609         {HAP_MODULE_INFO_NATIVE_LIBRARY_PATH, hapModuleInfo.nativeLibraryPath},
610         {HAP_MODULE_INFO_CPU_ABI, hapModuleInfo.cpuAbi},
611         {HAP_MODULE_INFO_MODULE_SOURCE_DIR, hapModuleInfo.moduleSourceDir},
612         {HAP_OVERLAY_MODULE_INFO, hapModuleInfo.overlayModuleInfos},
613         {HAP_MODULE_INFO_ATOMIC_SERVICE_MODULE_TYPE, hapModuleInfo.atomicServiceModuleType},
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     };
622 }
623 
from_json(const nlohmann::json & jsonObject,HapModuleInfo & hapModuleInfo)624 void from_json(const nlohmann::json &jsonObject, HapModuleInfo &hapModuleInfo)
625 {
626     const auto &jsonObjectEnd = jsonObject.end();
627     int32_t parseResult = ERR_OK;
628     GetValueIfFindKey<std::string>(jsonObject,
629         jsonObjectEnd,
630         HAP_MODULE_INFO_NAME,
631         hapModuleInfo.name,
632         JsonType::STRING,
633         false,
634         parseResult,
635         ArrayType::NOT_ARRAY);
636     GetValueIfFindKey<std::string>(jsonObject,
637         jsonObjectEnd,
638         HAP_MODULE_INFO_PACKAGE,
639         hapModuleInfo.package,
640         JsonType::STRING,
641         false,
642         parseResult,
643         ArrayType::NOT_ARRAY);
644     GetValueIfFindKey<std::string>(jsonObject,
645         jsonObjectEnd,
646         Constants::MODULE_NAME,
647         hapModuleInfo.moduleName,
648         JsonType::STRING,
649         false,
650         parseResult,
651         ArrayType::NOT_ARRAY);
652     GetValueIfFindKey<std::string>(jsonObject,
653         jsonObjectEnd,
654         HAP_MODULE_INFO_DESCRIPTION,
655         hapModuleInfo.description,
656         JsonType::STRING,
657         false,
658         parseResult,
659         ArrayType::NOT_ARRAY);
660     GetValueIfFindKey<int>(jsonObject,
661         jsonObjectEnd,
662         HAP_MODULE_INFO_DESCRIPTION_ID,
663         hapModuleInfo.descriptionId,
664         JsonType::NUMBER,
665         false,
666         parseResult,
667         ArrayType::NOT_ARRAY);
668     GetValueIfFindKey<std::string>(jsonObject,
669         jsonObjectEnd,
670         HAP_MODULE_INFO_ICON_PATH,
671         hapModuleInfo.iconPath,
672         JsonType::STRING,
673         false,
674         parseResult,
675         ArrayType::NOT_ARRAY);
676     GetValueIfFindKey<int>(jsonObject,
677         jsonObjectEnd,
678         HAP_MODULE_INFO_ICON_ID,
679         hapModuleInfo.iconId,
680         JsonType::NUMBER,
681         false,
682         parseResult,
683         ArrayType::NOT_ARRAY);
684     GetValueIfFindKey<std::string>(jsonObject,
685         jsonObjectEnd,
686         HAP_MODULE_INFO_LABEL,
687         hapModuleInfo.label,
688         JsonType::STRING,
689         false,
690         parseResult,
691         ArrayType::NOT_ARRAY);
692     GetValueIfFindKey<int>(jsonObject,
693         jsonObjectEnd,
694         HAP_MODULE_INFO_LABEL_ID,
695         hapModuleInfo.labelId,
696         JsonType::NUMBER,
697         false,
698         parseResult,
699         ArrayType::NOT_ARRAY);
700     GetValueIfFindKey<std::string>(jsonObject,
701         jsonObjectEnd,
702         HAP_MODULE_INFO_BACKGROUND_IMG,
703         hapModuleInfo.backgroundImg,
704         JsonType::STRING,
705         false,
706         parseResult,
707         ArrayType::NOT_ARRAY);
708     GetValueIfFindKey<std::string>(jsonObject,
709         jsonObjectEnd,
710         HAP_MODULE_INFO_MAIN_ABILITY,
711         hapModuleInfo.mainAbility,
712         JsonType::STRING,
713         false,
714         parseResult,
715         ArrayType::NOT_ARRAY);
716     GetValueIfFindKey<std::string>(jsonObject,
717         jsonObjectEnd,
718         HAP_MODULE_INFO_SRC_PATH,
719         hapModuleInfo.srcPath,
720         JsonType::STRING,
721         false,
722         parseResult,
723         ArrayType::NOT_ARRAY);
724     GetValueIfFindKey<std::string>(jsonObject,
725         jsonObjectEnd,
726         HAP_MODULE_INFO_HASH_VALUE,
727         hapModuleInfo.hashValue,
728         JsonType::STRING,
729         false,
730         parseResult,
731         ArrayType::NOT_ARRAY);
732     GetValueIfFindKey<std::string>(jsonObject,
733         jsonObjectEnd,
734         HAP_MODULE_INFO_HAP_PATH,
735         hapModuleInfo.hapPath,
736         JsonType::STRING,
737         false,
738         parseResult,
739         ArrayType::NOT_ARRAY);
740     GetValueIfFindKey<int>(jsonObject,
741         jsonObjectEnd,
742         HAP_MODULE_INFO_SUPPORTED_MODES,
743         hapModuleInfo.supportedModes,
744         JsonType::NUMBER,
745         false,
746         parseResult,
747         ArrayType::NOT_ARRAY);
748     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
749         jsonObjectEnd,
750         HAP_MODULE_INFO_REQ_CAPABILITIES,
751         hapModuleInfo.reqCapabilities,
752         JsonType::ARRAY,
753         false,
754         parseResult,
755         ArrayType::STRING);
756     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
757         jsonObjectEnd,
758         HAP_MODULE_INFO_DEVICE_TYPES,
759         hapModuleInfo.deviceTypes,
760         JsonType::ARRAY,
761         false,
762         parseResult,
763         ArrayType::STRING);
764     GetValueIfFindKey<std::vector<AbilityInfo>>(jsonObject,
765         jsonObjectEnd,
766         HAP_MODULE_INFO_ABILITY_INFOS,
767         hapModuleInfo.abilityInfos,
768         JsonType::ARRAY,
769         false,
770         parseResult,
771         ArrayType::OBJECT);
772     GetValueIfFindKey<ModuleColorMode>(jsonObject,
773         jsonObjectEnd,
774         HAP_MODULE_INFO_COLOR_MODE,
775         hapModuleInfo.colorMode,
776         JsonType::NUMBER,
777         false,
778         parseResult,
779         ArrayType::NOT_ARRAY);
780     GetValueIfFindKey<std::string>(jsonObject,
781         jsonObjectEnd,
782         Constants::BUNDLE_NAME,
783         hapModuleInfo.bundleName,
784         JsonType::STRING,
785         false,
786         parseResult,
787         ArrayType::NOT_ARRAY);
788     GetValueIfFindKey<std::string>(jsonObject,
789         jsonObjectEnd,
790         HAP_MODULE_INFO_MAIN_ELEMENTNAME,
791         hapModuleInfo.mainElementName,
792         JsonType::STRING,
793         false,
794         parseResult,
795         ArrayType::NOT_ARRAY);
796     GetValueIfFindKey<std::string>(jsonObject,
797         jsonObjectEnd,
798         HAP_MODULE_INFO_PAGES,
799         hapModuleInfo.pages,
800         JsonType::STRING,
801         false,
802         parseResult,
803         ArrayType::NOT_ARRAY);
804     GetValueIfFindKey<std::string>(jsonObject,
805         jsonObjectEnd,
806         HAP_MODULE_INFO_PROCESS,
807         hapModuleInfo.process,
808         JsonType::STRING,
809         false,
810         parseResult,
811         ArrayType::NOT_ARRAY);
812     GetValueIfFindKey<std::string>(jsonObject,
813         jsonObjectEnd,
814         HAP_MODULE_INFO_RESOURCE_PATH,
815         hapModuleInfo.resourcePath,
816         JsonType::STRING,
817         false,
818         parseResult,
819         ArrayType::NOT_ARRAY);
820     GetValueIfFindKey<std::string>(jsonObject,
821         jsonObjectEnd,
822         HAP_MODULE_INFO_SRC_ENTRANCE,
823         hapModuleInfo.srcEntrance,
824         JsonType::STRING,
825         false,
826         parseResult,
827         ArrayType::NOT_ARRAY);
828     GetValueIfFindKey<std::string>(jsonObject,
829         jsonObjectEnd,
830         HAP_MODULE_INFO_UI_SYNTAX,
831         hapModuleInfo.uiSyntax,
832         JsonType::STRING,
833         false,
834         parseResult,
835         ArrayType::NOT_ARRAY);
836     GetValueIfFindKey<std::string>(jsonObject,
837         jsonObjectEnd,
838         HAP_MODULE_INFO_VIRTUAL_MACHINE,
839         hapModuleInfo.virtualMachine,
840         JsonType::STRING,
841         false,
842         parseResult,
843         ArrayType::NOT_ARRAY);
844     GetValueIfFindKey<bool>(jsonObject,
845         jsonObjectEnd,
846         HAP_MODULE_INFO_DELIVERY_WITH_INSTALL,
847         hapModuleInfo.deliveryWithInstall,
848         JsonType::BOOLEAN,
849         false,
850         parseResult,
851         ArrayType::NOT_ARRAY);
852     GetValueIfFindKey<bool>(jsonObject,
853         jsonObjectEnd,
854         HAP_MODULE_INFO_INSTALLATION_FREE,
855         hapModuleInfo.installationFree,
856         JsonType::BOOLEAN,
857         false,
858         parseResult,
859         ArrayType::NOT_ARRAY);
860     GetValueIfFindKey<bool>(jsonObject,
861         jsonObjectEnd,
862         HAP_MODULE_INFO_IS_MODULE_JSON,
863         hapModuleInfo.isModuleJson,
864         JsonType::BOOLEAN,
865         false,
866         parseResult,
867         ArrayType::NOT_ARRAY);
868     GetValueIfFindKey<bool>(jsonObject,
869         jsonObjectEnd,
870         HAP_MODULE_INFO_IS_STAGE_BASED_MODEL,
871         hapModuleInfo.isStageBasedModel,
872         JsonType::BOOLEAN,
873         false,
874         parseResult,
875         ArrayType::NOT_ARRAY);
876     GetValueIfFindKey<std::map<std::string, bool>>(jsonObject,
877         jsonObjectEnd,
878         HAP_MODULE_INFO_IS_REMOVABLE,
879         hapModuleInfo.isRemovable,
880         JsonType::OBJECT,
881         false,
882         parseResult,
883         ArrayType::NOT_ARRAY);
884     GetValueIfFindKey<int32_t>(jsonObject,
885         jsonObjectEnd,
886         HAP_MODULE_INFO_UPGRADE_FLAG,
887         hapModuleInfo.upgradeFlag,
888         JsonType::NUMBER,
889         false,
890         parseResult,
891         ArrayType::NOT_ARRAY);
892     GetValueIfFindKey<ModuleType>(jsonObject,
893         jsonObjectEnd,
894         HAP_MODULE_INFO_MODULE_TYPE,
895         hapModuleInfo.moduleType,
896         JsonType::NUMBER,
897         false,
898         parseResult,
899         ArrayType::NOT_ARRAY);
900     GetValueIfFindKey<std::vector<ExtensionAbilityInfo>>(jsonObject,
901         jsonObjectEnd,
902         HAP_MODULE_INFO_EXTENSION_INFOS,
903         hapModuleInfo.extensionInfos,
904         JsonType::ARRAY,
905         false,
906         parseResult,
907         ArrayType::OBJECT);
908     GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
909         jsonObjectEnd,
910         HAP_MODULE_INFO_META_DATA,
911         hapModuleInfo.metadata,
912         JsonType::ARRAY,
913         false,
914         parseResult,
915         ArrayType::OBJECT);
916     GetValueIfFindKey<std::vector<Dependency>>(jsonObject,
917         jsonObjectEnd,
918         HAP_MODULE_INFO_DEPENDENCIES,
919         hapModuleInfo.dependencies,
920         JsonType::ARRAY,
921         false,
922         parseResult,
923         ArrayType::OBJECT);
924     GetValueIfFindKey<CompileMode>(jsonObject,
925         jsonObjectEnd,
926         HAP_MODULE_INFO_COMPILE_MODE,
927         hapModuleInfo.compileMode,
928         JsonType::NUMBER,
929         false,
930         parseResult,
931         ArrayType::NOT_ARRAY);
932     GetValueIfFindKey<HqfInfo>(jsonObject,
933         jsonObjectEnd,
934         HAP_MODULE_INFO_HQF_INFO,
935         hapModuleInfo.hqfInfo,
936         JsonType::OBJECT,
937         false,
938         parseResult,
939         ArrayType::NOT_ARRAY);
940     GetValueIfFindKey<bool>(jsonObject,
941         jsonObjectEnd,
942         HAP_MODULE_INFO_IS_LIB_ISOLATED,
943         hapModuleInfo.isLibIsolated,
944         JsonType::BOOLEAN,
945         false,
946         parseResult,
947         ArrayType::NOT_ARRAY);
948     GetValueIfFindKey<std::string>(jsonObject,
949         jsonObjectEnd,
950         HAP_MODULE_INFO_NATIVE_LIBRARY_PATH,
951         hapModuleInfo.nativeLibraryPath,
952         JsonType::STRING,
953         false,
954         parseResult,
955         ArrayType::NOT_ARRAY);
956     GetValueIfFindKey<std::string>(jsonObject,
957         jsonObjectEnd,
958         HAP_MODULE_INFO_CPU_ABI,
959         hapModuleInfo.cpuAbi,
960         JsonType::STRING,
961         false,
962         parseResult,
963         ArrayType::NOT_ARRAY);
964     GetValueIfFindKey<std::string>(jsonObject,
965         jsonObjectEnd,
966         HAP_MODULE_INFO_MODULE_SOURCE_DIR,
967         hapModuleInfo.moduleSourceDir,
968         JsonType::STRING,
969         false,
970         parseResult,
971         ArrayType::NOT_ARRAY);
972     GetValueIfFindKey<std::vector<OverlayModuleInfo>>(jsonObject,
973         jsonObjectEnd,
974         HAP_OVERLAY_MODULE_INFO,
975         hapModuleInfo.overlayModuleInfos,
976         JsonType::ARRAY,
977         false,
978         parseResult,
979         ArrayType::OBJECT);
980     GetValueIfFindKey<AtomicServiceModuleType>(jsonObject,
981         jsonObjectEnd,
982         HAP_MODULE_INFO_ATOMIC_SERVICE_MODULE_TYPE,
983         hapModuleInfo.atomicServiceModuleType,
984         JsonType::NUMBER,
985         false,
986         parseResult,
987         ArrayType::NOT_ARRAY);
988     GetValueIfFindKey<std::vector<PreloadItem>>(jsonObject,
989         jsonObjectEnd,
990         HAP_MODULE_INFO_PRELOADS,
991         hapModuleInfo.preloads,
992         JsonType::ARRAY,
993         false,
994         parseResult,
995         ArrayType::OBJECT);
996     GetValueIfFindKey<std::vector<ProxyData>>(jsonObject,
997         jsonObjectEnd,
998         HAP_MODULE_INFO_PROXY_DATAS,
999         hapModuleInfo.proxyDatas,
1000         JsonType::ARRAY,
1001         false,
1002         parseResult,
1003         ArrayType::OBJECT);
1004     GetValueIfFindKey<std::string>(jsonObject,
1005         jsonObjectEnd,
1006         HAP_MODULE_INFO_BUILD_HASH,
1007         hapModuleInfo.buildHash,
1008         JsonType::STRING,
1009         false,
1010         parseResult,
1011         ArrayType::NOT_ARRAY);
1012     GetValueIfFindKey<IsolationMode>(jsonObject,
1013         jsonObjectEnd,
1014         HAP_MODULE_INFO_ISOLATION_MODE,
1015         hapModuleInfo.isolationMode,
1016         JsonType::NUMBER,
1017         false,
1018         parseResult,
1019         ArrayType::NOT_ARRAY);
1020     GetValueIfFindKey<AOTCompileStatus>(jsonObject,
1021         jsonObjectEnd,
1022         HAP_MODULE_INFO_AOT_COMPILE_STATUS,
1023         hapModuleInfo.aotCompileStatus,
1024         JsonType::NUMBER,
1025         false,
1026         parseResult,
1027         ArrayType::NOT_ARRAY);
1028     GetValueIfFindKey<bool>(jsonObject,
1029         jsonObjectEnd,
1030         HAP_MODULE_INFO_COMPRESS_NATIVE_LIBS,
1031         hapModuleInfo.compressNativeLibs,
1032         JsonType::BOOLEAN,
1033         false,
1034         parseResult,
1035         ArrayType::NOT_ARRAY);
1036     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1037         jsonObjectEnd,
1038         HAP_MODULE_INFO_NATIVE_LIBRARY_FILE_NAMES,
1039         hapModuleInfo.nativeLibraryFileNames,
1040         JsonType::ARRAY,
1041         false,
1042         parseResult,
1043         ArrayType::STRING);
1044     if (parseResult != ERR_OK) {
1045         APP_LOGW("HapModuleInfo from_json error, error code : %{public}d", parseResult);
1046     }
1047 }
1048 }  // namespace AppExecFwk
1049 }  // namespace OHOS
1050