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