1 /*
2 * Copyright (c) 2022-2023 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 #include "common_func.h"
16
17 #include <vector>
18
19 #include "app_log_wrapper.h"
20 #include "appexecfwk_errors.h"
21 #include "bundle_errors.h"
22 #include "bundle_mgr_interface.h"
23 #include "bundle_mgr_proxy.h"
24 #include "iservice_registry.h"
25 #include "napi/native_api.h"
26 #include "napi/native_common.h"
27 #include "napi/native_node_api.h"
28 #include "system_ability_definition.h"
29 #include "want.h"
30
31 namespace OHOS {
32 namespace AppExecFwk {
33 namespace {
34 constexpr int32_t NAPI_RETURN_ZERO = 0;
35 constexpr int32_t NAPI_RETURN_ONE = 1;
36 constexpr const char* BUNDLE_NAME = "bundleName";
37 constexpr const char* MODULE_NAME = "moduleName";
38 constexpr const char* ABILITY_NAME = "abilityName";
39 constexpr const char* TARGET_MODULE_NAME = "targetModuleName";
40 constexpr const char* URI = "uri";
41 constexpr const char* TYPE = "type";
42 constexpr const char* ACTION = "action";
43 constexpr const char* ENTITIES = "entities";
44 constexpr const char* FLAGS = "flags";
45 constexpr const char* DEVICE_ID = "deviceId";
46 constexpr const char* NAME = "name";
47 constexpr const char* IS_VISIBLE = "isVisible";
48 constexpr const char* EXPORTED = "exported";
49 constexpr const char* PERMISSIONS = "permissions";
50 constexpr const char* META_DATA = "metadata";
51 constexpr const char* ENABLED = "enabled";
52 constexpr const char* EXCLUDE_FROM_DOCK = "excludeFromDock";
53 constexpr const char* READ_PERMISSION = "readPermission";
54 constexpr const char* WRITE_PERMISSION = "writePermission";
55 constexpr const char* LABEL = "label";
56 constexpr const char* LABEL_ID = "labelId";
57 constexpr const char* DESCRIPTION = "description";
58 constexpr const char* DESCRIPTION_ID = "descriptionId";
59 constexpr const char* ICON = "icon";
60 constexpr const char* ICON_ID = "iconId";
61 constexpr const char* APPLICATION_INFO = "applicationInfo";
62 constexpr const char* PRIORITY = "priority";
63 constexpr const char* STATE = "state";
64 constexpr const char* DEBUG = "debug";
65 constexpr const char* EXTENSION_ABILITY_TYPE_NAME = "extensionAbilityTypeName";
66 constexpr const char* ROUTER_MAP = "routerMap";
67 constexpr const char* PAGE_SOURCE_FILE = "pageSourceFile";
68 constexpr const char* BUILD_FUNCTION = "buildFunction";
69 constexpr const char* DATA = "data";
70 constexpr const char* CUSTOM_DATA = "customData";
71 constexpr const char* KEY = "key";
72 constexpr const char* VALUE = "value";
73 constexpr const char* CODE_PATH = "codePath";
74 const std::string PATH_PREFIX = "/data/app/el1/bundle/public";
75 const std::string CODE_PATH_PREFIX = "/data/storage/el1/bundle/";
76 const std::string CONTEXT_DATA_STORAGE_BUNDLE("/data/storage/el1/bundle/");
77 constexpr const char* SYSTEM_APP = "systemApp";
78 constexpr const char* BUNDLE_TYPE = "bundleType";
79 constexpr const char* CODE_PATHS = "codePaths";
80 constexpr const char* APP_INDEX = "appIndex";
81 constexpr const char* SKILLS = "skills";
82 constexpr const char* MAX_ADDITIONAL_NUMBER = "maxCount";
83 constexpr const char* MULTI_APP_MODE_TYPE = "multiAppModeType";
84 constexpr const char* MULTI_APP_MODE = "multiAppMode";
85 constexpr const char* ORIENTATION_ID = "orientationId";
86
87 static std::unordered_map<int32_t, int32_t> ERR_MAP = {
88 { ERR_OK, SUCCESS },
89 { ERR_BUNDLE_MANAGER_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
90 { ERR_BUNDLE_MANAGER_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
91 { ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST, ERROR_BUNDLE_NOT_EXIST },
92 { ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST, ERROR_MODULE_NOT_EXIST },
93 { ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST, ERROR_ABILITY_NOT_EXIST },
94 { ERR_BUNDLE_MANAGER_INVALID_USER_ID, ERROR_INVALID_USER_ID },
95 { ERR_BUNDLE_MANAGER_QUERY_PERMISSION_DEFINE_FAILED, ERROR_PERMISSION_NOT_EXIST },
96 { ERR_BUNDLE_MANAGER_DEVICE_ID_NOT_EXIST, ERROR_DEVICE_ID_NOT_EXIST },
97 { ERR_BUNDLE_MANAGER_INVALID_UID, ERROR_INVALID_UID },
98 { ERR_BUNDLE_MANAGER_INVALID_HAP_PATH, ERROR_INVALID_HAP_PATH },
99 { ERR_BUNDLE_MANAGER_DEFAULT_APP_NOT_EXIST, ERROR_DEFAULT_APP_NOT_EXIST },
100 { ERR_BUNDLE_MANAGER_INVALID_TYPE, ERROR_INVALID_TYPE },
101 { ERR_BUNDLE_MANAGER_ABILITY_AND_TYPE_MISMATCH, ERROR_ABILITY_AND_TYPE_MISMATCH },
102 { ERR_BUNDLE_MANAGER_PROFILE_NOT_EXIST, ERROR_PROFILE_NOT_EXIST },
103 { ERR_BUNDLE_MANAGER_APPLICATION_DISABLED, ERROR_BUNDLE_IS_DISABLED },
104 { ERROR_DISTRIBUTED_SERVICE_NOT_RUNNING, ERROR_DISTRIBUTED_SERVICE_NOT_RUNNING },
105 { ERR_BUNDLE_MANAGER_ABILITY_DISABLED, ERROR_ABILITY_IS_DISABLED },
106 { ERR_BUNDLE_MANAGER_CAN_NOT_CLEAR_USER_DATA, ERROR_CLEAR_CACHE_FILES_UNSUPPORTED },
107 { ERR_ZLIB_SRC_FILE_DISABLED, ERR_ZLIB_SRC_FILE_INVALID },
108 { ERR_ZLIB_DEST_FILE_DISABLED, ERR_ZLIB_DEST_FILE_INVALID },
109 { ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED, ERROR_NOT_SYSTEM_APP },
110 { ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
111 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE, ERROR_BUNDLE_NOT_EXIST },
112 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE, ERROR_SPECIFIED_BUNDLE_NOT_OVERLAY_BUNDLE },
113 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE, ERROR_MODULE_NOT_EXIST },
114 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE, ERROR_SPECIFIED_MODULE_NOT_OVERLAY_MODULE },
115 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_IS_OVERLAY_MODULE,
116 ERROR_SPECIFIED_MODULE_IS_OVERLAY_MODULE },
117 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_NOT_EXISTED, ERROR_MODULE_NOT_EXIST },
118 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID,
119 ERROR_BUNDLE_NOT_EXIST },
120 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_IS_OVERLAY_BUNDLE,
121 ERROR_SPECIFIED_BUNDLE_IS_OVERLAY_BUNDLE },
122 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
123 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED, ERROR_BUNDLE_NOT_EXIST },
124 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
125 { ERR_ZLIB_SRC_FILE_FORMAT_ERROR, ERR_ZLIB_SRC_FILE_FORMAT_ERROR_OR_DAMAGED },
126 { ERR_BUNDLE_MANAGER_NOT_APP_GALLERY_CALL, ERROR_NOT_APP_GALLERY_CALL },
127 { ERR_BUNDLE_MANAGER_VERIFY_GET_VERIFY_MGR_FAILED, ERROR_VERIFY_ABC },
128 { ERR_BUNDLE_MANAGER_VERIFY_INVALID_TARGET_DIR, ERROR_VERIFY_ABC },
129 { ERR_BUNDLE_MANAGER_VERIFY_PARAM_ERROR, ERROR_VERIFY_ABC },
130 { ERR_BUNDLE_MANAGER_VERIFY_INVALID_PATH, ERROR_VERIFY_ABC },
131 { ERR_BUNDLE_MANAGER_VERIFY_OPEN_SOURCE_FILE_FAILED, ERROR_VERIFY_ABC },
132 { ERR_BUNDLE_MANAGER_VERIFY_WRITE_FILE_FAILED, ERROR_VERIFY_ABC },
133 { ERR_BUNDLE_MANAGER_VERIFY_SEND_REQUEST_FAILED, ERROR_VERIFY_ABC },
134 { ERR_BUNDLE_MANAGER_VERIFY_CREATE_TARGET_DIR_FAILED, ERROR_VERIFY_ABC },
135 { ERR_BUNDLE_MANAGER_VERIFY_VERIFY_ABC_FAILED, ERROR_VERIFY_ABC },
136 { ERR_BUNDLE_MANAGER_VERIFY_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
137 { ERR_BUNDLE_MANAGER_DELETE_ABC_PARAM_ERROR, ERROR_DELETE_ABC },
138 { ERR_BUNDLE_MANAGER_DELETE_ABC_FAILED, ERROR_DELETE_ABC },
139 { ERR_BUNDLE_MANAGER_DELETE_ABC_SEND_REQUEST_FAILED, ERROR_DELETE_ABC },
140 { ERR_EXT_RESOURCE_MANAGER_CREATE_FD_FAILED, ERROR_ADD_EXTEND_RESOURCE },
141 { ERR_EXT_RESOURCE_MANAGER_INVALID_TARGET_DIR, ERROR_ADD_EXTEND_RESOURCE },
142 { ERR_EXT_RESOURCE_MANAGER_GET_EXT_RESOURCE_MGR_FAILED, ERROR_ADD_EXTEND_RESOURCE },
143 { ERR_EXT_RESOURCE_MANAGER_PARSE_FILE_FAILED, ERROR_ADD_EXTEND_RESOURCE },
144 { ERR_EXT_RESOURCE_MANAGER_COPY_FILE_FAILED, ERROR_ADD_EXTEND_RESOURCE },
145 { ERR_EXT_RESOURCE_MANAGER_INVALID_PATH_FAILED, ERROR_ADD_EXTEND_RESOURCE },
146 { ERR_EXT_RESOURCE_MANAGER_REMOVE_EXT_RESOURCE_FAILED, ERROR_REMOVE_EXTEND_RESOURCE },
147 { ERR_EXT_RESOURCE_MANAGER_GET_EXT_RESOURCE_FAILED, ERROR_GET_EXTEND_RESOURCE },
148 { ERR_EXT_RESOURCE_MANAGER_GET_DYNAMIC_ICON_FAILED, ERROR_GET_DYNAMIC_ICON },
149 { ERR_EXT_RESOURCE_MANAGER_DISABLE_DYNAMIC_ICON_FAILED, ERROR_DISABLE_DYNAMIC_ICON },
150 { ERR_APPEXECFWK_INSTALL_FAILED_CONTROLLED, ERROR_INSTALL_FAILED_CONTROLLED },
151 { ERR_EXT_RESOURCE_MANAGER_ENABLE_DYNAMIC_ICON_FAILED, ERROR_ENABLE_DYNAMIC_ICON },
152 { ERR_BUNDLE_MANAGER_INVALID_SCHEME, ERROR_INVALID_LINK },
153 { ERR_BUNDLE_MANAGER_SCHEME_NOT_IN_QUERYSCHEMES, ERROR_SCHEME_NOT_IN_QUERYSCHEMES },
154 { ERR_BUNDLE_MANAGER_BUNDLE_CAN_NOT_BE_UNINSTALLED, ERROR_BUNDLE_CAN_NOT_BE_UNINSTALLED},
155 { ERR_APPEXECFWK_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
156 { ERR_BUNDLE_MANAGER_INVALID_DEVELOPERID, ERROR_INVALID_DEVELOPERID },
157 { ERR_BUNDLE_MANAGER_START_SHORTCUT_FAILED, ERROR_START_SHORTCUT_ERROR },
158 { ERR_APPEXECFWK_NATIVE_INSTALL_FAILED, ERROR_INSTALL_NATIVE_FAILED},
159 { ERR_APPEXECFWK_NATIVE_UNINSTALL_FAILED, ERROR_UNINSTALL_NATIVE_FAILED},
160 { ERR_APPEXECFWK_APP_INDEX_OUT_OF_RANGE, ERROR_INVALID_APPINDEX},
161 { ERR_APPEXECFWK_CLONE_INSTALL_PARAM_ERROR, ERROR_BUNDLE_NOT_EXIST },
162 { ERR_APPEXECFWK_CLONE_INSTALL_APP_NOT_EXISTED, ERROR_BUNDLE_NOT_EXIST },
163 { ERR_APPEXECFWK_CLONE_INSTALL_NOT_INSTALLED_AT_SPECIFIED_USERID, ERROR_BUNDLE_NOT_EXIST },
164 { ERR_APPEXECFWK_CLONE_INSTALL_USER_NOT_EXIST, ERROR_INVALID_USER_ID },
165 { ERR_APPEXECFWK_CLONE_INSTALL_INVALID_APP_INDEX, ERROR_INVALID_APPINDEX },
166 { ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXISTED, ERROR_INVALID_APPINDEX },
167 { ERR_APPEXECFWK_SANDBOX_INSTALL_INVALID_APP_INDEX, ERROR_INVALID_APPINDEX },
168 { ERR_APPEXECFWK_CLONE_UNINSTALL_INVALID_BUNDLE_NAME, ERROR_BUNDLE_NOT_EXIST },
169 { ERR_APPEXECFWK_CLONE_UNINSTALL_INVALID_APP_INDEX, ERROR_INVALID_APPINDEX },
170 { ERR_APPEXECFWK_CLONE_UNINSTALL_USER_NOT_EXIST, ERROR_INVALID_USER_ID },
171 { ERR_APPEXECFWK_CLONE_UNINSTALL_APP_NOT_EXISTED, ERROR_BUNDLE_NOT_EXIST },
172 { ERR_APPEXECFWK_CLONE_UNINSTALL_NOT_INSTALLED_AT_SPECIFIED_USERID, ERROR_BUNDLE_NOT_EXIST },
173 { ERR_APPEXECFWK_CLONE_UNINSTALL_APP_NOT_CLONED, ERROR_INVALID_APPINDEX },
174 { ERR_APPEXECFWK_CLONE_INSTALL_APP_INDEX_EXCEED_MAX_NUMBER, ERROR_INVALID_APPINDEX },
175 { ERR_APPEXECFWK_CLONE_INSTALL_APP_NOT_SUPPORTED_MULTI_TYPE, ERROR_APP_NOT_SUPPORTED_MULTI_TYPE },
176 { ERR_APPEXECFWK_CLONE_QUERY_NO_CLONE_APP, ERROR_INVALID_APPINDEX },
177 { ERR_SHORTCUT_MANAGER_SHORTCUT_ID_ILLEGAL, ERROR_SHORTCUT_ID_ILLEGAL_ERROR },
178 { ERR_APPEXECFWK_INSTALL_ENTERPRISE_BUNDLE_NOT_ALLOWED, ERROR_INSTALL_ENTERPRISE_BUNDLE_NOT_ALLOWED },
179 { ERR_APPEXECFWK_INSTALL_EXISTED_ENTERPRISE_BUNDLE_NOT_ALLOWED,
180 ERROR_INSTALL_EXISTED_ENTERPRISE_NOT_ALLOWED_ERROR },
181 };
182 }
183 using Want = OHOS::AAFwk::Want;
184
185 sptr<IBundleMgr> CommonFunc::bundleMgr_ = nullptr;
186 std::mutex CommonFunc::bundleMgrMutex_;
187 sptr<IRemoteObject::DeathRecipient> CommonFunc::deathRecipient_(new (std::nothrow) BundleMgrCommonDeathRecipient());
188
OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject>& remote)189 void CommonFunc::BundleMgrCommonDeathRecipient::OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject>& remote)
190 {
191 APP_LOGD("BundleManagerService dead");
192 std::lock_guard<std::mutex> lock(bundleMgrMutex_);
193 bundleMgr_ = nullptr;
194 };
195
WrapVoidToJS(napi_env env)196 napi_value CommonFunc::WrapVoidToJS(napi_env env)
197 {
198 napi_value result = nullptr;
199 NAPI_CALL(env, napi_get_null(env, &result));
200 return result;
201 }
202
CheckBundleFlagWithPermission(int32_t flag)203 bool CommonFunc::CheckBundleFlagWithPermission(int32_t flag)
204 {
205 return (static_cast<uint32_t>(flag) &
206 static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION))
207 == static_cast<uint32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION);
208 }
209
ParseInt(napi_env env, napi_value args, int32_t ¶m)210 bool CommonFunc::ParseInt(napi_env env, napi_value args, int32_t ¶m)
211 {
212 napi_valuetype valuetype = napi_undefined;
213 napi_typeof(env, args, &valuetype);
214 if (valuetype != napi_number) {
215 APP_LOGD("Wrong argument type. int32 expected");
216 return false;
217 }
218 int32_t value = 0;
219 if (napi_get_value_int32(env, args, &value) != napi_ok) {
220 APP_LOGD("napi_get_value_int32 failed");
221 return false;
222 }
223 param = value;
224 return true;
225 }
226
ParseUint(napi_env env, napi_value args, uint32_t ¶m)227 bool CommonFunc::ParseUint(napi_env env, napi_value args, uint32_t ¶m)
228 {
229 napi_valuetype valuetype = napi_undefined;
230 napi_typeof(env, args, &valuetype);
231 if (valuetype != napi_number) {
232 APP_LOGD("Wrong argument type. uint32 expected");
233 return false;
234 }
235 uint32_t value = 0;
236 if (napi_get_value_uint32(env, args, &value) != napi_ok) {
237 APP_LOGD("napi_get_value_uint32 failed");
238 return false;
239 }
240 param = value;
241 return true;
242 }
243
ParsePropertyArray(napi_env env, napi_value args, const std::string &propertyName, std::vector<napi_value> &valueVec)244 bool CommonFunc::ParsePropertyArray(napi_env env, napi_value args, const std::string &propertyName,
245 std::vector<napi_value> &valueVec)
246 {
247 napi_valuetype type = napi_undefined;
248 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
249 if (type != napi_object) {
250 return false;
251 }
252
253 bool hasKey = false;
254 napi_has_named_property(env, args, propertyName.c_str(), &hasKey);
255 if (!hasKey) {
256 APP_LOGW("%{public}s is not existed", propertyName.c_str());
257 return true;
258 }
259 napi_value property = nullptr;
260 napi_status status = napi_get_named_property(env, args, propertyName.c_str(), &property);
261 if (status != napi_ok) {
262 return false;
263 }
264 bool isArray = false;
265 NAPI_CALL_BASE(env, napi_is_array(env, property, &isArray), false);
266 if (!isArray) {
267 return false;
268 }
269 uint32_t arrayLength = 0;
270 NAPI_CALL_BASE(env, napi_get_array_length(env, property, &arrayLength), false);
271 APP_LOGD("ParseHashParams property is array, length=%{public}ud", arrayLength);
272
273 napi_value valueAry = 0;
274 for (uint32_t j = 0; j < arrayLength; j++) {
275 NAPI_CALL_BASE(env, napi_get_element(env, property, j, &valueAry), false);
276 valueVec.emplace_back(valueAry);
277 }
278 return true;
279 }
280
ParseStringPropertyFromObject(napi_env env, napi_value args, const std::string &propertyName, bool isNecessary, std::string &value)281 bool CommonFunc::ParseStringPropertyFromObject(napi_env env, napi_value args, const std::string &propertyName,
282 bool isNecessary, std::string &value)
283 {
284 napi_valuetype type = napi_undefined;
285 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
286 if (type != napi_object) {
287 return false;
288 }
289 bool hasKey = false;
290 napi_has_named_property(env, args, propertyName.c_str(), &hasKey);
291 if (!hasKey) {
292 if (isNecessary) {
293 APP_LOGE("%{public}s is not existed", propertyName.c_str());
294 return false;
295 }
296 return true;
297 }
298 napi_value property = nullptr;
299 napi_status status = napi_get_named_property(env, args, propertyName.c_str(), &property);
300 if (status != napi_ok) {
301 return false;
302 }
303 napi_typeof(env, property, &type);
304 if (type != napi_string) {
305 return false;
306 }
307 if (property == nullptr) {
308 return false;
309 }
310 if (!CommonFunc::ParseString(env, property, value)) {
311 APP_LOGE("parse string failed");
312 return false;
313 }
314 return true;
315 }
316
ParsePropertyFromObject(napi_env env, napi_value args, const PropertyInfo &propertyInfo, napi_value &property)317 bool CommonFunc::ParsePropertyFromObject(napi_env env, napi_value args, const PropertyInfo &propertyInfo,
318 napi_value &property)
319 {
320 napi_valuetype type = napi_undefined;
321 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
322 if (type != napi_object) {
323 return false;
324 }
325 bool hasKey = false;
326 napi_has_named_property(env, args, propertyInfo.propertyName.c_str(), &hasKey);
327 if (!hasKey) {
328 if (propertyInfo.isNecessary) {
329 APP_LOGE("%{public}s is not existed", propertyInfo.propertyName.c_str());
330 return false;
331 }
332 return true;
333 }
334
335 napi_status status = napi_get_named_property(env, args, propertyInfo.propertyName.c_str(), &property);
336 if (status != napi_ok) {
337 return false;
338 }
339 napi_typeof(env, property, &type);
340 if (type != propertyInfo.propertyType) {
341 return false;
342 }
343 if (property == nullptr) {
344 return false;
345 }
346 return true;
347 }
348
ParseBool(napi_env env, napi_value value, bool& result)349 bool CommonFunc::ParseBool(napi_env env, napi_value value, bool& result)
350 {
351 napi_valuetype valueType = napi_undefined;
352 napi_typeof(env, value, &valueType);
353 if (valueType != napi_boolean) {
354 return false;
355 }
356 if (napi_get_value_bool(env, value, &result) != napi_ok) {
357 return false;
358 }
359 return true;
360 }
361
ParseString(napi_env env, napi_value value, std::string& result)362 bool CommonFunc::ParseString(napi_env env, napi_value value, std::string& result)
363 {
364 napi_valuetype valueType = napi_undefined;
365 napi_typeof(env, value, &valueType);
366 if (valueType != napi_string) {
367 return false;
368 }
369 size_t size = 0;
370 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
371 return false;
372 }
373 result.reserve(size + 1);
374 result.resize(size);
375 if (napi_get_value_string_utf8(env, value, result.data(), (size + 1), &size) != napi_ok) {
376 return false;
377 }
378 return true;
379 }
380
ParseAbilityInfo(napi_env env, napi_value param, AbilityInfo& abilityInfo)381 bool CommonFunc::ParseAbilityInfo(napi_env env, napi_value param, AbilityInfo& abilityInfo)
382 {
383 napi_valuetype valueType;
384 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
385 if (valueType != napi_object) {
386 return false;
387 }
388
389 napi_value prop = nullptr;
390 // parse bundleName
391 napi_get_named_property(env, param, "bundleName", &prop);
392 std::string bundleName;
393 if (!ParseString(env, prop, bundleName)) {
394 return false;
395 }
396 abilityInfo.bundleName = bundleName;
397
398 // parse moduleName
399 napi_get_named_property(env, param, "moduleName", &prop);
400 std::string moduleName;
401 if (!ParseString(env, prop, moduleName)) {
402 return false;
403 }
404 abilityInfo.moduleName = moduleName;
405
406 // parse abilityName
407 napi_get_named_property(env, param, "name", &prop);
408 std::string abilityName;
409 if (!ParseString(env, prop, abilityName)) {
410 return false;
411 }
412 abilityInfo.name = abilityName;
413 return true;
414 }
415
GetBundleMgr()416 sptr<IBundleMgr> CommonFunc::GetBundleMgr()
417 {
418 std::lock_guard<std::mutex> lock(bundleMgrMutex_);
419 if (bundleMgr_ == nullptr) {
420 auto systemAbilityManager = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
421 if (systemAbilityManager == nullptr) {
422 APP_LOGE("systemAbilityManager is null");
423 return nullptr;
424 }
425 auto bundleMgrSa = systemAbilityManager->GetSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
426 if (bundleMgrSa == nullptr) {
427 APP_LOGE("bundleMgrSa is null");
428 return nullptr;
429 }
430 bundleMgr_ = OHOS::iface_cast<IBundleMgr>(bundleMgrSa);
431 if (bundleMgr_ == nullptr) {
432 APP_LOGE("iface_cast failed");
433 return nullptr;
434 }
435 bundleMgr_->AsObject()->AddDeathRecipient(deathRecipient_);
436 }
437 return bundleMgr_;
438 }
439
GetBundleInstaller()440 sptr<IBundleInstaller> CommonFunc::GetBundleInstaller()
441 {
442 auto iBundleMgr = GetBundleMgr();
443 if (iBundleMgr == nullptr) {
444 APP_LOGE("can not get iBundleMgr");
445 return nullptr;
446 }
447 return iBundleMgr->GetBundleInstaller();
448 }
449
GetVerifyManager()450 sptr<IVerifyManager> CommonFunc::GetVerifyManager()
451 {
452 auto iBundleMgr = GetBundleMgr();
453 if (iBundleMgr == nullptr) {
454 APP_LOGE("can not get iBundleMgr");
455 return nullptr;
456 }
457 return iBundleMgr->GetVerifyManager();
458 }
459
GetExtendResourceManager()460 sptr<IExtendResourceManager> CommonFunc::GetExtendResourceManager()
461 {
462 auto iBundleMgr = GetBundleMgr();
463 if (iBundleMgr == nullptr) {
464 APP_LOGE("can not get iBundleMgr");
465 return nullptr;
466 }
467 return iBundleMgr->GetExtendResourceManager();
468 }
469
GetStringFromNAPI(napi_env env, napi_value value)470 std::string CommonFunc::GetStringFromNAPI(napi_env env, napi_value value)
471 {
472 napi_valuetype valueType = napi_undefined;
473 napi_typeof(env, value, &valueType);
474 if (valueType != napi_string) {
475 return "";
476 }
477 std::string result;
478 size_t size = 0;
479
480 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
481 return "";
482 }
483 result.reserve(size + NAPI_RETURN_ONE);
484 result.resize(size);
485 if (napi_get_value_string_utf8(env, value, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
486 return "";
487 }
488 return result;
489 }
490
ParseStringArray(napi_env env, std::vector<std::string> &stringArray, napi_value args)491 napi_value CommonFunc::ParseStringArray(napi_env env, std::vector<std::string> &stringArray, napi_value args)
492 {
493 APP_LOGD("begin to parse string array");
494 bool isArray = false;
495 NAPI_CALL(env, napi_is_array(env, args, &isArray));
496 if (!isArray) {
497 return nullptr;
498 }
499 uint32_t arrayLength = 0;
500 NAPI_CALL(env, napi_get_array_length(env, args, &arrayLength));
501 APP_LOGD("length=%{public}ud", arrayLength);
502 for (uint32_t j = 0; j < arrayLength; j++) {
503 napi_value value = nullptr;
504 NAPI_CALL(env, napi_get_element(env, args, j, &value));
505 napi_valuetype valueType = napi_undefined;
506 NAPI_CALL(env, napi_typeof(env, value, &valueType));
507 if (valueType != napi_string) {
508 stringArray.clear();
509 return nullptr;
510 }
511 stringArray.push_back(GetStringFromNAPI(env, value));
512 }
513 // create result code
514 napi_value result;
515 napi_status status = napi_create_int32(env, NAPI_RETURN_ONE, &result);
516 if (status != napi_ok) {
517 return nullptr;
518 }
519 return result;
520 }
521
ConvertWantInfo(napi_env env, napi_value objWantInfo, const Want &want)522 void CommonFunc::ConvertWantInfo(napi_env env, napi_value objWantInfo, const Want &want)
523 {
524 ElementName elementName = want.GetElement();
525 napi_value nbundleName;
526 NAPI_CALL_RETURN_VOID(
527 env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &nbundleName));
528 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "bundleName", nbundleName));
529
530 napi_value ndeviceId;
531 NAPI_CALL_RETURN_VOID(
532 env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &ndeviceId));
533 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "deviceId", ndeviceId));
534
535 napi_value nabilityName;
536 NAPI_CALL_RETURN_VOID(
537 env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &nabilityName));
538 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "abilityName", nabilityName));
539
540 napi_value naction;
541 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, want.GetAction().c_str(), NAPI_AUTO_LENGTH, &naction));
542 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "action", naction));
543
544 napi_value nmoduleName;
545 NAPI_CALL_RETURN_VOID(
546 env, napi_create_string_utf8(env, elementName.GetModuleName().c_str(), NAPI_AUTO_LENGTH, &nmoduleName));
547 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "moduleName", nmoduleName));
548
549 auto entities = want.GetEntities();
550 napi_value nGetEntities;
551 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nGetEntities));
552 if (entities.size() > 0) {
553 size_t index = 0;
554 for (const auto &item:entities) {
555 napi_value objEntities;
556 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &objEntities));
557 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nGetEntities, index, objEntities));
558 index++;
559 }
560 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "entities", nGetEntities));
561 }
562 }
563
ParseElementName(napi_env env, napi_value args, Want &want)564 bool CommonFunc::ParseElementName(napi_env env, napi_value args, Want &want)
565 {
566 APP_LOGD("begin to parse ElementName");
567 napi_valuetype valueType = napi_undefined;
568 napi_typeof(env, args, &valueType);
569 if (valueType != napi_object) {
570 APP_LOGW("args not object type");
571 return false;
572 }
573 napi_value prop = nullptr;
574 napi_get_named_property(env, args, "bundleName", &prop);
575 std::string bundleName;
576 ParseString(env, prop, bundleName);
577
578 prop = nullptr;
579 napi_get_named_property(env, args, "moduleName", &prop);
580 std::string moduleName;
581 ParseString(env, prop, moduleName);
582
583 prop = nullptr;
584 napi_get_named_property(env, args, "abilityName", &prop);
585 std::string abilityName;
586 ParseString(env, prop, abilityName);
587
588 APP_LOGD("ParseElementName, bundleName:%{public}s, moduleName: %{public}s, abilityName:%{public}s",
589 bundleName.c_str(), moduleName.c_str(), abilityName.c_str());
590 ElementName elementName("", bundleName, abilityName, moduleName);
591 want.SetElement(elementName);
592 return true;
593 }
594
ParseElementName(napi_env env, napi_value args, ElementName &elementName)595 bool CommonFunc::ParseElementName(napi_env env, napi_value args, ElementName &elementName)
596 {
597 APP_LOGD("begin to parse ElementName");
598 napi_valuetype valueType = napi_undefined;
599 napi_typeof(env, args, &valueType);
600 if (valueType != napi_object) {
601 APP_LOGW("args not object type");
602 return false;
603 }
604 napi_value prop = nullptr;
605 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
606 std::string bundleName = GetStringFromNAPI(env, prop);
607 elementName.SetBundleName(bundleName);
608
609 prop = nullptr;
610 napi_get_named_property(env, args, MODULE_NAME, &prop);
611 std::string moduleName = GetStringFromNAPI(env, prop);
612 elementName.SetModuleName(moduleName);
613
614 prop = nullptr;
615 napi_get_named_property(env, args, ABILITY_NAME, &prop);
616 std::string abilityName = GetStringFromNAPI(env, prop);
617 elementName.SetAbilityName(abilityName);
618
619 prop = nullptr;
620 napi_get_named_property(env, args, DEVICE_ID, &prop);
621 std::string deviceId = GetStringFromNAPI(env, prop);
622 elementName.SetDeviceID(deviceId);
623
624 return true;
625 }
626
ConvertElementName(napi_env env, napi_value elementInfo, const OHOS::AppExecFwk::ElementName &elementName)627 void CommonFunc::ConvertElementName(napi_env env, napi_value elementInfo,
628 const OHOS::AppExecFwk::ElementName &elementName)
629 {
630 // wrap deviceId
631 napi_value deviceId;
632 NAPI_CALL_RETURN_VOID(
633 env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &deviceId));
634 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "deviceId", deviceId));
635
636 // wrap bundleName
637 napi_value bundleName;
638 NAPI_CALL_RETURN_VOID(
639 env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &bundleName));
640 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "bundleName", bundleName));
641
642 // wrap moduleName
643 napi_value moduleName;
644 NAPI_CALL_RETURN_VOID(
645 env, napi_create_string_utf8(env, elementName.GetModuleName().c_str(), NAPI_AUTO_LENGTH, &moduleName));
646 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, MODULE_NAME, moduleName));
647
648 // wrap abilityName
649 napi_value abilityName;
650 NAPI_CALL_RETURN_VOID(
651 env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &abilityName));
652 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "abilityName", abilityName));
653
654 // wrap uri
655 napi_value uri;
656 NAPI_CALL_RETURN_VOID(
657 env, napi_create_string_utf8(env, elementName.GetURI().c_str(), NAPI_AUTO_LENGTH, &uri));
658 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "uri", uri));
659
660 // wrap shortName
661 napi_value shortName;
662 NAPI_CALL_RETURN_VOID(
663 env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &shortName));
664 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "shortName", shortName));
665 }
666
ConvertErrCode(ErrCode nativeErrCode)667 ErrCode CommonFunc::ConvertErrCode(ErrCode nativeErrCode)
668 {
669 if (ERR_MAP.find(nativeErrCode) != ERR_MAP.end()) {
670 return ERR_MAP.at(nativeErrCode);
671 }
672 return ERROR_BUNDLE_SERVICE_EXCEPTION;
673 }
674
ParseWant(napi_env env, napi_value args, Want &want)675 bool CommonFunc::ParseWant(napi_env env, napi_value args, Want &want)
676 {
677 APP_LOGD("begin to parse want");
678 napi_valuetype valueType;
679 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
680 if (valueType != napi_object) {
681 APP_LOGW("args not object type");
682 return false;
683 }
684 napi_value prop = nullptr;
685 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
686 std::string bundleName = GetStringFromNAPI(env, prop);
687
688 prop = nullptr;
689 napi_get_named_property(env, args, MODULE_NAME, &prop);
690 std::string moduleName = GetStringFromNAPI(env, prop);
691
692 prop = nullptr;
693 napi_get_named_property(env, args, ABILITY_NAME, &prop);
694 std::string abilityName = GetStringFromNAPI(env, prop);
695
696 prop = nullptr;
697 napi_get_named_property(env, args, URI, &prop);
698 std::string uri = GetStringFromNAPI(env, prop);
699
700 prop = nullptr;
701 napi_get_named_property(env, args, TYPE, &prop);
702 std::string type = GetStringFromNAPI(env, prop);
703
704 prop = nullptr;
705 napi_get_named_property(env, args, ACTION, &prop);
706 std::string action = GetStringFromNAPI(env, prop);
707
708 prop = nullptr;
709 napi_get_named_property(env, args, ENTITIES, &prop);
710 std::vector<std::string> entities;
711 ParseStringArray(env, entities, prop);
712 for (size_t idx = 0; idx < entities.size(); ++idx) {
713 APP_LOGD("entity:%{public}s", entities[idx].c_str());
714 want.AddEntity(entities[idx]);
715 }
716
717 prop = nullptr;
718 int32_t flags = 0;
719 napi_get_named_property(env, args, FLAGS, &prop);
720 napi_typeof(env, prop, &valueType);
721 if (valueType == napi_number) {
722 napi_get_value_int32(env, prop, &flags);
723 }
724
725 prop = nullptr;
726 napi_get_named_property(env, args, DEVICE_ID, &prop);
727 std::string deviceId = GetStringFromNAPI(env, prop);
728
729 APP_LOGD("bundleName:%{public}s, moduleName: %{public}s, abilityName:%{public}s",
730 bundleName.c_str(), moduleName.c_str(), abilityName.c_str());
731 APP_LOGD("action:%{public}s, uri:%{private}s, type:%{public}s, flags:%{public}d",
732 action.c_str(), uri.c_str(), type.c_str(), flags);
733 bool isExplicit = !bundleName.empty() && !abilityName.empty();
734 if (!isExplicit && action.empty() && entities.empty() && uri.empty() && type.empty()) {
735 APP_LOGE("implicit params all empty");
736 return false;
737 }
738 want.SetAction(action);
739 want.SetUri(uri);
740 want.SetType(type);
741 want.SetFlags(flags);
742 ElementName elementName(deviceId, bundleName, abilityName, moduleName);
743 want.SetElement(elementName);
744 return true;
745 }
746
ParseWantPerformance(napi_env env, napi_value args, Want &want)747 bool CommonFunc::ParseWantPerformance(napi_env env, napi_value args, Want &want)
748 {
749 APP_LOGD("begin to parse want performance");
750 napi_valuetype valueType;
751 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
752 if (valueType != napi_object) {
753 APP_LOGW("args not object type");
754 return false;
755 }
756 napi_value prop = nullptr;
757 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
758 std::string bundleName = GetStringFromNAPI(env, prop);
759
760 prop = nullptr;
761 napi_get_named_property(env, args, MODULE_NAME, &prop);
762 std::string moduleName = GetStringFromNAPI(env, prop);
763
764 prop = nullptr;
765 napi_get_named_property(env, args, ABILITY_NAME, &prop);
766 std::string abilityName = GetStringFromNAPI(env, prop);
767 if (!bundleName.empty() && !abilityName.empty()) {
768 ElementName elementName("", bundleName, abilityName, moduleName);
769 want.SetElement(elementName);
770 return true;
771 }
772 return ParseWant(env, args, want);
773 }
774
ParseWantWithoutVerification(napi_env env, napi_value args, Want &want)775 bool CommonFunc::ParseWantWithoutVerification(napi_env env, napi_value args, Want &want)
776 {
777 napi_valuetype valueType;
778 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
779 if (valueType != napi_object) {
780 return false;
781 }
782 napi_value prop = nullptr;
783 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
784 std::string bundleName = GetStringFromNAPI(env, prop);
785 prop = nullptr;
786 napi_get_named_property(env, args, MODULE_NAME, &prop);
787 std::string moduleName = GetStringFromNAPI(env, prop);
788 prop = nullptr;
789 napi_get_named_property(env, args, ABILITY_NAME, &prop);
790 std::string abilityName = GetStringFromNAPI(env, prop);
791 prop = nullptr;
792 napi_get_named_property(env, args, URI, &prop);
793 std::string uri = GetStringFromNAPI(env, prop);
794 prop = nullptr;
795 napi_get_named_property(env, args, TYPE, &prop);
796 std::string type = GetStringFromNAPI(env, prop);
797 prop = nullptr;
798 napi_get_named_property(env, args, ACTION, &prop);
799 std::string action = GetStringFromNAPI(env, prop);
800 prop = nullptr;
801 napi_get_named_property(env, args, ENTITIES, &prop);
802 std::vector<std::string> entities;
803 ParseStringArray(env, entities, prop);
804 for (size_t idx = 0; idx < entities.size(); ++idx) {
805 APP_LOGD("entity:%{public}s", entities[idx].c_str());
806 want.AddEntity(entities[idx]);
807 }
808 prop = nullptr;
809 int32_t flags = 0;
810 napi_get_named_property(env, args, FLAGS, &prop);
811 napi_typeof(env, prop, &valueType);
812 if (valueType == napi_number) {
813 napi_get_value_int32(env, prop, &flags);
814 }
815 prop = nullptr;
816 napi_get_named_property(env, args, DEVICE_ID, &prop);
817 std::string deviceId = GetStringFromNAPI(env, prop);
818 want.SetAction(action);
819 want.SetUri(uri);
820 want.SetType(type);
821 want.SetFlags(flags);
822 ElementName elementName(deviceId, bundleName, abilityName, moduleName);
823 want.SetElement(elementName);
824 return true;
825 }
826
ConvertWindowSize(napi_env env, const AbilityInfo &abilityInfo, napi_value value)827 void CommonFunc::ConvertWindowSize(napi_env env, const AbilityInfo &abilityInfo, napi_value value)
828 {
829 napi_value nMaxWindowRatio;
830 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.maxWindowRatio, &nMaxWindowRatio));
831 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowRatio", nMaxWindowRatio));
832
833 napi_value mMinWindowRatio;
834 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.minWindowRatio, &mMinWindowRatio));
835 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowRatio", mMinWindowRatio));
836
837 napi_value nMaxWindowWidth;
838 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowWidth, &nMaxWindowWidth));
839 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowWidth", nMaxWindowWidth));
840
841 napi_value nMinWindowWidth;
842 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowWidth, &nMinWindowWidth));
843 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowWidth", nMinWindowWidth));
844
845 napi_value nMaxWindowHeight;
846 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowHeight, &nMaxWindowHeight));
847 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowHeight", nMaxWindowHeight));
848
849 napi_value nMinWindowHeight;
850 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowHeight, &nMinWindowHeight));
851 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowHeight", nMinWindowHeight));
852 }
853
ConvertMetadata(napi_env env, const Metadata &metadata, napi_value value)854 void CommonFunc::ConvertMetadata(napi_env env, const Metadata &metadata, napi_value value)
855 {
856 napi_value nName;
857 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.name.c_str(), NAPI_AUTO_LENGTH, &nName));
858 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
859
860 napi_value nValue;
861 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.value.c_str(), NAPI_AUTO_LENGTH, &nValue));
862 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "value", nValue));
863
864 napi_value nResource;
865 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.resource.c_str(), NAPI_AUTO_LENGTH, &nResource));
866 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "resource", nResource));
867 }
868
ConvertAbilityInfos(napi_env env, const std::vector<AbilityInfo> &abilityInfos, napi_value value)869 void CommonFunc::ConvertAbilityInfos(napi_env env, const std::vector<AbilityInfo> &abilityInfos, napi_value value)
870 {
871 for (size_t index = 0; index < abilityInfos.size(); ++index) {
872 napi_value objAbilityInfo = nullptr;
873 napi_create_object(env, &objAbilityInfo);
874 ConvertAbilityInfo(env, abilityInfos[index], objAbilityInfo);
875 napi_set_element(env, value, index, objAbilityInfo);
876 }
877 }
878
ConvertAbilitySkillUri(napi_env env, const SkillUri &skillUri, napi_value value, bool isExtension)879 void CommonFunc::ConvertAbilitySkillUri(napi_env env, const SkillUri &skillUri, napi_value value, bool isExtension)
880 {
881 napi_value nScheme;
882 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.scheme.c_str(), NAPI_AUTO_LENGTH, &nScheme));
883 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "scheme", nScheme));
884
885 napi_value nHost;
886 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.host.c_str(), NAPI_AUTO_LENGTH, &nHost));
887 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "host", nHost));
888
889 napi_value nPort;
890 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.port.c_str(), NAPI_AUTO_LENGTH, &nPort));
891 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "port", nPort));
892
893 napi_value nPathStartWith;
894 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.pathStartWith.c_str(), NAPI_AUTO_LENGTH,
895 &nPathStartWith));
896 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pathStartWith", nPathStartWith));
897
898 napi_value nPath;
899 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.path.c_str(), NAPI_AUTO_LENGTH, &nPath));
900 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "path", nPath));
901
902 napi_value nPathRegex;
903 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.pathRegex.c_str(), NAPI_AUTO_LENGTH,
904 &nPathRegex));
905 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "pathRegex", nPathRegex));
906
907 napi_value nType;
908 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.type.c_str(), NAPI_AUTO_LENGTH, &nType));
909 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "type", nType));
910
911 napi_value nUtd;
912 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.utd.c_str(), NAPI_AUTO_LENGTH, &nUtd));
913 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "utd", nUtd));
914
915 napi_value nMaxFileSupported;
916 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, skillUri.maxFileSupported, &nMaxFileSupported));
917 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxFileSupported", nMaxFileSupported));
918
919 if (!isExtension) {
920 napi_value nLinkFeature;
921 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, skillUri.linkFeature.c_str(), NAPI_AUTO_LENGTH,
922 &nLinkFeature));
923 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "linkFeature", nLinkFeature));
924 }
925 }
926
ConvertAbilitySkill(napi_env env, const Skill &skill, napi_value value, bool isExtension)927 void CommonFunc::ConvertAbilitySkill(napi_env env, const Skill &skill, napi_value value, bool isExtension)
928 {
929 napi_value nActions;
930 size_t size = skill.actions.size();
931 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nActions));
932 for (size_t idx = 0; idx < size; ++idx) {
933 napi_value nAction;
934 NAPI_CALL_RETURN_VOID(
935 env, napi_create_string_utf8(env, skill.actions[idx].c_str(), NAPI_AUTO_LENGTH, &nAction));
936 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nActions, idx, nAction));
937 }
938 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "actions", nActions));
939
940 napi_value nEntities;
941 size = skill.entities.size();
942 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nEntities));
943 for (size_t idx = 0; idx < size; ++idx) {
944 napi_value nEntity;
945 NAPI_CALL_RETURN_VOID(
946 env, napi_create_string_utf8(env, skill.entities[idx].c_str(), NAPI_AUTO_LENGTH, &nEntity));
947 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nEntities, idx, nEntity));
948 }
949 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "entities", nEntities));
950
951 napi_value nUris;
952 size = skill.uris.size();
953 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nUris));
954 for (size_t idx = 0; idx < size; ++idx) {
955 napi_value nUri;
956 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nUri));
957 ConvertAbilitySkillUri(env, skill.uris[idx], nUri, isExtension);
958 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nUris, idx, nUri));
959 }
960 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "uris", nUris));
961
962 if (!isExtension) {
963 napi_value nDomainVerify;
964 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, skill.domainVerify, &nDomainVerify));
965 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "domainVerify", nDomainVerify));
966 }
967 }
968
969
ConvertAbilityInfo(napi_env env, const AbilityInfo &abilityInfo, napi_value objAbilityInfo)970 void CommonFunc::ConvertAbilityInfo(napi_env env, const AbilityInfo &abilityInfo, napi_value objAbilityInfo)
971 {
972 napi_value nBundleName;
973 NAPI_CALL_RETURN_VOID(
974 env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
975 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, BUNDLE_NAME, nBundleName));
976
977 napi_value nModuleName;
978 NAPI_CALL_RETURN_VOID(
979 env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
980 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, MODULE_NAME, nModuleName));
981
982 napi_value nName;
983 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
984 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, NAME, nName));
985
986 napi_value nLabel;
987 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
988 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, LABEL, nLabel));
989
990 napi_value nLabelId;
991 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.labelId, &nLabelId));
992 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, LABEL_ID, nLabelId));
993
994 napi_value nDescription;
995 NAPI_CALL_RETURN_VOID(
996 env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
997 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, DESCRIPTION, nDescription));
998
999 napi_value nDescriptionId;
1000 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.descriptionId, &nDescriptionId));
1001 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, DESCRIPTION_ID, nDescriptionId));
1002
1003 napi_value nIconPath;
1004 NAPI_CALL_RETURN_VOID(
1005 env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
1006 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ICON, nIconPath));
1007
1008 napi_value nIconId;
1009 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.iconId, &nIconId));
1010 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ICON_ID, nIconId));
1011
1012 napi_value nProcess;
1013 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
1014 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "process", nProcess));
1015
1016 napi_value nVisible;
1017 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.visible, &nVisible));
1018 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, IS_VISIBLE, nVisible));
1019
1020 napi_value nExported;
1021 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.visible, &nExported));
1022 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, EXPORTED, nExported));
1023
1024 napi_value nType;
1025 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.type), &nType));
1026 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "type", nType));
1027
1028 napi_value nOrientation;
1029 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.orientation), &nOrientation));
1030 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "orientation", nOrientation));
1031
1032 napi_value nLaunchType;
1033 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.launchMode), &nLaunchType));
1034 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "launchType", nLaunchType));
1035
1036 napi_value nPermissions;
1037 size_t size = abilityInfo.permissions.size();
1038 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPermissions));
1039 for (size_t idx = 0; idx < size; ++idx) {
1040 napi_value nPermission;
1041 NAPI_CALL_RETURN_VOID(
1042 env, napi_create_string_utf8(env, abilityInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
1043 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
1044 }
1045 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, PERMISSIONS, nPermissions));
1046
1047 napi_value nReadPermission;
1048 NAPI_CALL_RETURN_VOID(
1049 env, napi_create_string_utf8(env, abilityInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &nReadPermission));
1050 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, READ_PERMISSION, nReadPermission));
1051
1052 napi_value nWritePermission;
1053 NAPI_CALL_RETURN_VOID(
1054 env, napi_create_string_utf8(env, abilityInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &nWritePermission));
1055 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, WRITE_PERMISSION, nWritePermission));
1056
1057 napi_value nUri;
1058 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.uri.c_str(), NAPI_AUTO_LENGTH, &nUri));
1059 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, URI, nUri));
1060
1061 napi_value nDeviceTypes;
1062 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
1063 for (size_t idx = 0; idx < abilityInfo.deviceTypes.size(); ++idx) {
1064 napi_value nDeviceType;
1065 NAPI_CALL_RETURN_VOID(
1066 env, napi_create_string_utf8(env, abilityInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
1067 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
1068 }
1069 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "deviceTypes", nDeviceTypes));
1070
1071 napi_value nApplicationInfo;
1072 if (!abilityInfo.applicationInfo.name.empty()) {
1073 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nApplicationInfo));
1074 ConvertApplicationInfo(env, nApplicationInfo, abilityInfo.applicationInfo);
1075 } else {
1076 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nApplicationInfo));
1077 }
1078 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, APPLICATION_INFO, nApplicationInfo));
1079
1080 napi_value nMetadata;
1081 size = abilityInfo.metadata.size();
1082 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
1083 for (size_t index = 0; index < size; ++index) {
1084 napi_value nMetaData;
1085 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
1086 ConvertMetadata(env, abilityInfo.metadata[index], nMetaData);
1087 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, nMetaData));
1088 }
1089 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, META_DATA, nMetadata));
1090
1091 napi_value nEnabled;
1092 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.enabled, &nEnabled));
1093 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ENABLED, nEnabled));
1094
1095 napi_value nExcludeFromDock;
1096 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.excludeFromDock, &nExcludeFromDock));
1097 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, EXCLUDE_FROM_DOCK, nExcludeFromDock));
1098
1099 napi_value nSupportWindowModes;
1100 size = abilityInfo.windowModes.size();
1101 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSupportWindowModes));
1102 for (size_t index = 0; index < size; ++index) {
1103 napi_value innerMode;
1104 NAPI_CALL_RETURN_VOID(env,
1105 napi_create_int32(env, static_cast<int32_t>(abilityInfo.windowModes[index]), &innerMode));
1106 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSupportWindowModes, index, innerMode));
1107 }
1108 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "supportWindowModes", nSupportWindowModes));
1109
1110 napi_value nWindowSize;
1111 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nWindowSize));
1112 ConvertWindowSize(env, abilityInfo, nWindowSize);
1113 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "windowSize", nWindowSize));
1114
1115 napi_value nSkills;
1116 size = abilityInfo.skills.size();
1117 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSkills));
1118 for (size_t index = 0; index < size; ++index) {
1119 napi_value nSkill;
1120 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nSkill));
1121 ConvertAbilitySkill(env, abilityInfo.skills[index], nSkill, false);
1122 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSkills, index, nSkill));
1123 }
1124 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, SKILLS, nSkills));
1125 napi_value nAppIndex;
1126 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.appIndex, &nAppIndex));
1127 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, APP_INDEX, nAppIndex));
1128
1129 napi_value nOrientationId;
1130 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.orientationId, &nOrientationId));
1131 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ORIENTATION_ID, nOrientationId));
1132 }
1133
ConvertExtensionInfos(napi_env env, const std::vector<ExtensionAbilityInfo> &extensionInfos, napi_value value)1134 void CommonFunc::ConvertExtensionInfos(napi_env env, const std::vector<ExtensionAbilityInfo> &extensionInfos,
1135 napi_value value)
1136 {
1137 for (size_t index = 0; index < extensionInfos.size(); ++index) {
1138 napi_value objExtensionInfo = nullptr;
1139 napi_create_object(env, &objExtensionInfo);
1140 ConvertExtensionInfo(env, extensionInfos[index], objExtensionInfo);
1141 napi_set_element(env, value, index, objExtensionInfo);
1142 }
1143 }
1144
ConvertStringArrays(napi_env env, const std::vector<std::string> &strs, napi_value value)1145 void CommonFunc::ConvertStringArrays(napi_env env, const std::vector<std::string> &strs, napi_value value)
1146 {
1147 for (size_t index = 0; index < strs.size(); ++index) {
1148 napi_value nStr;
1149 NAPI_CALL_RETURN_VOID(
1150 env, napi_create_string_utf8(env, strs[index].c_str(), NAPI_AUTO_LENGTH, &nStr));
1151 napi_set_element(env, value, index, nStr);
1152 }
1153 }
1154
ConvertValidity(napi_env env, const Validity &validity, napi_value objValidity)1155 void CommonFunc::ConvertValidity(napi_env env, const Validity &validity, napi_value objValidity)
1156 {
1157 napi_value notBefore;
1158 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, validity.notBefore, ¬Before));
1159 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objValidity, "notBefore", notBefore));
1160
1161 napi_value notAfter;
1162 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, validity.notAfter, ¬After));
1163 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objValidity, "notAfter", notAfter));
1164 }
1165
ConvertAppProvisionInfo( napi_env env, const AppProvisionInfo &appProvisionInfo, napi_value objAppProvisionInfo)1166 void CommonFunc::ConvertAppProvisionInfo(
1167 napi_env env, const AppProvisionInfo &appProvisionInfo, napi_value objAppProvisionInfo)
1168 {
1169 napi_value versionCode;
1170 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appProvisionInfo.versionCode, &versionCode));
1171 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "versionCode", versionCode));
1172
1173 napi_value versionName;
1174 NAPI_CALL_RETURN_VOID(
1175 env, napi_create_string_utf8(env, appProvisionInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &versionName));
1176 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "versionName", versionName));
1177
1178 napi_value uuid;
1179 NAPI_CALL_RETURN_VOID(
1180 env, napi_create_string_utf8(env, appProvisionInfo.uuid.c_str(), NAPI_AUTO_LENGTH, &uuid));
1181 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "uuid", uuid));
1182
1183 napi_value type;
1184 NAPI_CALL_RETURN_VOID(
1185 env, napi_create_string_utf8(env, appProvisionInfo.type.c_str(), NAPI_AUTO_LENGTH, &type));
1186 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "type", type));
1187
1188 napi_value appDistributionType;
1189 NAPI_CALL_RETURN_VOID(
1190 env, napi_create_string_utf8(env, appProvisionInfo.appDistributionType.c_str(),
1191 NAPI_AUTO_LENGTH, &appDistributionType));
1192 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "appDistributionType",
1193 appDistributionType));
1194
1195 napi_value developerId;
1196 NAPI_CALL_RETURN_VOID(
1197 env, napi_create_string_utf8(env, appProvisionInfo.developerId.c_str(), NAPI_AUTO_LENGTH, &developerId));
1198 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "developerId", developerId));
1199
1200 napi_value certificate;
1201 NAPI_CALL_RETURN_VOID(
1202 env, napi_create_string_utf8(env, appProvisionInfo.certificate.c_str(), NAPI_AUTO_LENGTH, &certificate));
1203 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "certificate", certificate));
1204
1205 napi_value apl;
1206 NAPI_CALL_RETURN_VOID(
1207 env, napi_create_string_utf8(env, appProvisionInfo.apl.c_str(), NAPI_AUTO_LENGTH, &apl));
1208 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "apl", apl));
1209
1210 napi_value issuer;
1211 NAPI_CALL_RETURN_VOID(
1212 env, napi_create_string_utf8(env, appProvisionInfo.issuer.c_str(), NAPI_AUTO_LENGTH, &issuer));
1213 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "issuer", issuer));
1214
1215 napi_value validity;
1216 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &validity));
1217 ConvertValidity(env, appProvisionInfo.validity, validity);
1218 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "validity", validity));
1219
1220 napi_value appIdentifier;
1221 NAPI_CALL_RETURN_VOID(
1222 env, napi_create_string_utf8(env, appProvisionInfo.appIdentifier.c_str(), NAPI_AUTO_LENGTH, &appIdentifier));
1223 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "appIdentifier", appIdentifier));
1224
1225 napi_value organization;
1226 NAPI_CALL_RETURN_VOID(
1227 env, napi_create_string_utf8(env, appProvisionInfo.organization.c_str(), NAPI_AUTO_LENGTH, &organization));
1228 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "organization", organization));
1229 }
1230
ConvertExtensionInfo(napi_env env, const ExtensionAbilityInfo &extensionInfo, napi_value objExtensionInfo)1231 void CommonFunc::ConvertExtensionInfo(napi_env env, const ExtensionAbilityInfo &extensionInfo,
1232 napi_value objExtensionInfo)
1233 {
1234 napi_value nBundleName;
1235 NAPI_CALL_RETURN_VOID(
1236 env, napi_create_string_utf8(env, extensionInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1237 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, BUNDLE_NAME, nBundleName));
1238
1239 napi_value nModuleName;
1240 NAPI_CALL_RETURN_VOID(
1241 env, napi_create_string_utf8(env, extensionInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1242 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, MODULE_NAME, nModuleName));
1243
1244 napi_value nName;
1245 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, extensionInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1246 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, NAME, nName));
1247
1248 napi_value nLabelId;
1249 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, extensionInfo.labelId, &nLabelId));
1250 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, LABEL_ID, nLabelId));
1251
1252 napi_value nDescriptionId;
1253 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, extensionInfo.descriptionId, &nDescriptionId));
1254 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, DESCRIPTION_ID, nDescriptionId));
1255
1256 napi_value nIconId;
1257 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, extensionInfo.iconId, &nIconId));
1258 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, ICON_ID, nIconId));
1259
1260 napi_value nVisible;
1261 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.visible, &nVisible));
1262 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, IS_VISIBLE, nVisible));
1263
1264 napi_value nExported;
1265 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.visible, &nExported));
1266 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, EXPORTED, nExported));
1267
1268 napi_value nExtensionAbilityType;
1269 NAPI_CALL_RETURN_VOID(
1270 env, napi_create_int32(env, static_cast<int32_t>(extensionInfo.type), &nExtensionAbilityType));
1271 NAPI_CALL_RETURN_VOID(env,
1272 napi_set_named_property(env, objExtensionInfo, "extensionAbilityType", nExtensionAbilityType));
1273
1274 napi_value nExtensionTypeName;
1275 NAPI_CALL_RETURN_VOID(env,
1276 napi_create_string_utf8(env, extensionInfo.extensionTypeName.c_str(), NAPI_AUTO_LENGTH, &nExtensionTypeName));
1277 NAPI_CALL_RETURN_VOID(env,
1278 napi_set_named_property(env, objExtensionInfo, EXTENSION_ABILITY_TYPE_NAME, nExtensionTypeName));
1279
1280 napi_value nPermissions;
1281 size_t size = extensionInfo.permissions.size();
1282 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPermissions));
1283 for (size_t i = 0; i < size; ++i) {
1284 napi_value permission;
1285 NAPI_CALL_RETURN_VOID(
1286 env, napi_create_string_utf8(env, extensionInfo.permissions[i].c_str(), NAPI_AUTO_LENGTH, &permission));
1287 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, i, permission));
1288 }
1289 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, PERMISSIONS, nPermissions));
1290
1291 napi_value nApplicationInfo;
1292 if (!extensionInfo.applicationInfo.name.empty()) {
1293 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nApplicationInfo));
1294 ConvertApplicationInfo(env, nApplicationInfo, extensionInfo.applicationInfo);
1295 } else {
1296 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nApplicationInfo));
1297 }
1298 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, APPLICATION_INFO, nApplicationInfo));
1299
1300 napi_value nMetadata;
1301 size = extensionInfo.metadata.size();
1302 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
1303 for (size_t i = 0; i < size; ++i) {
1304 napi_value nMetaData;
1305 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
1306 ConvertMetadata(env, extensionInfo.metadata[i], nMetaData);
1307 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, i, nMetaData));
1308 }
1309 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, META_DATA, nMetadata));
1310
1311 napi_value nEnabled;
1312 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.enabled, &nEnabled));
1313 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, ENABLED, nEnabled));
1314
1315 napi_value nReadPermission;
1316 NAPI_CALL_RETURN_VOID(
1317 env, napi_create_string_utf8(env, extensionInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &nReadPermission));
1318 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, READ_PERMISSION, nReadPermission));
1319
1320 napi_value nWritePermission;
1321 NAPI_CALL_RETURN_VOID(
1322 env, napi_create_string_utf8(env, extensionInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &nWritePermission));
1323 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, WRITE_PERMISSION, nWritePermission));
1324
1325 napi_value nSkills;
1326 size = extensionInfo.skills.size();
1327 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSkills));
1328 for (size_t index = 0; index < size; ++index) {
1329 napi_value nSkill;
1330 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nSkill));
1331 ConvertAbilitySkill(env, extensionInfo.skills[index], nSkill, true);
1332 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSkills, index, nSkill));
1333 }
1334 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, SKILLS, nSkills));
1335
1336 napi_value nAppIndex;
1337 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.appIndex, &nAppIndex));
1338 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, APP_INDEX, nAppIndex));
1339 }
1340
1341
ConvertResource(napi_env env, const Resource &resource, napi_value objResource)1342 void CommonFunc::ConvertResource(napi_env env, const Resource &resource, napi_value objResource)
1343 {
1344 napi_value nBundleName;
1345 NAPI_CALL_RETURN_VOID(
1346 env, napi_create_string_utf8(env, resource.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1347 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, BUNDLE_NAME, nBundleName));
1348
1349 napi_value nModuleName;
1350 NAPI_CALL_RETURN_VOID(
1351 env, napi_create_string_utf8(env, resource.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1352 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, MODULE_NAME, nModuleName));
1353
1354 napi_value nId;
1355 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, resource.id, &nId));
1356 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, "id", nId));
1357 }
1358
ConvertApplicationInfo(napi_env env, napi_value objAppInfo, const ApplicationInfo &appInfo)1359 void CommonFunc::ConvertApplicationInfo(napi_env env, napi_value objAppInfo, const ApplicationInfo &appInfo)
1360 {
1361 napi_value nName;
1362 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1363 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, NAME, nName));
1364 APP_LOGD("ConvertApplicationInfo name=%{public}s", appInfo.name.c_str());
1365
1366 napi_value nBundleType;
1367 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(appInfo.bundleType), &nBundleType));
1368 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "bundleType", nBundleType));
1369
1370 napi_value nDebug;
1371 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.debug, &nDebug));
1372 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DEBUG, nDebug));
1373
1374 napi_value nDescription;
1375 NAPI_CALL_RETURN_VOID(
1376 env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1377 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION, nDescription));
1378
1379 napi_value nDescriptionId;
1380 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.descriptionId, &nDescriptionId));
1381 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION_ID, nDescriptionId));
1382
1383 napi_value nEnabled;
1384 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.enabled, &nEnabled));
1385 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ENABLED, nEnabled));
1386
1387 napi_value nLabel;
1388 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
1389 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL, nLabel));
1390
1391 napi_value nLabelId;
1392 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.labelId, &nLabelId));
1393 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL_ID, nLabelId));
1394
1395 napi_value nIconPath;
1396 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
1397 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON, nIconPath));
1398
1399 napi_value nIconId;
1400 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.iconId, &nIconId));
1401 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON_ID, nIconId));
1402
1403 napi_value nProcess;
1404 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
1405 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "process", nProcess));
1406
1407 napi_value nPermissions;
1408 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nPermissions));
1409 for (size_t idx = 0; idx < appInfo.permissions.size(); idx++) {
1410 napi_value nPermission;
1411 NAPI_CALL_RETURN_VOID(
1412 env, napi_create_string_utf8(env, appInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
1413 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
1414 }
1415 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, PERMISSIONS, nPermissions));
1416
1417 napi_value nEntryDir;
1418 NAPI_CALL_RETURN_VOID(
1419 env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &nEntryDir));
1420 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "entryDir", nEntryDir));
1421
1422 napi_value nCodePath;
1423 NAPI_CALL_RETURN_VOID(
1424 env, napi_create_string_utf8(env, appInfo.codePath.c_str(), NAPI_AUTO_LENGTH, &nCodePath));
1425 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "codePath", nCodePath));
1426
1427 napi_value nMetaData;
1428 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
1429 for (const auto &item : appInfo.metadata) {
1430 napi_value nmetaDataArray;
1431 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nmetaDataArray));
1432 for (size_t j = 0; j < item.second.size(); j++) {
1433 napi_value nmetaData;
1434 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nmetaData));
1435 ConvertMetadata(env, item.second[j], nmetaData);
1436 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nmetaDataArray, j, nmetaData));
1437 }
1438 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMetaData, item.first.c_str(), nmetaDataArray));
1439 }
1440 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, META_DATA, nMetaData));
1441
1442 napi_value nMetaDataArrayInfo;
1443 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nMetaDataArrayInfo));
1444 ConvertModuleMetaInfos(env, appInfo.metadata, nMetaDataArrayInfo);
1445 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "metadataArray", nMetaDataArrayInfo));
1446
1447 napi_value nRemovable;
1448 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.removable, &nRemovable));
1449 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "removable", nRemovable));
1450
1451 napi_value nAccessTokenId;
1452 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.accessTokenId, &nAccessTokenId));
1453 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "accessTokenId", nAccessTokenId));
1454
1455 napi_value nUid;
1456 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.uid, &nUid));
1457 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "uid", nUid));
1458
1459 napi_value nIconResource;
1460 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nIconResource));
1461 ConvertResource(env, appInfo.iconResource, nIconResource);
1462 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconResource", nIconResource));
1463
1464 napi_value nLabelResource;
1465 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nLabelResource));
1466 ConvertResource(env, appInfo.labelResource, nLabelResource);
1467 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelResource", nLabelResource));
1468
1469 napi_value nDescriptionResource;
1470 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDescriptionResource));
1471 ConvertResource(env, appInfo.descriptionResource, nDescriptionResource);
1472 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "descriptionResource", nDescriptionResource));
1473
1474 napi_value nAppDistributionType;
1475 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appDistributionType.c_str(), NAPI_AUTO_LENGTH,
1476 &nAppDistributionType));
1477 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appDistributionType", nAppDistributionType));
1478
1479 napi_value nAppProvisionType;
1480 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appProvisionType.c_str(), NAPI_AUTO_LENGTH,
1481 &nAppProvisionType));
1482 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appProvisionType", nAppProvisionType));
1483
1484 napi_value nIsSystemApp;
1485 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.isSystemApp, &nIsSystemApp));
1486 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "systemApp", nIsSystemApp));
1487
1488 napi_value ndataUnclearable;
1489 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, !appInfo.userDataClearable, &ndataUnclearable));
1490 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "dataUnclearable", ndataUnclearable));
1491
1492 std::string externalNativeLibraryPath = "";
1493 if (!appInfo.nativeLibraryPath.empty()) {
1494 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + appInfo.nativeLibraryPath;
1495 }
1496 napi_value nativeLibraryPath;
1497 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, externalNativeLibraryPath.c_str(), NAPI_AUTO_LENGTH,
1498 &nativeLibraryPath));
1499 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "nativeLibraryPath", nativeLibraryPath));
1500
1501 napi_value nAppIndex;
1502 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.appIndex, &nAppIndex));
1503 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, APP_INDEX, nAppIndex));
1504
1505 // add multiAppMode object
1506 napi_value nMultiAppMode;
1507 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMultiAppMode));
1508
1509 napi_value nMultiAppModeType;
1510 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(appInfo.multiAppMode.multiAppModeType),
1511 &nMultiAppModeType));
1512 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMultiAppMode, MULTI_APP_MODE_TYPE, nMultiAppModeType));
1513
1514 napi_value nMaxCount;
1515 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.multiAppMode.maxCount, &nMaxCount));
1516 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMultiAppMode, MAX_ADDITIONAL_NUMBER, nMaxCount));
1517
1518 if (nMultiAppModeType == nullptr || nMaxCount == nullptr || nMultiAppMode == nullptr) {
1519 APP_LOGW("napi_value is nullptr");
1520 }
1521
1522 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, MULTI_APP_MODE, nMultiAppMode));
1523
1524 napi_value nInstallSource;
1525 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.installSource.c_str(), NAPI_AUTO_LENGTH,
1526 &nInstallSource));
1527 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "installSource", nInstallSource));
1528
1529 napi_value nReleaseType;
1530 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.apiReleaseType.c_str(), NAPI_AUTO_LENGTH,
1531 &nReleaseType));
1532 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "releaseType", nReleaseType));
1533
1534 napi_value nCloudFileSyncEnabled;
1535 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.cloudFileSyncEnabled, &nCloudFileSyncEnabled));
1536 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "cloudFileSyncEnabled",
1537 nCloudFileSyncEnabled));
1538
1539 napi_value nFlags;
1540 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.applicationFlags, &nFlags));
1541 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, FLAGS, nFlags));
1542 }
1543
ConvertPermissionDef(napi_env env, napi_value result, const PermissionDef &permissionDef)1544 void CommonFunc::ConvertPermissionDef(napi_env env, napi_value result, const PermissionDef &permissionDef)
1545 {
1546 napi_value nPermissionName;
1547 NAPI_CALL_RETURN_VOID(
1548 env, napi_create_string_utf8(env, permissionDef.permissionName.c_str(), NAPI_AUTO_LENGTH, &nPermissionName));
1549 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "permissionName", nPermissionName));
1550
1551 napi_value nGrantMode;
1552 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, permissionDef.grantMode, &nGrantMode));
1553 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "grantMode", nGrantMode));
1554
1555 napi_value nLabelId;
1556 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, permissionDef.labelId, &nLabelId));
1557 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "labelId", nLabelId));
1558
1559 napi_value nDescriptionId;
1560 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, permissionDef.descriptionId, &nDescriptionId));
1561 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "descriptionId", nDescriptionId));
1562 }
1563
ConvertRequestPermissionUsedScene(napi_env env, const RequestPermissionUsedScene &requestPermissionUsedScene, napi_value result)1564 void CommonFunc::ConvertRequestPermissionUsedScene(napi_env env,
1565 const RequestPermissionUsedScene &requestPermissionUsedScene, napi_value result)
1566 {
1567 napi_value nAbilities;
1568 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilities));
1569 for (size_t index = 0; index < requestPermissionUsedScene.abilities.size(); index++) {
1570 napi_value objAbility;
1571 NAPI_CALL_RETURN_VOID(env,
1572 napi_create_string_utf8(env, requestPermissionUsedScene.abilities[index].c_str(),
1573 NAPI_AUTO_LENGTH, &objAbility));
1574 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilities, index, objAbility));
1575 }
1576 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "abilities", nAbilities));
1577
1578 napi_value nWhen;
1579 NAPI_CALL_RETURN_VOID(env,
1580 napi_create_string_utf8(env, requestPermissionUsedScene.when.c_str(), NAPI_AUTO_LENGTH, &nWhen));
1581 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "when", nWhen));
1582 }
1583
ConvertRequestPermission(napi_env env, const RequestPermission &requestPermission, napi_value result)1584 void CommonFunc::ConvertRequestPermission(napi_env env, const RequestPermission &requestPermission, napi_value result)
1585 {
1586 napi_value nPermissionName;
1587 NAPI_CALL_RETURN_VOID(
1588 env, napi_create_string_utf8(env, requestPermission.name.c_str(), NAPI_AUTO_LENGTH, &nPermissionName));
1589 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, NAME, nPermissionName));
1590
1591 napi_value nReason;
1592 NAPI_CALL_RETURN_VOID(
1593 env, napi_create_string_utf8(env, requestPermission.reason.c_str(), NAPI_AUTO_LENGTH, &nReason));
1594 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reason", nReason));
1595
1596 napi_value nReasonId;
1597 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, requestPermission.reasonId, &nReasonId));
1598 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reasonId", nReasonId));
1599
1600 napi_value nUsedScene;
1601 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nUsedScene));
1602 ConvertRequestPermissionUsedScene(env, requestPermission.usedScene, nUsedScene);
1603 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "usedScene", nUsedScene));
1604
1605 napi_value nModuleName;
1606 NAPI_CALL_RETURN_VOID(
1607 env, napi_create_string_utf8(env, requestPermission.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1608 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, MODULE_NAME, nModuleName));
1609 }
1610
ConvertPreloadItem(napi_env env, const PreloadItem &preloadItem, napi_value value)1611 void CommonFunc::ConvertPreloadItem(napi_env env, const PreloadItem &preloadItem, napi_value value)
1612 {
1613 napi_value nModuleName;
1614 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
1615 preloadItem.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1616 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, MODULE_NAME, nModuleName));
1617 }
1618
ConvertSignatureInfo(napi_env env, const SignatureInfo &signatureInfo, napi_value value)1619 void CommonFunc::ConvertSignatureInfo(napi_env env, const SignatureInfo &signatureInfo, napi_value value)
1620 {
1621 napi_value nAppId;
1622 NAPI_CALL_RETURN_VOID(
1623 env, napi_create_string_utf8(env, signatureInfo.appId.c_str(), NAPI_AUTO_LENGTH, &nAppId));
1624 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "appId", nAppId));
1625
1626 napi_value nFingerprint;
1627 NAPI_CALL_RETURN_VOID(
1628 env, napi_create_string_utf8(env, signatureInfo.fingerprint.c_str(), NAPI_AUTO_LENGTH, &nFingerprint));
1629 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "fingerprint", nFingerprint));
1630
1631 napi_value nAppIdentifier;
1632 NAPI_CALL_RETURN_VOID(
1633 env, napi_create_string_utf8(env, signatureInfo.appIdentifier.c_str(), NAPI_AUTO_LENGTH, &nAppIdentifier));
1634 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "appIdentifier", nAppIdentifier));
1635
1636 napi_value nCertificate;
1637 NAPI_CALL_RETURN_VOID(
1638 env, napi_create_string_utf8(env, signatureInfo.certificate.c_str(), NAPI_AUTO_LENGTH, &nCertificate));
1639 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "certificate", nCertificate));
1640 }
1641
ConvertHapModuleInfo(napi_env env, const HapModuleInfo &hapModuleInfo, napi_value objHapModuleInfo)1642 void CommonFunc::ConvertHapModuleInfo(napi_env env, const HapModuleInfo &hapModuleInfo, napi_value objHapModuleInfo)
1643 {
1644 napi_value nName;
1645 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1646 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, NAME, nName));
1647 APP_LOGD("ConvertHapModuleInfo name=%{public}s", hapModuleInfo.name.c_str());
1648
1649 napi_value nIcon;
1650 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIcon));
1651 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, ICON, nIcon));
1652
1653 napi_value nIconId;
1654 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.iconId, &nIconId));
1655 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, ICON_ID, nIconId));
1656
1657 napi_value nLabel;
1658 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
1659 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, LABEL, nLabel));
1660
1661 napi_value nLabelId;
1662 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.labelId, &nLabelId));
1663 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, LABEL_ID, nLabelId));
1664
1665 napi_value nDescription;
1666 NAPI_CALL_RETURN_VOID(
1667 env, napi_create_string_utf8(env, hapModuleInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1668 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, DESCRIPTION, nDescription));
1669
1670 napi_value ndescriptionId;
1671 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, hapModuleInfo.descriptionId, &ndescriptionId));
1672 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, DESCRIPTION_ID, ndescriptionId));
1673
1674 napi_value nMainElementName;
1675 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.mainElementName.c_str(), NAPI_AUTO_LENGTH,
1676 &nMainElementName));
1677 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "mainElementName", nMainElementName));
1678
1679 napi_value nAbilityInfos;
1680 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilityInfos));
1681 for (size_t idx = 0; idx < hapModuleInfo.abilityInfos.size(); idx++) {
1682 napi_value objAbilityInfo;
1683 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAbilityInfo));
1684 ConvertAbilityInfo(env, hapModuleInfo.abilityInfos[idx], objAbilityInfo);
1685 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilityInfos, idx, objAbilityInfo));
1686 }
1687 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "abilitiesInfo", nAbilityInfos));
1688
1689 napi_value nExtensionAbilityInfos;
1690 napi_create_array_with_length(env, hapModuleInfo.extensionInfos.size(), &nExtensionAbilityInfos);
1691 ConvertExtensionInfos(env, hapModuleInfo.extensionInfos, nExtensionAbilityInfos);
1692 NAPI_CALL_RETURN_VOID(env,
1693 napi_set_named_property(env, objHapModuleInfo, "extensionAbilitiesInfo", nExtensionAbilityInfos));
1694
1695 napi_value nMetadata;
1696 size_t size = hapModuleInfo.metadata.size();
1697 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
1698 for (size_t index = 0; index < size; ++index) {
1699 napi_value innerMeta;
1700 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &innerMeta));
1701 ConvertMetadata(env, hapModuleInfo.metadata[index], innerMeta);
1702 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, innerMeta));
1703 }
1704 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, META_DATA, nMetadata));
1705
1706 napi_value nDeviceTypes;
1707 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
1708 for (size_t idx = 0; idx < hapModuleInfo.deviceTypes.size(); idx++) {
1709 napi_value nDeviceType;
1710 NAPI_CALL_RETURN_VOID(
1711 env, napi_create_string_utf8(env, hapModuleInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
1712 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
1713 }
1714 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "deviceTypes", nDeviceTypes));
1715
1716 napi_value nInstallationFree;
1717 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, hapModuleInfo.installationFree, &nInstallationFree));
1718 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "installationFree", nInstallationFree));
1719
1720 napi_value nHashValue;
1721 NAPI_CALL_RETURN_VOID(
1722 env, napi_create_string_utf8(env, hapModuleInfo.hashValue.c_str(), NAPI_AUTO_LENGTH, &nHashValue));
1723 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "hashValue", nHashValue));
1724
1725 napi_value nModuleSourceDir;
1726 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.moduleSourceDir.c_str(), NAPI_AUTO_LENGTH,
1727 &nModuleSourceDir));
1728 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "moduleSourceDir", nModuleSourceDir));
1729
1730 napi_value nType;
1731 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(hapModuleInfo.moduleType), &nType));
1732 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "type", nType));
1733
1734 napi_value nDependencies;
1735 size = hapModuleInfo.dependencies.size();
1736 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nDependencies));
1737 for (size_t index = 0; index < size; ++index) {
1738 napi_value nDependency;
1739 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDependency));
1740 ConvertDependency(env, hapModuleInfo.dependencies[index], nDependency);
1741 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDependencies, index, nDependency));
1742 }
1743 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "dependencies", nDependencies));
1744
1745 napi_value nPreloads;
1746 size = hapModuleInfo.preloads.size();
1747 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPreloads));
1748 for (size_t index = 0; index < size; ++index) {
1749 napi_value nPreload;
1750 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nPreload));
1751 ConvertPreloadItem(env, hapModuleInfo.preloads[index], nPreload);
1752 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPreloads, index, nPreload));
1753 }
1754 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "preloads", nPreloads));
1755 if (!hapModuleInfo.fileContextMenu.empty()) {
1756 napi_value nMenu;
1757 NAPI_CALL_RETURN_VOID(
1758 env, napi_create_string_utf8(env, hapModuleInfo.fileContextMenu.c_str(), NAPI_AUTO_LENGTH, &nMenu));
1759 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "fileContextMenu", nMenu));
1760 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "fileContextMenuConfig", nMenu));
1761 }
1762
1763 napi_value nRouterMap;
1764 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nRouterMap));
1765 for (size_t idx = 0; idx < hapModuleInfo.routerArray.size(); idx++) {
1766 napi_value nRouterItem;
1767 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nRouterItem));
1768 ConvertRouterItem(env, hapModuleInfo.routerArray[idx], nRouterItem);
1769 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nRouterMap, idx, nRouterItem));
1770 }
1771 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, ROUTER_MAP, nRouterMap));
1772
1773 napi_value nCodePath;
1774 size_t result = hapModuleInfo.hapPath.find(PATH_PREFIX);
1775 if (result != std::string::npos) {
1776 size_t pos = hapModuleInfo.hapPath.find_last_of('/');
1777 std::string codePath = CODE_PATH_PREFIX;
1778 if (pos != std::string::npos && pos != hapModuleInfo.hapPath.size() - 1) {
1779 codePath += hapModuleInfo.hapPath.substr(pos + 1);
1780 }
1781 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, codePath.c_str(), NAPI_AUTO_LENGTH,
1782 &nCodePath));
1783 } else {
1784 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.hapPath.c_str(), NAPI_AUTO_LENGTH,
1785 &nCodePath));
1786 }
1787 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, CODE_PATH, nCodePath));
1788
1789 std::string externalNativeLibraryPath = "";
1790 if (!hapModuleInfo.nativeLibraryPath.empty() && !hapModuleInfo.moduleName.empty()) {
1791 externalNativeLibraryPath = CONTEXT_DATA_STORAGE_BUNDLE + hapModuleInfo.nativeLibraryPath;
1792 }
1793 napi_value nativeLibraryPath;
1794 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, externalNativeLibraryPath.c_str(), NAPI_AUTO_LENGTH,
1795 &nativeLibraryPath));
1796 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "nativeLibraryPath", nativeLibraryPath));
1797 }
1798
ConvertRouterItem(napi_env env, const RouterItem &routerItem, napi_value value)1799 void CommonFunc::ConvertRouterItem(napi_env env, const RouterItem &routerItem, napi_value value)
1800 {
1801 napi_value nName;
1802 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1803 env, routerItem.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1804 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
1805
1806 napi_value nPageSourceFile;
1807 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1808 env, routerItem.pageSourceFile.c_str(), NAPI_AUTO_LENGTH, &nPageSourceFile));
1809 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, PAGE_SOURCE_FILE, nPageSourceFile));
1810
1811 napi_value nBuildFunction;
1812 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1813 env, routerItem.buildFunction.c_str(), NAPI_AUTO_LENGTH, &nBuildFunction));
1814 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, BUILD_FUNCTION, nBuildFunction));
1815
1816 napi_value nDataArray;
1817 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDataArray));
1818 ConvertRouterDataInfos(env, routerItem.data, nDataArray);
1819 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, DATA, nDataArray));
1820
1821 napi_value nCustomData;
1822 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1823 env, routerItem.customData.c_str(), NAPI_AUTO_LENGTH, &nCustomData));
1824 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, CUSTOM_DATA, nCustomData));
1825 }
1826
ConvertRouterDataInfos(napi_env env, const std::map<std::string, std::string> &data, napi_value objInfos)1827 void CommonFunc::ConvertRouterDataInfos(napi_env env,
1828 const std::map<std::string, std::string> &data, napi_value objInfos)
1829 {
1830 size_t index = 0;
1831 for (const auto &item : data) {
1832 napi_value objInfo = nullptr;
1833 napi_create_object(env, &objInfo);
1834
1835 napi_value nKey;
1836 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1837 env, item.first.c_str(), NAPI_AUTO_LENGTH, &nKey));
1838 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, KEY, nKey));
1839
1840 napi_value nValue;
1841 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1842 env, item.second.c_str(), NAPI_AUTO_LENGTH, &nValue));
1843 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, VALUE, nValue));
1844
1845 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, objInfos, index++, objInfo));
1846 }
1847 }
1848
ConvertDependency(napi_env env, const Dependency &dependency, napi_value value)1849 void CommonFunc::ConvertDependency(napi_env env, const Dependency &dependency, napi_value value)
1850 {
1851 napi_value nBundleName;
1852 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1853 env, dependency.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1854 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, BUNDLE_NAME, nBundleName));
1855
1856 napi_value nModuleName;
1857 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1858 env, dependency.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1859 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, MODULE_NAME, nModuleName));
1860
1861 napi_value nVersionCode;
1862 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, dependency.versionCode, &nVersionCode));
1863 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionCode", nVersionCode));
1864 }
1865
ConvertBundleInfo(napi_env env, const BundleInfo &bundleInfo, napi_value objBundleInfo, int32_t flags)1866 void CommonFunc::ConvertBundleInfo(napi_env env, const BundleInfo &bundleInfo, napi_value objBundleInfo, int32_t flags)
1867 {
1868 napi_value nName;
1869 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1870 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, NAME, nName));
1871
1872 napi_value nVendor;
1873 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.vendor.c_str(), NAPI_AUTO_LENGTH, &nVendor));
1874 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "vendor", nVendor));
1875
1876 napi_value nVersionCode;
1877 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, bundleInfo.versionCode, &nVersionCode));
1878 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionCode", nVersionCode));
1879
1880 napi_value nVersionName;
1881 NAPI_CALL_RETURN_VOID(
1882 env, napi_create_string_utf8(env, bundleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
1883 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionName", nVersionName));
1884
1885 napi_value nMinCompatibleVersionCode;
1886 NAPI_CALL_RETURN_VOID(
1887 env, napi_create_int32(env, bundleInfo.minCompatibleVersionCode, &nMinCompatibleVersionCode));
1888 NAPI_CALL_RETURN_VOID(
1889 env, napi_set_named_property(env, objBundleInfo, "minCompatibleVersionCode", nMinCompatibleVersionCode));
1890
1891 napi_value nTargetVersion;
1892 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.targetVersion, &nTargetVersion));
1893 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "targetVersion", nTargetVersion));
1894
1895 napi_value nAppInfo;
1896 if ((static_cast<uint32_t>(flags) & static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
1897 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
1898 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nAppInfo));
1899 ConvertApplicationInfo(env, nAppInfo, bundleInfo.applicationInfo);
1900 } else {
1901 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nAppInfo));
1902 }
1903 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "appInfo", nAppInfo));
1904
1905 napi_value nHapModuleInfos;
1906 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nHapModuleInfos));
1907 for (size_t idx = 0; idx < bundleInfo.hapModuleInfos.size(); idx++) {
1908 napi_value objHapModuleInfo;
1909 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objHapModuleInfo));
1910 ConvertHapModuleInfo(env, bundleInfo.hapModuleInfos[idx], objHapModuleInfo);
1911 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nHapModuleInfos, idx, objHapModuleInfo));
1912 }
1913 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "hapModulesInfo", nHapModuleInfos));
1914
1915 napi_value nReqPermissionDetails;
1916 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionDetails));
1917 for (size_t idx = 0; idx < bundleInfo.reqPermissionDetails.size(); idx++) {
1918 napi_value objReqPermission;
1919 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objReqPermission));
1920 ConvertRequestPermission(env, bundleInfo.reqPermissionDetails[idx], objReqPermission);
1921 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionDetails, idx, objReqPermission));
1922 }
1923 NAPI_CALL_RETURN_VOID(
1924 env, napi_set_named_property(env, objBundleInfo, "reqPermissionDetails", nReqPermissionDetails));
1925
1926 napi_value nReqPermissionStates;
1927 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionStates));
1928 for (size_t idx = 0; idx < bundleInfo.reqPermissionStates.size(); idx++) {
1929 napi_value nReqPermissionState;
1930 NAPI_CALL_RETURN_VOID(env,
1931 napi_create_int32(env, static_cast<int32_t>(bundleInfo.reqPermissionStates[idx]), &nReqPermissionState));
1932 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionStates, idx, nReqPermissionState));
1933 }
1934 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "permissionGrantStates",
1935 nReqPermissionStates));
1936
1937 napi_value nSignatureInfo;
1938 if ((static_cast<uint32_t>(flags) & static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
1939 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
1940 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nSignatureInfo));
1941 ConvertSignatureInfo(env, bundleInfo.signatureInfo, nSignatureInfo);
1942 } else {
1943 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nSignatureInfo));
1944 }
1945 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "signatureInfo", nSignatureInfo));
1946
1947 napi_value nInstallTime;
1948 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.installTime, &nInstallTime));
1949 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "installTime", nInstallTime));
1950
1951 napi_value nUpdateTime;
1952 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.updateTime, &nUpdateTime));
1953 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "updateTime", nUpdateTime));
1954
1955 napi_value nRouterMap;
1956 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nRouterMap));
1957 for (size_t idx = 0; idx < bundleInfo.routerArray.size(); idx++) {
1958 napi_value nRouterItem;
1959 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nRouterItem));
1960 ConvertRouterItem(env, bundleInfo.routerArray[idx], nRouterItem);
1961 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nRouterMap, idx, nRouterItem));
1962 }
1963 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, ROUTER_MAP, nRouterMap));
1964
1965 napi_value nAppIndex;
1966 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.appIndex, &nAppIndex));
1967 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, APP_INDEX, nAppIndex));
1968 }
1969
ConvertBundleChangeInfo(napi_env env, const std::string &bundleName, int32_t userId, int32_t appIndex, napi_value bundleChangeInfo)1970 void CommonFunc::ConvertBundleChangeInfo(napi_env env, const std::string &bundleName,
1971 int32_t userId, int32_t appIndex, napi_value bundleChangeInfo)
1972 {
1973 napi_value nBundleName;
1974 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1975 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, bundleChangeInfo, "bundleName", nBundleName));
1976
1977 napi_value nUserId;
1978 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, userId, &nUserId));
1979 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, bundleChangeInfo, "userId", nUserId));
1980
1981 napi_value nAppIndex;
1982 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appIndex, &nAppIndex));
1983 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, bundleChangeInfo, "appIndex", nAppIndex));
1984 }
1985
ConvertLauncherAbilityInfo(napi_env env, const LauncherAbilityInfo &launcherAbility, napi_value value)1986 void CommonFunc::ConvertLauncherAbilityInfo(napi_env env,
1987 const LauncherAbilityInfo &launcherAbility, napi_value value)
1988 {
1989 // wrap labelId
1990 napi_value labelId;
1991 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, launcherAbility.labelId, &labelId));
1992 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "labelId", labelId));
1993
1994 // wrap iconId
1995 napi_value iconId;
1996 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, launcherAbility.iconId, &iconId));
1997 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "iconId", iconId));
1998
1999 // wrap userId
2000 napi_value userId;
2001 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbility.userId, &userId));
2002 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "userId", userId));
2003
2004 // wrap installTime
2005 napi_value installTime;
2006 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, launcherAbility.installTime, &installTime));
2007 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "installTime", installTime));
2008
2009 // wrap elementName
2010 napi_value elementName;
2011 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &elementName));
2012 ConvertElementName(env, elementName, launcherAbility.elementName);
2013 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "elementName", elementName));
2014
2015 // wrap application
2016 napi_value appInfo;
2017 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &appInfo));
2018 ConvertApplicationInfo(env, appInfo, launcherAbility.applicationInfo);
2019 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "applicationInfo", appInfo));
2020 }
2021
ConvertLauncherAbilityInfos(napi_env env, const std::vector<LauncherAbilityInfo> &launcherAbilities, napi_value value)2022 void CommonFunc::ConvertLauncherAbilityInfos(napi_env env,
2023 const std::vector<LauncherAbilityInfo> &launcherAbilities, napi_value value)
2024 {
2025 if (launcherAbilities.empty()) {
2026 return;
2027 }
2028 size_t index = 0;
2029 for (const auto &launcherAbility : launcherAbilities) {
2030 napi_value launcherAbilityObj = nullptr;
2031 napi_create_object(env, &launcherAbilityObj);
2032 ConvertLauncherAbilityInfo(env, launcherAbility, launcherAbilityObj);
2033 napi_set_element(env, value, index, launcherAbilityObj);
2034 ++index;
2035 }
2036 }
2037
ConvertShortcutIntent(napi_env env, const OHOS::AppExecFwk::ShortcutIntent &shortcutIntent, napi_value value)2038 void CommonFunc::ConvertShortcutIntent(napi_env env,
2039 const OHOS::AppExecFwk::ShortcutIntent &shortcutIntent, napi_value value)
2040 {
2041 napi_value nTargetBundle;
2042 NAPI_CALL_RETURN_VOID(
2043 env, napi_create_string_utf8(env, shortcutIntent.targetBundle.c_str(), NAPI_AUTO_LENGTH, &nTargetBundle));
2044 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetBundle", nTargetBundle));
2045
2046 napi_value nTargetModule;
2047 NAPI_CALL_RETURN_VOID(
2048 env, napi_create_string_utf8(env, shortcutIntent.targetModule.c_str(), NAPI_AUTO_LENGTH, &nTargetModule));
2049 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetModule", nTargetModule));
2050
2051 napi_value nTargetClass;
2052 NAPI_CALL_RETURN_VOID(
2053 env, napi_create_string_utf8(env, shortcutIntent.targetClass.c_str(), NAPI_AUTO_LENGTH, &nTargetClass));
2054 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetAbility", nTargetClass));
2055
2056 napi_value nParameters;
2057 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nParameters));
2058 ConvertParameters(env, shortcutIntent.parameters, nParameters);
2059 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "parameters", nParameters));
2060 }
2061
ConvertParameters(napi_env env, const std::map<std::string, std::string> &data, napi_value objInfos)2062 void CommonFunc::ConvertParameters(napi_env env,
2063 const std::map<std::string, std::string> &data, napi_value objInfos)
2064 {
2065 size_t index = 0;
2066 for (const auto &item : data) {
2067 napi_value objInfo = nullptr;
2068 napi_create_object(env, &objInfo);
2069
2070 napi_value nKey;
2071 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2072 env, item.first.c_str(), NAPI_AUTO_LENGTH, &nKey));
2073 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, KEY, nKey));
2074
2075 napi_value nValue;
2076 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2077 env, item.second.c_str(), NAPI_AUTO_LENGTH, &nValue));
2078 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, VALUE, nValue));
2079
2080 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, objInfos, index++, objInfo));
2081 }
2082 }
2083
ConvertShortCutInfo(napi_env env, const ShortcutInfo &shortcutInfo, napi_value value)2084 void CommonFunc::ConvertShortCutInfo(napi_env env, const ShortcutInfo &shortcutInfo, napi_value value)
2085 {
2086 // wrap id
2087 napi_value shortId;
2088 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.id.c_str(), NAPI_AUTO_LENGTH, &shortId));
2089 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "id", shortId));
2090 // wrap bundleName
2091 napi_value bundleName;
2092 NAPI_CALL_RETURN_VOID(
2093 env, napi_create_string_utf8(env, shortcutInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName));
2094 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "bundleName", bundleName));
2095 // wrap moduleName
2096 napi_value moduleName;
2097 NAPI_CALL_RETURN_VOID(
2098 env, napi_create_string_utf8(env, shortcutInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName));
2099 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "moduleName", moduleName));
2100 // wrap hostAbility
2101 napi_value hostAbility;
2102 NAPI_CALL_RETURN_VOID(
2103 env, napi_create_string_utf8(env, shortcutInfo.hostAbility.c_str(), NAPI_AUTO_LENGTH, &hostAbility));
2104 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "hostAbility", hostAbility));
2105 // wrap icon
2106 napi_value icon;
2107 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.icon.c_str(), NAPI_AUTO_LENGTH, &icon));
2108 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "icon", icon));
2109 // wrap iconId
2110 napi_value iconId;
2111 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, shortcutInfo.iconId, &iconId));
2112 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "iconId", iconId));
2113 // wrap label
2114 napi_value label;
2115 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.label.c_str(), NAPI_AUTO_LENGTH, &label));
2116 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "label", label));
2117 // wrap labelId
2118 napi_value labelId;
2119 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, shortcutInfo.labelId, &labelId));
2120 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "labelId", labelId));
2121
2122 // wrap wants
2123 napi_value intents;
2124 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &intents));
2125 for (size_t index = 0; index < shortcutInfo.intents.size(); ++index) {
2126 napi_value intent;
2127 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &intent));
2128 ConvertShortcutIntent(env, shortcutInfo.intents[index], intent);
2129 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, intents, index, intent));
2130 }
2131 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "wants", intents));
2132 // wrap appIndex
2133 napi_value appIndex;
2134 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.appIndex, &appIndex));
2135 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "appIndex", appIndex));
2136 // wrap sourceType
2137 napi_value sourceType;
2138 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.sourceType, &sourceType));
2139 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "sourceType", sourceType));
2140 }
2141
ConvertShortCutInfos(napi_env env, const std::vector<ShortcutInfo> &shortcutInfos, napi_value value)2142 void CommonFunc::ConvertShortCutInfos(napi_env env, const std::vector<ShortcutInfo> &shortcutInfos, napi_value value)
2143 {
2144 if (shortcutInfos.empty()) {
2145 return;
2146 }
2147 size_t index = 0;
2148 for (const auto &shortcutInfo : shortcutInfos) {
2149 napi_value shortcutObj = nullptr;
2150 napi_create_object(env, &shortcutObj);
2151 ConvertShortCutInfo(env, shortcutInfo, shortcutObj);
2152 napi_set_element(env, value, index, shortcutObj);
2153 ++index;
2154 }
2155 }
2156
ConvertOverlayModuleInfo(napi_env env, const OverlayModuleInfo &info, napi_value objOverlayModuleInfo)2157 void CommonFunc::ConvertOverlayModuleInfo(napi_env env, const OverlayModuleInfo &info,
2158 napi_value objOverlayModuleInfo)
2159 {
2160 napi_value nBundleName;
2161 NAPI_CALL_RETURN_VOID(env,
2162 napi_create_string_utf8(env, info.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
2163 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objOverlayModuleInfo, BUNDLE_NAME, nBundleName));
2164 APP_LOGD("ConvertOverlayModuleInfo bundleName=%{public}s", info.bundleName.c_str());
2165
2166 napi_value nModuleName;
2167 NAPI_CALL_RETURN_VOID(env,
2168 napi_create_string_utf8(env, info.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
2169 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objOverlayModuleInfo, MODULE_NAME, nModuleName));
2170 APP_LOGD("ConvertOverlayModuleInfo moduleName=%{public}s", info.moduleName.c_str());
2171
2172 napi_value nTargetModuleName;
2173 NAPI_CALL_RETURN_VOID(env,
2174 napi_create_string_utf8(env, info.targetModuleName.c_str(), NAPI_AUTO_LENGTH, &nTargetModuleName));
2175 NAPI_CALL_RETURN_VOID(env,
2176 napi_set_named_property(env, objOverlayModuleInfo, TARGET_MODULE_NAME, nTargetModuleName));
2177 APP_LOGD("ConvertOverlayModuleInfo targetModuleName=%{public}s", info.targetModuleName.c_str());
2178
2179 napi_value nPriority;
2180 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, info.priority, &nPriority));
2181 NAPI_CALL_RETURN_VOID(env,
2182 napi_set_named_property(env, objOverlayModuleInfo, PRIORITY, nPriority));
2183 APP_LOGD("ConvertOverlayModuleInfo priority=%{public}d", info.priority);
2184
2185 napi_value nState;
2186 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, info.state, &nState));
2187 NAPI_CALL_RETURN_VOID(env,
2188 napi_set_named_property(env, objOverlayModuleInfo, STATE, nState));
2189 APP_LOGD("ConvertOverlayModuleInfo state=%{public}d", info.state);
2190 }
2191
ConvertOverlayModuleInfos(napi_env env, const std::vector<OverlayModuleInfo> &Infos, napi_value objInfos)2192 void CommonFunc::ConvertOverlayModuleInfos(napi_env env, const std::vector<OverlayModuleInfo> &Infos,
2193 napi_value objInfos)
2194 {
2195 for (size_t index = 0; index < Infos.size(); ++index) {
2196 napi_value objInfo = nullptr;
2197 napi_create_object(env, &objInfo);
2198 ConvertOverlayModuleInfo(env, Infos[index], objInfo);
2199 napi_set_element(env, objInfos, index, objInfo);
2200 }
2201 }
2202
ConvertModuleMetaInfos(napi_env env, const std::map<std::string, std::vector<Metadata>> &metadata, napi_value objInfos)2203 void CommonFunc::ConvertModuleMetaInfos(napi_env env,
2204 const std::map<std::string, std::vector<Metadata>> &metadata, napi_value objInfos)
2205 {
2206 size_t index = 0;
2207 for (const auto &item : metadata) {
2208 napi_value objInfo = nullptr;
2209 napi_create_object(env, &objInfo);
2210
2211 napi_value nModuleName;
2212 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2213 env, item.first.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
2214 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, MODULE_NAME, nModuleName));
2215
2216 napi_value nMetadataInfos;
2217 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nMetadataInfos));
2218 for (size_t idx = 0; idx < item.second.size(); idx++) {
2219 napi_value nModuleMetadata;
2220 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nModuleMetadata));
2221 ConvertMetadata(env, item.second[idx], nModuleMetadata);
2222 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadataInfos, idx, nModuleMetadata));
2223 }
2224 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, META_DATA, nMetadataInfos));
2225
2226 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, objInfos, index++, objInfo));
2227 }
2228 }
2229
ObtainCallingBundleName()2230 std::string CommonFunc::ObtainCallingBundleName()
2231 {
2232 std::string callingBundleName;
2233 auto bundleMgr = GetBundleMgr();
2234 if (bundleMgr == nullptr) {
2235 APP_LOGE("CommonFunc::GetBundleMgr failed");
2236 return callingBundleName;
2237 }
2238 if (!bundleMgr->ObtainCallingBundleName(callingBundleName)) {
2239 APP_LOGE("obtain calling bundleName failed");
2240 }
2241 return callingBundleName;
2242 }
2243
ConvertSharedModuleInfo(napi_env env, napi_value value, const SharedModuleInfo &moduleInfo)2244 void CommonFunc::ConvertSharedModuleInfo(napi_env env, napi_value value, const SharedModuleInfo &moduleInfo)
2245 {
2246 napi_value nName;
2247 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2248 env, moduleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
2249 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
2250
2251 napi_value nVersionCode;
2252 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, moduleInfo.versionCode, &nVersionCode));
2253 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionCode", nVersionCode));
2254
2255 napi_value nVersionName;
2256 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2257 env, moduleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
2258 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionName", nVersionName));
2259
2260 napi_value nDescription;
2261 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2262 env, moduleInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
2263 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, DESCRIPTION, nDescription));
2264
2265 napi_value nDescriptionId;
2266 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, moduleInfo.descriptionId, &nDescriptionId));
2267 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, DESCRIPTION_ID, nDescriptionId));
2268 }
2269
ConvertSharedBundleInfo(napi_env env, napi_value value, const SharedBundleInfo &bundleInfo)2270 void CommonFunc::ConvertSharedBundleInfo(napi_env env, napi_value value, const SharedBundleInfo &bundleInfo)
2271 {
2272 napi_value nName;
2273 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2274 env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
2275 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
2276
2277 napi_value nCompatiblePolicy;
2278 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
2279 env, static_cast<int32_t>(bundleInfo.compatiblePolicy), &nCompatiblePolicy));
2280 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "compatiblePolicy", nCompatiblePolicy));
2281
2282 napi_value nSharedModuleInfos;
2283 size_t size = bundleInfo.sharedModuleInfos.size();
2284 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSharedModuleInfos));
2285 for (size_t index = 0; index < size; ++index) {
2286 napi_value nModuleInfo;
2287 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nModuleInfo));
2288 ConvertSharedModuleInfo(env, nModuleInfo, bundleInfo.sharedModuleInfos[index]);
2289 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSharedModuleInfos, index, nModuleInfo));
2290 }
2291 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "sharedModuleInfo", nSharedModuleInfos));
2292 }
2293
ConvertAllSharedBundleInfo(napi_env env, napi_value value, const std::vector<SharedBundleInfo> &sharedBundles)2294 void CommonFunc::ConvertAllSharedBundleInfo(napi_env env, napi_value value,
2295 const std::vector<SharedBundleInfo> &sharedBundles)
2296 {
2297 if (sharedBundles.empty()) {
2298 APP_LOGD("sharedBundles is empty");
2299 return;
2300 }
2301 size_t index = 0;
2302 for (const auto &item : sharedBundles) {
2303 napi_value objInfo;
2304 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objInfo));
2305 ConvertSharedBundleInfo(env, objInfo, item);
2306 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, value, index, objInfo));
2307 index++;
2308 }
2309 }
2310
ConvertRecoverableApplicationInfo( napi_env env, napi_value value, const RecoverableApplicationInfo &recoverableApplication)2311 void CommonFunc::ConvertRecoverableApplicationInfo(
2312 napi_env env, napi_value value, const RecoverableApplicationInfo &recoverableApplication)
2313 {
2314 napi_value nBundleName;
2315 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2316 env, recoverableApplication.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
2317 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, BUNDLE_NAME, nBundleName));
2318
2319 napi_value nModuleName;
2320 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
2321 env, recoverableApplication.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
2322 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, MODULE_NAME, nModuleName));
2323
2324 napi_value nLabelId;
2325 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, recoverableApplication.labelId, &nLabelId));
2326 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, LABEL_ID, nLabelId));
2327
2328 napi_value nIconId;
2329 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, recoverableApplication.iconId, &nIconId));
2330 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, ICON_ID, nIconId));
2331
2332 napi_value nSystemApp;
2333 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, recoverableApplication.systemApp, &nSystemApp));
2334 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, SYSTEM_APP, nSystemApp));
2335
2336 napi_value nBundleType;
2337 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env,
2338 static_cast<int32_t>(recoverableApplication.bundleType), &nBundleType));
2339 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, BUNDLE_TYPE, nBundleType));
2340
2341 napi_value nCodePaths;
2342 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nCodePaths));
2343 for (size_t idx = 0; idx < recoverableApplication.codePaths.size(); idx++) {
2344 napi_value nCodePath;
2345 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, recoverableApplication.codePaths[idx].c_str(),
2346 NAPI_AUTO_LENGTH, &nCodePath));
2347 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nCodePaths, idx, nCodePath));
2348 }
2349 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, CODE_PATHS, nCodePaths));
2350 }
2351
ConvertRecoverableApplicationInfos(napi_env env, napi_value value, const std::vector<RecoverableApplicationInfo> &recoverableApplications)2352 void CommonFunc::ConvertRecoverableApplicationInfos(napi_env env, napi_value value,
2353 const std::vector<RecoverableApplicationInfo> &recoverableApplications)
2354 {
2355 if (recoverableApplications.empty()) {
2356 APP_LOGD("recoverableApplications is empty");
2357 return;
2358 }
2359 size_t index = 0;
2360 for (const auto &item : recoverableApplications) {
2361 napi_value objInfo;
2362 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objInfo));
2363 ConvertRecoverableApplicationInfo(env, objInfo, item);
2364 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, value, index, objInfo));
2365 index++;
2366 }
2367 }
2368
ParseShortcutWant(napi_env env, napi_value param, ShortcutIntent &shortcutIntent)2369 bool CommonFunc::ParseShortcutWant(napi_env env, napi_value param, ShortcutIntent &shortcutIntent)
2370 {
2371 napi_valuetype valueType;
2372 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
2373 if (valueType != napi_object) {
2374 return false;
2375 }
2376
2377 napi_value prop = nullptr;
2378 // parse targetBundle
2379 napi_get_named_property(env, param, "targetBundle", &prop);
2380 std::string targetBundle;
2381 if (!ParseString(env, prop, targetBundle)) {
2382 return false;
2383 }
2384 shortcutIntent.targetBundle = targetBundle;
2385
2386 // parse targetModule
2387 napi_get_named_property(env, param, "targetModule", &prop);
2388 std::string targetModule;
2389 if (!ParseString(env, prop, targetModule)) {
2390 targetModule = "";
2391 }
2392 shortcutIntent.targetModule = targetModule;
2393
2394 // parse targetAbility
2395 napi_get_named_property(env, param, "targetAbility", &prop);
2396 std::string targetAbility;
2397 if (!ParseString(env, prop, targetAbility)) {
2398 return false;
2399 }
2400 shortcutIntent.targetClass = targetAbility;
2401
2402 // parse parameters
2403 napi_get_named_property(env, param, "parameters", &prop);
2404 std::map<std::string, std::string> parameters;
2405 if (!ParseParameters(env, prop, parameters)) {
2406 parameters.clear();
2407 }
2408 shortcutIntent.parameters = parameters;
2409 return true;
2410 }
2411
ParseShortcutWantArray( napi_env env, napi_value args, std::vector<ShortcutIntent> &shortcutIntents)2412 bool CommonFunc::ParseShortcutWantArray(
2413 napi_env env, napi_value args, std::vector<ShortcutIntent> &shortcutIntents)
2414 {
2415 APP_LOGD("begin to ParseShortcutWantArray");
2416 bool isArray = false;
2417 NAPI_CALL_BASE(env, napi_is_array(env, args, &isArray), false);
2418 if (!isArray) {
2419 return false;
2420 }
2421 uint32_t arrayLength = 0;
2422 NAPI_CALL_BASE(env, napi_get_array_length(env, args, &arrayLength), false);
2423 APP_LOGD("length=%{public}ud", arrayLength);
2424 for (uint32_t j = 0; j < arrayLength; j++) {
2425 ShortcutIntent shortcutIntent;
2426 napi_value value = nullptr;
2427 NAPI_CALL_BASE(env, napi_get_element(env, args, j, &value), false);
2428 if (!ParseShortcutWant(env, value, shortcutIntent)) {
2429 return false;
2430 }
2431 shortcutIntents.push_back(shortcutIntent);
2432 }
2433 return true;
2434 }
2435
ParseShortCutInfo(napi_env env, napi_value param, ShortcutInfo &shortcutInfo)2436 bool CommonFunc::ParseShortCutInfo(napi_env env, napi_value param, ShortcutInfo &shortcutInfo)
2437 {
2438 napi_valuetype valueType;
2439 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
2440 if (valueType != napi_object) {
2441 return false;
2442 }
2443
2444 napi_value prop = nullptr;
2445 // parse id
2446 napi_get_named_property(env, param, "id", &prop);
2447 std::string id;
2448 if (!ParseString(env, prop, id)) {
2449 return false;
2450 }
2451 shortcutInfo.id = id;
2452
2453 // parse bundleName
2454 napi_get_named_property(env, param, "bundleName", &prop);
2455 std::string bundleName;
2456 if (!ParseString(env, prop, bundleName)) {
2457 return false;
2458 }
2459 shortcutInfo.bundleName = bundleName;
2460
2461 // parse moduleName
2462 napi_get_named_property(env, param, "moduleName", &prop);
2463 std::string moduleName;
2464 if (!ParseString(env, prop, moduleName)) {
2465 moduleName = "";
2466 }
2467 shortcutInfo.moduleName = moduleName;
2468
2469 // parse hostAbility
2470 napi_get_named_property(env, param, "hostAbility", &prop);
2471 std::string hostAbility;
2472 if (!ParseString(env, prop, hostAbility)) {
2473 hostAbility = "";
2474 }
2475 shortcutInfo.hostAbility = hostAbility;
2476
2477 // parse icon
2478 napi_get_named_property(env, param, "icon", &prop);
2479 std::string icon;
2480 if (!ParseString(env, prop, icon)) {
2481 icon = "";
2482 }
2483 shortcutInfo.icon = icon;
2484
2485 // parse iconId
2486 napi_get_named_property(env, param, "iconId", &prop);
2487 uint32_t iconId;
2488 if (!ParseUint(env, prop, iconId)) {
2489 iconId = 0;
2490 }
2491 shortcutInfo.iconId = iconId;
2492
2493 // parse label
2494 napi_get_named_property(env, param, "label", &prop);
2495 std::string label;
2496 if (!ParseString(env, prop, label)) {
2497 label = "";
2498 }
2499 shortcutInfo.label = label;
2500
2501 // parse labelId
2502 napi_get_named_property(env, param, "labelId", &prop);
2503 uint32_t labelId;
2504 if (!ParseUint(env, prop, labelId)) {
2505 labelId = 0;
2506 }
2507 shortcutInfo.labelId = labelId;
2508
2509 // parse labelId
2510 napi_get_named_property(env, param, "wants", &prop);
2511 std::vector<ShortcutIntent> intents;
2512 if (!ParseShortcutWantArray(env, prop, intents)) {
2513 intents.clear();
2514 }
2515 shortcutInfo.intents = intents;
2516
2517 // parse appIndex
2518 napi_get_named_property(env, param, "appIndex", &prop);
2519 int32_t appIndex;
2520 if (!ParseInt(env, prop, appIndex)) {
2521 appIndex = -1;
2522 }
2523 shortcutInfo.appIndex = appIndex;
2524
2525 // parse sourceType
2526 napi_get_named_property(env, param, "sourceType", &prop);
2527 int32_t sourceType;
2528 if (!ParseInt(env, prop, sourceType)) {
2529 sourceType = -1;
2530 }
2531 shortcutInfo.sourceType = sourceType;
2532 return true;
2533 }
2534
CheckShortcutInfo(const ShortcutInfo &shortcutInfo)2535 bool CommonFunc::CheckShortcutInfo(const ShortcutInfo &shortcutInfo)
2536 {
2537 if (shortcutInfo.appIndex < 0 || shortcutInfo.sourceType == -1) {
2538 return false;
2539 }
2540 return true;
2541 }
2542
ParseParameters( napi_env env, napi_value args, std::map<std::string, std::string> ¶meters)2543 bool CommonFunc::ParseParameters(
2544 napi_env env, napi_value args, std::map<std::string, std::string> ¶meters)
2545 {
2546 bool isArray = false;
2547 NAPI_CALL_BASE(env, napi_is_array(env, args, &isArray), false);
2548 if (!isArray) {
2549 return false;
2550 }
2551 uint32_t arrayLength = 0;
2552 NAPI_CALL_BASE(env, napi_get_array_length(env, args, &arrayLength), false);
2553 APP_LOGD("length=%{public}ud", arrayLength);
2554 for (uint32_t j = 0; j < arrayLength; j++) {
2555 std::string nKey;
2556 std::string nValue;
2557 napi_value value = nullptr;
2558 NAPI_CALL_BASE(env, napi_get_element(env, args, j, &value), false);
2559 if (!ParseParameterItem(env, value, nKey, nValue)) {
2560 return false;
2561 }
2562 parameters[nKey] = nValue;
2563 }
2564 return true;
2565 }
2566
ParseParameterItem(napi_env env, napi_value param, std::string &key, std::string &value)2567 bool CommonFunc::ParseParameterItem(napi_env env, napi_value param, std::string &key, std::string &value)
2568 {
2569 napi_valuetype valueType;
2570 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
2571 if (valueType != napi_object) {
2572 return false;
2573 }
2574
2575 napi_value prop = nullptr;
2576 // parse key
2577 napi_get_named_property(env, param, "key", &prop);
2578 if (!ParseString(env, prop, key)) {
2579 return false;
2580 }
2581
2582 // parse value
2583 napi_get_named_property(env, param, "value", &prop);
2584 if (!ParseString(env, prop, value)) {
2585 return false;
2586 }
2587 return true;
2588 }
2589 } // AppExecFwk
2590 } // OHOS
2591