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