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