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