1 /*
2  * Copyright (c) 2023-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 "extension_ability_info.h"
17 
18 #include <fcntl.h>
19 #include <set>
20 #include <string>
21 #include <unistd.h>
22 
23 #include "bundle_constants.h"
24 #include "json_util.h"
25 #include "nlohmann/json.hpp"
26 #include "parcel_macro.h"
27 #include "string_ex.h"
28 
29 namespace OHOS {
30 namespace AppExecFwk {
31 const char* JSON_KEY_SKILLS = "skills";
32 namespace {
33 const char* NAME = "name";
34 const char* SRC_ENTRANCE = "srcEntrance";
35 const char* ICON = "icon";
36 const char* ICON_ID = "iconId";
37 const char* LABEL = "label";
38 const char* LABEL_ID = "labelId";
39 const char* DESCRIPTION = "description";
40 const char* DESCRIPTION_ID = "descriptionId";
41 const char* PRIORITY = "priority";
42 const char* TYPE = "type";
43 const char* EXTENSION_TYPE_NAME = "extensionTypeName";
44 const char* PERMISSIONS = "permissions";
45 const char* READ_PERMISSION = "readPermission";
46 const char* WRITE_PERMISSION = "writePermission";
47 const char* URI = "uri";
48 const char* VISIBLE = "visible";
49 const char* META_DATA = "metadata";
50 const char* RESOURCE_PATH = "resourcePath";
51 const char* ENABLED = "enabled";
52 const char* PROCESS = "process";
53 const char* COMPILE_MODE = "compileMode";
54 const char* UID = "uid";
55 const char* APP_INDEX = "appIndex";
56 const uint16_t ABILITY_CAPACITY = 10240; // 10K
57 const char* EXTENSION_PROCESS_MODE = "extensionProcessMode";
58 const char* SKILLS = "skills";
59 const char* NEED_CREATE_SANDBOX = "needCreateSandbox";
60 const char* DATA_GROUP_IDS = "dataGroupIds";
61 const char* JSON_KEY_VALID_DATA_GROUP_IDS = "validDataGroupIds";
62 const char* JSON_KEY_CUSTOM_PROCESS = "customProcess";
63 
64 const std::unordered_map<std::string, ExtensionAbilityType> EXTENSION_TYPE_MAP = {
65     { "form", ExtensionAbilityType::FORM },
66     { "workScheduler", ExtensionAbilityType::WORK_SCHEDULER },
67     { "inputMethod", ExtensionAbilityType::INPUTMETHOD },
68     { "service", ExtensionAbilityType::SERVICE },
69     { "accessibility", ExtensionAbilityType::ACCESSIBILITY },
70     { "fence", ExtensionAbilityType::FENCE },
71     { "dataShare", ExtensionAbilityType::DATASHARE },
72     { "fileShare", ExtensionAbilityType::FILESHARE },
73     { "staticSubscriber", ExtensionAbilityType::STATICSUBSCRIBER },
74     { "wallpaper", ExtensionAbilityType::WALLPAPER },
75     { "backup", ExtensionAbilityType::BACKUP },
76     { "window", ExtensionAbilityType::WINDOW },
77     { "enterpriseAdmin", ExtensionAbilityType::ENTERPRISE_ADMIN },
78     { "fileAccess", ExtensionAbilityType::FILEACCESS_EXTENSION },
79     { "thumbnail", ExtensionAbilityType::THUMBNAIL },
80     { "preview", ExtensionAbilityType::PREVIEW },
81     { "print", ExtensionAbilityType::PRINT },
82     { "share", ExtensionAbilityType::SHARE },
83     { "push", ExtensionAbilityType::PUSH },
84     { "driver", ExtensionAbilityType::DRIVER },
85     { "action", ExtensionAbilityType::ACTION },
86     { "adsService", ExtensionAbilityType::ADS_SERVICE },
87     { "embeddedUI", ExtensionAbilityType::EMBEDDED_UI },
88     { "statusBarView", ExtensionAbilityType::STATUS_BAR_VIEW },
89     { "insightIntentUI", ExtensionAbilityType::INSIGHT_INTENT_UI },
90     { "autoFill/password", ExtensionAbilityType::AUTO_FILL_PASSWORD },
91     { "appAccountAuthorization", ExtensionAbilityType::APP_ACCOUNT_AUTHORIZATION },
92     { "ui", ExtensionAbilityType::UI },
93     { "remoteNotification", ExtensionAbilityType::REMOTE_NOTIFICATION },
94     { "remoteLocation", ExtensionAbilityType::REMOTE_LOCATION },
95     { "voip", ExtensionAbilityType::VOIP },
96     { "accountLogout", ExtensionAbilityType::ACCOUNTLOGOUT },
97     { "sysDialog/userAuth", ExtensionAbilityType::SYSDIALOG_USERAUTH },
98     { "sysDialog/common", ExtensionAbilityType::SYSDIALOG_COMMON },
99     { "sysPicker/mediaControl", ExtensionAbilityType::SYSPICKER_MEDIACONTROL },
100     { "sysDialog/atomicServicePanel", ExtensionAbilityType::SYSDIALOG_ATOMICSERVICEPANEL },
101     { "sysDialog/power", ExtensionAbilityType::SYSDIALOG_POWER },
102     { "sysPicker/share", ExtensionAbilityType::SYSPICKER_SHARE },
103     { "hms/account", ExtensionAbilityType::HMS_ACCOUNT },
104     { "ads", ExtensionAbilityType::ADS },
105     { "sysDialog/meetimeCall", ExtensionAbilityType::SYSDIALOG_MEETIMECALL },
106     { "sysDialog/meetimeContact", ExtensionAbilityType::SYSDIALOG_MEETIMECONTACT },
107     { "sysDialog/meetimeMessage", ExtensionAbilityType::SYSDIALOG_MEETIMEMESSAGE },
108     { "sysDialog/print", ExtensionAbilityType::SYSDIALOG_PRINT },
109     { "sysPicker/meetimeContact", ExtensionAbilityType::SYSPICKER_MEETIMECONTACT },
110     { "sysPicker/meetimeCallLog", ExtensionAbilityType::SYSPICKER_MEETIMECALLLOG },
111     { "sysPicker/photoPicker", ExtensionAbilityType::SYSPICKER_PHOTOPICKER },
112     { "sysPicker/navigation", ExtensionAbilityType::SYSPICKER_NAVIGATION },
113     { "sysPicker/appSelector", ExtensionAbilityType::SYSPICKER_APPSELECTOR },
114     { "sysPicker/camera", ExtensionAbilityType::SYSPICKER_CAMERA },
115     { "sysPicker/filePicker", ExtensionAbilityType::SYSPICKER_FILEPICKER },
116     { "sysPicker/audioPicker", ExtensionAbilityType::SYSPICKER_AUDIOPICKER },
117     { "sys/commonUI", ExtensionAbilityType::SYS_COMMON_UI },
118     { "vpn", ExtensionAbilityType::VPN },
119     { "autoFill/smart", ExtensionAbilityType::AUTO_FILL_SMART },
120     { "liveViewLockScreen", ExtensionAbilityType::LIVEVIEW_LOCKSCREEN },
121     { "photoEditor", ExtensionAbilityType::PHOTO_EDITOR },
122     { "callerInfoQuery", ExtensionAbilityType::CALLER_INFO_QUERY },
123     { "sysPicker/photoEditor", ExtensionAbilityType::SYSPICKER_PHOTOEDITOR },
124     { "sys/visualExtension", ExtensionAbilityType::SYS_VISUAL },
125     { "uiService", ExtensionAbilityType::UI_SERVICE },
126     { "recentPhoto", ExtensionAbilityType::RECENT_PHOTO }
127 };
128 
129 // the new extension type does not need to be added here
130 const std::set<std::string> NOT_NEED_CREATE_SANBOX_MODE = {
131     "form", "workScheduler", "service", "accessibility", "dataShare", "fileShare", "staticSubscriber", "wallpaper",
132     "backup", "window", "enterpriseAdmin", "fileAccess", "thumbnail", "preview", "print", "share", "push", "driver",
133     "action", "adsService", "embeddedUI", "insightIntentUI", "statusBarView", "autoFill/password",
134     "appAccountAuthorization", "ui", "remoteNotification", "remoteLocation", "voip", "accountLogout",
135     "sysDialog/userAuth", "sysDialog/common", "sysPicker/mediaControl", "sysDialog/atomicServicePanel",
136     "sysDialog/power", "sysPicker/share", "hms/account", "ads", "sysDialog/meetimeCall",
137     "sysDialog/meetimeContact", "sysDialog/meetimeMessage", "sysDialog/print", "sysPicker/meetimeContact",
138     "sysPicker/meetimeCallLog", "sysPicker/photoPicker", "sysPicker/camera", "sysPicker/navigation",
139     "sysPicker/appSelector", "sys/commonUI", "vpn", "autoFill/smart", "liveViewLockScreen"
140 };
141 
142 const std::unordered_map<std::string, ExtensionProcessMode> EXTENSION_PROCESS_MODE_MAP = {
143     { "instance", ExtensionProcessMode::INSTANCE },
144     { "type", ExtensionProcessMode::TYPE },
145     { "bundle", ExtensionProcessMode::BUNDLE },
146     { "runWithMainProcess", ExtensionProcessMode::RUN_WITH_MAIN_PROCESS }
147 };
148 
ReadSkillInfoFromParcel(Parcel & parcel,std::vector<SkillUriForAbilityAndExtension> & skillUri)149 bool ReadSkillInfoFromParcel(Parcel &parcel, std::vector<SkillUriForAbilityAndExtension> &skillUri)
150 {
151     int32_t skillUriSize = 0;
152     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUriSize);
153     CONTAINER_SECURITY_VERIFY(parcel, skillUriSize, &skillUri);
154     for (auto i = 0; i < skillUriSize; i++) {
155         SkillUriForAbilityAndExtension stctUri;
156         stctUri.scheme = Str16ToStr8(parcel.ReadString16());
157         stctUri.host = Str16ToStr8(parcel.ReadString16());
158         stctUri.port = Str16ToStr8(parcel.ReadString16());
159         stctUri.path = Str16ToStr8(parcel.ReadString16());
160         stctUri.pathStartWith = Str16ToStr8(parcel.ReadString16());
161         stctUri.pathRegex = Str16ToStr8(parcel.ReadString16());
162         stctUri.type = Str16ToStr8(parcel.ReadString16());
163         stctUri.utd = Str16ToStr8(parcel.ReadString16());
164         stctUri.maxFileSupported = parcel.ReadInt32();
165         stctUri.linkFeature = Str16ToStr8(parcel.ReadString16());
166         stctUri.isMatch = parcel.ReadBool();
167         skillUri.emplace_back(stctUri);
168     }
169     return true;
170 }
171 
ReadMetadataFromParcel(Parcel & parcel,std::vector<Metadata> & metadata)172 bool ReadMetadataFromParcel(Parcel &parcel, std::vector<Metadata> &metadata)
173 {
174     int32_t metadataSize = 0;
175     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadataSize);
176     CONTAINER_SECURITY_VERIFY(parcel, metadataSize, &metadata);
177     for (auto i = 0; i < metadataSize; i++) {
178         std::unique_ptr<Metadata> meta(parcel.ReadParcelable<Metadata>());
179         if (!meta) {
180             APP_LOGE("ReadParcelable<Metadata> failed");
181             return false;
182         }
183         metadata.emplace_back(*meta);
184     }
185     return true;
186 }
187 }; // namespace
188 
ReadFromParcel(Parcel & parcel)189 bool ExtensionAbilityInfo::ReadFromParcel(Parcel &parcel)
190 {
191     bundleName = Str16ToStr8(parcel.ReadString16());
192     moduleName = Str16ToStr8(parcel.ReadString16());
193     name = Str16ToStr8(parcel.ReadString16());
194     srcEntrance = Str16ToStr8(parcel.ReadString16());
195     icon = Str16ToStr8(parcel.ReadString16());
196     iconId = parcel.ReadUint32();
197     label = Str16ToStr8(parcel.ReadString16());
198     labelId = parcel.ReadUint32();
199     description = Str16ToStr8(parcel.ReadString16());
200     descriptionId = parcel.ReadUint32();
201     priority = parcel.ReadInt32();
202     int32_t permissionsSize;
203     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissionsSize);
204     CONTAINER_SECURITY_VERIFY(parcel, permissionsSize, &permissions);
205     for (auto i = 0; i < permissionsSize; i++) {
206         permissions.emplace_back(Str16ToStr8(parcel.ReadString16()));
207     }
208     readPermission = Str16ToStr8(parcel.ReadString16());
209     writePermission = Str16ToStr8(parcel.ReadString16());
210     uri = Str16ToStr8(parcel.ReadString16());
211     type = static_cast<ExtensionAbilityType>(parcel.ReadInt32());
212     extensionTypeName = Str16ToStr8(parcel.ReadString16());
213     visible = parcel.ReadBool();
214     if (!ReadMetadataFromParcel(parcel, metadata)) {
215         APP_LOGE("Read meta data failed");
216         return false;
217     }
218 
219     std::unique_ptr<ApplicationInfo> appInfo(parcel.ReadParcelable<ApplicationInfo>());
220     if (!appInfo) {
221         APP_LOGE("ReadParcelable<ApplicationInfo> failed");
222         return false;
223     }
224     applicationInfo = *appInfo;
225 
226     resourcePath = Str16ToStr8(parcel.ReadString16());
227     hapPath = Str16ToStr8(parcel.ReadString16());
228     enabled = parcel.ReadBool();
229     process = Str16ToStr8(parcel.ReadString16());
230     compileMode = static_cast<CompileMode>(parcel.ReadInt32());
231     uid = parcel.ReadInt32();
232     appIndex = parcel.ReadInt32();
233     if (!ReadSkillInfoFromParcel(parcel, skillUri)) {
234         APP_LOGE("Read skill info failed");
235         return false;
236     }
237     extensionProcessMode = static_cast<ExtensionProcessMode>(parcel.ReadInt32());
238     int32_t skillsSize;
239     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillsSize);
240     CONTAINER_SECURITY_VERIFY(parcel, skillsSize, &skills);
241     for (auto i = 0; i < skillsSize; i++) {
242         std::unique_ptr<Skill> extensionSkillPtr(parcel.ReadParcelable<Skill>());
243         if (!extensionSkillPtr) {
244             APP_LOGE("ReadParcelable<SkillForExtension> failed");
245             return false;
246         }
247         skills.emplace_back(*extensionSkillPtr);
248     }
249 
250     needCreateSandbox = parcel.ReadBool();
251     int32_t dataGroupIdsSize;
252     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, dataGroupIdsSize);
253     CONTAINER_SECURITY_VERIFY(parcel, dataGroupIdsSize, &dataGroupIds);
254     for (auto i = 0; i < dataGroupIdsSize; i++) {
255         dataGroupIds.emplace_back(Str16ToStr8(parcel.ReadString16()));
256     }
257     int32_t validDataGroupIdsSize;
258     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, validDataGroupIdsSize);
259     CONTAINER_SECURITY_VERIFY(parcel, validDataGroupIdsSize, &validDataGroupIds);
260     for (auto i = 0; i < validDataGroupIdsSize; i++) {
261         dataGroupIds.emplace_back(Str16ToStr8(parcel.ReadString16()));
262     }
263     customProcess = Str16ToStr8(parcel.ReadString16());
264     return true;
265 }
266 
Unmarshalling(Parcel & parcel)267 ExtensionAbilityInfo *ExtensionAbilityInfo::Unmarshalling(Parcel &parcel)
268 {
269     ExtensionAbilityInfo *info = new (std::nothrow) ExtensionAbilityInfo();
270     if (info && !info->ReadFromParcel(parcel)) {
271         APP_LOGW("read from parcel failed");
272         delete info;
273         info = nullptr;
274     }
275     return info;
276 }
277 
MarshallingSkillUri(Parcel & parcel,SkillUriForAbilityAndExtension uri) const278 bool ExtensionAbilityInfo::MarshallingSkillUri(Parcel &parcel, SkillUriForAbilityAndExtension uri) const
279 {
280     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.scheme));
281     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.host));
282     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.port));
283     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.path));
284     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathStartWith));
285     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.pathRegex));
286     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.type));
287     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.utd));
288     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uri.maxFileSupported);
289     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri.linkFeature));
290     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, uri.isMatch);
291     return true;
292 }
293 
Marshalling(Parcel & parcel) const294 bool ExtensionAbilityInfo::Marshalling(Parcel &parcel) const
295 {
296     CHECK_PARCEL_CAPACITY(parcel, ABILITY_CAPACITY);
297     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(bundleName));
298     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(moduleName));
299     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(name));
300     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(srcEntrance));
301     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(icon));
302     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, iconId);
303     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(label));
304     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, labelId);
305     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(description));
306     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, parcel, descriptionId);
307     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, priority);
308     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, permissions.size());
309     for (auto &permission : permissions) {
310         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(permission));
311     }
312     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(readPermission));
313     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(writePermission));
314     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(uri));
315     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(type));
316     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(extensionTypeName));
317     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, visible);
318     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, metadata.size());
319     for (auto &mete : metadata) {
320         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &mete);
321     }
322     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &applicationInfo);
323     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(resourcePath));
324     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(hapPath));
325     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, enabled);
326     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(process));
327     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(compileMode));
328     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, uid);
329     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, appIndex);
330     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skillUri.size());
331     for (auto &uri : skillUri) {
332         MarshallingSkillUri(parcel, uri);
333     }
334     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, static_cast<int32_t>(extensionProcessMode));
335     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, skills.size());
336     for (auto &skill : skills) {
337         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, parcel, &skill);
338     }
339     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, parcel, needCreateSandbox);
340     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, dataGroupIds.size());
341     for (auto &dataGroupId : dataGroupIds) {
342         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(dataGroupId));
343     }
344     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, parcel, validDataGroupIds.size());
345     for (auto &dataGroupId : validDataGroupIds) {
346         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(dataGroupId));
347     }
348     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String16, parcel, Str8ToStr16(customProcess));
349     return true;
350 }
351 
to_json(nlohmann::json & jsonObject,const ExtensionAbilityInfo & extensionInfo)352 void to_json(nlohmann::json &jsonObject, const ExtensionAbilityInfo &extensionInfo)
353 {
354     APP_LOGD("ExtensionAbilityInfo to_json begin");
355     jsonObject = nlohmann::json {
356         {Constants::BUNDLE_NAME, extensionInfo.bundleName},
357         {Constants::MODULE_NAME, extensionInfo.moduleName},
358         {NAME, extensionInfo.name},
359         {SRC_ENTRANCE, extensionInfo.srcEntrance},
360         {ICON, extensionInfo.icon},
361         {ICON_ID, extensionInfo.iconId},
362         {LABEL, extensionInfo.label},
363         {LABEL_ID, extensionInfo.labelId},
364         {DESCRIPTION, extensionInfo.description},
365         {DESCRIPTION_ID, extensionInfo.descriptionId},
366         {PRIORITY, extensionInfo.priority},
367         {TYPE, extensionInfo.type},
368         {EXTENSION_TYPE_NAME, extensionInfo.extensionTypeName},
369         {READ_PERMISSION, extensionInfo.readPermission},
370         {WRITE_PERMISSION, extensionInfo.writePermission},
371         {URI, extensionInfo.uri},
372         {PERMISSIONS, extensionInfo.permissions},
373         {VISIBLE, extensionInfo.visible},
374         {META_DATA, extensionInfo.metadata},
375         {RESOURCE_PATH, extensionInfo.resourcePath},
376         {Constants::HAP_PATH, extensionInfo.hapPath},
377         {ENABLED, extensionInfo.enabled},
378         {PROCESS, extensionInfo.process},
379         {COMPILE_MODE, extensionInfo.compileMode},
380         {UID, extensionInfo.uid},
381         {APP_INDEX, extensionInfo.appIndex},
382         {EXTENSION_PROCESS_MODE, extensionInfo.extensionProcessMode},
383         {JSON_KEY_SKILLS, extensionInfo.skills},
384         {NEED_CREATE_SANDBOX, extensionInfo.needCreateSandbox},
385         {DATA_GROUP_IDS, extensionInfo.dataGroupIds},
386         {JSON_KEY_VALID_DATA_GROUP_IDS, extensionInfo.validDataGroupIds},
387         {JSON_KEY_CUSTOM_PROCESS, extensionInfo.customProcess}
388     };
389 }
390 
from_json(const nlohmann::json & jsonObject,ExtensionAbilityInfo & extensionInfo)391 void from_json(const nlohmann::json &jsonObject, ExtensionAbilityInfo &extensionInfo)
392 {
393     APP_LOGD("ExtensionAbilityInfo from_json begin");
394     const auto &jsonObjectEnd = jsonObject.end();
395     int32_t parseResult = ERR_OK;
396     GetValueIfFindKey<std::string>(jsonObject,
397         jsonObjectEnd,
398         Constants::BUNDLE_NAME,
399         extensionInfo.bundleName,
400         JsonType::STRING,
401         false,
402         parseResult,
403         ArrayType::NOT_ARRAY);
404     GetValueIfFindKey<std::string>(jsonObject,
405         jsonObjectEnd,
406         Constants::MODULE_NAME,
407         extensionInfo.moduleName,
408         JsonType::STRING,
409         false,
410         parseResult,
411         ArrayType::NOT_ARRAY);
412     GetValueIfFindKey<std::string>(jsonObject,
413         jsonObjectEnd,
414         NAME,
415         extensionInfo.name,
416         JsonType::STRING,
417         false,
418         parseResult,
419         ArrayType::NOT_ARRAY);
420     GetValueIfFindKey<std::string>(jsonObject,
421         jsonObjectEnd,
422         SRC_ENTRANCE,
423         extensionInfo.srcEntrance,
424         JsonType::STRING,
425         false,
426         parseResult,
427         ArrayType::NOT_ARRAY);
428     GetValueIfFindKey<std::string>(jsonObject,
429         jsonObjectEnd,
430         ICON,
431         extensionInfo.icon,
432         JsonType::STRING,
433         false,
434         parseResult,
435         ArrayType::NOT_ARRAY);
436     GetValueIfFindKey<uint32_t>(jsonObject,
437         jsonObjectEnd,
438         ICON_ID,
439         extensionInfo.iconId,
440         JsonType::NUMBER,
441         false,
442         parseResult,
443         ArrayType::NOT_ARRAY);
444     GetValueIfFindKey<std::string>(jsonObject,
445         jsonObjectEnd,
446         LABEL,
447         extensionInfo.label,
448         JsonType::STRING,
449         false,
450         parseResult,
451         ArrayType::NOT_ARRAY);
452     GetValueIfFindKey<uint32_t>(jsonObject,
453         jsonObjectEnd,
454         LABEL_ID,
455         extensionInfo.labelId,
456         JsonType::NUMBER,
457         false,
458         parseResult,
459         ArrayType::NOT_ARRAY);
460     GetValueIfFindKey<std::string>(jsonObject,
461         jsonObjectEnd,
462         DESCRIPTION,
463         extensionInfo.description,
464         JsonType::STRING,
465         false,
466         parseResult,
467         ArrayType::NOT_ARRAY);
468     GetValueIfFindKey<uint32_t>(jsonObject,
469         jsonObjectEnd,
470         DESCRIPTION_ID,
471         extensionInfo.descriptionId,
472         JsonType::NUMBER,
473         false,
474         parseResult,
475         ArrayType::NOT_ARRAY);
476     GetValueIfFindKey<int32_t>(jsonObject,
477         jsonObjectEnd,
478         PRIORITY,
479         extensionInfo.priority,
480         JsonType::NUMBER,
481         false,
482         parseResult,
483         ArrayType::NOT_ARRAY);
484     GetValueIfFindKey<ExtensionAbilityType>(jsonObject,
485         jsonObjectEnd,
486         TYPE,
487         extensionInfo.type,
488         JsonType::NUMBER,
489         false,
490         parseResult,
491         ArrayType::NOT_ARRAY);
492     GetValueIfFindKey<std::string>(jsonObject,
493         jsonObjectEnd,
494         EXTENSION_TYPE_NAME,
495         extensionInfo.extensionTypeName,
496         JsonType::STRING,
497         false,
498         parseResult,
499         ArrayType::NOT_ARRAY);
500     GetValueIfFindKey<std::string>(jsonObject,
501         jsonObjectEnd,
502         READ_PERMISSION,
503         extensionInfo.readPermission,
504         JsonType::STRING,
505         false,
506         parseResult,
507         ArrayType::NOT_ARRAY);
508     GetValueIfFindKey<std::string>(jsonObject,
509         jsonObjectEnd,
510         WRITE_PERMISSION,
511         extensionInfo.writePermission,
512         JsonType::STRING,
513         false,
514         parseResult,
515         ArrayType::NOT_ARRAY);
516     GetValueIfFindKey<std::string>(jsonObject,
517         jsonObjectEnd,
518         URI,
519         extensionInfo.uri,
520         JsonType::STRING,
521         false,
522         parseResult,
523         ArrayType::NOT_ARRAY);
524     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
525         jsonObjectEnd,
526         PERMISSIONS,
527         extensionInfo.permissions,
528         JsonType::ARRAY,
529         false,
530         parseResult,
531         ArrayType::STRING);
532     GetValueIfFindKey<bool>(jsonObject,
533         jsonObjectEnd,
534         VISIBLE,
535         extensionInfo.visible,
536         JsonType::BOOLEAN,
537         false,
538         parseResult,
539         ArrayType::NOT_ARRAY);
540     GetValueIfFindKey<std::vector<Metadata>>(jsonObject,
541         jsonObjectEnd,
542         META_DATA,
543         extensionInfo.metadata,
544         JsonType::ARRAY,
545         false,
546         parseResult,
547         ArrayType::OBJECT);
548     GetValueIfFindKey<std::string>(jsonObject,
549         jsonObjectEnd,
550         RESOURCE_PATH,
551         extensionInfo.resourcePath,
552         JsonType::STRING,
553         false,
554         parseResult,
555         ArrayType::NOT_ARRAY);
556     GetValueIfFindKey<std::string>(jsonObject,
557         jsonObjectEnd,
558         Constants::HAP_PATH,
559         extensionInfo.hapPath,
560         JsonType::STRING,
561         false,
562         parseResult,
563         ArrayType::NOT_ARRAY);
564     GetValueIfFindKey<bool>(jsonObject,
565         jsonObjectEnd,
566         ENABLED,
567         extensionInfo.enabled,
568         JsonType::BOOLEAN,
569         false,
570         parseResult,
571         ArrayType::NOT_ARRAY);
572     GetValueIfFindKey<std::string>(jsonObject,
573         jsonObjectEnd,
574         PROCESS,
575         extensionInfo.process,
576         JsonType::STRING,
577         false,
578         parseResult,
579         ArrayType::NOT_ARRAY);
580     GetValueIfFindKey<CompileMode>(jsonObject,
581         jsonObjectEnd,
582         COMPILE_MODE,
583         extensionInfo.compileMode,
584         JsonType::NUMBER,
585         false,
586         parseResult,
587         ArrayType::NOT_ARRAY);
588     GetValueIfFindKey<int32_t>(jsonObject,
589         jsonObjectEnd,
590         UID,
591         extensionInfo.uid,
592         JsonType::NUMBER,
593         false,
594         parseResult,
595         ArrayType::NOT_ARRAY);
596     GetValueIfFindKey<int32_t>(jsonObject,
597         jsonObjectEnd,
598         APP_INDEX,
599         extensionInfo.appIndex,
600         JsonType::NUMBER,
601         false,
602         parseResult,
603         ArrayType::NOT_ARRAY);
604     GetValueIfFindKey<ExtensionProcessMode>(jsonObject,
605         jsonObjectEnd,
606         EXTENSION_PROCESS_MODE,
607         extensionInfo.extensionProcessMode,
608         JsonType::NUMBER,
609         false,
610         parseResult,
611         ArrayType::NOT_ARRAY);
612     GetValueIfFindKey<std::vector<Skill>>(jsonObject,
613         jsonObjectEnd,
614         SKILLS,
615         extensionInfo.skills,
616         JsonType::ARRAY,
617         false,
618         parseResult,
619         ArrayType::OBJECT);
620     GetValueIfFindKey<bool>(jsonObject,
621         jsonObjectEnd,
622         NEED_CREATE_SANDBOX,
623         extensionInfo.needCreateSandbox,
624         JsonType::BOOLEAN,
625         false,
626         parseResult,
627         ArrayType::NOT_ARRAY);
628     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
629         jsonObjectEnd,
630         DATA_GROUP_IDS,
631         extensionInfo.dataGroupIds,
632         JsonType::ARRAY,
633         false,
634         parseResult,
635         ArrayType::STRING);
636     GetValueIfFindKey<std::vector<std::string>>(jsonObject,
637         jsonObjectEnd,
638         JSON_KEY_VALID_DATA_GROUP_IDS,
639         extensionInfo.validDataGroupIds,
640         JsonType::ARRAY,
641         false,
642         parseResult,
643         ArrayType::STRING);
644     GetValueIfFindKey<std::string>(jsonObject,
645         jsonObjectEnd,
646         JSON_KEY_CUSTOM_PROCESS,
647         extensionInfo.customProcess,
648         JsonType::STRING,
649         false,
650         parseResult,
651         ArrayType::NOT_ARRAY);
652     if (parseResult != ERR_OK) {
653         APP_LOGE("ExtensionAbilityInfo from_json error : %{public}d", parseResult);
654     }
655 }
656 
ConvertToExtensionAbilityType(const std::string & type)657 ExtensionAbilityType ConvertToExtensionAbilityType(const std::string &type)
658 {
659     if (EXTENSION_TYPE_MAP.find(type) != EXTENSION_TYPE_MAP.end()) {
660         return EXTENSION_TYPE_MAP.at(type);
661     }
662 
663     return ExtensionAbilityType::UNSPECIFIED;
664 }
665 
ConvertToExtensionTypeName(ExtensionAbilityType type)666 std::string ConvertToExtensionTypeName(ExtensionAbilityType type)
667 {
668     for (const auto &[key, val] : EXTENSION_TYPE_MAP) {
669         if (val == type) {
670             return key;
671         }
672     }
673 
674     return "Unspecified";
675 }
676 
ConvertToExtensionProcessMode(const std::string & extensionProcessMode)677 ExtensionProcessMode ConvertToExtensionProcessMode(const std::string &extensionProcessMode)
678 {
679     if (EXTENSION_PROCESS_MODE_MAP.find(extensionProcessMode) != EXTENSION_PROCESS_MODE_MAP.end()) {
680         return EXTENSION_PROCESS_MODE_MAP.at(extensionProcessMode);
681     }
682 
683     return ExtensionProcessMode::UNDEFINED;
684 }
685 
UpdateNeedCreateSandbox()686 void ExtensionAbilityInfo::UpdateNeedCreateSandbox()
687 {
688     needCreateSandbox = false;
689 }
690 }  // namespace AppExecFwk
691 }  // namespace OHOS
692