1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "common_func.h"
16
17 #include <vector>
18
19 #include "app_log_wrapper.h"
20 #include "appexecfwk_errors.h"
21 #include "bundle_errors.h"
22 #include "bundle_mgr_interface.h"
23 #include "bundle_mgr_proxy.h"
24 #include "iservice_registry.h"
25 #include "napi/native_api.h"
26 #include "napi/native_common.h"
27 #include "napi/native_node_api.h"
28 #include "system_ability_definition.h"
29 #include "want.h"
30
31 namespace OHOS {
32 namespace AppExecFwk {
33 namespace {
34 constexpr int32_t NAPI_RETURN_ZERO = 0;
35 constexpr int32_t NAPI_RETURN_ONE = 1;
36 constexpr const char* BUNDLE_NAME = "bundleName";
37 constexpr const char* MODULE_NAME = "moduleName";
38 constexpr const char* ABILITY_NAME = "abilityName";
39 constexpr const char* TARGET_MODULE_NAME = "targetModuleName";
40 constexpr const char* URI = "uri";
41 constexpr const char* TYPE = "type";
42 constexpr const char* ACTION = "action";
43 constexpr const char* ENTITIES = "entities";
44 constexpr const char* FLAGS = "flags";
45 constexpr const char* DEVICE_ID = "deviceId";
46 constexpr const char* NAME = "name";
47 constexpr const char* IS_VISIBLE = "isVisible";
48 constexpr const char* EXPORTED = "exported";
49 constexpr const char* PERMISSIONS = "permissions";
50 constexpr const char* META_DATA = "metadata";
51 constexpr const char* ENABLED = "enabled";
52 constexpr const char* READ_PERMISSION = "readPermission";
53 constexpr const char* WRITE_PERMISSION = "writePermission";
54 constexpr const char* LABEL = "label";
55 constexpr const char* LABEL_ID = "labelId";
56 constexpr const char* DESCRIPTION = "description";
57 constexpr const char* DESCRIPTION_ID = "descriptionId";
58 constexpr const char* ICON = "icon";
59 constexpr const char* ICON_ID = "iconId";
60 constexpr const char* APPLICATION_INFO = "applicationInfo";
61 constexpr const char* PRIORITY = "priority";
62 constexpr const char* STATE = "state";
63 constexpr const char* DEBUG = "debug";
64
65 static std::unordered_map<int32_t, int32_t> ERR_MAP = {
66 { ERR_OK, SUCCESS },
67 { ERR_BUNDLE_MANAGER_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
68 { ERR_BUNDLE_MANAGER_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
69 { ERR_BUNDLE_MANAGER_BUNDLE_NOT_EXIST, ERROR_BUNDLE_NOT_EXIST },
70 { ERR_BUNDLE_MANAGER_MODULE_NOT_EXIST, ERROR_MODULE_NOT_EXIST },
71 { ERR_BUNDLE_MANAGER_ABILITY_NOT_EXIST, ERROR_ABILITY_NOT_EXIST },
72 { ERR_BUNDLE_MANAGER_INVALID_USER_ID, ERROR_INVALID_USER_ID },
73 { ERR_BUNDLE_MANAGER_QUERY_PERMISSION_DEFINE_FAILED, ERROR_PERMISSION_NOT_EXIST },
74 { ERR_BUNDLE_MANAGER_DEVICE_ID_NOT_EXIST, ERROR_DEVICE_ID_NOT_EXIST },
75 { ERR_BUNDLE_MANAGER_INVALID_UID, ERROR_INVALID_UID },
76 { ERR_BUNDLE_MANAGER_INVALID_HAP_PATH, ERROR_INVALID_HAP_PATH },
77 { ERR_BUNDLE_MANAGER_DEFAULT_APP_NOT_EXIST, ERROR_DEFAULT_APP_NOT_EXIST },
78 { ERR_BUNDLE_MANAGER_INVALID_TYPE, ERROR_INVALID_TYPE },
79 { ERR_BUNDLE_MANAGER_ABILITY_AND_TYPE_MISMATCH, ERROR_ABILITY_AND_TYPE_MISMATCH },
80 { ERR_BUNDLE_MANAGER_PROFILE_NOT_EXIST, ERROR_PROFILE_NOT_EXIST },
81 { ERR_BUNDLE_MANAGER_APPLICATION_DISABLED, ERROR_BUNDLE_IS_DISABLED },
82 { ERROR_DISTRIBUTED_SERVICE_NOT_RUNNING, ERROR_DISTRIBUTED_SERVICE_NOT_RUNNING },
83 { ERR_BUNDLE_MANAGER_ABILITY_DISABLED, ERROR_ABILITY_IS_DISABLED },
84 { ERR_BUNDLE_MANAGER_CAN_NOT_CLEAR_USER_DATA, ERROR_CLEAR_CACHE_FILES_UNSUPPORTED },
85 { ERR_ZLIB_SRC_FILE_DISABLED, ERR_ZLIB_SRC_FILE_INVALID },
86 { ERR_ZLIB_DEST_FILE_DISABLED, ERR_ZLIB_DEST_FILE_INVALID },
87 { ERR_BUNDLE_MANAGER_SYSTEM_API_DENIED, ERROR_NOT_SYSTEM_APP },
88 { ERR_BUNDLEMANAGER_OVERLAY_SET_OVERLAY_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
89 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_BUNDLE, ERROR_BUNDLE_NOT_EXIST },
90 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_BUNDLE, ERROR_SPECIFIED_BUNDLE_NOT_OVERLAY_BUNDLE },
91 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_MISSING_OVERLAY_MODULE, ERROR_MODULE_NOT_EXIST },
92 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_NON_OVERLAY_MODULE, ERROR_SPECIFIED_MODULE_NOT_OVERLAY_MODULE },
93 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_IS_OVERLAY_MODULE,
94 ERROR_SPECIFIED_MODULE_IS_OVERLAY_MODULE },
95 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_MODULE_NOT_EXISTED, ERROR_MODULE_NOT_EXIST },
96 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_BUNDLE_NOT_INSTALLED_AT_SPECIFIED_USERID,
97 ERROR_BUNDLE_NOT_EXIST },
98 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_IS_OVERLAY_BUNDLE,
99 ERROR_SPECIFIED_BUNDLE_IS_OVERLAY_BUNDLE },
100 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PARAM_ERROR, ERROR_PARAM_CHECK_ERROR },
101 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_TARGET_BUNDLE_NOT_EXISTED, ERROR_BUNDLE_NOT_EXIST },
102 { ERR_BUNDLEMANAGER_OVERLAY_QUERY_FAILED_PERMISSION_DENIED, ERROR_PERMISSION_DENIED_ERROR },
103 { ERR_ZLIB_SRC_FILE_FORMAT_ERROR, ERR_ZLIB_SRC_FILE_FORMAT_ERROR_OR_DAMAGED },
104 };
105 }
106 using Want = OHOS::AAFwk::Want;
107
108 sptr<IBundleMgr> CommonFunc::bundleMgr_ = nullptr;
109 std::mutex CommonFunc::bundleMgrMutex_;
110
WrapVoidToJS(napi_env env)111 napi_value CommonFunc::WrapVoidToJS(napi_env env)
112 {
113 napi_value result = nullptr;
114 NAPI_CALL(env, napi_get_null(env, &result));
115 return result;
116 }
117
ParseInt(napi_env env,napi_value args,int32_t & param)118 bool CommonFunc::ParseInt(napi_env env, napi_value args, int32_t ¶m)
119 {
120 napi_valuetype valuetype = napi_undefined;
121 napi_typeof(env, args, &valuetype);
122 if (valuetype != napi_number) {
123 APP_LOGD("Wrong argument type. int32 expected.");
124 return false;
125 }
126 int32_t value = 0;
127 if (napi_get_value_int32(env, args, &value) != napi_ok) {
128 APP_LOGD("napi_get_value_int32 failed.");
129 return false;
130 }
131 param = value;
132 return true;
133 }
134
ParsePropertyArray(napi_env env,napi_value args,const std::string & propertyName,std::vector<napi_value> & valueVec)135 bool CommonFunc::ParsePropertyArray(napi_env env, napi_value args, const std::string &propertyName,
136 std::vector<napi_value> &valueVec)
137 {
138 napi_valuetype type = napi_undefined;
139 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
140 if (type != napi_object) {
141 return false;
142 }
143
144 bool hasKey = false;
145 napi_has_named_property(env, args, propertyName.c_str(), &hasKey);
146 if (!hasKey) {
147 APP_LOGW("%{public}s is not existed", propertyName.c_str());
148 return true;
149 }
150 napi_value property = nullptr;
151 napi_status status = napi_get_named_property(env, args, propertyName.c_str(), &property);
152 if (status != napi_ok) {
153 return false;
154 }
155 bool isArray = false;
156 NAPI_CALL_BASE(env, napi_is_array(env, property, &isArray), false);
157 if (!isArray) {
158 return false;
159 }
160 uint32_t arrayLength = 0;
161 NAPI_CALL_BASE(env, napi_get_array_length(env, property, &arrayLength), false);
162 APP_LOGD("ParseHashParams property is array, length=%{public}ud", arrayLength);
163
164 napi_value valueAry = 0;
165 for (uint32_t j = 0; j < arrayLength; j++) {
166 NAPI_CALL_BASE(env, napi_get_element(env, property, j, &valueAry), false);
167 valueVec.emplace_back(valueAry);
168 }
169 return true;
170 }
171
ParseStringPropertyFromObject(napi_env env,napi_value args,const std::string & propertyName,bool isNecessary,std::string & value)172 bool CommonFunc::ParseStringPropertyFromObject(napi_env env, napi_value args, const std::string &propertyName,
173 bool isNecessary, std::string &value)
174 {
175 napi_valuetype type = napi_undefined;
176 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
177 if (type != napi_object) {
178 return false;
179 }
180 bool hasKey = false;
181 napi_has_named_property(env, args, propertyName.c_str(), &hasKey);
182 if (!hasKey) {
183 if (isNecessary) {
184 APP_LOGE("%{public}s is not existed", propertyName.c_str());
185 return false;
186 }
187 return true;
188 }
189 napi_value property = nullptr;
190 napi_status status = napi_get_named_property(env, args, propertyName.c_str(), &property);
191 if (status != napi_ok) {
192 return false;
193 }
194 napi_typeof(env, property, &type);
195 if (type != napi_string) {
196 return false;
197 }
198 if (property == nullptr) {
199 return false;
200 }
201 if (!CommonFunc::ParseString(env, property, value)) {
202 APP_LOGE("parse string failed");
203 return false;
204 }
205 return true;
206 }
207
ParsePropertyFromObject(napi_env env,napi_value args,const PropertyInfo & propertyInfo,napi_value & property)208 bool CommonFunc::ParsePropertyFromObject(napi_env env, napi_value args, const PropertyInfo &propertyInfo,
209 napi_value &property)
210 {
211 napi_valuetype type = napi_undefined;
212 NAPI_CALL_BASE(env, napi_typeof(env, args, &type), false);
213 if (type != napi_object) {
214 return false;
215 }
216 bool hasKey = false;
217 napi_has_named_property(env, args, propertyInfo.propertyName.c_str(), &hasKey);
218 if (!hasKey) {
219 if (propertyInfo.isNecessary) {
220 APP_LOGE("%{public}s is not existed", propertyInfo.propertyName.c_str());
221 return false;
222 }
223 return true;
224 }
225
226 napi_status status = napi_get_named_property(env, args, propertyInfo.propertyName.c_str(), &property);
227 if (status != napi_ok) {
228 return false;
229 }
230 napi_typeof(env, property, &type);
231 if (type != propertyInfo.propertyType) {
232 return false;
233 }
234 if (property == nullptr) {
235 return false;
236 }
237 return true;
238 }
239
ParseBool(napi_env env,napi_value value,bool & result)240 bool CommonFunc::ParseBool(napi_env env, napi_value value, bool& result)
241 {
242 napi_valuetype valueType = napi_undefined;
243 napi_typeof(env, value, &valueType);
244 if (valueType != napi_boolean) {
245 return false;
246 }
247 if (napi_get_value_bool(env, value, &result) != napi_ok) {
248 return false;
249 }
250 return true;
251 }
252
ParseString(napi_env env,napi_value value,std::string & result)253 bool CommonFunc::ParseString(napi_env env, napi_value value, std::string& result)
254 {
255 napi_valuetype valueType = napi_undefined;
256 napi_typeof(env, value, &valueType);
257 if (valueType != napi_string) {
258 return false;
259 }
260 size_t size = 0;
261 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
262 return false;
263 }
264 result.reserve(size + 1);
265 result.resize(size);
266 if (napi_get_value_string_utf8(env, value, result.data(), (size + 1), &size) != napi_ok) {
267 return false;
268 }
269 return true;
270 }
271
ParseAbilityInfo(napi_env env,napi_value param,AbilityInfo & abilityInfo)272 bool CommonFunc::ParseAbilityInfo(napi_env env, napi_value param, AbilityInfo& abilityInfo)
273 {
274 napi_valuetype valueType;
275 NAPI_CALL_BASE(env, napi_typeof(env, param, &valueType), false);
276 if (valueType != napi_object) {
277 return false;
278 }
279
280 napi_value prop = nullptr;
281 // parse bundleName
282 napi_get_named_property(env, param, "bundleName", &prop);
283 std::string bundleName;
284 if (!ParseString(env, prop, bundleName)) {
285 return false;
286 }
287 abilityInfo.bundleName = bundleName;
288
289 // parse moduleName
290 napi_get_named_property(env, param, "moduleName", &prop);
291 std::string moduleName;
292 if (!ParseString(env, prop, moduleName)) {
293 return false;
294 }
295 abilityInfo.moduleName = moduleName;
296
297 // parse abilityName
298 napi_get_named_property(env, param, "name", &prop);
299 std::string abilityName;
300 if (!ParseString(env, prop, abilityName)) {
301 return false;
302 }
303 abilityInfo.name = abilityName;
304 return true;
305 }
306
GetBundleMgr()307 sptr<IBundleMgr> CommonFunc::GetBundleMgr()
308 {
309 std::lock_guard<std::mutex> lock(bundleMgrMutex_);
310 if (bundleMgr_ == nullptr) {
311 auto systemAbilityManager = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
312 if (systemAbilityManager == nullptr) {
313 APP_LOGE("systemAbilityManager is null.");
314 return nullptr;
315 }
316 auto bundleMgrSa = systemAbilityManager->GetSystemAbility(OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
317 if (bundleMgrSa == nullptr) {
318 APP_LOGE("bundleMgrSa is null.");
319 return nullptr;
320 }
321 bundleMgr_ = OHOS::iface_cast<IBundleMgr>(bundleMgrSa);
322 if (bundleMgr_ == nullptr) {
323 APP_LOGE("iface_cast failed.");
324 return nullptr;
325 }
326 }
327 return bundleMgr_;
328 }
329
GetBundleInstaller()330 sptr<IBundleInstaller> CommonFunc::GetBundleInstaller()
331 {
332 auto iBundleMgr = GetBundleMgr();
333 if (iBundleMgr == nullptr) {
334 APP_LOGE("can not get iBundleMgr");
335 return nullptr;
336 }
337 return iBundleMgr->GetBundleInstaller();
338 }
339
GetStringFromNAPI(napi_env env,napi_value value)340 std::string CommonFunc::GetStringFromNAPI(napi_env env, napi_value value)
341 {
342 napi_valuetype valueType = napi_undefined;
343 napi_typeof(env, value, &valueType);
344 if (valueType != napi_string) {
345 return "";
346 }
347 std::string result;
348 size_t size = 0;
349
350 if (napi_get_value_string_utf8(env, value, nullptr, NAPI_RETURN_ZERO, &size) != napi_ok) {
351 return "";
352 }
353 result.reserve(size + NAPI_RETURN_ONE);
354 result.resize(size);
355 if (napi_get_value_string_utf8(env, value, result.data(), (size + NAPI_RETURN_ONE), &size) != napi_ok) {
356 return "";
357 }
358 return result;
359 }
360
ParseStringArray(napi_env env,std::vector<std::string> & stringArray,napi_value args)361 napi_value CommonFunc::ParseStringArray(napi_env env, std::vector<std::string> &stringArray, napi_value args)
362 {
363 APP_LOGD("begin to parse string array");
364 bool isArray = false;
365 NAPI_CALL(env, napi_is_array(env, args, &isArray));
366 if (!isArray) {
367 return nullptr;
368 }
369 uint32_t arrayLength = 0;
370 NAPI_CALL(env, napi_get_array_length(env, args, &arrayLength));
371 APP_LOGD("length=%{public}ud", arrayLength);
372 for (uint32_t j = 0; j < arrayLength; j++) {
373 napi_value value = nullptr;
374 NAPI_CALL(env, napi_get_element(env, args, j, &value));
375 napi_valuetype valueType = napi_undefined;
376 NAPI_CALL(env, napi_typeof(env, value, &valueType));
377 if (valueType != napi_string) {
378 stringArray.clear();
379 return nullptr;
380 }
381 stringArray.push_back(GetStringFromNAPI(env, value));
382 }
383 // create result code
384 napi_value result;
385 napi_status status = napi_create_int32(env, NAPI_RETURN_ONE, &result);
386 if (status != napi_ok) {
387 return nullptr;
388 }
389 return result;
390 }
391
ConvertWantInfo(napi_env env,napi_value objWantInfo,const Want & want)392 void CommonFunc::ConvertWantInfo(napi_env env, napi_value objWantInfo, const Want &want)
393 {
394 ElementName elementName = want.GetElement();
395 napi_value nbundleName;
396 NAPI_CALL_RETURN_VOID(
397 env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &nbundleName));
398 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "bundleName", nbundleName));
399
400 napi_value ndeviceId;
401 NAPI_CALL_RETURN_VOID(
402 env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &ndeviceId));
403 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "deviceId", ndeviceId));
404
405 napi_value nabilityName;
406 NAPI_CALL_RETURN_VOID(
407 env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &nabilityName));
408 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "abilityName", nabilityName));
409
410 napi_value naction;
411 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, want.GetAction().c_str(), NAPI_AUTO_LENGTH, &naction));
412 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "action", naction));
413
414 auto entities = want.GetEntities();
415 napi_value nGetEntities;
416 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nGetEntities));
417 if (entities.size() > 0) {
418 size_t index = 0;
419 for (const auto &item:entities) {
420 napi_value objEntities;
421 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, item.c_str(), NAPI_AUTO_LENGTH, &objEntities));
422 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nGetEntities, index, objEntities));
423 index++;
424 }
425 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objWantInfo, "entities", nGetEntities));
426 }
427 }
428
ParseElementName(napi_env env,napi_value args,Want & want)429 bool CommonFunc::ParseElementName(napi_env env, napi_value args, Want &want)
430 {
431 APP_LOGD("begin to parse ElementName.");
432 napi_valuetype valueType = napi_undefined;
433 napi_typeof(env, args, &valueType);
434 if (valueType != napi_object) {
435 APP_LOGW("args not object type.");
436 return false;
437 }
438 napi_value prop = nullptr;
439 napi_get_named_property(env, args, "bundleName", &prop);
440 std::string bundleName;
441 ParseString(env, prop, bundleName);
442
443 prop = nullptr;
444 napi_get_named_property(env, args, "moduleName", &prop);
445 std::string moduleName;
446 ParseString(env, prop, moduleName);
447
448 prop = nullptr;
449 napi_get_named_property(env, args, "abilityName", &prop);
450 std::string abilityName;
451 ParseString(env, prop, abilityName);
452
453 APP_LOGD("ParseElementName, bundleName:%{public}s, moduleName: %{public}s, abilityName:%{public}s",
454 bundleName.c_str(), moduleName.c_str(), abilityName.c_str());
455 ElementName elementName("", bundleName, abilityName, moduleName);
456 want.SetElement(elementName);
457 return true;
458 }
459
ConvertElementName(napi_env env,napi_value elementInfo,const OHOS::AppExecFwk::ElementName & elementName)460 void CommonFunc::ConvertElementName(napi_env env, napi_value elementInfo,
461 const OHOS::AppExecFwk::ElementName &elementName)
462 {
463 // wrap deviceId
464 napi_value deviceId;
465 NAPI_CALL_RETURN_VOID(
466 env, napi_create_string_utf8(env, elementName.GetDeviceID().c_str(), NAPI_AUTO_LENGTH, &deviceId));
467 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "deviceId", deviceId));
468
469 // wrap bundleName
470 napi_value bundleName;
471 NAPI_CALL_RETURN_VOID(
472 env, napi_create_string_utf8(env, elementName.GetBundleName().c_str(), NAPI_AUTO_LENGTH, &bundleName));
473 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "bundleName", bundleName));
474
475 // wrap moduleName
476 napi_value moduleName;
477 NAPI_CALL_RETURN_VOID(
478 env, napi_create_string_utf8(env, elementName.GetModuleName().c_str(), NAPI_AUTO_LENGTH, &moduleName));
479 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "moduleName", moduleName));
480
481 // wrap abilityName
482 napi_value abilityName;
483 NAPI_CALL_RETURN_VOID(
484 env, napi_create_string_utf8(env, elementName.GetAbilityName().c_str(), NAPI_AUTO_LENGTH, &abilityName));
485 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "abilityName", abilityName));
486
487 // wrap uri
488 napi_value uri;
489 NAPI_CALL_RETURN_VOID(
490 env, napi_create_string_utf8(env, elementName.GetURI().c_str(), NAPI_AUTO_LENGTH, &uri));
491 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "uri", uri));
492
493 // wrap shortName
494 napi_value shortName;
495 NAPI_CALL_RETURN_VOID(
496 env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &shortName));
497 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, elementInfo, "shortName", shortName));
498 }
499
ConvertErrCode(ErrCode nativeErrCode)500 ErrCode CommonFunc::ConvertErrCode(ErrCode nativeErrCode)
501 {
502 if (ERR_MAP.find(nativeErrCode) != ERR_MAP.end()) {
503 return ERR_MAP.at(nativeErrCode);
504 }
505 return ERROR_BUNDLE_SERVICE_EXCEPTION;
506 }
507
ParseWant(napi_env env,napi_value args,Want & want)508 bool CommonFunc::ParseWant(napi_env env, napi_value args, Want &want)
509 {
510 APP_LOGD("begin to parse want");
511 napi_valuetype valueType;
512 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
513 if (valueType != napi_object) {
514 APP_LOGW("args not object type");
515 return false;
516 }
517 napi_value prop = nullptr;
518 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
519 std::string bundleName = GetStringFromNAPI(env, prop);
520
521 prop = nullptr;
522 napi_get_named_property(env, args, MODULE_NAME, &prop);
523 std::string moduleName = GetStringFromNAPI(env, prop);
524
525 prop = nullptr;
526 napi_get_named_property(env, args, ABILITY_NAME, &prop);
527 std::string abilityName = GetStringFromNAPI(env, prop);
528
529 prop = nullptr;
530 napi_get_named_property(env, args, URI, &prop);
531 std::string uri = GetStringFromNAPI(env, prop);
532
533 prop = nullptr;
534 napi_get_named_property(env, args, TYPE, &prop);
535 std::string type = GetStringFromNAPI(env, prop);
536
537 prop = nullptr;
538 napi_get_named_property(env, args, ACTION, &prop);
539 std::string action = GetStringFromNAPI(env, prop);
540
541 prop = nullptr;
542 napi_get_named_property(env, args, ENTITIES, &prop);
543 std::vector<std::string> entities;
544 ParseStringArray(env, entities, prop);
545 for (size_t idx = 0; idx < entities.size(); ++idx) {
546 APP_LOGD("entity:%{public}s", entities[idx].c_str());
547 want.AddEntity(entities[idx]);
548 }
549
550 prop = nullptr;
551 int32_t flags = 0;
552 napi_get_named_property(env, args, FLAGS, &prop);
553 napi_typeof(env, prop, &valueType);
554 if (valueType == napi_number) {
555 napi_get_value_int32(env, prop, &flags);
556 }
557
558 prop = nullptr;
559 napi_get_named_property(env, args, DEVICE_ID, &prop);
560 std::string deviceId = GetStringFromNAPI(env, prop);
561
562 APP_LOGD("bundleName:%{public}s, moduleName: %{public}s, abilityName:%{public}s",
563 bundleName.c_str(), moduleName.c_str(), abilityName.c_str());
564 APP_LOGD("action:%{public}s, uri:%{private}s, type:%{public}s, flags:%{public}d",
565 action.c_str(), uri.c_str(), type.c_str(), flags);
566 bool isExplicit = !bundleName.empty() && !abilityName.empty();
567 if (!isExplicit && action.empty() && entities.empty() && uri.empty() && type.empty()) {
568 APP_LOGE("implicit params all empty");
569 return false;
570 }
571 want.SetAction(action);
572 want.SetUri(uri);
573 want.SetType(type);
574 want.SetFlags(flags);
575 ElementName elementName(deviceId, bundleName, abilityName, moduleName);
576 want.SetElement(elementName);
577 return true;
578 }
579
ParseWantPerformance(napi_env env,napi_value args,Want & want)580 bool CommonFunc::ParseWantPerformance(napi_env env, napi_value args, Want &want)
581 {
582 APP_LOGD("begin to parse want performance");
583 napi_valuetype valueType;
584 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
585 if (valueType != napi_object) {
586 APP_LOGW("args not object type");
587 return false;
588 }
589 napi_value prop = nullptr;
590 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
591 std::string bundleName = GetStringFromNAPI(env, prop);
592
593 prop = nullptr;
594 napi_get_named_property(env, args, MODULE_NAME, &prop);
595 std::string moduleName = GetStringFromNAPI(env, prop);
596
597 prop = nullptr;
598 napi_get_named_property(env, args, ABILITY_NAME, &prop);
599 std::string abilityName = GetStringFromNAPI(env, prop);
600 if (!bundleName.empty() && !abilityName.empty()) {
601 ElementName elementName("", bundleName, abilityName, moduleName);
602 want.SetElement(elementName);
603 return true;
604 }
605 return ParseWant(env, args, want);
606 }
607
ParseWantWithoutVerification(napi_env env,napi_value args,Want & want)608 bool CommonFunc::ParseWantWithoutVerification(napi_env env, napi_value args, Want &want)
609 {
610 napi_valuetype valueType;
611 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
612 if (valueType != napi_object) {
613 return false;
614 }
615 napi_value prop = nullptr;
616 napi_get_named_property(env, args, BUNDLE_NAME, &prop);
617 std::string bundleName = GetStringFromNAPI(env, prop);
618 prop = nullptr;
619 napi_get_named_property(env, args, MODULE_NAME, &prop);
620 std::string moduleName = GetStringFromNAPI(env, prop);
621 prop = nullptr;
622 napi_get_named_property(env, args, ABILITY_NAME, &prop);
623 std::string abilityName = GetStringFromNAPI(env, prop);
624 prop = nullptr;
625 napi_get_named_property(env, args, URI, &prop);
626 std::string uri = GetStringFromNAPI(env, prop);
627 prop = nullptr;
628 napi_get_named_property(env, args, TYPE, &prop);
629 std::string type = GetStringFromNAPI(env, prop);
630 prop = nullptr;
631 napi_get_named_property(env, args, ACTION, &prop);
632 std::string action = GetStringFromNAPI(env, prop);
633 prop = nullptr;
634 napi_get_named_property(env, args, ENTITIES, &prop);
635 std::vector<std::string> entities;
636 ParseStringArray(env, entities, prop);
637 for (size_t idx = 0; idx < entities.size(); ++idx) {
638 APP_LOGD("entity:%{public}s", entities[idx].c_str());
639 want.AddEntity(entities[idx]);
640 }
641 prop = nullptr;
642 int32_t flags = 0;
643 napi_get_named_property(env, args, FLAGS, &prop);
644 napi_typeof(env, prop, &valueType);
645 if (valueType == napi_number) {
646 napi_get_value_int32(env, prop, &flags);
647 }
648 prop = nullptr;
649 napi_get_named_property(env, args, DEVICE_ID, &prop);
650 std::string deviceId = GetStringFromNAPI(env, prop);
651 want.SetAction(action);
652 want.SetUri(uri);
653 want.SetType(type);
654 want.SetFlags(flags);
655 ElementName elementName(deviceId, bundleName, abilityName, moduleName);
656 want.SetElement(elementName);
657 return true;
658 }
659
ConvertWindowSize(napi_env env,const AbilityInfo & abilityInfo,napi_value value)660 void CommonFunc::ConvertWindowSize(napi_env env, const AbilityInfo &abilityInfo, napi_value value)
661 {
662 napi_value nMaxWindowRatio;
663 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.maxWindowRatio, &nMaxWindowRatio));
664 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowRatio", nMaxWindowRatio));
665
666 napi_value mMinWindowRatio;
667 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, abilityInfo.minWindowRatio, &mMinWindowRatio));
668 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowRatio", mMinWindowRatio));
669
670 napi_value nMaxWindowWidth;
671 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowWidth, &nMaxWindowWidth));
672 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowWidth", nMaxWindowWidth));
673
674 napi_value nMinWindowWidth;
675 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowWidth, &nMinWindowWidth));
676 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowWidth", nMinWindowWidth));
677
678 napi_value nMaxWindowHeight;
679 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.maxWindowHeight, &nMaxWindowHeight));
680 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "maxWindowHeight", nMaxWindowHeight));
681
682 napi_value nMinWindowHeight;
683 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, abilityInfo.minWindowHeight, &nMinWindowHeight));
684 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "minWindowHeight", nMinWindowHeight));
685 }
686
ConvertMetadata(napi_env env,const Metadata & metadata,napi_value value)687 void CommonFunc::ConvertMetadata(napi_env env, const Metadata &metadata, napi_value value)
688 {
689 napi_value nName;
690 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.name.c_str(), NAPI_AUTO_LENGTH, &nName));
691 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
692
693 napi_value nValue;
694 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.value.c_str(), NAPI_AUTO_LENGTH, &nValue));
695 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "value", nValue));
696
697 napi_value nResource;
698 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, metadata.resource.c_str(), NAPI_AUTO_LENGTH, &nResource));
699 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "resource", nResource));
700 }
701
ConvertAbilityInfos(napi_env env,const std::vector<AbilityInfo> & abilityInfos,napi_value value)702 void CommonFunc::ConvertAbilityInfos(napi_env env, const std::vector<AbilityInfo> &abilityInfos, napi_value value)
703 {
704 for (size_t index = 0; index < abilityInfos.size(); ++index) {
705 napi_value objAbilityInfo = nullptr;
706 napi_create_object(env, &objAbilityInfo);
707 ConvertAbilityInfo(env, abilityInfos[index], objAbilityInfo);
708 napi_set_element(env, value, index, objAbilityInfo);
709 }
710 }
711
ConvertAbilityInfo(napi_env env,const AbilityInfo & abilityInfo,napi_value objAbilityInfo)712 void CommonFunc::ConvertAbilityInfo(napi_env env, const AbilityInfo &abilityInfo, napi_value objAbilityInfo)
713 {
714 napi_value nBundleName;
715 NAPI_CALL_RETURN_VOID(
716 env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
717 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, BUNDLE_NAME, nBundleName));
718
719 napi_value nModuleName;
720 NAPI_CALL_RETURN_VOID(
721 env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
722 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, MODULE_NAME, nModuleName));
723
724 napi_value nName;
725 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
726 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, NAME, nName));
727
728 napi_value nLabel;
729 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
730 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, LABEL, nLabel));
731
732 napi_value nLabelId;
733 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.labelId, &nLabelId));
734 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, LABEL_ID, nLabelId));
735
736 napi_value nDescription;
737 NAPI_CALL_RETURN_VOID(
738 env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
739 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, DESCRIPTION, nDescription));
740
741 napi_value nDescriptionId;
742 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.descriptionId, &nDescriptionId));
743 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, DESCRIPTION_ID, nDescriptionId));
744
745 napi_value nIconPath;
746 NAPI_CALL_RETURN_VOID(
747 env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
748 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ICON, nIconPath));
749
750 napi_value nIconId;
751 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, abilityInfo.iconId, &nIconId));
752 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ICON_ID, nIconId));
753
754 napi_value nProcess;
755 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
756 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "process", nProcess));
757
758 napi_value nVisible;
759 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.visible, &nVisible));
760 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, IS_VISIBLE, nVisible));
761
762 napi_value nExported;
763 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.visible, &nExported));
764 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, EXPORTED, nExported));
765
766 napi_value nType;
767 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.type), &nType));
768 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "type", nType));
769
770 napi_value nOrientation;
771 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.orientation), &nOrientation));
772 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "orientation", nOrientation));
773
774 napi_value nLaunchType;
775 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.launchMode), &nLaunchType));
776 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "launchType", nLaunchType));
777
778 napi_value nPermissions;
779 size_t size = abilityInfo.permissions.size();
780 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPermissions));
781 for (size_t idx = 0; idx < size; ++idx) {
782 napi_value nPermission;
783 NAPI_CALL_RETURN_VOID(
784 env, napi_create_string_utf8(env, abilityInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
785 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
786 }
787 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, PERMISSIONS, nPermissions));
788
789 napi_value nReadPermission;
790 NAPI_CALL_RETURN_VOID(
791 env, napi_create_string_utf8(env, abilityInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &nReadPermission));
792 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, READ_PERMISSION, nReadPermission));
793
794 napi_value nWritePermission;
795 NAPI_CALL_RETURN_VOID(
796 env, napi_create_string_utf8(env, abilityInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &nWritePermission));
797 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, WRITE_PERMISSION, nWritePermission));
798
799 napi_value nUri;
800 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, abilityInfo.uri.c_str(), NAPI_AUTO_LENGTH, &nUri));
801 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, URI, nUri));
802
803 napi_value nDeviceTypes;
804 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
805 for (size_t idx = 0; idx < abilityInfo.deviceTypes.size(); ++idx) {
806 napi_value nDeviceType;
807 NAPI_CALL_RETURN_VOID(
808 env, napi_create_string_utf8(env, abilityInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
809 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
810 }
811 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "deviceTypes", nDeviceTypes));
812
813 napi_value nApplicationInfo;
814 if (!abilityInfo.applicationInfo.name.empty()) {
815 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nApplicationInfo));
816 ConvertApplicationInfo(env, nApplicationInfo, abilityInfo.applicationInfo);
817 } else {
818 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nApplicationInfo));
819 }
820 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, APPLICATION_INFO, nApplicationInfo));
821
822 napi_value nMetadata;
823 size = abilityInfo.metadata.size();
824 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
825 for (size_t index = 0; index < size; ++index) {
826 napi_value nMetaData;
827 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
828 ConvertMetadata(env, abilityInfo.metadata[index], nMetaData);
829 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, nMetaData));
830 }
831 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, META_DATA, nMetadata));
832
833 napi_value nEnabled;
834 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, abilityInfo.enabled, &nEnabled));
835 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, ENABLED, nEnabled));
836
837 napi_value nSupportWindowModes;
838 size = abilityInfo.windowModes.size();
839 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSupportWindowModes));
840 for (size_t index = 0; index < size; ++index) {
841 napi_value innerMode;
842 NAPI_CALL_RETURN_VOID(env,
843 napi_create_int32(env, static_cast<int32_t>(abilityInfo.windowModes[index]), &innerMode));
844 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSupportWindowModes, index, innerMode));
845 }
846 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "supportWindowModes", nSupportWindowModes));
847
848 napi_value nWindowSize;
849 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nWindowSize));
850 ConvertWindowSize(env, abilityInfo, nWindowSize);
851 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAbilityInfo, "windowSize", nWindowSize));
852 }
853
ConvertExtensionInfos(napi_env env,const std::vector<ExtensionAbilityInfo> & extensionInfos,napi_value value)854 void CommonFunc::ConvertExtensionInfos(napi_env env, const std::vector<ExtensionAbilityInfo> &extensionInfos,
855 napi_value value)
856 {
857 for (size_t index = 0; index < extensionInfos.size(); ++index) {
858 napi_value objExtensionInfo = nullptr;
859 napi_create_object(env, &objExtensionInfo);
860 ConvertExtensionInfo(env, extensionInfos[index], objExtensionInfo);
861 napi_set_element(env, value, index, objExtensionInfo);
862 }
863 }
864
ConvertStringArrays(napi_env env,const std::vector<std::string> & strs,napi_value value)865 void CommonFunc::ConvertStringArrays(napi_env env, const std::vector<std::string> &strs, napi_value value)
866 {
867 for (size_t index = 0; index < strs.size(); ++index) {
868 napi_value nStr;
869 NAPI_CALL_RETURN_VOID(
870 env, napi_create_string_utf8(env, strs[index].c_str(), NAPI_AUTO_LENGTH, &nStr));
871 napi_set_element(env, value, index, nStr);
872 }
873 }
874
ConvertValidity(napi_env env,const Validity & validity,napi_value objValidity)875 void CommonFunc::ConvertValidity(napi_env env, const Validity &validity, napi_value objValidity)
876 {
877 napi_value notBefore;
878 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, validity.notBefore, ¬Before));
879 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objValidity, "notBefore", notBefore));
880
881 napi_value notAfter;
882 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, validity.notAfter, ¬After));
883 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objValidity, "notAfter", notAfter));
884 }
885
ConvertAppProvisionInfo(napi_env env,const AppProvisionInfo & appProvisionInfo,napi_value objAppProvisionInfo)886 void CommonFunc::ConvertAppProvisionInfo(
887 napi_env env, const AppProvisionInfo &appProvisionInfo, napi_value objAppProvisionInfo)
888 {
889 napi_value versionCode;
890 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appProvisionInfo.versionCode, &versionCode));
891 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "versionCode", versionCode));
892
893 napi_value versionName;
894 NAPI_CALL_RETURN_VOID(
895 env, napi_create_string_utf8(env, appProvisionInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &versionName));
896 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "versionName", versionName));
897
898 napi_value uuid;
899 NAPI_CALL_RETURN_VOID(
900 env, napi_create_string_utf8(env, appProvisionInfo.uuid.c_str(), NAPI_AUTO_LENGTH, &uuid));
901 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "uuid", uuid));
902
903 napi_value type;
904 NAPI_CALL_RETURN_VOID(
905 env, napi_create_string_utf8(env, appProvisionInfo.type.c_str(), NAPI_AUTO_LENGTH, &type));
906 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "type", type));
907
908 napi_value appDistributionType;
909 NAPI_CALL_RETURN_VOID(
910 env, napi_create_string_utf8(env, appProvisionInfo.appDistributionType.c_str(),
911 NAPI_AUTO_LENGTH, &appDistributionType));
912 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "appDistributionType",
913 appDistributionType));
914
915 napi_value developerId;
916 NAPI_CALL_RETURN_VOID(
917 env, napi_create_string_utf8(env, appProvisionInfo.developerId.c_str(), NAPI_AUTO_LENGTH, &developerId));
918 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "developerId", developerId));
919
920 napi_value certificate;
921 NAPI_CALL_RETURN_VOID(
922 env, napi_create_string_utf8(env, appProvisionInfo.certificate.c_str(), NAPI_AUTO_LENGTH, &certificate));
923 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "certificate", certificate));
924
925 napi_value apl;
926 NAPI_CALL_RETURN_VOID(
927 env, napi_create_string_utf8(env, appProvisionInfo.apl.c_str(), NAPI_AUTO_LENGTH, &apl));
928 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "apl", apl));
929
930 napi_value issuer;
931 NAPI_CALL_RETURN_VOID(
932 env, napi_create_string_utf8(env, appProvisionInfo.issuer.c_str(), NAPI_AUTO_LENGTH, &issuer));
933 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "issuer", issuer));
934
935 napi_value validity;
936 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &validity));
937 ConvertValidity(env, appProvisionInfo.validity, validity);
938 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppProvisionInfo, "validity", validity));
939 }
940
ConvertExtensionInfo(napi_env env,const ExtensionAbilityInfo & extensionInfo,napi_value objExtensionInfo)941 void CommonFunc::ConvertExtensionInfo(napi_env env, const ExtensionAbilityInfo &extensionInfo,
942 napi_value objExtensionInfo)
943 {
944 napi_value nBundleName;
945 NAPI_CALL_RETURN_VOID(
946 env, napi_create_string_utf8(env, extensionInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
947 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, BUNDLE_NAME, nBundleName));
948
949 napi_value nModuleName;
950 NAPI_CALL_RETURN_VOID(
951 env, napi_create_string_utf8(env, extensionInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
952 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, MODULE_NAME, nModuleName));
953
954 napi_value nName;
955 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, extensionInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
956 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, NAME, nName));
957
958 napi_value nLabelId;
959 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.labelId, &nLabelId));
960 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, LABEL_ID, nLabelId));
961
962 napi_value nDescriptionId;
963 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.descriptionId, &nDescriptionId));
964 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, DESCRIPTION_ID, nDescriptionId));
965
966 napi_value nIconId;
967 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, extensionInfo.iconId, &nIconId));
968 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, ICON_ID, nIconId));
969
970 napi_value nVisible;
971 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.visible, &nVisible));
972 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, IS_VISIBLE, nVisible));
973
974 napi_value nExported;
975 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.visible, &nExported));
976 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, EXPORTED, nExported));
977
978 napi_value nExtensionAbilityType;
979 NAPI_CALL_RETURN_VOID(
980 env, napi_create_int32(env, static_cast<int32_t>(extensionInfo.type), &nExtensionAbilityType));
981 NAPI_CALL_RETURN_VOID(env,
982 napi_set_named_property(env, objExtensionInfo, "extensionAbilityType", nExtensionAbilityType));
983
984 napi_value nPermissions;
985 size_t size = extensionInfo.permissions.size();
986 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPermissions));
987 for (size_t i = 0; i < size; ++i) {
988 napi_value permission;
989 NAPI_CALL_RETURN_VOID(
990 env, napi_create_string_utf8(env, extensionInfo.permissions[i].c_str(), NAPI_AUTO_LENGTH, &permission));
991 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, i, permission));
992 }
993 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, PERMISSIONS, nPermissions));
994
995 napi_value nApplicationInfo;
996 if (!extensionInfo.applicationInfo.name.empty()) {
997 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nApplicationInfo));
998 ConvertApplicationInfo(env, nApplicationInfo, extensionInfo.applicationInfo);
999 } else {
1000 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nApplicationInfo));
1001 }
1002 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, APPLICATION_INFO, nApplicationInfo));
1003
1004 napi_value nMetadata;
1005 size = extensionInfo.metadata.size();
1006 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
1007 for (size_t i = 0; i < size; ++i) {
1008 napi_value nMetaData;
1009 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
1010 ConvertMetadata(env, extensionInfo.metadata[i], nMetaData);
1011 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, i, nMetaData));
1012 }
1013 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, META_DATA, nMetadata));
1014
1015 napi_value nEnabled;
1016 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, extensionInfo.enabled, &nEnabled));
1017 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, ENABLED, nEnabled));
1018
1019 napi_value nReadPermission;
1020 NAPI_CALL_RETURN_VOID(
1021 env, napi_create_string_utf8(env, extensionInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &nReadPermission));
1022 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, READ_PERMISSION, nReadPermission));
1023
1024 napi_value nWritePermission;
1025 NAPI_CALL_RETURN_VOID(
1026 env, napi_create_string_utf8(env, extensionInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &nWritePermission));
1027 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objExtensionInfo, WRITE_PERMISSION, nWritePermission));
1028 }
1029
1030
ConvertResource(napi_env env,const Resource & resource,napi_value objResource)1031 void CommonFunc::ConvertResource(napi_env env, const Resource &resource, napi_value objResource)
1032 {
1033 napi_value nBundleName;
1034 NAPI_CALL_RETURN_VOID(
1035 env, napi_create_string_utf8(env, resource.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1036 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, BUNDLE_NAME, nBundleName));
1037
1038 napi_value nModuleName;
1039 NAPI_CALL_RETURN_VOID(
1040 env, napi_create_string_utf8(env, resource.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1041 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, MODULE_NAME, nModuleName));
1042
1043 napi_value nId;
1044 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, resource.id, &nId));
1045 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objResource, "id", nId));
1046 }
1047
ConvertApplicationInfo(napi_env env,napi_value objAppInfo,const ApplicationInfo & appInfo)1048 void CommonFunc::ConvertApplicationInfo(napi_env env, napi_value objAppInfo, const ApplicationInfo &appInfo)
1049 {
1050 napi_value nName;
1051 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1052 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, NAME, nName));
1053 APP_LOGD("ConvertApplicationInfo name=%{public}s.", appInfo.name.c_str());
1054
1055 napi_value nBundleType;
1056 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(appInfo.bundleType), &nBundleType));
1057 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "bundleType", nBundleType));
1058
1059 napi_value nDebug;
1060 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.debug, &nDebug));
1061 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DEBUG, nDebug));
1062
1063 napi_value nDescription;
1064 NAPI_CALL_RETURN_VOID(
1065 env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1066 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION, nDescription));
1067
1068 napi_value nDescriptionId;
1069 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.descriptionId, &nDescriptionId));
1070 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, DESCRIPTION_ID, nDescriptionId));
1071
1072 napi_value nEnabled;
1073 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.enabled, &nEnabled));
1074 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ENABLED, nEnabled));
1075
1076 napi_value nLabel;
1077 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
1078 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL, nLabel));
1079
1080 napi_value nLabelId;
1081 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.labelId, &nLabelId));
1082 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, LABEL_ID, nLabelId));
1083
1084 napi_value nIconPath;
1085 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIconPath));
1086 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON, nIconPath));
1087
1088 napi_value nIconId;
1089 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.iconId, &nIconId));
1090 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, ICON_ID, nIconId));
1091
1092 napi_value nProcess;
1093 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &nProcess));
1094 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "process", nProcess));
1095
1096 napi_value nPermissions;
1097 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nPermissions));
1098 for (size_t idx = 0; idx < appInfo.permissions.size(); idx++) {
1099 napi_value nPermission;
1100 NAPI_CALL_RETURN_VOID(
1101 env, napi_create_string_utf8(env, appInfo.permissions[idx].c_str(), NAPI_AUTO_LENGTH, &nPermission));
1102 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPermissions, idx, nPermission));
1103 }
1104 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, PERMISSIONS, nPermissions));
1105
1106 napi_value nEntryDir;
1107 NAPI_CALL_RETURN_VOID(
1108 env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &nEntryDir));
1109 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "entryDir", nEntryDir));
1110
1111 napi_value nCodePath;
1112 NAPI_CALL_RETURN_VOID(
1113 env, napi_create_string_utf8(env, appInfo.codePath.c_str(), NAPI_AUTO_LENGTH, &nCodePath));
1114 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "codePath", nCodePath));
1115
1116 napi_value nMetaData;
1117 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nMetaData));
1118 for (const auto &item : appInfo.metadata) {
1119 napi_value nmetaDataArray;
1120 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nmetaDataArray));
1121 for (size_t j = 0; j < item.second.size(); j++) {
1122 napi_value nmetaData;
1123 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nmetaData));
1124 ConvertMetadata(env, item.second[j], nmetaData);
1125 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nmetaDataArray, j, nmetaData));
1126 }
1127 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, nMetaData, item.first.c_str(), nmetaDataArray));
1128 }
1129 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, META_DATA, nMetaData));
1130
1131 napi_value nMetaDataArrayInfo;
1132 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nMetaDataArrayInfo));
1133 ConvertModuleMetaInfos(env, appInfo.metadata, nMetaDataArrayInfo);
1134 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "metadataArray", nMetaDataArrayInfo));
1135
1136 napi_value nRemovable;
1137 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.removable, &nRemovable));
1138 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "removable", nRemovable));
1139
1140 napi_value nAccessTokenId;
1141 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, appInfo.accessTokenId, &nAccessTokenId));
1142 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "accessTokenId", nAccessTokenId));
1143
1144 napi_value nUid;
1145 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, appInfo.uid, &nUid));
1146 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "uid", nUid));
1147
1148 napi_value nIconResource;
1149 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nIconResource));
1150 ConvertResource(env, appInfo.iconResource, nIconResource);
1151 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "iconResource", nIconResource));
1152
1153 napi_value nLabelResource;
1154 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nLabelResource));
1155 ConvertResource(env, appInfo.labelResource, nLabelResource);
1156 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "labelResource", nLabelResource));
1157
1158 napi_value nDescriptionResource;
1159 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDescriptionResource));
1160 ConvertResource(env, appInfo.descriptionResource, nDescriptionResource);
1161 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "descriptionResource", nDescriptionResource));
1162
1163 napi_value nAppDistributionType;
1164 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appDistributionType.c_str(), NAPI_AUTO_LENGTH,
1165 &nAppDistributionType));
1166 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appDistributionType", nAppDistributionType));
1167
1168 napi_value nAppProvisionType;
1169 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, appInfo.appProvisionType.c_str(), NAPI_AUTO_LENGTH,
1170 &nAppProvisionType));
1171 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "appProvisionType", nAppProvisionType));
1172
1173 napi_value nIsSystemApp;
1174 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, appInfo.isSystemApp, &nIsSystemApp));
1175 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objAppInfo, "systemApp", nIsSystemApp));
1176 }
1177
ConvertPermissionDef(napi_env env,napi_value result,const PermissionDef & permissionDef)1178 void CommonFunc::ConvertPermissionDef(napi_env env, napi_value result, const PermissionDef &permissionDef)
1179 {
1180 napi_value nPermissionName;
1181 NAPI_CALL_RETURN_VOID(
1182 env, napi_create_string_utf8(env, permissionDef.permissionName.c_str(), NAPI_AUTO_LENGTH, &nPermissionName));
1183 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "permissionName", nPermissionName));
1184
1185 napi_value nGrantMode;
1186 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, permissionDef.grantMode, &nGrantMode));
1187 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "grantMode", nGrantMode));
1188
1189 napi_value nLabelId;
1190 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, permissionDef.labelId, &nLabelId));
1191 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "labelId", nLabelId));
1192
1193 napi_value nDescriptionId;
1194 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, permissionDef.descriptionId, &nDescriptionId));
1195 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "descriptionId", nDescriptionId));
1196 }
1197
ConvertRequestPermissionUsedScene(napi_env env,const RequestPermissionUsedScene & requestPermissionUsedScene,napi_value result)1198 void CommonFunc::ConvertRequestPermissionUsedScene(napi_env env,
1199 const RequestPermissionUsedScene &requestPermissionUsedScene, napi_value result)
1200 {
1201 napi_value nAbilities;
1202 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilities));
1203 for (size_t index = 0; index < requestPermissionUsedScene.abilities.size(); index++) {
1204 napi_value objAbility;
1205 NAPI_CALL_RETURN_VOID(env,
1206 napi_create_string_utf8(env, requestPermissionUsedScene.abilities[index].c_str(),
1207 NAPI_AUTO_LENGTH, &objAbility));
1208 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilities, index, objAbility));
1209 }
1210 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "abilities", nAbilities));
1211
1212 napi_value nWhen;
1213 NAPI_CALL_RETURN_VOID(env,
1214 napi_create_string_utf8(env, requestPermissionUsedScene.when.c_str(), NAPI_AUTO_LENGTH, &nWhen));
1215 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "when", nWhen));
1216 }
1217
ConvertRequestPermission(napi_env env,const RequestPermission & requestPermission,napi_value result)1218 void CommonFunc::ConvertRequestPermission(napi_env env, const RequestPermission &requestPermission, napi_value result)
1219 {
1220 napi_value nPermissionName;
1221 NAPI_CALL_RETURN_VOID(
1222 env, napi_create_string_utf8(env, requestPermission.name.c_str(), NAPI_AUTO_LENGTH, &nPermissionName));
1223 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, NAME, nPermissionName));
1224
1225 napi_value nReason;
1226 NAPI_CALL_RETURN_VOID(
1227 env, napi_create_string_utf8(env, requestPermission.reason.c_str(), NAPI_AUTO_LENGTH, &nReason));
1228 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reason", nReason));
1229
1230 napi_value nReasonId;
1231 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, requestPermission.reasonId, &nReasonId));
1232 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "reasonId", nReasonId));
1233
1234 napi_value nUsedScene;
1235 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nUsedScene));
1236 ConvertRequestPermissionUsedScene(env, requestPermission.usedScene, nUsedScene);
1237 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "usedScene", nUsedScene));
1238
1239 napi_value nModuleName;
1240 NAPI_CALL_RETURN_VOID(
1241 env, napi_create_string_utf8(env, requestPermission.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1242 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, result, "moduleName", nModuleName));
1243 }
1244
ConvertPreloadItem(napi_env env,const PreloadItem & preloadItem,napi_value value)1245 void CommonFunc::ConvertPreloadItem(napi_env env, const PreloadItem &preloadItem, napi_value value)
1246 {
1247 napi_value nModuleName;
1248 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
1249 preloadItem.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1250 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "moduleName", nModuleName));
1251 }
1252
ConvertSignatureInfo(napi_env env,const SignatureInfo & signatureInfo,napi_value value)1253 void CommonFunc::ConvertSignatureInfo(napi_env env, const SignatureInfo &signatureInfo, napi_value value)
1254 {
1255 napi_value nAppId;
1256 NAPI_CALL_RETURN_VOID(
1257 env, napi_create_string_utf8(env, signatureInfo.appId.c_str(), NAPI_AUTO_LENGTH, &nAppId));
1258 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "appId", nAppId));
1259
1260 napi_value nFingerprint;
1261 NAPI_CALL_RETURN_VOID(
1262 env, napi_create_string_utf8(env, signatureInfo.fingerprint.c_str(), NAPI_AUTO_LENGTH, &nFingerprint));
1263 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "fingerprint", nFingerprint));
1264 }
1265
ConvertHapModuleInfo(napi_env env,const HapModuleInfo & hapModuleInfo,napi_value objHapModuleInfo)1266 void CommonFunc::ConvertHapModuleInfo(napi_env env, const HapModuleInfo &hapModuleInfo, napi_value objHapModuleInfo)
1267 {
1268 napi_value nName;
1269 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1270 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, NAME, nName));
1271 APP_LOGD("ConvertHapModuleInfo name=%{public}s.", hapModuleInfo.name.c_str());
1272
1273 napi_value nIcon;
1274 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &nIcon));
1275 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, ICON, nIcon));
1276
1277 napi_value nIconId;
1278 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, hapModuleInfo.iconId, &nIconId));
1279 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, ICON_ID, nIconId));
1280
1281 napi_value nLabel;
1282 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.label.c_str(), NAPI_AUTO_LENGTH, &nLabel));
1283 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, LABEL, nLabel));
1284
1285 napi_value nLabelId;
1286 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, hapModuleInfo.labelId, &nLabelId));
1287 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, LABEL_ID, nLabelId));
1288
1289 napi_value nDescription;
1290 NAPI_CALL_RETURN_VOID(
1291 env, napi_create_string_utf8(env, hapModuleInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1292 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, DESCRIPTION, nDescription));
1293
1294 napi_value ndescriptionId;
1295 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, hapModuleInfo.descriptionId, &ndescriptionId));
1296 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, DESCRIPTION_ID, ndescriptionId));
1297
1298 napi_value nMainElementName;
1299 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.mainElementName.c_str(), NAPI_AUTO_LENGTH,
1300 &nMainElementName));
1301 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "mainElementName", nMainElementName));
1302
1303 napi_value nAbilityInfos;
1304 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nAbilityInfos));
1305 for (size_t idx = 0; idx < hapModuleInfo.abilityInfos.size(); idx++) {
1306 napi_value objAbilityInfo;
1307 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objAbilityInfo));
1308 ConvertAbilityInfo(env, hapModuleInfo.abilityInfos[idx], objAbilityInfo);
1309 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nAbilityInfos, idx, objAbilityInfo));
1310 }
1311 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "abilitiesInfo", nAbilityInfos));
1312
1313 napi_value nExtensionAbilityInfos;
1314 napi_create_array_with_length(env, hapModuleInfo.extensionInfos.size(), &nExtensionAbilityInfos);
1315 ConvertExtensionInfos(env, hapModuleInfo.extensionInfos, nExtensionAbilityInfos);
1316 NAPI_CALL_RETURN_VOID(env,
1317 napi_set_named_property(env, objHapModuleInfo, "extensionAbilitiesInfo", nExtensionAbilityInfos));
1318
1319 napi_value nMetadata;
1320 size_t size = hapModuleInfo.metadata.size();
1321 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nMetadata));
1322 for (size_t index = 0; index < size; ++index) {
1323 napi_value innerMeta;
1324 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &innerMeta));
1325 ConvertMetadata(env, hapModuleInfo.metadata[index], innerMeta);
1326 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadata, index, innerMeta));
1327 }
1328 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "metadata", nMetadata));
1329
1330 napi_value nDeviceTypes;
1331 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nDeviceTypes));
1332 for (size_t idx = 0; idx < hapModuleInfo.deviceTypes.size(); idx++) {
1333 napi_value nDeviceType;
1334 NAPI_CALL_RETURN_VOID(
1335 env, napi_create_string_utf8(env, hapModuleInfo.deviceTypes[idx].c_str(), NAPI_AUTO_LENGTH, &nDeviceType));
1336 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDeviceTypes, idx, nDeviceType));
1337 }
1338 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "deviceTypes", nDeviceTypes));
1339
1340 napi_value nInstallationFree;
1341 NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, hapModuleInfo.installationFree, &nInstallationFree));
1342 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "installationFree", nInstallationFree));
1343
1344 napi_value nHashValue;
1345 NAPI_CALL_RETURN_VOID(
1346 env, napi_create_string_utf8(env, hapModuleInfo.hashValue.c_str(), NAPI_AUTO_LENGTH, &nHashValue));
1347 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "hashValue", nHashValue));
1348
1349 napi_value nModuleSourceDir;
1350 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, hapModuleInfo.moduleSourceDir.c_str(), NAPI_AUTO_LENGTH,
1351 &nModuleSourceDir));
1352 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "moduleSourceDir", nModuleSourceDir));
1353
1354 napi_value nType;
1355 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, static_cast<int32_t>(hapModuleInfo.moduleType), &nType));
1356 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "type", nType));
1357
1358 napi_value nDependencies;
1359 size = hapModuleInfo.dependencies.size();
1360 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nDependencies));
1361 for (size_t index = 0; index < size; ++index) {
1362 napi_value nDependency;
1363 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nDependency));
1364 ConvertDependency(env, hapModuleInfo.dependencies[index], nDependency);
1365 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nDependencies, index, nDependency));
1366 }
1367 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "dependencies", nDependencies));
1368
1369 napi_value nPreloads;
1370 size = hapModuleInfo.preloads.size();
1371 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nPreloads));
1372 for (size_t index = 0; index < size; ++index) {
1373 napi_value nPreload;
1374 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nPreload));
1375 ConvertPreloadItem(env, hapModuleInfo.preloads[index], nPreload);
1376 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nPreloads, index, nPreload));
1377 }
1378 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objHapModuleInfo, "preloads", nPreloads));
1379 }
1380
ConvertDependency(napi_env env,const Dependency & dependency,napi_value value)1381 void CommonFunc::ConvertDependency(napi_env env, const Dependency &dependency, napi_value value)
1382 {
1383 napi_value nBundleName;
1384 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1385 env, dependency.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1386 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, BUNDLE_NAME, nBundleName));
1387
1388 napi_value nModuleName;
1389 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1390 env, dependency.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1391 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, MODULE_NAME, nModuleName));
1392
1393 napi_value nVersionCode;
1394 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, dependency.versionCode, &nVersionCode));
1395 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionCode", nVersionCode));
1396 }
1397
ConvertBundleInfo(napi_env env,const BundleInfo & bundleInfo,napi_value objBundleInfo,int32_t flags)1398 void CommonFunc::ConvertBundleInfo(napi_env env, const BundleInfo &bundleInfo, napi_value objBundleInfo, int32_t flags)
1399 {
1400 napi_value nName;
1401 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1402 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, NAME, nName));
1403
1404 napi_value nVendor;
1405 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleInfo.vendor.c_str(), NAPI_AUTO_LENGTH, &nVendor));
1406 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "vendor", nVendor));
1407
1408 napi_value nVersionCode;
1409 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, bundleInfo.versionCode, &nVersionCode));
1410 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionCode", nVersionCode));
1411
1412 napi_value nVersionName;
1413 NAPI_CALL_RETURN_VOID(
1414 env, napi_create_string_utf8(env, bundleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
1415 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "versionName", nVersionName));
1416
1417 napi_value nMinCompatibleVersionCode;
1418 NAPI_CALL_RETURN_VOID(
1419 env, napi_create_int32(env, bundleInfo.minCompatibleVersionCode, &nMinCompatibleVersionCode));
1420 NAPI_CALL_RETURN_VOID(
1421 env, napi_set_named_property(env, objBundleInfo, "minCompatibleVersionCode", nMinCompatibleVersionCode));
1422
1423 napi_value nTargetVersion;
1424 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, bundleInfo.targetVersion, &nTargetVersion));
1425 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "targetVersion", nTargetVersion));
1426
1427 napi_value nAppInfo;
1428 if ((static_cast<uint32_t>(flags) & static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION))
1429 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_APPLICATION)) {
1430 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nAppInfo));
1431 ConvertApplicationInfo(env, nAppInfo, bundleInfo.applicationInfo);
1432 } else {
1433 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nAppInfo));
1434 }
1435 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "appInfo", nAppInfo));
1436
1437 napi_value nHapModuleInfos;
1438 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nHapModuleInfos));
1439 for (size_t idx = 0; idx < bundleInfo.hapModuleInfos.size(); idx++) {
1440 napi_value objHapModuleInfo;
1441 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objHapModuleInfo));
1442 ConvertHapModuleInfo(env, bundleInfo.hapModuleInfos[idx], objHapModuleInfo);
1443 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nHapModuleInfos, idx, objHapModuleInfo));
1444 }
1445 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "hapModulesInfo", nHapModuleInfos));
1446
1447 napi_value nReqPermissionDetails;
1448 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionDetails));
1449 for (size_t idx = 0; idx < bundleInfo.reqPermissionDetails.size(); idx++) {
1450 napi_value objReqPermission;
1451 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objReqPermission));
1452 ConvertRequestPermission(env, bundleInfo.reqPermissionDetails[idx], objReqPermission);
1453 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionDetails, idx, objReqPermission));
1454 }
1455 NAPI_CALL_RETURN_VOID(
1456 env, napi_set_named_property(env, objBundleInfo, "reqPermissionDetails", nReqPermissionDetails));
1457
1458 napi_value nReqPermissionStates;
1459 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nReqPermissionStates));
1460 for (size_t idx = 0; idx < bundleInfo.reqPermissionStates.size(); idx++) {
1461 napi_value nReqPermissionState;
1462 NAPI_CALL_RETURN_VOID(env,
1463 napi_create_int32(env, static_cast<int32_t>(bundleInfo.reqPermissionStates[idx]), &nReqPermissionState));
1464 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nReqPermissionStates, idx, nReqPermissionState));
1465 }
1466 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "permissionGrantStates",
1467 nReqPermissionStates));
1468
1469 napi_value nSignatureInfo;
1470 if ((static_cast<uint32_t>(flags) & static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO))
1471 == static_cast<int32_t>(GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO)) {
1472 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nSignatureInfo));
1473 ConvertSignatureInfo(env, bundleInfo.signatureInfo, nSignatureInfo);
1474 } else {
1475 NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &nSignatureInfo));
1476 }
1477 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "signatureInfo", nSignatureInfo));
1478
1479 napi_value nInstallTime;
1480 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.installTime, &nInstallTime));
1481 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "installTime", nInstallTime));
1482
1483 napi_value nUpdateTime;
1484 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, bundleInfo.updateTime, &nUpdateTime));
1485 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objBundleInfo, "updateTime", nUpdateTime));
1486 }
1487
ConvertBundleChangeInfo(napi_env env,const std::string & bundleName,int32_t userId,napi_value bundleChangeInfo)1488 void CommonFunc::ConvertBundleChangeInfo(napi_env env, const std::string &bundleName,
1489 int32_t userId, napi_value bundleChangeInfo)
1490 {
1491 napi_value nBundleName;
1492 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1493 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, bundleChangeInfo, "bundleName", nBundleName));
1494
1495 napi_value nUserId;
1496 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, userId, &nUserId));
1497 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, bundleChangeInfo, "userId", nUserId));
1498 }
1499
ConvertLauncherAbilityInfo(napi_env env,const LauncherAbilityInfo & launcherAbility,napi_value value)1500 void CommonFunc::ConvertLauncherAbilityInfo(napi_env env,
1501 const LauncherAbilityInfo &launcherAbility, napi_value value)
1502 {
1503 // wrap labelId
1504 napi_value labelId;
1505 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbility.labelId, &labelId));
1506 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "labelId", labelId));
1507
1508 // wrap iconId
1509 napi_value iconId;
1510 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbility.iconId, &iconId));
1511 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "iconId", iconId));
1512
1513 // wrap userId
1514 napi_value userId;
1515 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, launcherAbility.userId, &userId));
1516 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "userId", userId));
1517
1518 // wrap installTime
1519 napi_value installTime;
1520 NAPI_CALL_RETURN_VOID(env, napi_create_int64(env, launcherAbility.installTime, &installTime));
1521 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "installTime", installTime));
1522
1523 // wrap elementName
1524 napi_value elementName;
1525 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &elementName));
1526 ConvertElementName(env, elementName, launcherAbility.elementName);
1527 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "elementName", elementName));
1528
1529 // wrap application
1530 napi_value appInfo;
1531 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &appInfo));
1532 ConvertApplicationInfo(env, appInfo, launcherAbility.applicationInfo);
1533 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "applicationInfo", appInfo));
1534 }
1535
ConvertLauncherAbilityInfos(napi_env env,const std::vector<LauncherAbilityInfo> & launcherAbilities,napi_value value)1536 void CommonFunc::ConvertLauncherAbilityInfos(napi_env env,
1537 const std::vector<LauncherAbilityInfo> &launcherAbilities, napi_value value)
1538 {
1539 if (launcherAbilities.empty()) {
1540 return;
1541 }
1542 size_t index = 0;
1543 for (const auto &launcherAbility : launcherAbilities) {
1544 napi_value launcherAbilityObj = nullptr;
1545 napi_create_object(env, &launcherAbilityObj);
1546 ConvertLauncherAbilityInfo(env, launcherAbility, launcherAbilityObj);
1547 napi_set_element(env, value, index, launcherAbilityObj);
1548 ++index;
1549 }
1550 }
1551
ConvertShortcutIntent(napi_env env,const OHOS::AppExecFwk::ShortcutIntent & shortcutIntent,napi_value value)1552 void CommonFunc::ConvertShortcutIntent(napi_env env,
1553 const OHOS::AppExecFwk::ShortcutIntent &shortcutIntent, napi_value value)
1554 {
1555 napi_value nTargetBundle;
1556 NAPI_CALL_RETURN_VOID(
1557 env, napi_create_string_utf8(env, shortcutIntent.targetBundle.c_str(), NAPI_AUTO_LENGTH, &nTargetBundle));
1558 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetBundle", nTargetBundle));
1559
1560 napi_value nTargetModule;
1561 NAPI_CALL_RETURN_VOID(
1562 env, napi_create_string_utf8(env, shortcutIntent.targetModule.c_str(), NAPI_AUTO_LENGTH, &nTargetModule));
1563 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetModule", nTargetModule));
1564
1565 napi_value nTargetClass;
1566 NAPI_CALL_RETURN_VOID(
1567 env, napi_create_string_utf8(env, shortcutIntent.targetClass.c_str(), NAPI_AUTO_LENGTH, &nTargetClass));
1568 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "targetAbility", nTargetClass));
1569 }
1570
ConvertShortCutInfo(napi_env env,const ShortcutInfo & shortcutInfo,napi_value value)1571 void CommonFunc::ConvertShortCutInfo(napi_env env, const ShortcutInfo &shortcutInfo, napi_value value)
1572 {
1573 // wrap id
1574 napi_value shortId;
1575 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.id.c_str(), NAPI_AUTO_LENGTH, &shortId));
1576 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "id", shortId));
1577 // wrap bundleName
1578 napi_value bundleName;
1579 NAPI_CALL_RETURN_VOID(
1580 env, napi_create_string_utf8(env, shortcutInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &bundleName));
1581 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "bundleName", bundleName));
1582 // wrap moduleName
1583 napi_value moduleName;
1584 NAPI_CALL_RETURN_VOID(
1585 env, napi_create_string_utf8(env, shortcutInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &moduleName));
1586 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "moduleName", moduleName));
1587 // wrap hostAbility
1588 napi_value hostAbility;
1589 NAPI_CALL_RETURN_VOID(
1590 env, napi_create_string_utf8(env, shortcutInfo.hostAbility.c_str(), NAPI_AUTO_LENGTH, &hostAbility));
1591 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "hostAbility", hostAbility));
1592 // wrap icon
1593 napi_value icon;
1594 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.icon.c_str(), NAPI_AUTO_LENGTH, &icon));
1595 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "icon", icon));
1596 // wrap iconId
1597 napi_value iconId;
1598 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.iconId, &iconId));
1599 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "iconId", iconId));
1600 // wrap label
1601 napi_value label;
1602 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, shortcutInfo.label.c_str(), NAPI_AUTO_LENGTH, &label));
1603 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "label", label));
1604 // wrap labelId
1605 napi_value labelId;
1606 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, shortcutInfo.labelId, &labelId));
1607 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "labelId", labelId));
1608
1609 // wrap wants
1610 napi_value intents;
1611 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &intents));
1612 for (size_t index = 0; index < shortcutInfo.intents.size(); ++index) {
1613 napi_value intent;
1614 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &intent));
1615 ConvertShortcutIntent(env, shortcutInfo.intents[index], intent);
1616 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, intents, index, intent));
1617 }
1618 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "wants", intents));
1619 }
1620
ConvertShortCutInfos(napi_env env,const std::vector<ShortcutInfo> & shortcutInfos,napi_value value)1621 void CommonFunc::ConvertShortCutInfos(napi_env env, const std::vector<ShortcutInfo> &shortcutInfos, napi_value value)
1622 {
1623 if (shortcutInfos.empty()) {
1624 return;
1625 }
1626 size_t index = 0;
1627 for (const auto &shortcutInfo : shortcutInfos) {
1628 napi_value shortcutObj = nullptr;
1629 napi_create_object(env, &shortcutObj);
1630 ConvertShortCutInfo(env, shortcutInfo, shortcutObj);
1631 napi_set_element(env, value, index, shortcutObj);
1632 ++index;
1633 }
1634 }
1635
ConvertOverlayModuleInfo(napi_env env,const OverlayModuleInfo & info,napi_value objOverlayModuleInfo)1636 void CommonFunc::ConvertOverlayModuleInfo(napi_env env, const OverlayModuleInfo &info,
1637 napi_value objOverlayModuleInfo)
1638 {
1639 napi_value nBundleName;
1640 NAPI_CALL_RETURN_VOID(env,
1641 napi_create_string_utf8(env, info.bundleName.c_str(), NAPI_AUTO_LENGTH, &nBundleName));
1642 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objOverlayModuleInfo, BUNDLE_NAME, nBundleName));
1643 APP_LOGD("ConvertOverlayModuleInfo bundleName=%{public}s.", info.bundleName.c_str());
1644
1645 napi_value nModuleName;
1646 NAPI_CALL_RETURN_VOID(env,
1647 napi_create_string_utf8(env, info.moduleName.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1648 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objOverlayModuleInfo, MODULE_NAME, nModuleName));
1649 APP_LOGD("ConvertOverlayModuleInfo moduleName=%{public}s.", info.moduleName.c_str());
1650
1651 napi_value nTargetModuleName;
1652 NAPI_CALL_RETURN_VOID(env,
1653 napi_create_string_utf8(env, info.targetModuleName.c_str(), NAPI_AUTO_LENGTH, &nTargetModuleName));
1654 NAPI_CALL_RETURN_VOID(env,
1655 napi_set_named_property(env, objOverlayModuleInfo, TARGET_MODULE_NAME, nTargetModuleName));
1656 APP_LOGD("ConvertOverlayModuleInfo targetModuleName=%{public}s.", info.targetModuleName.c_str());
1657
1658 napi_value nPriority;
1659 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, info.priority, &nPriority));
1660 NAPI_CALL_RETURN_VOID(env,
1661 napi_set_named_property(env, objOverlayModuleInfo, PRIORITY, nPriority));
1662 APP_LOGD("ConvertOverlayModuleInfo priority=%{public}d.", info.priority);
1663
1664 napi_value nState;
1665 NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, info.state, &nState));
1666 NAPI_CALL_RETURN_VOID(env,
1667 napi_set_named_property(env, objOverlayModuleInfo, STATE, nState));
1668 APP_LOGD("ConvertOverlayModuleInfo state=%{public}d.", info.state);
1669 }
1670
ConvertOverlayModuleInfos(napi_env env,const std::vector<OverlayModuleInfo> & Infos,napi_value objInfos)1671 void CommonFunc::ConvertOverlayModuleInfos(napi_env env, const std::vector<OverlayModuleInfo> &Infos,
1672 napi_value objInfos)
1673 {
1674 for (size_t index = 0; index < Infos.size(); ++index) {
1675 napi_value objInfo = nullptr;
1676 napi_create_object(env, &objInfo);
1677 ConvertOverlayModuleInfo(env, Infos[index], objInfo);
1678 napi_set_element(env, objInfos, index, objInfo);
1679 }
1680 }
1681
ConvertModuleMetaInfos(napi_env env,const std::map<std::string,std::vector<Metadata>> & metadata,napi_value objInfos)1682 void CommonFunc::ConvertModuleMetaInfos(napi_env env,
1683 const std::map<std::string, std::vector<Metadata>> &metadata, napi_value objInfos)
1684 {
1685 size_t index = 0;
1686 for (const auto &item : metadata) {
1687 napi_value objInfo = nullptr;
1688 napi_create_object(env, &objInfo);
1689
1690 napi_value nModuleName;
1691 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1692 env, item.first.c_str(), NAPI_AUTO_LENGTH, &nModuleName));
1693 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, MODULE_NAME, nModuleName));
1694
1695 napi_value nMetadataInfos;
1696 NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &nMetadataInfos));
1697 for (size_t idx = 0; idx < item.second.size(); idx++) {
1698 napi_value nModuleMetadata;
1699 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nModuleMetadata));
1700 ConvertMetadata(env, item.second[idx], nModuleMetadata);
1701 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nMetadataInfos, idx, nModuleMetadata));
1702 }
1703 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, objInfo, "metadata", nMetadataInfos));
1704
1705 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, objInfos, index++, objInfo));
1706 }
1707 }
1708
ObtainCallingBundleName()1709 std::string CommonFunc::ObtainCallingBundleName()
1710 {
1711 std::string callingBundleName;
1712 auto bundleMgr = GetBundleMgr();
1713 if (bundleMgr == nullptr) {
1714 APP_LOGE("CommonFunc::GetBundleMgr failed.");
1715 return callingBundleName;
1716 }
1717 if (!bundleMgr->ObtainCallingBundleName(callingBundleName)) {
1718 APP_LOGE("obtain calling bundleName failed.");
1719 }
1720 return callingBundleName;
1721 }
1722
ConvertSharedModuleInfo(napi_env env,napi_value value,const SharedModuleInfo & moduleInfo)1723 void CommonFunc::ConvertSharedModuleInfo(napi_env env, napi_value value, const SharedModuleInfo &moduleInfo)
1724 {
1725 napi_value nName;
1726 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1727 env, moduleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1728 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
1729
1730 napi_value nVersionCode;
1731 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, moduleInfo.versionCode, &nVersionCode));
1732 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionCode", nVersionCode));
1733
1734 napi_value nVersionName;
1735 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1736 env, moduleInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &nVersionName));
1737 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "versionName", nVersionName));
1738
1739 napi_value nDescription;
1740 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1741 env, moduleInfo.description.c_str(), NAPI_AUTO_LENGTH, &nDescription));
1742 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, DESCRIPTION, nDescription));
1743
1744 napi_value nDescriptionId;
1745 NAPI_CALL_RETURN_VOID(env, napi_create_uint32(env, moduleInfo.descriptionId, &nDescriptionId));
1746 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, DESCRIPTION_ID, nDescriptionId));
1747 }
1748
ConvertSharedBundleInfo(napi_env env,napi_value value,const SharedBundleInfo & bundleInfo)1749 void CommonFunc::ConvertSharedBundleInfo(napi_env env, napi_value value, const SharedBundleInfo &bundleInfo)
1750 {
1751 napi_value nName;
1752 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
1753 env, bundleInfo.name.c_str(), NAPI_AUTO_LENGTH, &nName));
1754 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, NAME, nName));
1755
1756 napi_value nCompatiblePolicy;
1757 NAPI_CALL_RETURN_VOID(env, napi_create_int32(
1758 env, static_cast<int32_t>(bundleInfo.compatiblePolicy), &nCompatiblePolicy));
1759 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "compatiblePolicy", nCompatiblePolicy));
1760
1761 napi_value nSharedModuleInfos;
1762 size_t size = bundleInfo.sharedModuleInfos.size();
1763 NAPI_CALL_RETURN_VOID(env, napi_create_array_with_length(env, size, &nSharedModuleInfos));
1764 for (size_t index = 0; index < size; ++index) {
1765 napi_value nModuleInfo;
1766 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &nModuleInfo));
1767 ConvertSharedModuleInfo(env, nModuleInfo, bundleInfo.sharedModuleInfos[index]);
1768 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, nSharedModuleInfos, index, nModuleInfo));
1769 }
1770 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, value, "sharedModuleInfo", nSharedModuleInfos));
1771 }
1772
ConvertAllSharedBundleInfo(napi_env env,napi_value value,const std::vector<SharedBundleInfo> & sharedBundles)1773 void CommonFunc::ConvertAllSharedBundleInfo(napi_env env, napi_value value,
1774 const std::vector<SharedBundleInfo> &sharedBundles)
1775 {
1776 if (sharedBundles.empty()) {
1777 APP_LOGD("sharedBundles is empty");
1778 return;
1779 }
1780 size_t index = 0;
1781 for (const auto &item : sharedBundles) {
1782 napi_value objInfo;
1783 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &objInfo));
1784 ConvertSharedBundleInfo(env, objInfo, item);
1785 NAPI_CALL_RETURN_VOID(env, napi_set_element(env, value, index, objInfo));
1786 index++;
1787 }
1788 }
1789 } // AppExecFwk
1790 } // OHOS
1791