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