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