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