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