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