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