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