• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-2024 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 "ability_info.h"
17 
18 #include <cstdint>
19 #include <errno.h>
20 #include <fcntl.h>
21 #include <string>
22 #include <unistd.h>
23 
24 #include "bundle_constants.h"
25 #include "json_util.h"
26 #include "nlohmann/json.hpp"
27 #include "parcel_macro.h"
28 #include "string_ex.h"
29 
30 namespace OHOS {
31 namespace AppExecFwk {
32 namespace {
33 const char* JSON_KEY_PACKAGE = "package";
34 const char* JSON_KEY_NAME = "name";
35 const char* JSON_KEY_APPLICATION_NAME = "applicationName";
36 const char* JSON_KEY_LABEL = "label";
37 const char* JSON_KEY_DESCRIPTION = "description";
38 const char* JSON_KEY_ICON_PATH = "iconPath";
39 const char* JSON_KEY_THEME = "theme";
40 const char* JSON_KEY_VISIBLE = "visible";
41 const char* JSON_KEY_KIND = "kind";
42 const char* JSON_KEY_TYPE = "type";
43 const char* JSON_KEY_EXTENSION_ABILITY_TYPE = "extensionAbilityType";
44 const char* JSON_KEY_ORIENTATION = "orientation";
45 const char* JSON_KEY_LAUNCH_MODE = "launchMode";
46 const char* JSON_KEY_CODE_PATH = "codePath";
47 const char* JSON_KEY_RESOURCE_PATH = "resourcePath";
48 const char* JSON_KEY_PERMISSIONS = "permissions";
49 const char* JSON_KEY_PROCESS = "process";
50 const char* JSON_KEY_DEVICE_TYPES = "deviceTypes";
51 const char* JSON_KEY_DEVICE_CAPABILITIES = "deviceCapabilities";
52 const char* JSON_KEY_URI = "uri";
53 const char* JSON_KEY_IS_LAUNCHER_ABILITY = "isLauncherAbility";
54 const char* JSON_KEY_REMOVE_MISSION_AFTER_TERMINATE = "removeMissionAfterTerminate";
55 const char* JSON_KEY_IS_NATIVE_ABILITY = "isNativeAbility";
56 const char* JSON_KEY_ENABLED = "enabled";
57 const char* JSON_KEY_SUPPORT_PIP_MODE = "supportPipMode";
58 const char* JSON_KEY_TARGET_ABILITY = "targetAbility";
59 const char* JSON_KEY_READ_PERMISSION = "readPermission";
60 const char* JSON_KEY_WRITE_PERMISSION = "writePermission";
61 const char* JSON_KEY_CONFIG_CHANGES = "configChanges";
62 const char* JSON_KEY_FORM_ENTITY = "formEntity";
63 const char* JSON_KEY_MIN_FORM_HEIGHT = "minFormHeight";
64 const char* JSON_KEY_DEFAULT_FORM_HEIGHT = "defaultFormHeight";
65 const char* JSON_KEY_MIN_FORM_WIDTH = "minFormWidth";
66 const char* JSON_KEY_DEFAULT_FORM_WIDTH = "defaultFormWidth";
67 const char* JSON_KEY_BACKGROUND_MODES = "backgroundModes";
68 const char* JSON_KEY_CUSTOMIZE_DATA = "customizeData";
69 const char* JSON_KEY_META_DATA = "metaData";
70 const char* JSON_KEY_META_VALUE = "value";
71 const char* JSON_KEY_META_EXTRA = "extra";
72 const char* JSON_KEY_LABEL_ID = "labelId";
73 const char* JSON_KEY_DESCRIPTION_ID = "descriptionId";
74 const char* JSON_KEY_ICON_ID = "iconId";
75 const char* JSON_KEY_FORM_ENABLED = "formEnabled";
76 const char* JSON_KEY_SRC_PATH = "srcPath";
77 const char* JSON_KEY_SRC_LANGUAGE = "srcLanguage";
78 const char* JSON_KEY_START_WINDOW = "startWindow";
79 const char* JSON_KEY_START_WINDOW_ID = "startWindowId";
80 const char* JSON_KEY_START_WINDOW_RESOURCE = "startWindowResource";
81 const char* JSON_KEY_START_WINDOW_ICON = "startWindowIcon";
82 const char* JSON_KEY_START_WINDOW_ICON_ID = "startWindowIconId";
83 const char* JSON_KEY_START_WINDOW_BACKGROUND = "startWindowBackground";
84 const char* JSON_KEY_START_WINDOW_BACKGROUND_ID = "startWindowBackgroundId";
85 const char* JSON_KEY_COMPILE_MODE = "compileMode";
86 const char* META_DATA = "metadata";
87 const char* META_DATA_VALUEID = "valueId";
88 const char* META_DATA_NAME = "name";
89 const char* META_DATA_VALUE = "value";
90 const char* META_DATA_RESOURCE = "resource";
91 const char* SRC_ENTRANCE = "srcEntrance";
92 const char* IS_MODULE_JSON = "isModuleJson";
93 const char* IS_STAGE_BASED_MODEL = "isStageBasedModel";
94 const char* CONTINUABLE = "continuable";
95 const char* PRIORITY = "priority";
96 const char* JOSN_KEY_SUPPORT_WINDOW_MODE = "supportWindowMode";
97 const char* JOSN_KEY_MAX_WINDOW_RATIO = "maxWindowRatio";
98 const char* JOSN_KEY_MIN_WINDOW_RATIO = "minWindowRatio";
99 const char* JOSN_KEY_MAX_WINDOW_WIDTH = "maxWindowWidth";
100 const char* JOSN_KEY_MIN_WINDOW_WIDTH = "minWindowWidth";
101 const char* JOSN_KEY_MAX_WINDOW_HEIGHT = "maxWindowHeight";
102 const char* JOSN_KEY_MIN_WINDOW_HEIGHT = "minWindowHeight";
103 const char* JOSN_KEY_UID = "uid";
104 const char* JOSN_KEY_EXCLUDE_FROM_MISSIONS = "excludeFromMissions";
105 const char* JOSN_KEY_UNCLEARABLE_MISSION = "unclearableMission";
106 const char* JSON_KEY_EXCLUDE_FROM_DOCK_MISSION = "excludeFromDock";
107 const char* JSON_KEY_PREFER_MULTI_WINDOW_ORIENTATION_MISSION = "preferMultiWindowOrientation";
108 const char* JSON_KEY_RECOVERABLE = "recoverable";
109 const char* JSON_KEY_SUPPORT_EXT_NAMES = "supportExtNames";
110 const char* JSON_KEY_SUPPORT_MIME_TYPES = "supportMimeTypes";
111 const char* JSON_KEY_ISOLATION_PROCESS = "isolationProcess";
112 const char* JSON_KEY_CONTINUE_TYPE = "continueType";
113 const char* JSON_KEY_APP_INDEX = "appIndex";
114 const char* JSON_KEY_SKILLS = "skills";
115 const char* JSON_KEY_ORIENTATION_ID = "orientationId";
116 const char* JSON_KEY_CONTINUE_BUNDLE_NAME = "continueBundleName";
117 const uint32_t ABILITY_CAPACITY = 204800; // 200K
118 const char* START_WINDOW_APP_ICON_ID = "startWindowAppIconId";
119 const char* START_WINDOW_ILLUSTRATION_ID = "startWindowIllustrationId";
120 const char* START_WINDOW_BRANDING_IMAGE_ID = "startWindowBrandingImageId";
121 const char* START_WINDOW_BACKGROUND_COLOR_ID = "startWindowBackgroundColorId";
122 const char* START_WINDOW_BACKGROUND_IMAGE_ID = "startWindowBackgroundImageId";
123 const char* START_WINDOW_BACKGROUND_IMAGE_FIT = "startWindowBackgroundImageFit";
124 }  // namespace
125 
ReadFromParcel(Parcel & parcel)126 bool AbilityInfo::ReadFromParcel(Parcel &parcel)
127 {
128     name = Str16ToStr8(parcel.ReadString16());
129     label = Str16ToStr8(parcel.ReadString16());
130     description = Str16ToStr8(parcel.ReadString16());
131     iconPath = Str16ToStr8(parcel.ReadString16());
132     labelId = parcel.ReadUint32();
133     descriptionId = parcel.ReadUint32();
134     iconId = parcel.ReadUint32();
135     theme = Str16ToStr8(parcel.ReadString16());
136     visible = parcel.ReadBool();
137     kind = Str16ToStr8(parcel.ReadString16());
138     type = static_cast<AbilityType>(parcel.ReadInt32());
139     extensionTypeName = Str16ToStr8(parcel.ReadString16());
140     extensionAbilityType = static_cast<ExtensionAbilityType>(parcel.ReadInt32());
141     orientation = static_cast<DisplayOrientation>(parcel.ReadInt32());
142     launchMode = static_cast<LaunchMode>(parcel.ReadInt32());
143     srcPath = Str16ToStr8(parcel.ReadString16());
144     srcLanguage = Str16ToStr8(parcel.ReadString16());
145 
146     int32_t permissionsSize;
147     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissionsSize);
148     CONTAINER_SECURITY_VERIFY(parcel, permissionsSize, &permissions);
149     for (auto i = 0; i < permissionsSize; i++) {
150         permissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
151     }
152 
153     process = Str16ToStr8(parcel.ReadString16());
154 
155     int32_t deviceTypesSize;
156     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceTypesSize);
157     CONTAINER_SECURITY_VERIFY(parcel, deviceTypesSize, &deviceTypes);
158     for (auto i = 0; i < deviceTypesSize; i++) {
159         deviceTypes.emplace_back(Str16ToStr8(parcel.ReadString16()));
160     }
161 
162     int32_t deviceCapabilitiesSize;
163     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceCapabilitiesSize);
164     CONTAINER_SECURITY_VERIFY(parcel, deviceCapabilitiesSize, &deviceCapabilities);
165     for (auto i = 0; i < deviceCapabilitiesSize; i++) {
166         deviceCapabilities.emplace_back(Str16ToStr8(parcel.ReadString16()));
167     }
168     uri = Str16ToStr8(parcel.ReadString16());
169     targetAbility = Str16ToStr8(parcel.ReadString16());
170 
171     std::unique_ptr<ApplicationInfo> appInfo(parcel.ReadParcelable<ApplicationInfo>());
172     if (!appInfo) {
173         APP_LOGE("ReadParcelable<ApplicationInfo> failed");
174         return false;
175     }
176     applicationInfo = *appInfo;
177 
178     isLauncherAbility = parcel.ReadBool();
179     isNativeAbility = parcel.ReadBool();
180     enabled = parcel.ReadBool();
181     supportPipMode = parcel.ReadBool();
182     formEnabled = parcel.ReadBool();
183     removeMissionAfterTerminate = parcel.ReadBool();
184 
185     readPermission = Str16ToStr8(parcel.ReadString16());
186     writePermission = Str16ToStr8(parcel.ReadString16());
187     int32_t configChangesSize;
188     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, configChangesSize);
189     CONTAINER_SECURITY_VERIFY(parcel, configChangesSize, &configChanges);
190     for (auto i = 0; i < configChangesSize; i++) {
191         configChanges.emplace_back(Str16ToStr8(parcel.ReadString16()));
192     }
193     formEntity = parcel.ReadUint32();
194     minFormHeight = parcel.ReadInt32();
195     defaultFormHeight = parcel.ReadInt32();
196     minFormWidth = parcel.ReadInt32();
197     defaultFormWidth = parcel.ReadInt32();
198     int32_t metaDataSize;
199     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metaDataSize);
200     CONTAINER_SECURITY_VERIFY(parcel, metaDataSize, &metaData.customizeData);
201     for (auto i = 0; i < metaDataSize; i++) {
202         std::unique_ptr<CustomizeData> customizeDataPtr(parcel.ReadParcelable<CustomizeData>());
203         if (!customizeDataPtr) {
204             APP_LOGE("ReadParcelable<Metadata> failed");
205             return false;
206         }
207         metaData.customizeData.emplace_back(*customizeDataPtr);
208     }
209     backgroundModes = parcel.ReadUint32();
210 
211     package = Str16ToStr8(parcel.ReadString16());
212     bundleName = Str16ToStr8(parcel.ReadString16());
213     moduleName = Str16ToStr8(parcel.ReadString16());
214     applicationName = Str16ToStr8(parcel.ReadString16());
215 
216     codePath = Str16ToStr8(parcel.ReadString16());
217     resourcePath = Str16ToStr8(parcel.ReadString16());
218     hapPath = Str16ToStr8(parcel.ReadString16());
219 
220     srcEntrance = Str16ToStr8(parcel.ReadString16());
221     int32_t metadataSize;
222     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadataSize);
223     CONTAINER_SECURITY_VERIFY(parcel, metadataSize, &metadata);
224     for (auto i = 0; i < metadataSize; i++) {
225         std::unique_ptr<Metadata> metadataPtr(parcel.ReadParcelable<Metadata>());
226         if (!metadataPtr) {
227             APP_LOGE("ReadParcelable<Metadata> failed");
228             return false;
229         }
230         metadata.emplace_back(*metadataPtr);
231     }
232     isModuleJson = parcel.ReadBool();
233     isStageBasedModel = parcel.ReadBool();
234     continuable = parcel.ReadBool();
235     priority = parcel.ReadInt32();
236 
237     startWindow = Str16ToStr8(parcel.ReadString16());
238     startWindowId = parcel.ReadUint32();
239     startWindowIcon = Str16ToStr8(parcel.ReadString16());
240     startWindowIconId = parcel.ReadUint32();
241     startWindowBackground = Str16ToStr8(parcel.ReadString16());
242     startWindowBackgroundId = parcel.ReadUint32();
243 
244     originalBundleName = Str16ToStr8(parcel.ReadString16());
245     appName = Str16ToStr8(parcel.ReadString16());
246     privacyUrl = Str16ToStr8(parcel.ReadString16());
247     privacyName = Str16ToStr8(parcel.ReadString16());
248     downloadUrl = Str16ToStr8(parcel.ReadString16());
249     versionName = Str16ToStr8(parcel.ReadString16());
250     className = Str16ToStr8(parcel.ReadString16());
251     originalClassName = Str16ToStr8(parcel.ReadString16());
252     uriPermissionMode = Str16ToStr8(parcel.ReadString16());
253     uriPermissionPath = Str16ToStr8(parcel.ReadString16());
254     packageSize = parcel.ReadUint32();
255     multiUserShared = parcel.ReadBool();
256     grantPermission = parcel.ReadBool();
257     directLaunch = parcel.ReadBool();
258     subType = static_cast<AbilitySubType>(parcel.ReadInt32());
259     libPath = Str16ToStr8(parcel.ReadString16());
260     deviceId = Str16ToStr8(parcel.ReadString16());
261     compileMode = static_cast<CompileMode>(parcel.ReadInt32());
262 
263     int32_t windowModeSize = parcel.ReadInt32();
264     CONTAINER_SECURITY_VERIFY(parcel, windowModeSize, &windowModes);
265     for (auto index = 0; index < windowModeSize; ++index) {
266         windowModes.emplace_back(static_cast<SupportWindowMode>(parcel.ReadInt32()));
267     }
268     maxWindowRatio = parcel.ReadDouble();
269     minWindowRatio = parcel.ReadDouble();
270     maxWindowWidth = parcel.ReadUint32();
271     minWindowWidth = parcel.ReadUint32();
272     maxWindowHeight = parcel.ReadUint32();
273     minWindowHeight = parcel.ReadUint32();
274     uid = parcel.ReadInt32();
275     recoverable = parcel.ReadBool();
276     installTime = parcel.ReadInt64();
277     int32_t supportExtNameSize;
278     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportExtNameSize);
279     CONTAINER_SECURITY_VERIFY(parcel, supportExtNameSize, &supportExtNames);
280     for (auto i = 0; i < supportExtNameSize; i++) {
281         supportExtNames.emplace_back(Str16ToStr8(parcel.ReadString16()));
282     }
283     int32_t supportMimeTypeSize;
284     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportMimeTypeSize);
285     CONTAINER_SECURITY_VERIFY(parcel, supportMimeTypeSize, &supportMimeTypes);
286     for (auto i = 0; i < supportMimeTypeSize; i++) {
287         supportMimeTypes.emplace_back(Str16ToStr8(parcel.ReadString16()));
288     }
289     int32_t skillUriSize;
290     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUriSize);
291     CONTAINER_SECURITY_VERIFY(parcel, skillUriSize, &skillUri);
292     for (auto i = 0; i < skillUriSize; i++) {
293         SkillUriForAbilityAndExtension stctUri;
294         stctUri.scheme = Str16ToStr8(parcel.ReadString16());
295         stctUri.host = Str16ToStr8(parcel.ReadString16());
296         stctUri.port = Str16ToStr8(parcel.ReadString16());
297         stctUri.path = Str16ToStr8(parcel.ReadString16());
298         stctUri.pathStartWith = Str16ToStr8(parcel.ReadString16());
299         stctUri.pathRegex = Str16ToStr8(parcel.ReadString16());
300         stctUri.type = Str16ToStr8(parcel.ReadString16());
301         stctUri.utd = Str16ToStr8(parcel.ReadString16());
302         stctUri.maxFileSupported = parcel.ReadInt32();
303         stctUri.linkFeature = Str16ToStr8(parcel.ReadString16());
304         stctUri.isMatch = parcel.ReadBool();
305         skillUri.emplace_back(stctUri);
306     }
307     isolationProcess = parcel.ReadBool();
308     excludeFromMissions = parcel.ReadBool();
309     unclearableMission = parcel.ReadBool();
310     excludeFromDock = parcel.ReadBool();
311     preferMultiWindowOrientation = Str16ToStr8(parcel.ReadString16());
312     int32_t continueTypeSize;
313     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, continueTypeSize);
314     CONTAINER_SECURITY_VERIFY(parcel, continueTypeSize, &continueType);
315     for (auto i = 0; i < continueTypeSize; i++) {
316         continueType.emplace_back(Str16ToStr8(parcel.ReadString16()));
317     }
318 
319     int32_t continueBundleNameSize = 0;
320     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, continueBundleNameSize);
321     CONTAINER_SECURITY_VERIFY(parcel, continueBundleNameSize, &continueBundleNames);
322     for (auto i = 0; i < continueBundleNameSize; ++i) {
323         continueBundleNames.emplace(Str16ToStr8(parcel.ReadString16()));
324     }
325 
326     linkType = static_cast<LinkType>(parcel.ReadInt32());
327 
328     int32_t skillsSize;
329     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillsSize);
330     CONTAINER_SECURITY_VERIFY(parcel, skillsSize, &skills);
331     for (auto i = 0; i < skillsSize; i++) {
332         std::unique_ptr<Skill> abilitySkillPtr(parcel.ReadParcelable<Skill>());
333         if (!abilitySkillPtr) {
334             APP_LOGE("ReadParcelable<SkillForAbility> failed");
335             return false;
336         }
337         skills.emplace_back(*abilitySkillPtr);
338     }
339     appIndex = parcel.ReadInt32();
340     orientationId = parcel.ReadUint32();
341     std::unique_ptr<StartWindowResource> startWindowResourcePtr(parcel.ReadParcelable<StartWindowResource>());
342     if (!startWindowResourcePtr) {
343         APP_LOGE("ReadParcelable<StartWindowResource> failed");
344         return false;
345     }
346     startWindowResource = *startWindowResourcePtr;
347     return true;
348 }
349 
Unmarshalling(Parcel & parcel)350 AbilityInfo *AbilityInfo::Unmarshalling(Parcel &parcel)
351 {
352     AbilityInfo *info = new (std::nothrow) AbilityInfo();
353     if (info && !info->ReadFromParcel(parcel)) {
354         APP_LOGW("read from parcel failed");
355         delete info;
356         info = nullptr;
357     }
358     return info;
359 }
360 
Marshalling(Parcel & parcel) const361 bool AbilityInfo::Marshalling(Parcel &parcel) const
362 {
363     CHECK_PARCEL_CAPACITY(parcel, ABILITY_CAPACITY);
364     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
365     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
366     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
367     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(iconPath));
368     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, labelId);
369     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, descriptionId);
370     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, iconId);
371     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(theme));
372     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible);
373     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(kind));
374     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(type));
375     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(extensionTypeName));
376     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(extensionAbilityType));
377     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(orientation));
378     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(launchMode));
379     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcPath));
380     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcLanguage));
381     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissions.size());
382     for (auto &permission : permissions) {
383         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(permission));
384     }
385 
386     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(process));
387     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceTypes.size());
388     for (auto &deviceType : deviceTypes) {
389         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(deviceType));
390     }
391 
392     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, deviceCapabilities.size());
393     for (auto &deviceCapability : deviceCapabilities) {
394         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(deviceCapability));
395     }
396     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri));
397     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(targetAbility));
398     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &applicationInfo);
399     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isLauncherAbility);
400     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isNativeAbility);
401     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enabled);
402     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, supportPipMode);
403     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, formEnabled);
404     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, removeMissionAfterTerminate);
405     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(readPermission));
406     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(writePermission));
407     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, configChanges.size());
408     for (auto &configChange : configChanges) {
409         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(configChange));
410     }
411     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, formEntity);
412     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, minFormHeight);
413     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, defaultFormHeight);
414     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, minFormWidth);
415     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, defaultFormWidth);
416     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metaData.customizeData.size());
417     for (auto &meta : metaData.customizeData) {
418         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &meta);
419     }
420     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, backgroundModes);
421 
422     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(package));
423     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
424     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
425     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(applicationName));
426     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(codePath));
427     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(resourcePath));
428     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapPath));
429 
430     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcEntrance));
431 
432     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadata.size());
433     for (auto &meta : metadata) {
434         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &meta);
435     }
436 
437     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isModuleJson);
438     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isStageBasedModel);
439     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, continuable);
440     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, priority);
441 
442     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(startWindow));
443     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowId);
444     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(startWindowIcon));
445     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowIconId);
446     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(startWindowBackground));
447     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBackgroundId);
448 
449     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(originalBundleName));
450     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(appName));
451     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(privacyUrl));
452     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(privacyName));
453     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(downloadUrl));
454     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(versionName));
455     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(className));
456     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(originalClassName));
457     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uriPermissionMode));
458     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uriPermissionPath));
459     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, packageSize);
460     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, multiUserShared);
461     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, grantPermission);
462     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, directLaunch);
463     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(subType));
464     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(libPath));
465     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(deviceId));
466     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(compileMode));
467 
468     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, windowModes.size());
469     for (auto &mode : windowModes) {
470         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(mode));
471     }
472     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, maxWindowRatio);
473     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Double, parcel, minWindowRatio);
474     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, maxWindowWidth);
475     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, minWindowWidth);
476     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, maxWindowHeight);
477     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, minWindowHeight);
478     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uid);
479     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, recoverable);
480     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int64, parcel, installTime);
481     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportExtNames.size());
482     for (auto &supporExtName : supportExtNames) {
483         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(supporExtName));
484     }
485     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, supportMimeTypes.size());
486     for (auto &supportMimeType : supportMimeTypes) {
487         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(supportMimeType));
488     }
489     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUri.size());
490     for (auto &uri : skillUri) {
491         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.scheme));
492         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.host));
493         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.port));
494         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.path));
495         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathStartWith));
496         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathRegex));
497         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.type));
498         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.utd));
499         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uri.maxFileSupported);
500         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.linkFeature));
501         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, uri.isMatch);
502     }
503     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, isolationProcess);
504     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, excludeFromMissions);
505     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, unclearableMission);
506     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, excludeFromDock);
507     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(preferMultiWindowOrientation));
508     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, continueType.size());
509     for (auto &continueTypeItem : continueType) {
510         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(continueTypeItem));
511     }
512     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, continueBundleNames.size());
513     for (auto &continueBundleNameItem : continueBundleNames) {
514         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(continueBundleNameItem));
515     }
516     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(linkType));
517     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skills.size());
518     for (auto &skill : skills) {
519         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &skill);
520     }
521     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appIndex);
522     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, orientationId);
523     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &startWindowResource);
524     return true;
525 }
526 
Dump(std::string prefix,int fd)527 void AbilityInfo::Dump(std::string prefix, int fd)
528 {
529     APP_LOGI("call Dump");
530     if (fd < 0) {
531         APP_LOGE("dump Abilityinfo fd error");
532         return;
533     }
534     int flags = fcntl(fd, F_GETFL);
535     if (flags < 0) {
536         APP_LOGE("dump Abilityinfo fcntl error : %{public}d", errno);
537         return;
538     }
539     uint uflags = static_cast<uint>(flags);
540     uflags &= O_ACCMODE;
541     if ((uflags == O_WRONLY) || (uflags == O_RDWR)) {
542         nlohmann::json jsonObject = *this;
543         std::string result;
544         result.append(prefix);
545         result.append(jsonObject.dump(Constants::DUMP_INDENT));
546         int ret = TEMP_FAILURE_RETRY(write(fd, result.c_str(), result.size()));
547         if (ret < 0) {
548             APP_LOGE("dump Abilityinfo write error : %{public}d", errno);
549         }
550     }
551     return;
552 }
553 
to_json(nlohmann::json & jsonObject,const StartWindowResource & startWindowResource)554 void to_json(nlohmann::json &jsonObject, const StartWindowResource &startWindowResource)
555 {
556     jsonObject = nlohmann::json {
557         {START_WINDOW_APP_ICON_ID, startWindowResource.startWindowAppIconId},
558         {START_WINDOW_ILLUSTRATION_ID, startWindowResource.startWindowIllustrationId},
559         {START_WINDOW_BRANDING_IMAGE_ID, startWindowResource.startWindowBrandingImageId},
560         {START_WINDOW_BACKGROUND_COLOR_ID, startWindowResource.startWindowBackgroundColorId},
561         {START_WINDOW_BACKGROUND_IMAGE_ID, startWindowResource.startWindowBackgroundImageId},
562         {START_WINDOW_BACKGROUND_IMAGE_FIT, startWindowResource.startWindowBackgroundImageFit}
563     };
564 }
565 
from_json(const nlohmann::json & jsonObject,StartWindowResource & startWindowResource)566 void from_json(const nlohmann::json &jsonObject, StartWindowResource &startWindowResource)
567 {
568     const auto &jsonObjectEnd = jsonObject.end();
569     int32_t parseResult = ERR_OK;
570     GetValueIfFindKey<uint32_t>(jsonObject, jsonObjectEnd,
571         START_WINDOW_APP_ICON_ID,
572         startWindowResource.startWindowAppIconId,
573         JsonType::NUMBER, false,
574         parseResult,
575         ArrayType::NOT_ARRAY);
576     GetValueIfFindKey<uint32_t>(jsonObject, jsonObjectEnd,
577         START_WINDOW_ILLUSTRATION_ID,
578         startWindowResource.startWindowIllustrationId,
579         JsonType::NUMBER, false,
580         parseResult,
581         ArrayType::NOT_ARRAY);
582     GetValueIfFindKey<uint32_t>(jsonObject, jsonObjectEnd,
583         START_WINDOW_BRANDING_IMAGE_ID,
584         startWindowResource.startWindowBrandingImageId,
585         JsonType::NUMBER, false,
586         parseResult,
587         ArrayType::NOT_ARRAY);
588     GetValueIfFindKey<uint32_t>(jsonObject, jsonObjectEnd,
589         START_WINDOW_BACKGROUND_COLOR_ID,
590         startWindowResource.startWindowBackgroundColorId,
591         JsonType::NUMBER, false,
592         parseResult,
593         ArrayType::NOT_ARRAY);
594     GetValueIfFindKey<uint32_t>(jsonObject, jsonObjectEnd,
595         START_WINDOW_BACKGROUND_IMAGE_ID,
596         startWindowResource.startWindowBackgroundImageId,
597         JsonType::NUMBER, false,
598         parseResult,
599         ArrayType::NOT_ARRAY);
600     BMSJsonUtil::GetStrValueIfFindKey(jsonObject, jsonObjectEnd,
601         START_WINDOW_BACKGROUND_IMAGE_FIT,
602         startWindowResource.startWindowBackgroundImageFit,
603         false,
604         parseResult);
605     if (parseResult != ERR_OK) {
606         APP_LOGE("read Resource error %{public}d", parseResult);
607     }
608 }
609 
to_json(nlohmann::json & jsonObject,const CustomizeData & customizeData)610 void to_json(nlohmann::json &jsonObject, const CustomizeData &customizeData)
611 {
612     jsonObject = nlohmann::json {
613         {JSON_KEY_NAME, customizeData.name},
614         {JSON_KEY_META_VALUE, customizeData.value},
615         {JSON_KEY_META_EXTRA, customizeData.extra}
616     };
617 }
618 
to_json(nlohmann::json & jsonObject,const MetaData & metaData)619 void to_json(nlohmann::json &jsonObject, const MetaData &metaData)
620 {
621     jsonObject = nlohmann::json {
622         {JSON_KEY_CUSTOMIZE_DATA, metaData.customizeData}
623     };
624 }
625 
to_json(nlohmann::json & jsonObject,const Metadata & metadata)626 void to_json(nlohmann::json &jsonObject, const Metadata &metadata)
627 {
628     jsonObject = nlohmann::json {
629         {META_DATA_VALUEID, metadata.valueId},
630         {META_DATA_NAME, metadata.name},
631         {META_DATA_VALUE, metadata.value},
632         {META_DATA_RESOURCE, metadata.resource}
633     };
634 }
635 
to_json(nlohmann::json & jsonObject,const AbilityInfo & abilityInfo)636 void to_json(nlohmann::json &jsonObject, const AbilityInfo &abilityInfo)
637 {
638     APP_LOGD("AbilityInfo to_json begin");
639     jsonObject = nlohmann::json {
640         {JSON_KEY_NAME, abilityInfo.name},
641         {JSON_KEY_LABEL, abilityInfo.label},
642         {JSON_KEY_DESCRIPTION, abilityInfo.description},
643         {JSON_KEY_ICON_PATH, abilityInfo.iconPath},
644         {JSON_KEY_LABEL_ID, abilityInfo.labelId},
645         {JSON_KEY_DESCRIPTION_ID, abilityInfo.descriptionId},
646         {JSON_KEY_ICON_ID, abilityInfo.iconId},
647         {JSON_KEY_THEME, abilityInfo.theme},
648         {JSON_KEY_VISIBLE, abilityInfo.visible},
649         {JSON_KEY_KIND, abilityInfo.kind},
650         {JSON_KEY_TYPE, abilityInfo.type},
651         {JSON_KEY_EXTENSION_ABILITY_TYPE, abilityInfo.extensionAbilityType},
652         {JSON_KEY_ORIENTATION, abilityInfo.orientation},
653         {JSON_KEY_LAUNCH_MODE, abilityInfo.launchMode},
654         {JSON_KEY_SRC_PATH, abilityInfo.srcPath},
655         {JSON_KEY_SRC_LANGUAGE, abilityInfo.srcLanguage},
656         {JSON_KEY_PERMISSIONS, abilityInfo.permissions},
657         {JSON_KEY_PROCESS, abilityInfo.process},
658         {JSON_KEY_DEVICE_TYPES, abilityInfo.deviceTypes},
659         {JSON_KEY_DEVICE_CAPABILITIES, abilityInfo.deviceCapabilities},
660         {JSON_KEY_URI, abilityInfo.uri},
661         {JSON_KEY_TARGET_ABILITY, abilityInfo.targetAbility},
662         {JSON_KEY_IS_LAUNCHER_ABILITY, abilityInfo.isLauncherAbility},
663         {JSON_KEY_IS_NATIVE_ABILITY, abilityInfo.isNativeAbility},
664         {JSON_KEY_ENABLED, abilityInfo.enabled},
665         {JSON_KEY_SUPPORT_PIP_MODE, abilityInfo.supportPipMode},
666         {JSON_KEY_FORM_ENABLED, abilityInfo.formEnabled},
667         {JSON_KEY_READ_PERMISSION, abilityInfo.readPermission},
668         {JSON_KEY_WRITE_PERMISSION, abilityInfo.writePermission},
669         {JSON_KEY_CONFIG_CHANGES, abilityInfo.configChanges},
670         {JSON_KEY_FORM_ENTITY, abilityInfo.formEntity},
671         {JSON_KEY_MIN_FORM_HEIGHT, abilityInfo.minFormHeight},
672         {JSON_KEY_DEFAULT_FORM_HEIGHT, abilityInfo.defaultFormHeight},
673         {JSON_KEY_MIN_FORM_WIDTH, abilityInfo.minFormWidth},
674         {JSON_KEY_DEFAULT_FORM_WIDTH, abilityInfo.defaultFormWidth},
675         {JSON_KEY_META_DATA, abilityInfo.metaData},
676         {JSON_KEY_BACKGROUND_MODES, abilityInfo.backgroundModes},
677         {JSON_KEY_PACKAGE, abilityInfo.package},
678         {Constants::BUNDLE_NAME, abilityInfo.bundleName},
679         {Constants::MODULE_NAME, abilityInfo.moduleName},
680         {JSON_KEY_APPLICATION_NAME, abilityInfo.applicationName},
681         {JSON_KEY_CODE_PATH, abilityInfo.codePath},
682         {JSON_KEY_RESOURCE_PATH, abilityInfo.resourcePath},
683         {Constants::HAP_PATH, abilityInfo.hapPath},
684         {SRC_ENTRANCE, abilityInfo.srcEntrance},
685         {META_DATA, abilityInfo.metadata},
686         {IS_MODULE_JSON, abilityInfo.isModuleJson},
687         {IS_STAGE_BASED_MODEL, abilityInfo.isStageBasedModel},
688         {CONTINUABLE, abilityInfo.continuable},
689         {PRIORITY, abilityInfo.priority},
690         {JSON_KEY_START_WINDOW, abilityInfo.startWindow},
691         {JSON_KEY_START_WINDOW_ID, abilityInfo.startWindowId},
692         {JSON_KEY_START_WINDOW_ICON, abilityInfo.startWindowIcon},
693         {JSON_KEY_START_WINDOW_ICON_ID, abilityInfo.startWindowIconId},
694         {JSON_KEY_START_WINDOW_BACKGROUND, abilityInfo.startWindowBackground},
695         {JSON_KEY_START_WINDOW_BACKGROUND_ID, abilityInfo.startWindowBackgroundId},
696         {JSON_KEY_REMOVE_MISSION_AFTER_TERMINATE, abilityInfo.removeMissionAfterTerminate},
697         {JSON_KEY_COMPILE_MODE, abilityInfo.compileMode},
698         {JOSN_KEY_SUPPORT_WINDOW_MODE, abilityInfo.windowModes},
699         {JOSN_KEY_MAX_WINDOW_WIDTH, abilityInfo.maxWindowWidth},
700         {JOSN_KEY_MIN_WINDOW_WIDTH, abilityInfo.minWindowWidth},
701         {JOSN_KEY_MAX_WINDOW_HEIGHT, abilityInfo.maxWindowHeight},
702         {JOSN_KEY_MIN_WINDOW_HEIGHT, abilityInfo.minWindowHeight},
703         {JOSN_KEY_UID, abilityInfo.uid},
704         {JOSN_KEY_EXCLUDE_FROM_MISSIONS, abilityInfo.excludeFromMissions},
705         {JOSN_KEY_UNCLEARABLE_MISSION, abilityInfo.unclearableMission},
706         {JSON_KEY_EXCLUDE_FROM_DOCK_MISSION, abilityInfo.excludeFromDock},
707         {JSON_KEY_PREFER_MULTI_WINDOW_ORIENTATION_MISSION, abilityInfo.preferMultiWindowOrientation},
708         {JSON_KEY_RECOVERABLE, abilityInfo.recoverable},
709         {JSON_KEY_SUPPORT_EXT_NAMES, abilityInfo.supportExtNames},
710         {JSON_KEY_SUPPORT_MIME_TYPES, abilityInfo.supportMimeTypes},
711         {JSON_KEY_ISOLATION_PROCESS, abilityInfo.isolationProcess},
712         {JSON_KEY_CONTINUE_TYPE, abilityInfo.continueType},
713         {JSON_KEY_CONTINUE_BUNDLE_NAME, abilityInfo.continueBundleNames},
714         {JSON_KEY_SKILLS, abilityInfo.skills},
715         {JSON_KEY_APP_INDEX, abilityInfo.appIndex},
716         {JSON_KEY_ORIENTATION_ID, abilityInfo.orientationId},
717         {JSON_KEY_START_WINDOW_RESOURCE, abilityInfo.startWindowResource}
718     };
719     if (abilityInfo.maxWindowRatio == 0) {
720         // maxWindowRatio in json string will be 0 instead of 0.0
721         jsonObject[JOSN_KEY_MAX_WINDOW_RATIO] = 0;
722     } else {
723         jsonObject[JOSN_KEY_MAX_WINDOW_RATIO] = abilityInfo.maxWindowRatio;
724     }
725 
726     if (abilityInfo.minWindowRatio == 0) {
727         jsonObject[JOSN_KEY_MIN_WINDOW_RATIO] = 0;
728     } else {
729         jsonObject[JOSN_KEY_MIN_WINDOW_RATIO] = abilityInfo.minWindowRatio;
730     }
731 }
732 
from_json(const nlohmann::json & jsonObject,CustomizeData & customizeData)733 void from_json(const nlohmann::json &jsonObject, CustomizeData &customizeData)
734 {
735     const auto &jsonObjectEnd = jsonObject.end();
736     int32_t parseResult = ERR_OK;
737     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
738         jsonObjectEnd,
739         JSON_KEY_NAME,
740         customizeData.name,
741         false,
742         parseResult);
743     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
744         jsonObjectEnd,
745         JSON_KEY_META_VALUE,
746         customizeData.value,
747         false,
748         parseResult);
749     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
750         jsonObjectEnd,
751         JSON_KEY_META_EXTRA,
752         customizeData.extra,
753         false,
754         parseResult);
755 }
756 
from_json(const nlohmann::json & jsonObject,MetaData & metaData)757 void from_json(const nlohmann::json &jsonObject, MetaData &metaData)
758 {
759     const auto &jsonObjectEnd = jsonObject.end();
760     int32_t parseResult = ERR_OK;
761     GetValueIfFindKey<std::vector<CustomizeData>>(jsonObject,
762         jsonObjectEnd,
763         JSON_KEY_CUSTOMIZE_DATA,
764         metaData.customizeData,
765         JsonType::ARRAY,
766         false,
767         parseResult,
768         ArrayType::OBJECT);
769 }
770 
from_json(const nlohmann::json & jsonObject,Metadata & metadata)771 void from_json(const nlohmann::json &jsonObject, Metadata &metadata)
772 {
773     const auto &jsonObjectEnd = jsonObject.end();
774     int32_t parseResult = ERR_OK;
775     GetValueIfFindKey<uint32_t>(jsonObject,
776         jsonObjectEnd,
777         META_DATA_VALUEID,
778         metadata.valueId,
779         JsonType::NUMBER,
780         false,
781         parseResult,
782         ArrayType::NOT_ARRAY);
783     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
784         jsonObjectEnd,
785         META_DATA_NAME,
786         metadata.name,
787         false,
788         parseResult);
789     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
790         jsonObjectEnd,
791         META_DATA_VALUE,
792         metadata.value,
793         false,
794         parseResult);
795     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
796         jsonObjectEnd,
797         META_DATA_RESOURCE,
798         metadata.resource,
799         false,
800         parseResult);
801     if (parseResult != ERR_OK) {
802         APP_LOGE("read database error : %{public}d", parseResult);
803     }
804 }
805 
from_json(const nlohmann::json & jsonObject,AbilityInfo & abilityInfo)806 void from_json(const nlohmann::json &jsonObject, AbilityInfo &abilityInfo)
807 {
808     APP_LOGD("AbilityInfo from_json begin");
809     const auto &jsonObjectEnd = jsonObject.end();
810     int32_t parseResult = ERR_OK;
811     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
812         jsonObjectEnd,
813         JSON_KEY_NAME,
814         abilityInfo.name,
815         false,
816         parseResult);
817     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
818         jsonObjectEnd,
819         JSON_KEY_LABEL,
820         abilityInfo.label,
821         false,
822         parseResult);
823     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
824         jsonObjectEnd,
825         JSON_KEY_DESCRIPTION,
826         abilityInfo.description,
827         false,
828         parseResult);
829     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
830         jsonObjectEnd,
831         JSON_KEY_ICON_PATH,
832         abilityInfo.iconPath,
833         false,
834         parseResult);
835     GetValueIfFindKey<uint32_t>(jsonObject,
836         jsonObjectEnd,
837         JSON_KEY_LABEL_ID,
838         abilityInfo.labelId,
839         JsonType::NUMBER,
840         false,
841         parseResult,
842         ArrayType::NOT_ARRAY);
843     GetValueIfFindKey<uint32_t>(jsonObject,
844         jsonObjectEnd,
845         JSON_KEY_DESCRIPTION_ID,
846         abilityInfo.descriptionId,
847         JsonType::NUMBER,
848         false,
849         parseResult,
850         ArrayType::NOT_ARRAY);
851     GetValueIfFindKey<uint32_t>(jsonObject,
852         jsonObjectEnd,
853         JSON_KEY_ICON_ID,
854         abilityInfo.iconId,
855         JsonType::NUMBER,
856         false,
857         parseResult,
858         ArrayType::NOT_ARRAY);
859     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
860         jsonObjectEnd,
861         JSON_KEY_THEME,
862         abilityInfo.theme,
863         false,
864         parseResult);
865     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
866         jsonObjectEnd,
867         JSON_KEY_VISIBLE,
868         abilityInfo.visible,
869         false,
870         parseResult);
871     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
872         jsonObjectEnd,
873         JSON_KEY_KIND,
874         abilityInfo.kind,
875         false,
876         parseResult);
877     GetValueIfFindKey<AbilityType>(jsonObject,
878         jsonObjectEnd,
879         JSON_KEY_TYPE,
880         abilityInfo.type,
881         JsonType::NUMBER,
882         false,
883         parseResult,
884         ArrayType::NOT_ARRAY);
885     GetValueIfFindKey<ExtensionAbilityType>(jsonObject,
886         jsonObjectEnd,
887         JSON_KEY_EXTENSION_ABILITY_TYPE,
888         abilityInfo.extensionAbilityType,
889         JsonType::NUMBER,
890         false,
891         parseResult,
892         ArrayType::NOT_ARRAY);
893     GetValueIfFindKey<DisplayOrientation>(jsonObject,
894         jsonObjectEnd,
895         JSON_KEY_ORIENTATION,
896         abilityInfo.orientation,
897         JsonType::NUMBER,
898         false,
899         parseResult,
900         ArrayType::NOT_ARRAY);
901     GetValueIfFindKey<LaunchMode>(jsonObject,
902         jsonObjectEnd,
903         JSON_KEY_LAUNCH_MODE,
904         abilityInfo.launchMode,
905         JsonType::NUMBER,
906         false,
907         parseResult,
908         ArrayType::NOT_ARRAY);
909     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
910         jsonObjectEnd,
911         JSON_KEY_SRC_PATH,
912         abilityInfo.srcPath,
913         false,
914         parseResult);
915     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
916         jsonObjectEnd,
917         JSON_KEY_SRC_LANGUAGE,
918         abilityInfo.srcLanguage,
919         false,
920         parseResult);
921     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
922         jsonObjectEnd,
923         JSON_KEY_PERMISSIONS,
924         abilityInfo.permissions,
925         JsonType::ARRAY,
926         false,
927         parseResult,
928         ArrayType::STRING);
929     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
930         jsonObjectEnd,
931         JSON_KEY_PROCESS,
932         abilityInfo.process,
933         false,
934         parseResult);
935     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
936         jsonObjectEnd,
937         JSON_KEY_DEVICE_TYPES,
938         abilityInfo.deviceTypes,
939         JsonType::ARRAY,
940         false,
941         parseResult,
942         ArrayType::STRING);
943     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
944         jsonObjectEnd,
945         JSON_KEY_DEVICE_CAPABILITIES,
946         abilityInfo.deviceCapabilities,
947         JsonType::ARRAY,
948         false,
949         parseResult,
950         ArrayType::STRING);
951     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
952         jsonObjectEnd,
953         JSON_KEY_URI,
954         abilityInfo.uri,
955         false,
956         parseResult);
957     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
958         jsonObjectEnd,
959         JSON_KEY_TARGET_ABILITY,
960         abilityInfo.targetAbility,
961         false,
962         parseResult);
963     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
964         jsonObjectEnd,
965         JSON_KEY_IS_LAUNCHER_ABILITY,
966         abilityInfo.isLauncherAbility,
967         false,
968         parseResult);
969     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
970         jsonObjectEnd,
971         JSON_KEY_IS_NATIVE_ABILITY,
972         abilityInfo.isNativeAbility,
973         false,
974         parseResult);
975     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
976         jsonObjectEnd,
977         JSON_KEY_ENABLED,
978         abilityInfo.enabled,
979         false,
980         parseResult);
981     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
982         jsonObjectEnd,
983         JSON_KEY_SUPPORT_PIP_MODE,
984         abilityInfo.supportPipMode,
985         false,
986         parseResult);
987     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
988         jsonObjectEnd,
989         JSON_KEY_FORM_ENABLED,
990         abilityInfo.formEnabled,
991         false,
992         parseResult);
993     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
994         jsonObjectEnd,
995         JSON_KEY_READ_PERMISSION,
996         abilityInfo.readPermission,
997         false,
998         parseResult);
999     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1000         jsonObjectEnd,
1001         JSON_KEY_WRITE_PERMISSION,
1002         abilityInfo.writePermission,
1003         false,
1004         parseResult);
1005     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1006         jsonObjectEnd,
1007         JSON_KEY_CONFIG_CHANGES,
1008         abilityInfo.configChanges,
1009         JsonType::ARRAY,
1010         false,
1011         parseResult,
1012         ArrayType::STRING);
1013     GetValueIfFindKey<uint32_t>(jsonObject,
1014         jsonObjectEnd,
1015         JSON_KEY_FORM_ENTITY,
1016         abilityInfo.formEntity,
1017         JsonType::NUMBER,
1018         false,
1019         parseResult,
1020         ArrayType::NOT_ARRAY);
1021     GetValueIfFindKey<int32_t>(jsonObject,
1022         jsonObjectEnd,
1023         JSON_KEY_MIN_FORM_HEIGHT,
1024         abilityInfo.minFormHeight,
1025         JsonType::NUMBER,
1026         false,
1027         parseResult,
1028         ArrayType::NOT_ARRAY);
1029     GetValueIfFindKey<int32_t>(jsonObject,
1030         jsonObjectEnd,
1031         JSON_KEY_DEFAULT_FORM_HEIGHT,
1032         abilityInfo.defaultFormHeight,
1033         JsonType::NUMBER,
1034         false,
1035         parseResult,
1036         ArrayType::NOT_ARRAY);
1037     GetValueIfFindKey<int32_t>(jsonObject,
1038         jsonObjectEnd,
1039         JSON_KEY_MIN_FORM_WIDTH,
1040         abilityInfo.minFormWidth,
1041         JsonType::NUMBER,
1042         false,
1043         parseResult,
1044         ArrayType::NOT_ARRAY);
1045     GetValueIfFindKey<int32_t>(jsonObject,
1046         jsonObjectEnd,
1047         JSON_KEY_DEFAULT_FORM_WIDTH,
1048         abilityInfo.defaultFormWidth,
1049         JsonType::NUMBER,
1050         false,
1051         parseResult,
1052         ArrayType::NOT_ARRAY);
1053     GetValueIfFindKey<MetaData>(jsonObject,
1054         jsonObjectEnd,
1055         JSON_KEY_META_DATA,
1056         abilityInfo.metaData,
1057         JsonType::OBJECT,
1058         false,
1059         parseResult,
1060         ArrayType::NOT_ARRAY);
1061     GetValueIfFindKey<uint32_t>(jsonObject,
1062         jsonObjectEnd,
1063         JSON_KEY_BACKGROUND_MODES,
1064         abilityInfo.backgroundModes,
1065         JsonType::NUMBER,
1066         false,
1067         parseResult,
1068         ArrayType::NOT_ARRAY);
1069     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1070         jsonObjectEnd,
1071         JSON_KEY_PACKAGE,
1072         abilityInfo.package,
1073         false,
1074         parseResult);
1075     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1076         jsonObjectEnd,
1077         Constants::BUNDLE_NAME,
1078         abilityInfo.bundleName,
1079         false,
1080         parseResult);
1081     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1082         jsonObjectEnd,
1083         Constants::MODULE_NAME,
1084         abilityInfo.moduleName,
1085         false,
1086         parseResult);
1087     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1088         jsonObjectEnd,
1089         JSON_KEY_APPLICATION_NAME,
1090         abilityInfo.applicationName,
1091         false,
1092         parseResult);
1093     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1094         jsonObjectEnd,
1095         JSON_KEY_CODE_PATH,
1096         abilityInfo.codePath,
1097         false,
1098         parseResult);
1099     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1100         jsonObjectEnd,
1101         JSON_KEY_RESOURCE_PATH,
1102         abilityInfo.resourcePath,
1103         false,
1104         parseResult);
1105     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1106         jsonObjectEnd,
1107         Constants::HAP_PATH,
1108         abilityInfo.hapPath,
1109         false,
1110         parseResult);
1111     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1112         jsonObjectEnd,
1113         SRC_ENTRANCE,
1114         abilityInfo.srcEntrance,
1115         false,
1116         parseResult);
1117     GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
1118         jsonObjectEnd,
1119         META_DATA,
1120         abilityInfo.metadata,
1121         JsonType::ARRAY,
1122         false,
1123         parseResult,
1124         ArrayType::OBJECT);
1125     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1126         jsonObjectEnd,
1127         IS_MODULE_JSON,
1128         abilityInfo.isModuleJson,
1129         false,
1130         parseResult);
1131     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1132         jsonObjectEnd,
1133         IS_STAGE_BASED_MODEL,
1134         abilityInfo.isStageBasedModel,
1135         false,
1136         parseResult);
1137     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1138         jsonObjectEnd,
1139         CONTINUABLE,
1140         abilityInfo.continuable,
1141         false,
1142         parseResult);
1143     GetValueIfFindKey<int32_t>(jsonObject,
1144         jsonObjectEnd,
1145         PRIORITY,
1146         abilityInfo.priority,
1147         JsonType::NUMBER,
1148         false,
1149         parseResult,
1150         ArrayType::NOT_ARRAY);
1151     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1152         jsonObjectEnd,
1153         JSON_KEY_START_WINDOW_ICON,
1154         abilityInfo.startWindowIcon,
1155         false,
1156         parseResult);
1157     GetValueIfFindKey<uint32_t>(jsonObject,
1158         jsonObjectEnd,
1159         JSON_KEY_START_WINDOW_ICON_ID,
1160         abilityInfo.startWindowIconId,
1161         JsonType::NUMBER,
1162         false,
1163         parseResult,
1164         ArrayType::NOT_ARRAY);
1165     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1166         jsonObjectEnd,
1167         JSON_KEY_START_WINDOW_BACKGROUND,
1168         abilityInfo.startWindowBackground,
1169         false,
1170         parseResult);
1171     GetValueIfFindKey<uint32_t>(jsonObject,
1172         jsonObjectEnd,
1173         JSON_KEY_START_WINDOW_BACKGROUND_ID,
1174         abilityInfo.startWindowBackgroundId,
1175         JsonType::NUMBER,
1176         false,
1177         parseResult,
1178         ArrayType::NOT_ARRAY);
1179     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1180         jsonObjectEnd,
1181         JSON_KEY_REMOVE_MISSION_AFTER_TERMINATE,
1182         abilityInfo.removeMissionAfterTerminate,
1183         false,
1184         parseResult);
1185     GetValueIfFindKey<CompileMode>(jsonObject,
1186         jsonObjectEnd,
1187         JSON_KEY_COMPILE_MODE,
1188         abilityInfo.compileMode,
1189         JsonType::NUMBER,
1190         false,
1191         parseResult,
1192         ArrayType::NOT_ARRAY);
1193     GetValueIfFindKey<std::vector<SupportWindowMode>>(jsonObject,
1194         jsonObjectEnd,
1195         JOSN_KEY_SUPPORT_WINDOW_MODE,
1196         abilityInfo.windowModes,
1197         JsonType::ARRAY,
1198         false,
1199         parseResult,
1200         ArrayType::NUMBER);
1201     GetValueIfFindKey<double>(jsonObject,
1202         jsonObjectEnd,
1203         JOSN_KEY_MAX_WINDOW_RATIO,
1204         abilityInfo.maxWindowRatio,
1205         JsonType::NUMBER,
1206         false,
1207         parseResult,
1208         ArrayType::NOT_ARRAY);
1209     GetValueIfFindKey<double>(jsonObject,
1210         jsonObjectEnd,
1211         JOSN_KEY_MIN_WINDOW_RATIO,
1212         abilityInfo.minWindowRatio,
1213         JsonType::NUMBER,
1214         false,
1215         parseResult,
1216         ArrayType::NOT_ARRAY);
1217     GetValueIfFindKey<uint32_t>(jsonObject,
1218         jsonObjectEnd,
1219         JOSN_KEY_MAX_WINDOW_WIDTH,
1220         abilityInfo.maxWindowWidth,
1221         JsonType::NUMBER,
1222         false,
1223         parseResult,
1224         ArrayType::NOT_ARRAY);
1225     GetValueIfFindKey<uint32_t>(jsonObject,
1226         jsonObjectEnd,
1227         JOSN_KEY_MIN_WINDOW_WIDTH,
1228         abilityInfo.minWindowWidth,
1229         JsonType::NUMBER,
1230         false,
1231         parseResult,
1232         ArrayType::NOT_ARRAY);
1233     GetValueIfFindKey<uint32_t>(jsonObject,
1234         jsonObjectEnd,
1235         JOSN_KEY_MAX_WINDOW_HEIGHT,
1236         abilityInfo.maxWindowHeight,
1237         JsonType::NUMBER,
1238         false,
1239         parseResult,
1240         ArrayType::NOT_ARRAY);
1241     GetValueIfFindKey<uint32_t>(jsonObject,
1242         jsonObjectEnd,
1243         JOSN_KEY_MIN_WINDOW_HEIGHT,
1244         abilityInfo.minWindowHeight,
1245         JsonType::NUMBER,
1246         false,
1247         parseResult,
1248         ArrayType::NOT_ARRAY);
1249     GetValueIfFindKey<int32_t>(jsonObject,
1250         jsonObjectEnd,
1251         JOSN_KEY_UID,
1252         abilityInfo.uid,
1253         JsonType::NUMBER,
1254         false,
1255         parseResult,
1256         ArrayType::NOT_ARRAY);
1257     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1258         jsonObjectEnd,
1259         JOSN_KEY_EXCLUDE_FROM_MISSIONS,
1260         abilityInfo.excludeFromMissions,
1261         false,
1262         parseResult);
1263     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1264         jsonObjectEnd,
1265         JOSN_KEY_UNCLEARABLE_MISSION,
1266         abilityInfo.unclearableMission,
1267         false,
1268         parseResult);
1269     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1270         jsonObjectEnd,
1271         JSON_KEY_EXCLUDE_FROM_DOCK_MISSION,
1272         abilityInfo.excludeFromDock,
1273         false,
1274         parseResult);
1275     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1276         jsonObjectEnd,
1277         JSON_KEY_PREFER_MULTI_WINDOW_ORIENTATION_MISSION,
1278         abilityInfo.preferMultiWindowOrientation,
1279         false,
1280         parseResult);
1281     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1282         jsonObjectEnd,
1283         JSON_KEY_RECOVERABLE,
1284         abilityInfo.recoverable,
1285         false,
1286         parseResult);
1287     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1288         jsonObjectEnd,
1289         JSON_KEY_SUPPORT_EXT_NAMES,
1290         abilityInfo.supportExtNames,
1291         JsonType::ARRAY,
1292         false,
1293         parseResult,
1294         ArrayType::STRING);
1295     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1296         jsonObjectEnd,
1297         JSON_KEY_SUPPORT_MIME_TYPES,
1298         abilityInfo.supportMimeTypes,
1299         JsonType::ARRAY,
1300         false,
1301         parseResult,
1302         ArrayType::STRING);
1303     BMSJsonUtil::GetBoolValueIfFindKey(jsonObject,
1304         jsonObjectEnd,
1305         JSON_KEY_ISOLATION_PROCESS,
1306         abilityInfo.isolationProcess,
1307         false,
1308         parseResult);
1309     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
1310         jsonObjectEnd,
1311         JSON_KEY_CONTINUE_TYPE,
1312         abilityInfo.continueType,
1313         JsonType::ARRAY,
1314         false,
1315         parseResult,
1316         ArrayType::STRING);
1317     GetValueIfFindKey<std::unordered_set<std::string>>(jsonObject,
1318         jsonObjectEnd,
1319         JSON_KEY_CONTINUE_BUNDLE_NAME,
1320         abilityInfo.continueBundleNames,
1321         JsonType::ARRAY,
1322         false,
1323         parseResult,
1324         ArrayType::STRING);
1325     GetValueIfFindKey<std::vector<Skill>>(jsonObject,
1326         jsonObjectEnd,
1327         JSON_KEY_SKILLS,
1328         abilityInfo.skills,
1329         JsonType::ARRAY,
1330         false,
1331         parseResult,
1332         ArrayType::OBJECT);
1333     GetValueIfFindKey<int32_t>(jsonObject,
1334         jsonObjectEnd,
1335         JSON_KEY_APP_INDEX,
1336         abilityInfo.appIndex,
1337         JsonType::NUMBER,
1338         false,
1339         parseResult,
1340         ArrayType::NOT_ARRAY);
1341     GetValueIfFindKey<uint32_t>(jsonObject,
1342         jsonObjectEnd,
1343         JSON_KEY_ORIENTATION_ID,
1344         abilityInfo.orientationId,
1345         JsonType::NUMBER,
1346         false,
1347         parseResult,
1348         ArrayType::NOT_ARRAY);
1349     BMSJsonUtil::GetStrValueIfFindKey(jsonObject,
1350         jsonObjectEnd,
1351         JSON_KEY_START_WINDOW,
1352         abilityInfo.startWindow,
1353         false,
1354         parseResult);
1355     GetValueIfFindKey<uint32_t>(jsonObject,
1356         jsonObjectEnd,
1357         JSON_KEY_START_WINDOW_ID,
1358         abilityInfo.startWindowId,
1359         JsonType::NUMBER,
1360         false,
1361         parseResult,
1362         ArrayType::NOT_ARRAY);
1363     GetValueIfFindKey<StartWindowResource>(jsonObject,
1364         jsonObjectEnd,
1365         JSON_KEY_START_WINDOW_RESOURCE,
1366         abilityInfo.startWindowResource,
1367         JsonType::OBJECT,
1368         false,
1369         parseResult,
1370         ArrayType::NOT_ARRAY);
1371     if (parseResult != ERR_OK) {
1372         APP_LOGE("AbilityInfo from_json error : %{public}d", parseResult);
1373     }
1374 }
1375 
ConvertToCompatiableAbilityInfo(CompatibleAbilityInfo & compatibleAbilityInfo) const1376 void AbilityInfo::ConvertToCompatiableAbilityInfo(CompatibleAbilityInfo& compatibleAbilityInfo) const
1377 {
1378     APP_LOGE("AbilityInfo::ConvertToCompatiableAbilityInfo called");
1379     compatibleAbilityInfo.package = package;
1380     compatibleAbilityInfo.name = name;
1381     compatibleAbilityInfo.label = label;
1382     compatibleAbilityInfo.description = description;
1383     compatibleAbilityInfo.iconPath = iconPath;
1384     compatibleAbilityInfo.uri = uri;
1385     compatibleAbilityInfo.moduleName = moduleName;
1386     compatibleAbilityInfo.process = process;
1387     compatibleAbilityInfo.targetAbility = targetAbility;
1388     compatibleAbilityInfo.appName = appName;
1389     compatibleAbilityInfo.privacyUrl = privacyUrl;
1390     compatibleAbilityInfo.privacyName = privacyName;
1391     compatibleAbilityInfo.downloadUrl = downloadUrl;
1392     compatibleAbilityInfo.versionName = versionName;
1393     compatibleAbilityInfo.backgroundModes = backgroundModes;
1394     compatibleAbilityInfo.packageSize = packageSize;
1395     compatibleAbilityInfo.visible = visible;
1396     compatibleAbilityInfo.formEnabled = formEnabled;
1397     compatibleAbilityInfo.multiUserShared = multiUserShared;
1398     compatibleAbilityInfo.type = type;
1399     compatibleAbilityInfo.subType = subType;
1400     compatibleAbilityInfo.orientation = orientation;
1401     compatibleAbilityInfo.launchMode = launchMode;
1402     compatibleAbilityInfo.permissions = permissions;
1403     compatibleAbilityInfo.deviceTypes = deviceTypes;
1404     compatibleAbilityInfo.deviceCapabilities = deviceCapabilities;
1405     compatibleAbilityInfo.supportPipMode = supportPipMode;
1406     compatibleAbilityInfo.grantPermission = grantPermission;
1407     compatibleAbilityInfo.readPermission = readPermission;
1408     compatibleAbilityInfo.writePermission = writePermission;
1409     compatibleAbilityInfo.uriPermissionMode = uriPermissionMode;
1410     compatibleAbilityInfo.uriPermissionPath = uriPermissionPath;
1411     compatibleAbilityInfo.directLaunch = directLaunch;
1412     compatibleAbilityInfo.bundleName = bundleName;
1413     compatibleAbilityInfo.className = className;
1414     compatibleAbilityInfo.originalClassName = originalClassName;
1415     compatibleAbilityInfo.deviceId = deviceId;
1416     CompatibleApplicationInfo convertedCompatibleApplicationInfo;
1417     applicationInfo.ConvertToCompatibleApplicationInfo(convertedCompatibleApplicationInfo);
1418     compatibleAbilityInfo.applicationInfo = convertedCompatibleApplicationInfo;
1419     compatibleAbilityInfo.formEntity = formEntity;
1420     compatibleAbilityInfo.minFormHeight = minFormHeight;
1421     compatibleAbilityInfo.defaultFormHeight = defaultFormHeight;
1422     compatibleAbilityInfo.minFormWidth = minFormWidth;
1423     compatibleAbilityInfo.defaultFormWidth = defaultFormWidth;
1424     compatibleAbilityInfo.iconId = iconId;
1425     compatibleAbilityInfo.labelId = labelId;
1426     compatibleAbilityInfo.descriptionId = descriptionId;
1427     compatibleAbilityInfo.enabled = enabled;
1428 }
1429 
ReadFromParcel(Parcel & parcel)1430 bool StartWindowResource::ReadFromParcel(Parcel &parcel)
1431 {
1432     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowAppIconId);
1433     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowIllustrationId);
1434     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBrandingImageId);
1435     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBackgroundColorId);
1436     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBackgroundImageId);
1437     std::u16string startWindowBackgroundImageFitVal;
1438     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, startWindowBackgroundImageFitVal);
1439     startWindowBackgroundImageFit = Str16ToStr8(startWindowBackgroundImageFitVal);
1440     return true;
1441 }
1442 
Marshalling(Parcel & parcel) const1443 bool StartWindowResource::Marshalling(Parcel &parcel) const
1444 {
1445     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowAppIconId);
1446     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowIllustrationId);
1447     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBrandingImageId);
1448     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBackgroundColorId);
1449     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, startWindowBackgroundImageId);
1450     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(startWindowBackgroundImageFit));
1451     return true;
1452 }
1453 
Unmarshalling(Parcel & parcel)1454 StartWindowResource *StartWindowResource::Unmarshalling(Parcel &parcel)
1455 {
1456     StartWindowResource *startWindowResource = new (std::nothrow) StartWindowResource;
1457     if (startWindowResource && !startWindowResource->ReadFromParcel(parcel)) {
1458         APP_LOGE("read from parcel failed");
1459         delete startWindowResource;
1460         startWindowResource = nullptr;
1461     }
1462     return startWindowResource;
1463 }
1464 }  // namespace AppExecFwk
1465 }  // namespace OHOS
1466