• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2022 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 "bundle_info.h"
17 
18 #include "json_util.h"
19 #include "parcel_macro.h"
20 #include "string_ex.h"
21 #include <cstdint>
22 
23 namespace OHOS {
24 namespace AppExecFwk {
25 namespace {
26 const char* BUNDLE_INFO_NAME = "name";
27 const char* BUNDLE_INFO_LABEL = "label";
28 const char* BUNDLE_INFO_DESCRIPTION = "description";
29 const char* BUNDLE_INFO_VENDOR = "vendor";
30 const char* BUNDLE_INFO_IS_KEEP_ALIVE = "isKeepAlive";
31 const char* BUNDLE_INFO_SINGLETON = "singleton";
32 const char* BUNDLE_INFO_IS_NATIVE_APP = "isNativeApp";
33 const char* BUNDLE_INFO_IS_PREINSTALL_APP = "isPreInstallApp";
34 const char* BUNDLE_INFO_IS_DIFFERENT_NAME = "isDifferentName";
35 const char* BUNDLE_INFO_ABILITY_INFOS = "abilityInfos";
36 const char* BUNDLE_INFO_HAP_MODULE_INFOS = "hapModuleInfos";
37 const char* BUNDLE_INFO_EXTENSION_ABILITY_INFOS = "extensionAbilityInfo";
38 const char* BUNDLE_INFO_JOINT_USERID = "jointUserId";
39 const char* BUNDLE_INFO_VERSION_CODE = "versionCode";
40 const char* BUNDLE_INFO_MIN_COMPATIBLE_VERSION_CODE = "minCompatibleVersionCode";
41 const char* BUNDLE_INFO_VERSION_NAME = "versionName";
42 const char* BUNDLE_INFO_MIN_SDK_VERSION = "minSdkVersion";
43 const char* BUNDLE_INFO_MAX_SDK_VERSION = "maxSdkVersion";
44 const char* BUNDLE_INFO_MAIN_ENTRY = "mainEntry";
45 const char* BUNDLE_INFO_CPU_ABI = "cpuAbi";
46 const char* BUNDLE_INFO_APPID = "appId";
47 const char* BUNDLE_INFO_COMPATIBLE_VERSION = "compatibleVersion";
48 const char* BUNDLE_INFO_TARGET_VERSION = "targetVersion";
49 const char* BUNDLE_INFO_RELEASE_TYPE = "releaseType";
50 const char* BUNDLE_INFO_UID = "uid";
51 const char* BUNDLE_INFO_GID = "gid";
52 const char* BUNDLE_INFO_SEINFO = "seInfo";
53 const char* BUNDLE_INFO_INSTALL_TIME = "installTime";
54 const char* BUNDLE_INFO_UPDATE_TIME = "updateTime";
55 const char* BUNDLE_INFO_ENTRY_MODULE_NAME = "entryModuleName";
56 const char* BUNDLE_INFO_ENTRY_INSTALLATION_FREE = "entryInstallationFree";
57 const char* BUNDLE_INFO_REQ_PERMISSIONS = "reqPermissions";
58 const char* BUNDLE_INFO_REQ_PERMISSION_STATES = "reqPermissionStates";
59 const char* BUNDLE_INFO_REQ_PERMISSION_DETAILS = "reqPermissionDetails";
60 const char* BUNDLE_INFO_DEF_PERMISSIONS = "defPermissions";
61 const char* BUNDLE_INFO_HAP_MODULE_NAMES = "hapModuleNames";
62 const char* BUNDLE_INFO_MODULE_NAMES = "moduleNames";
63 const char* BUNDLE_INFO_MODULE_PUBLIC_DIRS = "modulePublicDirs";
64 const char* BUNDLE_INFO_MODULE_DIRS = "moduleDirs";
65 const char* BUNDLE_INFO_MODULE_RES_PATHS = "moduleResPaths";
66 const char* REQUESTPERMISSION_NAME = "name";
67 const char* REQUESTPERMISSION_REASON = "reason";
68 const char* REQUESTPERMISSION_REASON_ID = "reasonId";
69 const char* REQUESTPERMISSION_USEDSCENE = "usedScene";
70 const char* REQUESTPERMISSION_ABILITIES = "abilities";
71 const char* REQUESTPERMISSION_ABILITY = "ability";
72 const char* REQUESTPERMISSION_WHEN = "when";
73 const char* REQUESTPERMISSION_MODULE_NAME = "moduleName";
74 const char* SIGNATUREINFO_APPID = "appId";
75 const char* SIGNATUREINFO_FINGERPRINT = "fingerprint";
76 const char* BUNDLE_INFO_APP_INDEX = "appIndex";
77 const char* BUNDLE_INFO_SIGNATURE_INFO = "signatureInfo";
78 const char* OVERLAY_TYPE = "overlayType";
79 const char* OVERLAY_BUNDLE_INFO = "overlayBundleInfos";
80 const char* APP_IDENTIFIER = "appIdentifier";
81 const char* BUNDLE_INFO_OLD_APPIDS = "oldAppIds";
82 const char* BUNDLE_INFO_ROUTER_ARRAY = "routerArray";
83 const char* BUNDLE_INFO_IS_NEW_VERSION = "isNewVersion";
84 const uint16_t BUNDLE_CAPACITY = 20480; // 20K
85 }
86 
ReadFromParcel(Parcel & parcel)87 bool RequestPermissionUsedScene::ReadFromParcel(Parcel &parcel)
88 {
89     int32_t size;
90     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, size);
91     CONTAINER_SECURITY_VERIFY(parcel, size, &abilities);
92     for (int32_t i = 0; i < size; i++) {
93         abilities.emplace_back(Str16ToStr8(parcel.ReadString16()));
94     }
95     when = Str16ToStr8(parcel.ReadString16());
96     return true;
97 }
98 
Marshalling(Parcel & parcel) const99 bool RequestPermissionUsedScene::Marshalling(Parcel &parcel) const
100 {
101     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilities.size());
102     for (auto &ability : abilities) {
103         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(ability));
104     }
105     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(when));
106     return true;
107 }
108 
Unmarshalling(Parcel & parcel)109 RequestPermissionUsedScene *RequestPermissionUsedScene::Unmarshalling(Parcel &parcel)
110 {
111     RequestPermissionUsedScene *info = new (std::nothrow) RequestPermissionUsedScene();
112     if (info && !info->ReadFromParcel(parcel)) {
113         APP_LOGW("read from parcel failed");
114         delete info;
115         info = nullptr;
116     }
117     return info;
118 }
119 
ReadFromParcel(Parcel & parcel)120 bool RequestPermission::ReadFromParcel(Parcel &parcel)
121 {
122     name = Str16ToStr8(parcel.ReadString16());
123     reason = Str16ToStr8(parcel.ReadString16());
124     reasonId = parcel.ReadUint32();
125     std::unique_ptr<RequestPermissionUsedScene> scene(parcel.ReadParcelable<RequestPermissionUsedScene>());
126     if (!scene) {
127         APP_LOGE("ReadParcelable<RequestPermissionUsedScene> failed");
128         return false;
129     }
130     usedScene = *scene;
131     moduleName = Str16ToStr8(parcel.ReadString16());
132     return true;
133 }
134 
Marshalling(Parcel & parcel) const135 bool RequestPermission::Marshalling(Parcel &parcel) const
136 {
137     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
138     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(reason));
139     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reasonId);
140     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &usedScene);
141     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
142     return true;
143 }
144 
Unmarshalling(Parcel & parcel)145 RequestPermission *RequestPermission::Unmarshalling(Parcel &parcel)
146 {
147     RequestPermission *info = new (std::nothrow) RequestPermission();
148     if (info && !info->ReadFromParcel(parcel)) {
149         APP_LOGW("read from parcel failed");
150         delete info;
151         info = nullptr;
152     }
153     return info;
154 }
155 
ReadFromParcel(Parcel & parcel)156 bool SignatureInfo::ReadFromParcel(Parcel &parcel)
157 {
158     appId = Str16ToStr8(parcel.ReadString16());
159     fingerprint = Str16ToStr8(parcel.ReadString16());
160     appIdentifier = Str16ToStr8(parcel.ReadString16());
161     return true;
162 }
163 
Marshalling(Parcel & parcel) const164 bool SignatureInfo::Marshalling(Parcel &parcel) const
165 {
166     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(appId));
167     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(fingerprint));
168     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(appIdentifier));
169     return true;
170 }
171 
Unmarshalling(Parcel & parcel)172 SignatureInfo *SignatureInfo::Unmarshalling(Parcel &parcel)
173 {
174     SignatureInfo *info = new (std::nothrow) SignatureInfo();
175     if (info && !info->ReadFromParcel(parcel)) {
176         APP_LOGW("read from parcel failed");
177         delete info;
178         info = nullptr;
179     }
180     return info;
181 }
182 
ReadFromParcel(Parcel & parcel)183 bool BundleInfo::ReadFromParcel(Parcel &parcel)
184 {
185     std::unique_ptr<ApplicationInfo> appInfo(parcel.ReadParcelable<ApplicationInfo>());
186     if (!appInfo) {
187         APP_LOGE("ReadParcelable<ApplicationInfo> failed");
188         return false;
189     }
190     applicationInfo = *appInfo;
191 
192     int32_t abilityInfosSize;
193     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilityInfosSize);
194     CONTAINER_SECURITY_VERIFY(parcel, abilityInfosSize, &abilityInfos);
195     for (auto i = 0; i < abilityInfosSize; i++) {
196         std::unique_ptr<AbilityInfo> abilityInfo(parcel.ReadParcelable<AbilityInfo>());
197         if (!abilityInfo) {
198             APP_LOGE("ReadParcelable<AbilityInfo> failed");
199             return false;
200         }
201         abilityInfos.emplace_back(*abilityInfo);
202     }
203 
204     int32_t extensionInfosSize;
205     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extensionInfosSize);
206     CONTAINER_SECURITY_VERIFY(parcel, extensionInfosSize, &extensionInfos);
207     for (auto i = 0; i < extensionInfosSize; i++) {
208         std::unique_ptr<ExtensionAbilityInfo> extensionAbilityInfo(parcel.ReadParcelable<ExtensionAbilityInfo>());
209         if (!extensionAbilityInfo) {
210             APP_LOGE("ReadParcelable<ExtensionAbilityInfo> failed");
211             return false;
212         }
213         extensionInfos.emplace_back(*extensionAbilityInfo);
214     }
215 
216     int32_t hapModuleInfosSize;
217     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, hapModuleInfosSize);
218     CONTAINER_SECURITY_VERIFY(parcel, hapModuleInfosSize, &hapModuleInfos);
219     for (auto i = 0; i < hapModuleInfosSize; i++) {
220         std::unique_ptr<HapModuleInfo> hapModuleInfo(parcel.ReadParcelable<HapModuleInfo>());
221         if (!hapModuleInfo) {
222             APP_LOGE("ReadParcelable<HapModuleInfo> failed");
223             return false;
224         }
225         hapModuleInfos.emplace_back(*hapModuleInfo);
226     }
227 
228     name = Str16ToStr8(parcel.ReadString16());
229     versionCode = parcel.ReadUint32();
230     versionName = Str16ToStr8(parcel.ReadString16());
231     minCompatibleVersionCode = parcel.ReadUint32();
232     compatibleVersion = parcel.ReadUint32();
233     targetVersion = parcel.ReadUint32();
234     isKeepAlive = parcel.ReadBool();
235     singleton = parcel.ReadBool();
236     isPreInstallApp = parcel.ReadBool();
237 
238     vendor = Str16ToStr8(parcel.ReadString16());
239     releaseType = Str16ToStr8(parcel.ReadString16());
240     isNativeApp = parcel.ReadBool();
241 
242     mainEntry = Str16ToStr8(parcel.ReadString16());
243     entryModuleName = Str16ToStr8(parcel.ReadString16());
244     entryInstallationFree = parcel.ReadBool();
245 
246     appId = Str16ToStr8(parcel.ReadString16());
247     uid = parcel.ReadInt32();
248     gid = parcel.ReadInt32();
249     installTime = parcel.ReadInt64();
250     updateTime = parcel.ReadInt64();
251 
252     int32_t hapModuleNamesSize;
253     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, hapModuleNamesSize);
254     CONTAINER_SECURITY_VERIFY(parcel, hapModuleNamesSize, &hapModuleNames);
255     for (auto i = 0; i < hapModuleNamesSize; i++) {
256         hapModuleNames.emplace_back(Str16ToStr8(parcel.ReadString16()));
257     }
258 
259     int32_t moduleNamesSize;
260     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleNamesSize);
261     CONTAINER_SECURITY_VERIFY(parcel, moduleNamesSize, &moduleNames);
262     for (auto i = 0; i < moduleNamesSize; i++) {
263         moduleNames.emplace_back(Str16ToStr8(parcel.ReadString16()));
264     }
265 
266     int32_t modulePublicDirsSize;
267     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, modulePublicDirsSize);
268     CONTAINER_SECURITY_VERIFY(parcel, modulePublicDirsSize, &modulePublicDirs);
269     for (auto i = 0; i < modulePublicDirsSize; i++) {
270         modulePublicDirs.emplace_back(Str16ToStr8(parcel.ReadString16()));
271     }
272 
273     int32_t moduleDirsSize;
274     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleDirsSize);
275     CONTAINER_SECURITY_VERIFY(parcel, moduleDirsSize, &moduleDirs);
276     for (auto i = 0; i < moduleDirsSize; i++) {
277         moduleDirs.emplace_back(Str16ToStr8(parcel.ReadString16()));
278     }
279 
280     int32_t moduleResPathsSize;
281     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleResPathsSize);
282     CONTAINER_SECURITY_VERIFY(parcel, moduleResPathsSize, &moduleResPaths);
283     for (auto i = 0; i < moduleResPathsSize; i++) {
284         moduleResPaths.emplace_back(Str16ToStr8(parcel.ReadString16()));
285     }
286 
287     int32_t reqPermissionsSize;
288     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionsSize);
289     CONTAINER_SECURITY_VERIFY(parcel, reqPermissionsSize, &reqPermissions);
290     for (auto i = 0; i < reqPermissionsSize; i++) {
291         reqPermissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
292     }
293 
294     int32_t defPermissionsSize;
295     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, defPermissionsSize);
296     CONTAINER_SECURITY_VERIFY(parcel, defPermissionsSize, &defPermissions);
297     for (auto i = 0; i < defPermissionsSize; i++) {
298         defPermissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
299     }
300 
301     int32_t reqPermissionStatesSize;
302     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionStatesSize);
303     CONTAINER_SECURITY_VERIFY(parcel, reqPermissionStatesSize, &reqPermissionStates);
304     for (auto i = 0; i < reqPermissionStatesSize; i++) {
305         reqPermissionStates.emplace_back(parcel.ReadInt32());
306     }
307 
308     int32_t reqPermissionDetailsSize;
309     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionDetailsSize);
310     CONTAINER_SECURITY_VERIFY(parcel, reqPermissionDetailsSize, &reqPermissionDetails);
311     for (auto i = 0; i < reqPermissionDetailsSize; i++) {
312         std::unique_ptr<RequestPermission> requestPermission(parcel.ReadParcelable<RequestPermission>());
313         if (!requestPermission) {
314             APP_LOGE("ReadParcelable<RequestPermission> failed");
315             return false;
316         }
317         reqPermissionDetails.emplace_back(*requestPermission);
318     }
319 
320     cpuAbi = Str16ToStr8(parcel.ReadString16());
321     seInfo = Str16ToStr8(parcel.ReadString16());
322     label = Str16ToStr8(parcel.ReadString16());
323     description = Str16ToStr8(parcel.ReadString16());
324     jointUserId = Str16ToStr8(parcel.ReadString16());
325     minSdkVersion = parcel.ReadInt32();
326     maxSdkVersion = parcel.ReadInt32();
327     isDifferentName = parcel.ReadBool();
328     appIndex = parcel.ReadInt32();
329 
330     std::unique_ptr<SignatureInfo> sigInfo(parcel.ReadParcelable<SignatureInfo>());
331     if (!sigInfo) {
332         APP_LOGE("ReadParcelable<SignatureInfo> failed");
333         return false;
334     }
335     signatureInfo = *sigInfo;
336     overlayType = parcel.ReadInt32();
337 
338     int32_t overlayBundleInfoSize;
339     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayBundleInfoSize);
340     CONTAINER_SECURITY_VERIFY(parcel, overlayBundleInfoSize, &overlayBundleInfos);
341     for (auto i = 0; i < overlayBundleInfoSize; i++) {
342         std::unique_ptr<OverlayBundleInfo> overlayBundleInfo(parcel.ReadParcelable<OverlayBundleInfo>());
343         if (!overlayBundleInfo) {
344             APP_LOGE("ReadParcelable<OverlayBundleInfo> failed");
345             return false;
346         }
347         overlayBundleInfos.emplace_back(*overlayBundleInfo);
348     }
349     int32_t oldAppIdsSize;
350     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, oldAppIdsSize);
351     CONTAINER_SECURITY_VERIFY(parcel, oldAppIdsSize, &oldAppIds);
352     for (auto i = 0; i < oldAppIdsSize; i++) {
353         oldAppIds.emplace_back(Str16ToStr8(parcel.ReadString16()));
354     }
355     int32_t routerArraySize;
356     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, routerArraySize);
357     CONTAINER_SECURITY_VERIFY(parcel, routerArraySize, &routerArray);
358     for (int32_t i = 0; i < routerArraySize; ++i) {
359         std::unique_ptr<RouterItem> routerItem(parcel.ReadParcelable<RouterItem>());
360         if (!routerItem) {
361             APP_LOGE("ReadParcelable<RouterItem> failed");
362             return false;
363         }
364         routerArray.emplace_back(*routerItem);
365     }
366     isNewVersion = parcel.ReadBool();
367     return true;
368 }
369 
Marshalling(Parcel & parcel) const370 bool BundleInfo::Marshalling(Parcel &parcel) const
371 {
372     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &applicationInfo);
373 
374     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, abilityInfos.size());
375     for (auto &abilityInfo : abilityInfos) {
376         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &abilityInfo);
377     }
378 
379     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, extensionInfos.size());
380     for (auto &extensionInfo : extensionInfos) {
381         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &extensionInfo);
382     }
383 
384     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, hapModuleInfos.size());
385     for (auto &hapModuleInfo : hapModuleInfos) {
386         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &hapModuleInfo);
387     }
388 
389     CHECK_PARCEL_CAPACITY(parcel, BUNDLE_CAPACITY);
390     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
391     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, versionCode);
392     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(versionName));
393     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, minCompatibleVersionCode);
394     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, compatibleVersion);
395     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, targetVersion);
396 
397     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isKeepAlive);
398     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, singleton);
399     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isPreInstallApp);
400 
401     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(vendor));
402     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(releaseType));
403     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isNativeApp);
404 
405     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(mainEntry));
406     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(entryModuleName));
407     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, entryInstallationFree);
408 
409     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(appId));
410 
411     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uid);
412     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, gid);
413 
414     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, installTime);
415     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, updateTime);
416 
417     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, hapModuleNames.size());
418     for (auto &hapModuleName : hapModuleNames) {
419         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapModuleName));
420     }
421 
422     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleNames.size());
423     for (auto &moduleName : moduleNames) {
424         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
425     }
426     CHECK_PARCEL_CAPACITY(parcel, BUNDLE_CAPACITY);
427     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, modulePublicDirs.size());
428     for (auto &modulePublicDir : modulePublicDirs) {
429         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(modulePublicDir));
430     }
431 
432     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleDirs.size());
433     for (auto &moduleDir : moduleDirs) {
434         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleDir));
435     }
436 
437     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, moduleResPaths.size());
438     for (auto &moduleResPath : moduleResPaths) {
439         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleResPath));
440     }
441 
442     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissions.size());
443     for (auto &reqPermission : reqPermissions) {
444         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(reqPermission));
445     }
446 
447     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, defPermissions.size());
448     for (auto &defPermission : defPermissions) {
449         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(defPermission));
450     }
451 
452     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionStates.size());
453     for (auto &reqPermissionState : reqPermissionStates) {
454         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionState);
455     }
456 
457     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, reqPermissionDetails.size());
458     for (auto &reqPermissionDetail : reqPermissionDetails) {
459         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &reqPermissionDetail);
460     }
461 
462     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(cpuAbi));
463     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(seInfo));
464     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
465     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
466     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(jointUserId));
467     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, minSdkVersion);
468     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, maxSdkVersion);
469     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isDifferentName);
470     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appIndex);
471     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &signatureInfo);
472     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayType);
473     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, overlayBundleInfos.size());
474     for (auto &overlayBundleInfo : overlayBundleInfos) {
475         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &overlayBundleInfo);
476     }
477     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, oldAppIds.size());
478     for (auto &oldAppId : oldAppIds) {
479         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(oldAppId));
480     }
481     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, routerArray.size());
482     for (auto &router : routerArray) {
483         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &router);
484     }
485     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isNewVersion);
486     return true;
487 }
488 
Unmarshalling(Parcel & parcel)489 BundleInfo *BundleInfo::Unmarshalling(Parcel &parcel)
490 {
491     BundleInfo *info = new (std::nothrow) BundleInfo();
492     if (info && !info->ReadFromParcel(parcel)) {
493         APP_LOGW("read from parcel failed");
494         delete info;
495         info = nullptr;
496     }
497     return info;
498 }
499 
to_json(nlohmann::json & jsonObject,const RequestPermissionUsedScene & usedScene)500 void to_json(nlohmann::json &jsonObject, const RequestPermissionUsedScene &usedScene)
501 {
502     jsonObject = nlohmann::json {
503         {REQUESTPERMISSION_ABILITIES, usedScene.abilities},
504         {REQUESTPERMISSION_WHEN, usedScene.when}
505     };
506 }
507 
to_json(nlohmann::json & jsonObject,const RequestPermission & requestPermission)508 void to_json(nlohmann::json &jsonObject, const RequestPermission &requestPermission)
509 {
510     jsonObject = nlohmann::json {
511         {REQUESTPERMISSION_NAME, requestPermission.name},
512         {REQUESTPERMISSION_REASON, requestPermission.reason},
513         {REQUESTPERMISSION_REASON_ID, requestPermission.reasonId},
514         {REQUESTPERMISSION_USEDSCENE, requestPermission.usedScene},
515         {REQUESTPERMISSION_MODULE_NAME, requestPermission.moduleName}
516     };
517 }
518 
to_json(nlohmann::json & jsonObject,const SignatureInfo & signatureInfo)519 void to_json(nlohmann::json &jsonObject, const SignatureInfo &signatureInfo)
520 {
521     jsonObject = nlohmann::json {
522         {SIGNATUREINFO_APPID, signatureInfo.appId},
523         {SIGNATUREINFO_FINGERPRINT, signatureInfo.fingerprint},
524         {APP_IDENTIFIER, signatureInfo.appIdentifier}
525     };
526 }
527 
from_json(const nlohmann::json & jsonObject,RequestPermissionUsedScene & usedScene)528 void from_json(const nlohmann::json &jsonObject, RequestPermissionUsedScene &usedScene)
529 {
530     const auto &jsonObjectEnd = jsonObject.end();
531     int32_t parseResult = ERR_OK;
532     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
533         jsonObjectEnd,
534         REQUESTPERMISSION_ABILITIES,
535         usedScene.abilities,
536         JsonType::ARRAY,
537         false,
538         parseResult,
539         ArrayType::STRING);
540     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
541         jsonObjectEnd,
542         REQUESTPERMISSION_ABILITY,
543         usedScene.abilities,
544         JsonType::ARRAY,
545         false,
546         parseResult,
547         ArrayType::STRING);
548     GetValueIfFindKey<std::string>(jsonObject,
549         jsonObjectEnd,
550         REQUESTPERMISSION_WHEN,
551         usedScene.when,
552         JsonType::STRING,
553         false,
554         parseResult,
555         ArrayType::NOT_ARRAY);
556     if (parseResult != ERR_OK) {
557         APP_LOGE("read RequestPermissionUsedScene error : %{public}d", parseResult);
558     }
559 }
560 
from_json(const nlohmann::json & jsonObject,RequestPermission & requestPermission)561 void from_json(const nlohmann::json &jsonObject, RequestPermission &requestPermission)
562 {
563     const auto &jsonObjectEnd = jsonObject.end();
564     int32_t parseResult = ERR_OK;
565     GetValueIfFindKey<std::string>(jsonObject,
566         jsonObjectEnd,
567         REQUESTPERMISSION_NAME,
568         requestPermission.name,
569         JsonType::STRING,
570         false,
571         parseResult,
572         ArrayType::NOT_ARRAY);
573     GetValueIfFindKey<std::string>(jsonObject,
574         jsonObjectEnd,
575         REQUESTPERMISSION_REASON,
576         requestPermission.reason,
577         JsonType::STRING,
578         false,
579         parseResult,
580         ArrayType::NOT_ARRAY);
581     GetValueIfFindKey<int32_t>(jsonObject,
582         jsonObjectEnd,
583         REQUESTPERMISSION_REASON_ID,
584         requestPermission.reasonId,
585         JsonType::NUMBER,
586         false,
587         parseResult,
588         ArrayType::NOT_ARRAY);
589     GetValueIfFindKey<RequestPermissionUsedScene>(jsonObject,
590         jsonObjectEnd,
591         REQUESTPERMISSION_USEDSCENE,
592         requestPermission.usedScene,
593         JsonType::OBJECT,
594         false,
595         parseResult,
596         ArrayType::NOT_ARRAY);
597     GetValueIfFindKey<std::string>(jsonObject,
598         jsonObjectEnd,
599         REQUESTPERMISSION_MODULE_NAME,
600         requestPermission.moduleName,
601         JsonType::STRING,
602         false,
603         parseResult,
604         ArrayType::NOT_ARRAY);
605     if (parseResult != ERR_OK) {
606         APP_LOGE("read RequestPermission error : %{public}d", parseResult);
607     }
608 }
609 
from_json(const nlohmann::json & jsonObject,SignatureInfo & signatureInfo)610 void from_json(const nlohmann::json &jsonObject, SignatureInfo &signatureInfo)
611 {
612     const auto &jsonObjectEnd = jsonObject.end();
613     int32_t parseResult = ERR_OK;
614     GetValueIfFindKey<std::string>(jsonObject,
615         jsonObjectEnd,
616         SIGNATUREINFO_APPID,
617         signatureInfo.appId,
618         JsonType::STRING,
619         false,
620         parseResult,
621         ArrayType::NOT_ARRAY);
622     GetValueIfFindKey<std::string>(jsonObject,
623         jsonObjectEnd,
624         SIGNATUREINFO_FINGERPRINT,
625         signatureInfo.fingerprint,
626         JsonType::STRING,
627         false,
628         parseResult,
629         ArrayType::NOT_ARRAY);
630     GetValueIfFindKey<std::string>(jsonObject,
631         jsonObjectEnd,
632         APP_IDENTIFIER,
633         signatureInfo.appIdentifier,
634         JsonType::STRING,
635         false,
636         parseResult,
637         ArrayType::NOT_ARRAY);
638     if (parseResult != ERR_OK) {
639         APP_LOGE("read SignatureInfo error : %{public}d", parseResult);
640     }
641 }
642 
to_json(nlohmann::json & jsonObject,const BundleInfo & bundleInfo)643 void to_json(nlohmann::json &jsonObject, const BundleInfo &bundleInfo)
644 {
645     jsonObject = nlohmann::json {
646         {BUNDLE_INFO_NAME, bundleInfo.name}, {BUNDLE_INFO_LABEL, bundleInfo.label},
647         {BUNDLE_INFO_DESCRIPTION, bundleInfo.description}, {BUNDLE_INFO_VENDOR, bundleInfo.vendor},
648         {BUNDLE_INFO_IS_KEEP_ALIVE, bundleInfo.isKeepAlive}, {BUNDLE_INFO_IS_NATIVE_APP, bundleInfo.isNativeApp},
649         {BUNDLE_INFO_IS_PREINSTALL_APP, bundleInfo.isPreInstallApp},
650         {BUNDLE_INFO_IS_DIFFERENT_NAME, bundleInfo.isDifferentName},
651         {BUNDLE_INFO_ABILITY_INFOS, bundleInfo.abilityInfos},
652         {BUNDLE_INFO_HAP_MODULE_INFOS, bundleInfo.hapModuleInfos},
653         {BUNDLE_INFO_EXTENSION_ABILITY_INFOS, bundleInfo.extensionInfos},
654         {BUNDLE_INFO_JOINT_USERID, bundleInfo.jointUserId},
655         {BUNDLE_INFO_VERSION_CODE, bundleInfo.versionCode},
656         {BUNDLE_INFO_MIN_COMPATIBLE_VERSION_CODE, bundleInfo.minCompatibleVersionCode},
657         {BUNDLE_INFO_VERSION_NAME, bundleInfo.versionName},
658         {BUNDLE_INFO_MIN_SDK_VERSION, bundleInfo.minSdkVersion},
659         {BUNDLE_INFO_MAX_SDK_VERSION, bundleInfo.maxSdkVersion},
660         {BUNDLE_INFO_MAIN_ENTRY, bundleInfo.mainEntry},
661         {BUNDLE_INFO_CPU_ABI, bundleInfo.cpuAbi},
662         {BUNDLE_INFO_APPID, bundleInfo.appId},
663         {BUNDLE_INFO_COMPATIBLE_VERSION, bundleInfo.compatibleVersion},
664         {BUNDLE_INFO_TARGET_VERSION, bundleInfo.targetVersion},
665         {BUNDLE_INFO_RELEASE_TYPE, bundleInfo.releaseType},
666         {BUNDLE_INFO_UID, bundleInfo.uid},
667         {BUNDLE_INFO_GID, bundleInfo.gid},
668         {BUNDLE_INFO_SEINFO, bundleInfo.seInfo},
669         {BUNDLE_INFO_INSTALL_TIME, bundleInfo.installTime},
670         {BUNDLE_INFO_UPDATE_TIME, bundleInfo.updateTime},
671         {BUNDLE_INFO_ENTRY_MODULE_NAME, bundleInfo.entryModuleName},
672         {BUNDLE_INFO_ENTRY_INSTALLATION_FREE, bundleInfo.entryInstallationFree},
673         {BUNDLE_INFO_REQ_PERMISSIONS, bundleInfo.reqPermissions},
674         {BUNDLE_INFO_REQ_PERMISSION_STATES, bundleInfo.reqPermissionStates},
675         {BUNDLE_INFO_REQ_PERMISSION_DETAILS, bundleInfo.reqPermissionDetails},
676         {BUNDLE_INFO_DEF_PERMISSIONS, bundleInfo.defPermissions},
677         {BUNDLE_INFO_HAP_MODULE_NAMES, bundleInfo.hapModuleNames},
678         {BUNDLE_INFO_MODULE_NAMES, bundleInfo.moduleNames},
679         {BUNDLE_INFO_MODULE_PUBLIC_DIRS, bundleInfo.modulePublicDirs},
680         {BUNDLE_INFO_MODULE_DIRS, bundleInfo.moduleDirs},
681         {BUNDLE_INFO_MODULE_RES_PATHS, bundleInfo.moduleResPaths},
682         {BUNDLE_INFO_SINGLETON, bundleInfo.singleton},
683         {BUNDLE_INFO_APP_INDEX, bundleInfo.appIndex},
684         {BUNDLE_INFO_SIGNATURE_INFO, bundleInfo.signatureInfo},
685         {OVERLAY_TYPE, bundleInfo.overlayType},
686         {OVERLAY_BUNDLE_INFO, bundleInfo.overlayBundleInfos},
687         {BUNDLE_INFO_OLD_APPIDS, bundleInfo.oldAppIds},
688         {BUNDLE_INFO_ROUTER_ARRAY, bundleInfo.routerArray},
689         {BUNDLE_INFO_IS_NEW_VERSION, bundleInfo.isNewVersion}
690     };
691 }
692 
from_json(const nlohmann::json & jsonObject,BundleInfo & bundleInfo)693 void from_json(const nlohmann::json &jsonObject, BundleInfo &bundleInfo)
694 {
695     const auto &jsonObjectEnd = jsonObject.end();
696     int32_t parseResult = ERR_OK;
697     GetValueIfFindKey<std::string>(jsonObject,
698         jsonObjectEnd,
699         BUNDLE_INFO_NAME,
700         bundleInfo.name,
701         JsonType::STRING,
702         false,
703         parseResult,
704         ArrayType::NOT_ARRAY);
705     GetValueIfFindKey<std::string>(jsonObject,
706         jsonObjectEnd,
707         BUNDLE_INFO_LABEL,
708         bundleInfo.label,
709         JsonType::STRING,
710         false,
711         parseResult,
712         ArrayType::NOT_ARRAY);
713     GetValueIfFindKey<std::string>(jsonObject,
714         jsonObjectEnd,
715         BUNDLE_INFO_DESCRIPTION,
716         bundleInfo.description,
717         JsonType::STRING,
718         false,
719         parseResult,
720         ArrayType::NOT_ARRAY);
721     GetValueIfFindKey<std::string>(jsonObject,
722         jsonObjectEnd,
723         BUNDLE_INFO_VENDOR,
724         bundleInfo.vendor,
725         JsonType::STRING,
726         false,
727         parseResult,
728         ArrayType::NOT_ARRAY);
729     GetValueIfFindKey<bool>(jsonObject,
730         jsonObjectEnd,
731         BUNDLE_INFO_IS_KEEP_ALIVE,
732         bundleInfo.isKeepAlive,
733         JsonType::BOOLEAN,
734         false,
735         parseResult,
736         ArrayType::NOT_ARRAY);
737     GetValueIfFindKey<bool>(jsonObject,
738         jsonObjectEnd,
739         BUNDLE_INFO_IS_NATIVE_APP,
740         bundleInfo.isNativeApp,
741         JsonType::BOOLEAN,
742         false,
743         parseResult,
744         ArrayType::NOT_ARRAY);
745     GetValueIfFindKey<bool>(jsonObject,
746         jsonObjectEnd,
747         BUNDLE_INFO_IS_PREINSTALL_APP,
748         bundleInfo.isPreInstallApp,
749         JsonType::BOOLEAN,
750         false,
751         parseResult,
752         ArrayType::NOT_ARRAY);
753     GetValueIfFindKey<bool>(jsonObject,
754         jsonObjectEnd,
755         BUNDLE_INFO_IS_DIFFERENT_NAME,
756         bundleInfo.isDifferentName,
757         JsonType::BOOLEAN,
758         false,
759         parseResult,
760         ArrayType::NOT_ARRAY);
761     GetValueIfFindKey<std::vector<AbilityInfo>>(jsonObject,
762         jsonObjectEnd,
763         BUNDLE_INFO_ABILITY_INFOS,
764         bundleInfo.abilityInfos,
765         JsonType::ARRAY,
766         false,
767         parseResult,
768         ArrayType::OBJECT);
769     GetValueIfFindKey<std::vector<HapModuleInfo>>(jsonObject,
770         jsonObjectEnd,
771         BUNDLE_INFO_HAP_MODULE_INFOS,
772         bundleInfo.hapModuleInfos,
773         JsonType::ARRAY,
774         false,
775         parseResult,
776         ArrayType::OBJECT);
777     GetValueIfFindKey<uint32_t>(jsonObject,
778         jsonObjectEnd,
779         BUNDLE_INFO_VERSION_CODE,
780         bundleInfo.versionCode,
781         JsonType::NUMBER,
782         false,
783         parseResult,
784         ArrayType::NOT_ARRAY);
785     GetValueIfFindKey<uint32_t>(jsonObject,
786         jsonObjectEnd,
787         BUNDLE_INFO_MIN_COMPATIBLE_VERSION_CODE,
788         bundleInfo.minCompatibleVersionCode,
789         JsonType::NUMBER,
790         false,
791         parseResult,
792         ArrayType::NOT_ARRAY);
793     GetValueIfFindKey<std::string>(jsonObject,
794         jsonObjectEnd,
795         BUNDLE_INFO_VERSION_NAME,
796         bundleInfo.versionName,
797         JsonType::STRING,
798         false,
799         parseResult,
800         ArrayType::NOT_ARRAY);
801     GetValueIfFindKey<std::string>(jsonObject,
802         jsonObjectEnd,
803         BUNDLE_INFO_JOINT_USERID,
804         bundleInfo.jointUserId,
805         JsonType::STRING,
806         false,
807         parseResult,
808         ArrayType::NOT_ARRAY);
809     GetValueIfFindKey<int32_t>(jsonObject,
810         jsonObjectEnd,
811         BUNDLE_INFO_MIN_SDK_VERSION,
812         bundleInfo.minSdkVersion,
813         JsonType::NUMBER,
814         false,
815         parseResult,
816         ArrayType::NOT_ARRAY);
817     GetValueIfFindKey<int32_t>(jsonObject,
818         jsonObjectEnd,
819         BUNDLE_INFO_MAX_SDK_VERSION,
820         bundleInfo.maxSdkVersion,
821         JsonType::NUMBER,
822         false,
823         parseResult,
824         ArrayType::NOT_ARRAY);
825     GetValueIfFindKey<std::string>(jsonObject,
826         jsonObjectEnd,
827         BUNDLE_INFO_MAIN_ENTRY,
828         bundleInfo.mainEntry,
829         JsonType::STRING,
830         false,
831         parseResult,
832         ArrayType::NOT_ARRAY);
833     GetValueIfFindKey<std::string>(jsonObject,
834         jsonObjectEnd,
835         BUNDLE_INFO_CPU_ABI,
836         bundleInfo.cpuAbi,
837         JsonType::STRING,
838         false,
839         parseResult,
840         ArrayType::NOT_ARRAY);
841     GetValueIfFindKey<std::string>(jsonObject,
842         jsonObjectEnd,
843         BUNDLE_INFO_APPID,
844         bundleInfo.appId,
845         JsonType::STRING,
846         false,
847         parseResult,
848         ArrayType::NOT_ARRAY);
849     GetValueIfFindKey<int>(jsonObject,
850         jsonObjectEnd,
851         BUNDLE_INFO_COMPATIBLE_VERSION,
852         bundleInfo.compatibleVersion,
853         JsonType::NUMBER,
854         false,
855         parseResult,
856         ArrayType::NOT_ARRAY);
857     GetValueIfFindKey<uint32_t>(jsonObject,
858         jsonObjectEnd,
859         BUNDLE_INFO_TARGET_VERSION,
860         bundleInfo.targetVersion,
861         JsonType::NUMBER,
862         false,
863         parseResult,
864         ArrayType::NOT_ARRAY);
865     GetValueIfFindKey<std::string>(jsonObject,
866         jsonObjectEnd,
867         BUNDLE_INFO_RELEASE_TYPE,
868         bundleInfo.releaseType,
869         JsonType::STRING,
870         false,
871         parseResult,
872         ArrayType::NOT_ARRAY);
873     GetValueIfFindKey<int>(jsonObject,
874         jsonObjectEnd,
875         BUNDLE_INFO_UID,
876         bundleInfo.uid,
877         JsonType::NUMBER,
878         false,
879         parseResult,
880         ArrayType::NOT_ARRAY);
881     GetValueIfFindKey<int>(jsonObject,
882         jsonObjectEnd,
883         BUNDLE_INFO_GID,
884         bundleInfo.gid,
885         JsonType::NUMBER,
886         false,
887         parseResult,
888         ArrayType::NOT_ARRAY);
889     GetValueIfFindKey<std::string>(jsonObject,
890         jsonObjectEnd,
891         BUNDLE_INFO_SEINFO,
892         bundleInfo.seInfo,
893         JsonType::STRING,
894         false,
895         parseResult,
896         ArrayType::NOT_ARRAY);
897     GetValueIfFindKey<int64_t>(jsonObject,
898         jsonObjectEnd,
899         BUNDLE_INFO_INSTALL_TIME,
900         bundleInfo.installTime,
901         JsonType::NUMBER,
902         false,
903         parseResult,
904         ArrayType::NOT_ARRAY);
905     GetValueIfFindKey<int64_t>(jsonObject,
906         jsonObjectEnd,
907         BUNDLE_INFO_UPDATE_TIME,
908         bundleInfo.updateTime,
909         JsonType::NUMBER,
910         false,
911         parseResult,
912         ArrayType::NOT_ARRAY);
913     GetValueIfFindKey<std::string>(jsonObject,
914         jsonObjectEnd,
915         BUNDLE_INFO_ENTRY_MODULE_NAME,
916         bundleInfo.entryModuleName,
917         JsonType::STRING,
918         false,
919         parseResult,
920         ArrayType::NOT_ARRAY);
921     GetValueIfFindKey<bool>(jsonObject,
922         jsonObjectEnd,
923         BUNDLE_INFO_ENTRY_INSTALLATION_FREE,
924         bundleInfo.entryInstallationFree,
925         JsonType::BOOLEAN,
926         false,
927         parseResult,
928         ArrayType::NOT_ARRAY);
929     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
930         jsonObjectEnd,
931         BUNDLE_INFO_REQ_PERMISSIONS,
932         bundleInfo.reqPermissions,
933         JsonType::ARRAY,
934         false,
935         parseResult,
936         ArrayType::STRING);
937     GetValueIfFindKey<std::vector<int32_t>>(jsonObject,
938         jsonObjectEnd,
939         BUNDLE_INFO_REQ_PERMISSION_STATES,
940         bundleInfo.reqPermissionStates,
941         JsonType::ARRAY,
942         false,
943         parseResult,
944         ArrayType::NUMBER);
945     GetValueIfFindKey<std::vector<RequestPermission>>(jsonObject,
946         jsonObjectEnd,
947         BUNDLE_INFO_REQ_PERMISSION_DETAILS,
948         bundleInfo.reqPermissionDetails,
949         JsonType::ARRAY,
950         false,
951         parseResult,
952         ArrayType::OBJECT);
953     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
954         jsonObjectEnd,
955         BUNDLE_INFO_DEF_PERMISSIONS,
956         bundleInfo.defPermissions,
957         JsonType::ARRAY,
958         false,
959         parseResult,
960         ArrayType::STRING);
961     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
962         jsonObjectEnd,
963         BUNDLE_INFO_HAP_MODULE_NAMES,
964         bundleInfo.hapModuleNames,
965         JsonType::ARRAY,
966         false,
967         parseResult,
968         ArrayType::STRING);
969     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
970         jsonObjectEnd,
971         BUNDLE_INFO_MODULE_NAMES,
972         bundleInfo.moduleNames,
973         JsonType::ARRAY,
974         false,
975         parseResult,
976         ArrayType::STRING);
977     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
978         jsonObjectEnd,
979         BUNDLE_INFO_MODULE_PUBLIC_DIRS,
980         bundleInfo.modulePublicDirs,
981         JsonType::ARRAY,
982         false,
983         parseResult,
984         ArrayType::STRING);
985     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
986         jsonObjectEnd,
987         BUNDLE_INFO_MODULE_DIRS,
988         bundleInfo.moduleDirs,
989         JsonType::ARRAY,
990         false,
991         parseResult,
992         ArrayType::STRING);
993     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
994         jsonObjectEnd,
995         BUNDLE_INFO_MODULE_RES_PATHS,
996         bundleInfo.moduleResPaths,
997         JsonType::ARRAY,
998         false,
999         parseResult,
1000         ArrayType::STRING);
1001     GetValueIfFindKey<bool>(jsonObject,
1002         jsonObjectEnd,
1003         BUNDLE_INFO_SINGLETON,
1004         bundleInfo.singleton,
1005         JsonType::BOOLEAN,
1006         false,
1007         parseResult,
1008         ArrayType::NOT_ARRAY);
1009     GetValueIfFindKey<std::vector<ExtensionAbilityInfo>>(jsonObject,
1010         jsonObjectEnd,
1011         BUNDLE_INFO_EXTENSION_ABILITY_INFOS,
1012         bundleInfo.extensionInfos,
1013         JsonType::ARRAY,
1014         false,
1015         parseResult,
1016         ArrayType::OBJECT);
1017     GetValueIfFindKey<int32_t>(jsonObject,
1018         jsonObjectEnd,
1019         BUNDLE_INFO_APP_INDEX,
1020         bundleInfo.appIndex,
1021         JsonType::NUMBER,
1022         false,
1023         parseResult,
1024         ArrayType::NOT_ARRAY);
1025     GetValueIfFindKey<SignatureInfo>(jsonObject,
1026         jsonObjectEnd,
1027         BUNDLE_INFO_SIGNATURE_INFO,
1028         bundleInfo.signatureInfo,
1029         JsonType::OBJECT,
1030         false,
1031         parseResult,
1032         ArrayType::NOT_ARRAY);
1033     GetValueIfFindKey<int32_t>(jsonObject,
1034         jsonObjectEnd,
1035         OVERLAY_TYPE,
1036         bundleInfo.overlayType,
1037         JsonType::NUMBER,
1038         false,
1039         parseResult,
1040         ArrayType::NOT_ARRAY);
1041     GetValueIfFindKey<std::vector<OverlayBundleInfo>>(jsonObject,
1042         jsonObjectEnd,
1043         OVERLAY_BUNDLE_INFO,
1044         bundleInfo.overlayBundleInfos,
1045         JsonType::ARRAY,
1046         false,
1047         parseResult,
1048         ArrayType::OBJECT);
1049     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1050         jsonObjectEnd,
1051         BUNDLE_INFO_OLD_APPIDS,
1052         bundleInfo.oldAppIds,
1053         JsonType::ARRAY,
1054         false,
1055         parseResult,
1056         ArrayType::STRING);
1057     GetValueIfFindKey<std::vector<RouterItem>>(jsonObject,
1058         jsonObjectEnd,
1059         BUNDLE_INFO_ROUTER_ARRAY,
1060         bundleInfo.routerArray,
1061         JsonType::ARRAY,
1062         false,
1063         parseResult,
1064         ArrayType::OBJECT);
1065     GetValueIfFindKey<bool>(jsonObject,
1066         jsonObjectEnd,
1067         BUNDLE_INFO_IS_NEW_VERSION,
1068         bundleInfo.isNewVersion,
1069         JsonType::BOOLEAN,
1070         false,
1071         parseResult,
1072         ArrayType::NOT_ARRAY);
1073     if (parseResult != ERR_OK) {
1074         APP_LOGE("BundleInfo from_json error %{public}d", parseResult);
1075     }
1076 }
1077 }  // namespace AppExecFwk
1078 }  // namespace OHOS
1079