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