1 /*
2 * Copyright (c) 2021 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
16 #include "napi_common_ability.h"
17
18 #include <chrono>
19 #include <dlfcn.h>
20 #include <uv.h>
21
22 #include "ability_util.h"
23 #include "hilog_wrapper.h"
24 #include "js_napi_common_ability.h"
25 #include "js_runtime_utils.h"
26 #include "napi_common_util.h"
27 #include "napi_context.h"
28 #include "napi_base_context.h"
29 #include "napi_remote_object.h"
30 #include "securec.h"
31
32 using namespace OHOS::AbilityRuntime;
33
34 namespace OHOS {
35 namespace AppExecFwk {
36 napi_ref thread_local g_contextObject = nullptr;
37 napi_ref thread_local g_dataAbilityHelper = nullptr;
38 bool thread_local g_dataAbilityHelperStatus = false;
39 const int32_t ERR_ABILITY_START_SUCCESS = 0;
40 const int32_t ERR_ABILITY_QUERY_FAILED = 1;
41 const int32_t ERR_NETWORK_UNAVAILABLE = 2;
42 const int32_t ERR_SYSTEM_ERROR = 3;
43 const int32_t ERR_LOADING_ERROR = 4;
44 const int32_t ERR_CONCURRENT_TASKS_WAITING_FOR_RETRY = 5;
45 const int32_t ERR_FREE_INSTALL_NOT_SUPPORTED = 6;
46 const int32_t ERR_SERVICE_ERROR = 7;
47 const int32_t ERR_PERMISSION_VERIFY_FAILED = 8;
48 const int32_t ERR_PARAMETER_INVALID = 9;
49 const int32_t ERR_REMOTE_INCOMPATIBLE = 10;
50 const int32_t ERR_DEVICE_OFFLINE = 11;
51 const int32_t ERR_FREE_INSTALL_TIMEOUT = 12;
52 const int32_t ERR_NOT_TOP_ABILITY = 13;
53 const int32_t ERR_TARGET_BUNDLE_NOT_EXIST = 14;
54 const int32_t ERR_CONTINUE_FREE_INSTALL_FAILED = 15;
55 const int32_t ERR_PARAM_INVALID = 202;
56 const std::map<int32_t, int32_t> START_ABILITY_ERROR_CODE_MAP = {
57 { NAPI_ERR_NO_ERROR, ERR_ABILITY_START_SUCCESS },
58 { NAPI_ERR_NO_PERMISSION, ERR_PERMISSION_VERIFY_FAILED },
59 { NAPI_ERR_ACE_ABILITY, ERR_ABILITY_QUERY_FAILED },
60 { NAPI_ERR_PARAM_INVALID, ERR_PARAM_INVALID },
61 { NAPI_ERR_ABILITY_TYPE_INVALID, ERR_ABILITY_QUERY_FAILED },
62 { NAPI_ERR_ABILITY_CALL_INVALID, ERR_ABILITY_QUERY_FAILED },
63 { ERR_OK, ERR_ABILITY_START_SUCCESS },
64 { RESOLVE_ABILITY_ERR, ERR_ABILITY_QUERY_FAILED },
65 { CHECK_PERMISSION_FAILED, ERR_PERMISSION_VERIFY_FAILED },
66 { RESOLVE_CALL_NO_PERMISSIONS, ERR_PERMISSION_VERIFY_FAILED },
67 { FA_FREE_INSTALL_QUERY_ERROR, ERR_ABILITY_QUERY_FAILED },
68 { HAG_QUERY_TIMEOUT, ERR_ABILITY_QUERY_FAILED },
69 { FA_NETWORK_UNAVAILABLE, ERR_NETWORK_UNAVAILABLE },
70 { FA_FREE_INSTALL_SERVICE_ERROR, ERR_SYSTEM_ERROR },
71 { FA_CRASH, ERR_SYSTEM_ERROR },
72 { FA_TIMEOUT, ERR_SYSTEM_ERROR },
73 { UNKNOWN_EXCEPTION, ERR_SYSTEM_ERROR },
74 { NOT_SUPPORT_PA_ON_SAME_DEVICE, ERR_SYSTEM_ERROR },
75 { FA_INTERNET_ERROR, ERR_SYSTEM_ERROR },
76 { JUMP_TO_THE_APPLICATION_MARKET_UPGRADE, ERR_SYSTEM_ERROR },
77 { USER_GIVES_UP, ERR_LOADING_ERROR },
78 { INSTALLATION_ERROR_IN_FREE_INSTALL, ERR_LOADING_ERROR },
79 { HAP_PACKAGE_DOWNLOAD_TIMED_OUT, ERR_LOADING_ERROR },
80 { CONCURRENT_TASKS_WAITING_FOR_RETRY, ERR_CONCURRENT_TASKS_WAITING_FOR_RETRY },
81 { FA_PACKAGE_DOES_NOT_SUPPORT_FREE_INSTALL, ERR_FREE_INSTALL_NOT_SUPPORTED },
82 { NOT_ALLOWED_TO_PULL_THIS_FA, ERR_SERVICE_ERROR },
83 { NOT_SUPPORT_CROSS_DEVICE_FREE_INSTALL_PA, ERR_SERVICE_ERROR },
84 { DMS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
85 { DMS_COMPONENT_ACCESS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
86 { DMS_ACCOUNT_ACCESS_PERMISSION_DENIED, ERR_PERMISSION_VERIFY_FAILED },
87 { INVALID_PARAMETERS_ERR, ERR_PARAMETER_INVALID },
88 { INVALID_REMOTE_PARAMETERS_ERR, ERR_PARAMETER_INVALID },
89 { REMOTE_DEVICE_NOT_COMPATIBLE, ERR_REMOTE_INCOMPATIBLE },
90 { DEVICE_OFFLINE_ERR, ERR_DEVICE_OFFLINE },
91 { FREE_INSTALL_TIMEOUT, ERR_FREE_INSTALL_TIMEOUT },
92 { NOT_TOP_ABILITY, ERR_NOT_TOP_ABILITY },
93 { TARGET_BUNDLE_NOT_EXIST, ERR_TARGET_BUNDLE_NOT_EXIST },
94 { CONTINUE_FREE_INSTALL_FAILED, ERR_CONTINUE_FREE_INSTALL_FAILED }
95 };
96
97 using NAPICreateJsRemoteObject = napi_value (*)(napi_env env, const sptr<IRemoteObject> target);
98
SetGlobalClassContext(napi_env env,napi_value constructor)99 napi_status SetGlobalClassContext(napi_env env, napi_value constructor)
100 {
101 return napi_create_reference(env, constructor, 1, &g_contextObject);
102 }
103
GetGlobalClassContext(napi_env env)104 napi_value GetGlobalClassContext(napi_env env)
105 {
106 napi_value constructor;
107 NAPI_CALL(env, napi_get_reference_value(env, g_contextObject, &constructor));
108 return constructor;
109 }
110
SaveGlobalDataAbilityHelper(napi_env env,napi_value constructor)111 napi_status SaveGlobalDataAbilityHelper(napi_env env, napi_value constructor)
112 {
113 return napi_create_reference(env, constructor, 1, &g_dataAbilityHelper);
114 }
115
GetGlobalDataAbilityHelper(napi_env env)116 napi_value GetGlobalDataAbilityHelper(napi_env env)
117 {
118 napi_value constructor;
119 NAPI_CALL(env, napi_get_reference_value(env, g_dataAbilityHelper, &constructor));
120 return constructor;
121 }
122
GetDataAbilityHelperStatus()123 bool& GetDataAbilityHelperStatus()
124 {
125 return g_dataAbilityHelperStatus;
126 }
127
CheckAbilityType(AbilityType typeInAbility,AbilityType typeWant)128 bool CheckAbilityType(AbilityType typeInAbility, AbilityType typeWant)
129 {
130 switch (typeWant) {
131 case AbilityType::PAGE:
132 if (typeInAbility == AbilityType::PAGE || typeInAbility == AbilityType::DATA) {
133 return true;
134 }
135 return false;
136 default:
137 return typeInAbility != AbilityType::PAGE;
138 }
139 return false;
140 }
141
CheckAbilityType(const CBBase * cbBase)142 bool CheckAbilityType(const CBBase *cbBase)
143 {
144 if (cbBase == nullptr) {
145 HILOG_ERROR("%{public}s cbBase == nullptr", __func__);
146 return false;
147 }
148
149 if (cbBase->ability == nullptr) {
150 HILOG_ERROR("%{public}s cbBase->ability == nullptr", __func__);
151 return false;
152 }
153
154 const std::shared_ptr<AbilityInfo> info = cbBase->ability->GetAbilityInfo();
155 if (info == nullptr) {
156 HILOG_ERROR("%{public}s info == nullptr", __func__);
157 return false;
158 }
159 return CheckAbilityType((AbilityType)info->type, cbBase->abilityType);
160 }
161
CheckAbilityType(const AsyncJSCallbackInfo * asyncCallbackInfo)162 bool CheckAbilityType(const AsyncJSCallbackInfo *asyncCallbackInfo)
163 {
164 HILOG_INFO("%{public}s called.", __func__);
165 if (asyncCallbackInfo == nullptr) {
166 HILOG_ERROR("%{public}s asyncCallbackInfo == nullptr", __func__);
167 return false;
168 }
169
170 if (asyncCallbackInfo->ability == nullptr) {
171 HILOG_ERROR("%{public}s ability == nullptr", __func__);
172 return false;
173 }
174
175 const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
176 if (info == nullptr) {
177 HILOG_ERROR("%{public}s info == nullptr", __func__);
178 return false;
179 }
180 HILOG_INFO("%{public}s end.", __func__);
181 return CheckAbilityType((AbilityType)info->type, asyncCallbackInfo->abilityType);
182 }
183
CheckAbilityType(const AsyncCallbackInfo * asyncCallbackInfo)184 bool CheckAbilityType(const AsyncCallbackInfo *asyncCallbackInfo)
185 {
186 HILOG_INFO("%{public}s called.", __func__);
187 if (asyncCallbackInfo == nullptr) {
188 HILOG_ERROR("%{public}s asyncCallbackInfo == nullptr", __func__);
189 return false;
190 }
191
192 if (asyncCallbackInfo->ability == nullptr) {
193 HILOG_ERROR("%{public}s ability == nullptr", __func__);
194 return false;
195 }
196
197 const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
198 if (info == nullptr) {
199 HILOG_ERROR("%{public}s info == nullptr", __func__);
200 return false;
201 }
202
203 HILOG_INFO("%{public}s end.", __func__);
204 return CheckAbilityType((AbilityType)info->type, asyncCallbackInfo->abilityType);
205 }
206
GetContinueAbilityOptionsInfoCommon(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)207 napi_value GetContinueAbilityOptionsInfoCommon(
208 const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
209 {
210 HILOG_INFO("%{public}s.", __func__);
211 napi_value result = nullptr;
212
213 // reversible?: boolean
214 if (GetContinueAbilityOptionsReversible(env, value, info) == nullptr) {
215 return nullptr;
216 }
217
218 // deviceId?: string
219 if (GetContinueAbilityOptionsDeviceID(env, value, info) == nullptr) {
220 return nullptr;
221 }
222
223 napi_get_null(env, &result);
224 HILOG_INFO("%{public}s.", __func__);
225 return result;
226 }
227
GetContinueAbilityOptionsReversible(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)228 napi_value GetContinueAbilityOptionsReversible(
229 const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
230 {
231 HILOG_INFO("%{public}s.", __func__);
232 napi_valuetype valuetype = napi_undefined;
233 napi_value result = nullptr;
234 bool hasProperty = false;
235 bool reversible = false;
236
237 NAPI_CALL(env, napi_has_named_property(env, value, "reversible", &hasProperty));
238 if (hasProperty) {
239 napi_get_named_property(env, value, "reversible", &result);
240 NAPI_CALL(env, napi_typeof(env, result, &valuetype));
241 if (valuetype != napi_boolean) {
242 HILOG_ERROR("%{public}s, Wrong argument type. Bool expected.", __func__);
243 return nullptr;
244 }
245 napi_get_value_bool(env, result, &reversible);
246 info.reversible = reversible;
247 }
248 HILOG_INFO("%{public}s.", __func__);
249 return result;
250 }
251
GetContinueAbilityOptionsDeviceID(const napi_env & env,const napi_value & value,ContinueAbilityOptionsInfo & info)252 napi_value GetContinueAbilityOptionsDeviceID(
253 const napi_env &env, const napi_value &value, ContinueAbilityOptionsInfo &info)
254 {
255 HILOG_INFO("%{public}s.", __func__);
256 napi_valuetype valuetype = napi_undefined;
257 napi_value result = nullptr;
258 bool hasProperty = false;
259 char str[STR_MAX_SIZE] = {0};
260 size_t strLen = 0;
261
262 NAPI_CALL(env, napi_has_named_property(env, value, "deviceId", &hasProperty));
263 if (hasProperty) {
264 napi_get_named_property(env, value, "deviceId", &result);
265 NAPI_CALL(env, napi_typeof(env, result, &valuetype));
266 if (valuetype != napi_string) {
267 HILOG_ERROR("%{public}s, Wrong argument type. String expected.", __func__);
268 return nullptr;
269 }
270 NAPI_CALL(env, napi_get_value_string_utf8(env, result, str, STR_MAX_SIZE - 1, &strLen));
271 info.deviceId = str;
272 }
273 HILOG_INFO("%{public}s.", __func__);
274 return result;
275 }
276
WrapAppInfo(napi_env env,const ApplicationInfo & appInfo)277 napi_value WrapAppInfo(napi_env env, const ApplicationInfo &appInfo)
278 {
279 HILOG_INFO("%{public}s.", __func__);
280 napi_value result = nullptr;
281 napi_value proValue = nullptr;
282 NAPI_CALL(env, napi_create_object(env, &result));
283 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
284 NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
285
286 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
287 NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
288
289 NAPI_CALL(env, napi_create_int32(env, appInfo.descriptionId, &proValue));
290 NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
291
292 NAPI_CALL(env, napi_get_boolean(env, appInfo.isSystemApp, &proValue));
293 NAPI_CALL(env, napi_set_named_property(env, result, "systemApp", proValue));
294 NAPI_CALL(env, napi_get_boolean(env, appInfo.enabled, &proValue));
295 NAPI_CALL(env, napi_set_named_property(env, result, "enabled", proValue));
296 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
297 NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
298 NAPI_CALL(env, napi_create_string_utf8(env, std::to_string(appInfo.labelId).c_str(), NAPI_AUTO_LENGTH, &proValue));
299 NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
300 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
301 NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
302 NAPI_CALL(env, napi_create_string_utf8(env, std::to_string(appInfo.iconId).c_str(), NAPI_AUTO_LENGTH, &proValue));
303 NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
304 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.process.c_str(), NAPI_AUTO_LENGTH, &proValue));
305 NAPI_CALL(env, napi_set_named_property(env, result, "process", proValue));
306 NAPI_CALL(env, napi_create_int32(env, appInfo.supportedModes, &proValue));
307 NAPI_CALL(env, napi_set_named_property(env, result, "supportedModes", proValue));
308
309 (void)WrapProperties(env, appInfo.moduleSourceDirs, "moduleSourceDirs", result);
310 (void)WrapProperties(env, appInfo.permissions, "permissions", result);
311 (void)WrapModuleInfos(env, appInfo, result);
312 NAPI_CALL(env, napi_create_string_utf8(env, appInfo.entryDir.c_str(), NAPI_AUTO_LENGTH, &proValue));
313 NAPI_CALL(env, napi_set_named_property(env, result, "entryDir", proValue));
314 HILOG_INFO("%{public}s end.", __func__);
315 return result;
316 }
317
GetStartAbilityErrorCode(ErrCode innerErrorCode)318 int32_t GetStartAbilityErrorCode(ErrCode innerErrorCode)
319 {
320 auto iter = START_ABILITY_ERROR_CODE_MAP.find(innerErrorCode);
321 if (iter != START_ABILITY_ERROR_CODE_MAP.end()) {
322 return iter->second;
323 }
324 return ERR_ABILITY_QUERY_FAILED;
325 }
326
327 /**
328 * @brief GetFilesDir asynchronous processing function.
329 *
330 * @param env The environment that the Node-API call is invoked under.
331 * @param data Point to asynchronous processing of data.
332 */
GetFilesDirExecuteCallback(napi_env,void * data)333 void GetFilesDirExecuteCallback(napi_env, void *data)
334 {
335 HILOG_INFO("%{public}s called", __func__);
336 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
337 if (asyncCallbackInfo == nullptr) {
338 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
339 return;
340 }
341
342 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
343 asyncCallbackInfo->native_data.data_type = NVT_NONE;
344 if (asyncCallbackInfo->ability == nullptr) {
345 HILOG_ERROR("%{public}s ability == nullptr", __func__);
346 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
347 return;
348 }
349
350 if (!CheckAbilityType(asyncCallbackInfo)) {
351 HILOG_ERROR("%{public}s wrong ability type", __func__);
352 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
353 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
354 return;
355 }
356
357 asyncCallbackInfo->native_data.data_type = NVT_STRING;
358 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
359 if (abilityContext == nullptr) {
360 HILOG_ERROR("%{public}s GetAbilityContext is nullptr", __func__);
361 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
362 return;
363 }
364 asyncCallbackInfo->native_data.str_value = abilityContext->GetFilesDir();
365 HILOG_INFO("%{public}s end. filesDir=%{public}s", __func__, asyncCallbackInfo->native_data.str_value.c_str());
366 }
367
IsUpdatingConfigurationsExecuteCallback(napi_env,void * data)368 void IsUpdatingConfigurationsExecuteCallback(napi_env, void *data)
369 {
370 HILOG_INFO("%{public}s called", __func__);
371 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
372 if (asyncCallbackInfo == nullptr) {
373 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
374 return;
375 }
376
377 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
378 asyncCallbackInfo->native_data.data_type = NVT_NONE;
379 if (asyncCallbackInfo->ability == nullptr) {
380 HILOG_ERROR("%{public}s ability == nullptr", __func__);
381 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
382 return;
383 }
384
385 if (!CheckAbilityType(asyncCallbackInfo)) {
386 HILOG_ERROR("%{public}s wrong ability type", __func__);
387 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
388 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
389 return;
390 }
391
392 asyncCallbackInfo->native_data.data_type = NVT_BOOL;
393 asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->IsUpdatingConfigurations();
394 HILOG_INFO("%{public}s end", __func__);
395 }
396
397 /**
398 * @brief PrintDrawnCompleted asynchronous processing function.
399 *
400 * @param env The environment that the Node-API call is invoked under.
401 * @param data Point to asynchronous processing of data.
402 */
PrintDrawnCompletedExecuteCallback(napi_env,void * data)403 void PrintDrawnCompletedExecuteCallback(napi_env, void *data)
404 {
405 HILOG_INFO("%{public}s called", __func__);
406 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
407 if (asyncCallbackInfo == nullptr) {
408 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
409 return;
410 }
411
412 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
413 asyncCallbackInfo->native_data.data_type = NVT_NONE;
414 if (asyncCallbackInfo->ability == nullptr) {
415 HILOG_ERROR("%{public}s ability == nullptr", __func__);
416 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
417 return;
418 }
419
420 if (!CheckAbilityType(asyncCallbackInfo)) {
421 HILOG_ERROR("%{public}s wrong ability type", __func__);
422 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
423 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
424 return;
425 }
426
427 asyncCallbackInfo->native_data.data_type = NVT_NONE;
428 asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->PrintDrawnCompleted();
429 HILOG_INFO("%{public}s end", __func__);
430 }
431
NAPI_GetFilesDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)432 napi_value NAPI_GetFilesDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
433 {
434 HILOG_INFO("%{public}s called", __func__);
435 size_t argc = ARGS_MAX_COUNT;
436 napi_value args[ARGS_MAX_COUNT] = {nullptr};
437 napi_value jsthis = nullptr;
438 void *data = nullptr;
439
440 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
441
442 if (argc > ARGS_ONE) {
443 HILOG_INFO("%{public}s called, parameters is invalid.", __func__);
444 return nullptr;
445 }
446
447 if (argc == ARGS_ONE) {
448 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
449 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
450 return nullptr;
451 }
452 }
453
454 AsyncParamEx asyncParamEx;
455 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
456 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
457 asyncParamEx.resource = "NAPI_GetFilesDirCallback";
458 asyncParamEx.execute = GetFilesDirExecuteCallback;
459 asyncParamEx.complete = CompleteAsyncCallbackWork;
460
461 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
462 } else {
463 HILOG_INFO("%{public}s called. promise.", __func__);
464 asyncParamEx.resource = "NAPI_GetFilesDirPromise";
465 asyncParamEx.execute = GetFilesDirExecuteCallback;
466 asyncParamEx.complete = CompletePromiseCallbackWork;
467
468 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
469 }
470 }
NAPI_GetFilesDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)471 napi_value NAPI_GetFilesDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
472 {
473 HILOG_INFO("%{public}s called", __func__);
474 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
475 if (asyncCallbackInfo == nullptr) {
476 HILOG_INFO("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
477 return WrapVoidToJS(env);
478 }
479
480 asyncCallbackInfo->abilityType = abilityType;
481 napi_value ret = NAPI_GetFilesDirWrap(env, info, asyncCallbackInfo);
482 if (ret == nullptr) {
483 HILOG_ERROR("%{public}s ret == nullptr", __func__);
484 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
485 ret = WrapVoidToJS(env);
486 }
487 HILOG_INFO("%{public}s end", __func__);
488 return ret;
489 }
490
GetOrCreateDistributedDirExecuteCallback(napi_env,void * data)491 void GetOrCreateDistributedDirExecuteCallback(napi_env, void *data)
492 {
493 HILOG_INFO("%{public}s called", __func__);
494 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
495 if (asyncCallbackInfo == nullptr) {
496 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
497 return;
498 }
499
500 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
501 asyncCallbackInfo->native_data.data_type = NVT_NONE;
502 if (asyncCallbackInfo->ability == nullptr) {
503 HILOG_ERROR("%{public}s ability == nullptr", __func__);
504 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
505 return;
506 }
507
508 if (!CheckAbilityType(asyncCallbackInfo)) {
509 HILOG_ERROR("%{public}s wrong ability type", __func__);
510 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
511 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
512 return;
513 }
514
515 asyncCallbackInfo->native_data.data_type = NVT_STRING;
516 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
517 if (abilityContext == nullptr) {
518 HILOG_ERROR("%{public}s GetAbilityContext is nullptr", __func__);
519 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
520 return;
521 }
522 asyncCallbackInfo->native_data.str_value = abilityContext->GetDistributedFilesDir();
523 HILOG_INFO("%{public}s end. filesDir=%{public}s", __func__, asyncCallbackInfo->native_data.str_value.c_str());
524 }
525
526 /**
527 * @brief GetFilesDir processing function.
528 *
529 * @param env The environment that the Node-API call is invoked under.
530 * @param asyncCallbackInfo Process data asynchronously.
531 *
532 * @return Return JS data successfully, otherwise return nullptr.
533 */
NAPI_GetOrCreateDistributedDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)534 napi_value NAPI_GetOrCreateDistributedDirWrap(
535 napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
536 {
537 HILOG_INFO("%{public}s called", __func__);
538 size_t argc = ARGS_MAX_COUNT;
539 napi_value args[ARGS_MAX_COUNT] = {nullptr};
540 napi_value jsthis = nullptr;
541 void *data = nullptr;
542
543 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
544
545 if (argc > ARGS_ONE) {
546 HILOG_ERROR("%{public}s called, parameters is invalid.", __func__);
547 return nullptr;
548 }
549
550 if (argc == ARGS_ONE) {
551 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
552 HILOG_ERROR("%{public}s called, the first parameter is invalid.", __func__);
553 return nullptr;
554 }
555 }
556
557 AsyncParamEx asyncParamEx;
558 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
559 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
560 asyncParamEx.resource = "NAPI_GetFilesDirCallback";
561 asyncParamEx.execute = GetOrCreateDistributedDirExecuteCallback;
562 asyncParamEx.complete = CompleteAsyncCallbackWork;
563
564 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
565 } else {
566 HILOG_INFO("%{public}s called. promise.", __func__);
567 asyncParamEx.resource = "NAPI_GetFilesDirPromise";
568 asyncParamEx.execute = GetOrCreateDistributedDirExecuteCallback;
569 asyncParamEx.complete = CompletePromiseCallbackWork;
570
571 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
572 }
573 }
574
NAPI_GetOrCreateDistributedDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)575 napi_value NAPI_GetOrCreateDistributedDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
576 {
577 HILOG_INFO("%{public}s called", __func__);
578 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
579 if (asyncCallbackInfo == nullptr) {
580 HILOG_ERROR("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
581 return WrapVoidToJS(env);
582 }
583
584 asyncCallbackInfo->abilityType = abilityType;
585 napi_value ret = NAPI_GetOrCreateDistributedDirWrap(env, info, asyncCallbackInfo);
586 if (ret == nullptr) {
587 HILOG_ERROR("%{public}s ret == nullptr", __func__);
588 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
589 ret = WrapVoidToJS(env);
590 }
591 HILOG_INFO("%{public}s end", __func__);
592 return ret;
593 }
594
595 /**
596 * @brief GetCacheDir asynchronous processing function.
597 *
598 * @param env The environment that the Node-API call is invoked under.
599 * @param data Point to asynchronous processing of data.
600 */
GetCacheDirExecuteCallback(napi_env,void * data)601 void GetCacheDirExecuteCallback(napi_env, void *data)
602 {
603 HILOG_INFO("%{public}s called", __func__);
604 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
605 if (asyncCallbackInfo == nullptr) {
606 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
607 return;
608 }
609
610 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
611 asyncCallbackInfo->native_data.data_type = NVT_NONE;
612 if (asyncCallbackInfo->ability == nullptr) {
613 HILOG_ERROR("%{public}s ability == nullptr", __func__);
614 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
615 return;
616 }
617
618 if (!CheckAbilityType(asyncCallbackInfo)) {
619 HILOG_ERROR("%{public}s wrong ability type", __func__);
620 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
621 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
622 return;
623 }
624
625 asyncCallbackInfo->native_data.data_type = NVT_STRING;
626 std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext = asyncCallbackInfo->ability->GetAbilityContext();
627 if (abilityContext == nullptr) {
628 HILOG_ERROR("%{public}s GetAbilityContext is nullptr", __func__);
629 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
630 return;
631 }
632 asyncCallbackInfo->native_data.str_value = abilityContext->GetCacheDir();
633 HILOG_INFO("%{public}s end. CacheDir=%{public}s", __func__, asyncCallbackInfo->native_data.str_value.c_str());
634 }
635
636 /**
637 * @brief NAPI_GetCacheDirWrap processing function.
638 *
639 * @param env The environment that the Node-API call is invoked under.
640 * @param asyncCallbackInfo Process data asynchronously.
641 *
642 * @return Return JS data successfully, otherwise return nullptr.
643 */
NAPI_GetCacheDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)644 napi_value NAPI_GetCacheDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
645 {
646 HILOG_INFO("%{public}s called", __func__);
647 size_t argc = ARGS_MAX_COUNT;
648 napi_value args[ARGS_MAX_COUNT] = {nullptr};
649 napi_value jsthis = nullptr;
650 void *data = nullptr;
651
652 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
653
654 if (argc > ARGS_ONE) {
655 HILOG_ERROR("%{public}s called, parameters is invalid.", __func__);
656 return nullptr;
657 }
658
659 if (argc == ARGS_ONE) {
660 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
661 HILOG_ERROR("%{public}s called, the first parameter is invalid.", __func__);
662 return nullptr;
663 }
664 }
665
666 AsyncParamEx asyncParamEx;
667 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
668 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
669 asyncParamEx.resource = "NAPI_GetCacheDirCallback";
670 asyncParamEx.execute = GetCacheDirExecuteCallback;
671 asyncParamEx.complete = CompleteAsyncCallbackWork;
672
673 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
674 } else {
675 HILOG_INFO("%{public}s called. promise.", __func__);
676 asyncParamEx.resource = "NAPI_GetCacheDirPromise";
677 asyncParamEx.execute = GetCacheDirExecuteCallback;
678 asyncParamEx.complete = CompletePromiseCallbackWork;
679
680 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
681 }
682 }
683
NAPI_GetCacheDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)684 napi_value NAPI_GetCacheDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
685 {
686 HILOG_INFO("%{public}s called", __func__);
687 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
688 if (asyncCallbackInfo == nullptr) {
689 HILOG_ERROR("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
690 return WrapVoidToJS(env);
691 }
692
693 asyncCallbackInfo->abilityType = abilityType;
694 napi_value ret = NAPI_GetCacheDirWrap(env, info, asyncCallbackInfo);
695 if (ret == nullptr) {
696 HILOG_ERROR("%{public}s ret == nullptr", __func__);
697 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
698 ret = WrapVoidToJS(env);
699 }
700 HILOG_INFO("%{public}s end", __func__);
701 return ret;
702 }
703
704 /**
705 * @brief GetExternalCacheDir asynchronous processing function.
706 *
707 * @param env The environment that the Node-API call is invoked under.
708 * @param data Point to asynchronous processing of data.
709 */
GetExternalCacheDirExecuteCallback(napi_env,void * data)710 void GetExternalCacheDirExecuteCallback(napi_env, void *data)
711 {
712 HILOG_INFO("%{public}s called", __func__);
713 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
714 if (asyncCallbackInfo == nullptr) {
715 HILOG_ERROR("%{public}s. asyncCallbackInfo is null", __func__);
716 return;
717 }
718
719 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
720 asyncCallbackInfo->native_data.data_type = NVT_NONE;
721 if (asyncCallbackInfo->ability == nullptr) {
722 HILOG_ERROR("%{public}s ability == nullptr", __func__);
723 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
724 return;
725 }
726
727 if (!CheckAbilityType(asyncCallbackInfo)) {
728 HILOG_ERROR("%{public}s wrong ability type", __func__);
729 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
730 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
731 return;
732 }
733
734 asyncCallbackInfo->native_data.data_type = NVT_STRING;
735 asyncCallbackInfo->native_data.str_value = asyncCallbackInfo->ability->GetExternalCacheDir();
736 HILOG_INFO(
737 "%{public}s end. ExternalCacheDir=%{private}s", __func__, asyncCallbackInfo->native_data.str_value.c_str());
738 }
739
740 /**
741 * @brief NAPI_GetExternalCacheDirWrap processing function.
742 *
743 * @param env The environment that the Node-API call is invoked under.
744 * @param asyncCallbackInfo Process data asynchronously.
745 *
746 * @return Return JS data successfully, otherwise return nullptr.
747 */
NAPI_GetExternalCacheDirWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)748 napi_value NAPI_GetExternalCacheDirWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
749 {
750 HILOG_INFO("%{public}s called", __func__);
751 size_t argc = ARGS_MAX_COUNT;
752 napi_value args[ARGS_MAX_COUNT] = {nullptr};
753 napi_value jsthis = nullptr;
754 void *data = nullptr;
755
756 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
757
758 if (argc > ARGS_ONE) {
759 HILOG_INFO("%{public}s called, parameters is invalid.", __func__);
760 return nullptr;
761 }
762
763 if (argc == ARGS_ONE) {
764 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
765 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
766 return nullptr;
767 }
768 }
769
770 AsyncParamEx asyncParamEx;
771 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
772 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
773 asyncParamEx.resource = "NAPI_GetExternalCacheDirCallback";
774 asyncParamEx.execute = GetExternalCacheDirExecuteCallback;
775 asyncParamEx.complete = CompleteAsyncCallbackWork;
776
777 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
778 } else {
779 HILOG_INFO("%{public}s called. promise.", __func__);
780 asyncParamEx.resource = "NAPI_GetExternalCacheDirPromise";
781 asyncParamEx.execute = GetExternalCacheDirExecuteCallback;
782 asyncParamEx.complete = CompletePromiseCallbackWork;
783
784 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
785 }
786 }
787
NAPI_GetExternalCacheDirCommon(napi_env env,napi_callback_info info,AbilityType abilityType)788 napi_value NAPI_GetExternalCacheDirCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
789 {
790 HILOG_INFO("%{public}s called", __func__);
791 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
792 if (asyncCallbackInfo == nullptr) {
793 HILOG_INFO("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
794 return WrapVoidToJS(env);
795 }
796
797 asyncCallbackInfo->abilityType = abilityType;
798 napi_value ret = NAPI_GetExternalCacheDirWrap(env, info, asyncCallbackInfo);
799 if (ret == nullptr) {
800 HILOG_ERROR("%{public}s ret == nullptr", __func__);
801 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
802 ret = WrapVoidToJS(env);
803 }
804 HILOG_INFO("%{public}s end", __func__);
805 return ret;
806 }
807
NAPI_IsUpdatingConfigurationsWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)808 napi_value NAPI_IsUpdatingConfigurationsWrap(
809 napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
810 {
811 HILOG_INFO("%{public}s called", __func__);
812 size_t argc = ARGS_MAX_COUNT;
813 napi_value args[ARGS_MAX_COUNT] = {nullptr};
814 napi_value jsthis = nullptr;
815 void *data = nullptr;
816
817 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
818
819 if (argc > ARGS_ONE) {
820 HILOG_INFO("%{public}s called, parameters is invalid.", __func__);
821 return nullptr;
822 }
823
824 if (argc == ARGS_ONE) {
825 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
826 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
827 return nullptr;
828 }
829 }
830
831 AsyncParamEx asyncParamEx;
832 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
833 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
834 asyncParamEx.resource = "NAPI_IsUpdatingConfigurationsCallback";
835 asyncParamEx.execute = IsUpdatingConfigurationsExecuteCallback;
836 asyncParamEx.complete = CompleteAsyncCallbackWork;
837
838 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
839 } else {
840 HILOG_INFO("%{public}s called. promise.", __func__);
841 asyncParamEx.resource = "NAPI_IsUpdatingConfigurationsPromise";
842 asyncParamEx.execute = IsUpdatingConfigurationsExecuteCallback;
843 asyncParamEx.complete = CompletePromiseCallbackWork;
844
845 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
846 }
847 }
848
NAPI_PrintDrawnCompletedWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)849 napi_value NAPI_PrintDrawnCompletedWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
850 {
851 HILOG_INFO("%{public}s called", __func__);
852 size_t argc = ARGS_MAX_COUNT;
853 napi_value args[ARGS_MAX_COUNT] = {nullptr};
854 napi_value jsthis = nullptr;
855 void *data = nullptr;
856
857 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
858
859 if (argc > ARGS_ONE) {
860 HILOG_INFO("%{public}s called, parameters is invalid.", __func__);
861 return nullptr;
862 }
863
864 if (argc == ARGS_ONE) {
865 if (!CreateAsyncCallback(env, args[PARAM0], asyncCallbackInfo)) {
866 HILOG_INFO("%{public}s called, the first parameter is invalid.", __func__);
867 return nullptr;
868 }
869 }
870
871 AsyncParamEx asyncParamEx;
872 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
873 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
874 asyncParamEx.resource = "NAPI_PrintDrawnCompletedCallback";
875 asyncParamEx.execute = PrintDrawnCompletedExecuteCallback;
876 asyncParamEx.complete = CompleteAsyncVoidCallbackWork;
877
878 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
879 } else {
880 HILOG_INFO("%{public}s called. promise.", __func__);
881 asyncParamEx.resource = "NAPI_PrintDrawnCompletedPromise";
882 asyncParamEx.execute = PrintDrawnCompletedExecuteCallback;
883 asyncParamEx.complete = CompletePromiseVoidCallbackWork;
884
885 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
886 }
887 }
888
NAPI_IsUpdatingConfigurationsCommon(napi_env env,napi_callback_info info,AbilityType abilityType)889 napi_value NAPI_IsUpdatingConfigurationsCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
890 {
891 HILOG_INFO("%{public}s called", __func__);
892 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
893 if (asyncCallbackInfo == nullptr) {
894 HILOG_INFO("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
895 return WrapVoidToJS(env);
896 }
897
898 asyncCallbackInfo->abilityType = abilityType;
899 napi_value ret = NAPI_IsUpdatingConfigurationsWrap(env, info, asyncCallbackInfo);
900 if (ret == nullptr) {
901 HILOG_ERROR("%{public}s ret == nullptr", __func__);
902 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
903 ret = WrapVoidToJS(env);
904 }
905 HILOG_INFO("%{public}s end", __func__);
906 return ret;
907 }
908
NAPI_PrintDrawnCompletedCommon(napi_env env,napi_callback_info info,AbilityType abilityType)909 napi_value NAPI_PrintDrawnCompletedCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
910 {
911 HILOG_INFO("%{public}s called", __func__);
912 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
913 if (asyncCallbackInfo == nullptr) {
914 HILOG_INFO("%{public}s called. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
915 return WrapVoidToJS(env);
916 }
917
918 asyncCallbackInfo->abilityType = abilityType;
919 napi_value ret = NAPI_PrintDrawnCompletedWrap(env, info, asyncCallbackInfo);
920 if (ret == nullptr) {
921 HILOG_ERROR("%{public}s ret == nullptr", __func__);
922 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
923 ret = WrapVoidToJS(env);
924 }
925 HILOG_INFO("%{public}s end", __func__);
926 return ret;
927 }
928
929 /**
930 * @brief Create asynchronous data.
931 *
932 * @param env The environment that the Node-API call is invoked under.
933 *
934 * @return Return a pointer to AppTypeCB on success, nullptr on failure.
935 */
CreateAppTypeCBInfo(napi_env env)936 AppTypeCB *CreateAppTypeCBInfo(napi_env env)
937 {
938 HILOG_INFO("%{public}s, called.", __func__);
939 napi_value global = nullptr;
940 NAPI_CALL(env, napi_get_global(env, &global));
941
942 napi_value abilityObj = nullptr;
943 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
944
945 Ability *ability = nullptr;
946 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
947
948 AppTypeCB *appTypeCB = new (std::nothrow) AppTypeCB;
949 if (appTypeCB == nullptr) {
950 HILOG_ERROR("%{public}s, appTypeCB == nullptr.", __func__);
951 return nullptr;
952 }
953 appTypeCB->cbBase.cbInfo.env = env;
954 appTypeCB->cbBase.asyncWork = nullptr;
955 appTypeCB->cbBase.deferred = nullptr;
956 appTypeCB->cbBase.ability = ability;
957
958 HILOG_INFO("%{public}s, end.", __func__);
959 return appTypeCB;
960 }
961
962 /**
963 * @brief GetAppType asynchronous processing function.
964 *
965 * @param env The environment that the Node-API call is invoked under.
966 * @param data Point to asynchronous processing of data.
967 */
GetAppTypeExecuteCB(napi_env,void * data)968 void GetAppTypeExecuteCB(napi_env, void *data)
969 {
970 HILOG_INFO("NAPI_GetApplicationInfo, worker pool thread execute.");
971 AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
972 if (appTypeCB == nullptr) {
973 HILOG_ERROR("NAPI_GetApplicationInfo,appTypeCB == nullptr");
974 return;
975 }
976
977 appTypeCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
978 if (appTypeCB->cbBase.ability == nullptr) {
979 HILOG_ERROR("NAPI_GetApplicationInfo,ability == nullptr");
980 appTypeCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
981 return;
982 }
983
984 if (!CheckAbilityType(&appTypeCB->cbBase)) {
985 HILOG_ERROR("NAPI_GetApplicationInfo,wrong ability type");
986 appTypeCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
987 return;
988 }
989
990 appTypeCB->name = appTypeCB->cbBase.ability->GetAppType();
991 HILOG_INFO("NAPI_GetApplicationInfo, worker pool thread execute end.");
992 }
993
994 /**
995 * @brief The callback at the end of the asynchronous callback.
996 *
997 * @param env The environment that the Node-API call is invoked under.
998 * @param data Point to asynchronous processing of data.
999 */
GetAppTypeAsyncCompleteCB(napi_env env,napi_status,void * data)1000 void GetAppTypeAsyncCompleteCB(napi_env env, napi_status, void *data)
1001 {
1002 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete.");
1003 AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
1004 napi_value callback = nullptr;
1005 napi_value undefined = nullptr;
1006 napi_value result[ARGS_TWO] = {nullptr};
1007 napi_value callResult = nullptr;
1008 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1009
1010 result[PARAM0] = GetCallbackErrorValue(env, appTypeCB->cbBase.errCode);
1011 if (appTypeCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1012 NAPI_CALL_RETURN_VOID(env,
1013 napi_create_string_utf8(
1014 env, appTypeCB->cbBase.ability->GetAppType().c_str(), NAPI_AUTO_LENGTH, &result[PARAM1]));
1015 } else {
1016 result[PARAM1] = WrapUndefinedToJS(env);
1017 }
1018 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appTypeCB->cbBase.cbInfo.callback, &callback));
1019 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1020
1021 if (appTypeCB->cbBase.cbInfo.callback != nullptr) {
1022 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appTypeCB->cbBase.cbInfo.callback));
1023 }
1024 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appTypeCB->cbBase.asyncWork));
1025 delete appTypeCB;
1026 appTypeCB = nullptr;
1027 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete end.");
1028 }
1029
1030 /**
1031 * @brief The callback at the end of the Promise callback.
1032 *
1033 * @param env The environment that the Node-API call is invoked under.
1034 * @param data Point to asynchronous processing of data.
1035 */
GetAppTypePromiseCompleteCB(napi_env env,napi_status,void * data)1036 void GetAppTypePromiseCompleteCB(napi_env env, napi_status, void *data)
1037 {
1038 HILOG_INFO("GetAppTypePromiseCompleteCB, main event thread complete.");
1039 AppTypeCB *appTypeCB = static_cast<AppTypeCB *>(data);
1040 napi_value result = nullptr;
1041 if (appTypeCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1042 napi_create_string_utf8(env, appTypeCB->cbBase.ability->GetAppType().c_str(), NAPI_AUTO_LENGTH, &result);
1043 napi_resolve_deferred(env, appTypeCB->cbBase.deferred, result);
1044 } else {
1045 result = GetCallbackErrorValue(env, appTypeCB->cbBase.errCode);
1046 napi_reject_deferred(env, appTypeCB->cbBase.deferred, result);
1047 }
1048
1049 napi_delete_async_work(env, appTypeCB->cbBase.asyncWork);
1050 delete appTypeCB;
1051 appTypeCB = nullptr;
1052 HILOG_INFO("GetAppTypePromiseCompleteCB, main event thread complete end.");
1053 }
1054
1055 /**
1056 * @brief GetAppType Async.
1057 *
1058 * @param env The environment that the Node-API call is invoked under.
1059 * @param args Indicates the arguments passed into the callback.
1060 * @param argcPromise Asynchronous data processing.
1061 * @param appTypeCB Process data asynchronously.
1062 *
1063 * @return Return JS data successfully, otherwise return nullptr.
1064 */
GetAppTypeAsync(napi_env env,napi_value * args,const size_t argCallback,AppTypeCB * appTypeCB)1065 napi_value GetAppTypeAsync(napi_env env, napi_value *args, const size_t argCallback, AppTypeCB *appTypeCB)
1066 {
1067 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1068 if (args == nullptr || appTypeCB == nullptr) {
1069 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1070 return nullptr;
1071 }
1072 napi_value resourceName = nullptr;
1073 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1074
1075 napi_valuetype valuetype = napi_undefined;
1076 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1077 if (valuetype == napi_function) {
1078 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appTypeCB->cbBase.cbInfo.callback));
1079 }
1080 NAPI_CALL(env,
1081 napi_create_async_work(env,
1082 nullptr,
1083 resourceName,
1084 GetAppTypeExecuteCB,
1085 GetAppTypeAsyncCompleteCB,
1086 static_cast<void *>(appTypeCB),
1087 &appTypeCB->cbBase.asyncWork));
1088 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appTypeCB->cbBase.asyncWork, napi_qos_user_initiated));
1089 napi_value result = nullptr;
1090 NAPI_CALL(env, napi_get_null(env, &result));
1091 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
1092 return result;
1093 }
1094
1095 /**
1096 * @brief GetAppType Promise.
1097 *
1098 * @param env The environment that the Node-API call is invoked under.
1099 * @param appTypeCB Process data asynchronously.
1100 *
1101 * @return Return JS data successfully, otherwise return nullptr.
1102 */
GetAppTypePromise(napi_env env,AppTypeCB * appTypeCB)1103 napi_value GetAppTypePromise(napi_env env, AppTypeCB *appTypeCB)
1104 {
1105 HILOG_INFO("%{public}s, promise.", __func__);
1106 if (appTypeCB == nullptr) {
1107 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1108 return nullptr;
1109 }
1110 napi_value resourceName = nullptr;
1111 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1112 napi_deferred deferred;
1113 napi_value promise = nullptr;
1114 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1115 appTypeCB->cbBase.deferred = deferred;
1116
1117 NAPI_CALL(env,
1118 napi_create_async_work(env,
1119 nullptr,
1120 resourceName,
1121 GetAppTypeExecuteCB,
1122 GetAppTypePromiseCompleteCB,
1123 static_cast<void *>(appTypeCB),
1124 &appTypeCB->cbBase.asyncWork));
1125 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appTypeCB->cbBase.asyncWork, napi_qos_user_initiated));
1126 HILOG_INFO("%{public}s, promise end.", __func__);
1127 return promise;
1128 }
1129
1130 /**
1131 * @brief GetAppType processing function.
1132 *
1133 * @param env The environment that the Node-API call is invoked under.
1134 * @param appTypeCB Process data asynchronously.
1135 *
1136 * @return Return JS data successfully, otherwise return nullptr.
1137 */
GetAppTypeWrap(napi_env env,napi_callback_info info,AppTypeCB * appTypeCB)1138 napi_value GetAppTypeWrap(napi_env env, napi_callback_info info, AppTypeCB *appTypeCB)
1139 {
1140 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1141 if (appTypeCB == nullptr) {
1142 HILOG_ERROR("%{public}s, appTypeCB == nullptr.", __func__);
1143 return nullptr;
1144 }
1145
1146 size_t argcAsync = 1;
1147 const size_t argcPromise = 0;
1148 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1149 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1150 napi_value ret = nullptr;
1151
1152 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1153 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1154 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
1155 return nullptr;
1156 }
1157
1158 if (argcAsync > argcPromise) {
1159 ret = GetAppTypeAsync(env, args, 0, appTypeCB);
1160 } else {
1161 ret = GetAppTypePromise(env, appTypeCB);
1162 }
1163 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
1164 return ret;
1165 }
1166
1167 /**
1168 * @brief Obtains the type of this application.
1169 *
1170 * @param env The environment that the Node-API call is invoked under.
1171 * @param info The callback info passed into the callback function.
1172 *
1173 * @return The return value from NAPI C++ to JS for the module.
1174 */
NAPI_GetAppTypeCommon(napi_env env,napi_callback_info info,AbilityType abilityType)1175 napi_value NAPI_GetAppTypeCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
1176 {
1177 HILOG_INFO("%{public}s called.", __func__);
1178 AppTypeCB *appTypeCB = CreateAppTypeCBInfo(env);
1179 if (appTypeCB == nullptr) {
1180 return WrapVoidToJS(env);
1181 }
1182
1183 appTypeCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1184 appTypeCB->cbBase.abilityType = abilityType;
1185 napi_value ret = GetAppTypeWrap(env, info, appTypeCB);
1186 if (ret == nullptr) {
1187 HILOG_ERROR("%{public}s, ret == nullptr.", __func__);
1188 if (appTypeCB != nullptr) {
1189 delete appTypeCB;
1190 appTypeCB = nullptr;
1191 }
1192 ret = WrapVoidToJS(env);
1193 }
1194 HILOG_INFO("%{public}s, end.", __func__);
1195 return ret;
1196 }
1197
1198 #ifdef SUPPORT_GRAPHICS
GetDisplayOrientationWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)1199 napi_value GetDisplayOrientationWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
1200 {
1201 HILOG_DEBUG("%{public}s called.", __func__);
1202 size_t argc = ARGS_MAX_COUNT;
1203 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1204 napi_value jsthis = nullptr;
1205 void *data = nullptr;
1206
1207 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
1208
1209 if (!UnwrapParamGetDisplayOrientationWrap(env, argc, args, asyncCallbackInfo)) {
1210 HILOG_INFO("%{public}s called. Invoke UnwrapParamGetDisplayOrientationWrap fail", __func__);
1211 return nullptr;
1212 }
1213
1214 AsyncParamEx asyncParamEx;
1215 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
1216 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
1217 asyncParamEx.resource = "NAPI_GetDisplayOrientationWrapCallback";
1218 asyncParamEx.execute = GetDisplayOrientationExecuteCallback;
1219 asyncParamEx.complete = CompleteAsyncCallbackWork;
1220
1221 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1222 } else {
1223 HILOG_INFO("%{public}s called. promise.", __func__);
1224 asyncParamEx.resource = "NAPI_GetDisplayOrientationWrapPromise";
1225 asyncParamEx.execute = GetDisplayOrientationExecuteCallback;
1226 asyncParamEx.complete = CompletePromiseCallbackWork;
1227
1228 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
1229 }
1230 }
1231
GetDisplayOrientationExecuteCallback(napi_env env,void * data)1232 void GetDisplayOrientationExecuteCallback(napi_env env, void *data)
1233 {
1234 HILOG_INFO("%{public}s called.", __func__);
1235 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
1236 if (asyncCallbackInfo == nullptr) {
1237 HILOG_ERROR("%{public}s asyncCallbackInfo is null", __func__);
1238 return;
1239 }
1240
1241 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1242 asyncCallbackInfo->native_data.data_type = NVT_NONE;
1243
1244 if (asyncCallbackInfo->ability == nullptr) {
1245 HILOG_ERROR("%{public}s ability is null", __func__);
1246 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
1247 return;
1248 }
1249
1250 if (!CheckAbilityType(asyncCallbackInfo)) {
1251 HILOG_ERROR("%{public}s wrong ability type", __func__);
1252 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
1253 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
1254 return;
1255 }
1256
1257 asyncCallbackInfo->native_data.data_type = NVT_INT32;
1258 asyncCallbackInfo->native_data.int32_value = asyncCallbackInfo->ability->GetDisplayOrientation();
1259 HILOG_INFO("%{public}s end.", __func__);
1260 }
1261
UnwrapParamGetDisplayOrientationWrap(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)1262 bool UnwrapParamGetDisplayOrientationWrap(napi_env env, size_t argc, napi_value *argv,
1263 AsyncJSCallbackInfo *asyncCallbackInfo)
1264 {
1265 HILOG_INFO("%{public}s called, argc=%{public}zu", __func__, argc);
1266 const size_t argcMax = 1;
1267 if (argc > argcMax || argc < argcMax - 1) {
1268 HILOG_ERROR("%{public}s, Params is invalid.", __func__);
1269 return false;
1270 }
1271
1272 if (argc == argcMax) {
1273 if (!CreateAsyncCallback(env, argv[PARAM0], asyncCallbackInfo)) {
1274 HILOG_INFO("%{public}s, the first parameter is invalid.", __func__);
1275 return false;
1276 }
1277 }
1278
1279 return true;
1280 }
1281
NAPI_GetDisplayOrientationCommon(napi_env env,napi_callback_info info,AbilityType abilityType)1282 napi_value NAPI_GetDisplayOrientationCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
1283 {
1284 HILOG_DEBUG("%{public}s called.", __func__);
1285 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
1286 if (asyncCallbackInfo == nullptr) {
1287 HILOG_ERROR("%{public}s. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
1288 return WrapVoidToJS(env);
1289 }
1290
1291 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
1292 asyncCallbackInfo->abilityType = abilityType;
1293 napi_value ret = GetDisplayOrientationWrap(env, info, asyncCallbackInfo);
1294 if (ret == nullptr) {
1295 HILOG_ERROR("%{public}s, ret == nullptr.", __func__);
1296 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
1297 ret = WrapVoidToJS(env);
1298 }
1299 HILOG_DEBUG("%{public}s, end.", __func__);
1300 return ret;
1301 }
1302 #endif
1303
1304 /**
1305 * @brief Create asynchronous data.
1306 *
1307 * @param env The environment that the Node-API call is invoked under.
1308 *
1309 * @return Return a pointer to AbilityInfoCB on success, nullptr on failure.
1310 */
CreateAbilityInfoCBInfo(napi_env env)1311 AbilityInfoCB *CreateAbilityInfoCBInfo(napi_env env)
1312 {
1313 HILOG_INFO("%{public}s called.", __func__);
1314 napi_value global = nullptr;
1315 NAPI_CALL(env, napi_get_global(env, &global));
1316
1317 napi_value abilityObj = nullptr;
1318 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1319
1320 Ability *ability = nullptr;
1321 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1322
1323 AbilityInfoCB *abilityInfoCB = new (std::nothrow) AbilityInfoCB;
1324 if (abilityInfoCB == nullptr) {
1325 HILOG_ERROR("%{public}s, abilityInfoCB == nullptr.", __func__);
1326 return nullptr;
1327 }
1328 abilityInfoCB->cbBase.cbInfo.env = env;
1329 abilityInfoCB->cbBase.asyncWork = nullptr;
1330 abilityInfoCB->cbBase.deferred = nullptr;
1331 abilityInfoCB->cbBase.ability = ability;
1332
1333 HILOG_INFO("%{public}s end.", __func__);
1334 return abilityInfoCB;
1335 }
1336
WrapAbilityInfo(napi_env env,const AbilityInfo & abilityInfo)1337 napi_value WrapAbilityInfo(napi_env env, const AbilityInfo &abilityInfo)
1338 {
1339 HILOG_INFO("%{public}s called.", __func__);
1340 napi_value result = nullptr;
1341 napi_value proValue = nullptr;
1342 NAPI_CALL(env, napi_create_object(env, &result));
1343 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.bundleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1344 NAPI_CALL(env, napi_set_named_property(env, result, "bundleName", proValue));
1345
1346 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
1347 NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
1348
1349 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
1350 NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
1351
1352 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
1353 NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
1354
1355 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
1356 NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
1357
1358 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1359 NAPI_CALL(env, napi_set_named_property(env, result, "moduleName", proValue));
1360
1361 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.process.c_str(), NAPI_AUTO_LENGTH, &proValue));
1362 NAPI_CALL(env, napi_set_named_property(env, result, "process", proValue));
1363
1364 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.type), &proValue));
1365 NAPI_CALL(env, napi_set_named_property(env, result, "type", proValue));
1366
1367 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.orientation), &proValue));
1368 NAPI_CALL(env, napi_set_named_property(env, result, "orientation", proValue));
1369
1370 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.launchMode), &proValue));
1371 NAPI_CALL(env, napi_set_named_property(env, result, "launchMode", proValue));
1372
1373 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.uri.c_str(), NAPI_AUTO_LENGTH, &proValue));
1374 NAPI_CALL(env, napi_set_named_property(env, result, "uri", proValue));
1375
1376 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.readPermission.c_str(), NAPI_AUTO_LENGTH, &proValue));
1377 NAPI_CALL(env, napi_set_named_property(env, result, "readPermission", proValue));
1378
1379 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.writePermission.c_str(), NAPI_AUTO_LENGTH, &proValue));
1380 NAPI_CALL(env, napi_set_named_property(env, result, "writePermission", proValue));
1381
1382 NAPI_CALL(env, napi_create_string_utf8(env, abilityInfo.targetAbility.c_str(), NAPI_AUTO_LENGTH, &proValue));
1383 NAPI_CALL(env, napi_set_named_property(env, result, "targetAbility", proValue));
1384
1385 NAPI_CALL(env, napi_create_int32(env, abilityInfo.labelId, &proValue));
1386 NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
1387
1388 NAPI_CALL(env, napi_create_int32(env, abilityInfo.descriptionId, &proValue));
1389 NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
1390
1391 NAPI_CALL(env, napi_create_int32(env, abilityInfo.iconId, &proValue));
1392 NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
1393
1394 NAPI_CALL(env, napi_create_int32(env, abilityInfo.formEntity, &proValue));
1395 NAPI_CALL(env, napi_set_named_property(env, result, "formEntity", proValue));
1396
1397 NAPI_CALL(env, napi_create_int32(env, abilityInfo.minFormHeight, &proValue));
1398 NAPI_CALL(env, napi_set_named_property(env, result, "minFormHeight", proValue));
1399
1400 NAPI_CALL(env, napi_create_int32(env, abilityInfo.defaultFormHeight, &proValue));
1401 NAPI_CALL(env, napi_set_named_property(env, result, "defaultFormHeight", proValue));
1402
1403 NAPI_CALL(env, napi_create_int32(env, abilityInfo.minFormWidth, &proValue));
1404 NAPI_CALL(env, napi_set_named_property(env, result, "minFormWidth", proValue));
1405
1406 NAPI_CALL(env, napi_create_int32(env, abilityInfo.defaultFormWidth, &proValue));
1407 NAPI_CALL(env, napi_set_named_property(env, result, "defaultFormWidth", proValue));
1408
1409 NAPI_CALL(env, napi_create_int32(env, abilityInfo.backgroundModes, &proValue));
1410 NAPI_CALL(env, napi_set_named_property(env, result, "backgroundModes", proValue));
1411
1412 NAPI_CALL(env, napi_create_int32(env, static_cast<int32_t>(abilityInfo.subType), &proValue));
1413 NAPI_CALL(env, napi_set_named_property(env, result, "subType", proValue));
1414
1415 NAPI_CALL(env, napi_get_boolean(env, abilityInfo.visible, &proValue));
1416 NAPI_CALL(env, napi_set_named_property(env, result, "isVisible", proValue));
1417
1418 NAPI_CALL(env, napi_get_boolean(env, abilityInfo.formEnabled, &proValue));
1419 NAPI_CALL(env, napi_set_named_property(env, result, "formEnabled", proValue));
1420
1421 (void)WrapProperties(env, abilityInfo.permissions, "permissions", result);
1422 (void)WrapProperties(env, abilityInfo.deviceCapabilities, "deviceCapabilities", result);
1423 (void)WrapProperties(env, abilityInfo.deviceTypes, "deviceTypes", result);
1424
1425 napi_value applicationInfo = nullptr;
1426 applicationInfo = WrapAppInfo(env, abilityInfo.applicationInfo);
1427 NAPI_CALL(env, napi_set_named_property(env, result, "applicationInfo", applicationInfo));
1428 HILOG_INFO("%{public}s end.", __func__);
1429 return result;
1430 }
1431
WrapProperties(napi_env env,const std::vector<std::string> properties,const std::string & proName,napi_value & result)1432 napi_value WrapProperties(napi_env env, const std::vector<std::string> properties, const std::string &proName,
1433 napi_value &result)
1434 {
1435 napi_value jsArrayProperties = nullptr;
1436 NAPI_CALL(env, napi_create_array(env, &jsArrayProperties));
1437 napi_value proValue = nullptr;
1438 for (size_t i = 0; i < properties.size(); i++) {
1439 NAPI_CALL(
1440 env, napi_create_string_utf8(env, properties.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
1441 NAPI_CALL(env, napi_set_element(env, jsArrayProperties, i, proValue));
1442 }
1443 NAPI_CALL(env, napi_set_named_property(env, result, proName.c_str(), jsArrayProperties));
1444 return result;
1445 }
1446
WrapModuleInfos(napi_env env,const ApplicationInfo & appInfo,napi_value & result)1447 napi_value WrapModuleInfos(napi_env env, const ApplicationInfo &appInfo, napi_value &result)
1448 {
1449 napi_value jsArrayModuleInfo = nullptr;
1450 napi_value jsModuleInfoObject = nullptr;
1451 napi_value proValue = nullptr;
1452 NAPI_CALL(env, napi_create_array(env, &jsArrayModuleInfo));
1453 for (size_t i = 0; i < appInfo.moduleInfos.size(); i++) {
1454 NAPI_CALL(env, napi_create_object(env, &jsModuleInfoObject));
1455 proValue = nullptr;
1456 NAPI_CALL(env,
1457 napi_create_string_utf8(env, appInfo.moduleInfos.at(i).moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1458 NAPI_CALL(env, napi_set_named_property(env, jsModuleInfoObject, "moduleName", proValue));
1459
1460 NAPI_CALL(env,
1461 napi_create_string_utf8(
1462 env, appInfo.moduleInfos.at(i).moduleSourceDir.c_str(), NAPI_AUTO_LENGTH, &proValue));
1463 NAPI_CALL(env, napi_set_named_property(env, jsModuleInfoObject, "moduleSourceDir", proValue));
1464 NAPI_CALL(env, napi_set_element(env, jsArrayModuleInfo, i, jsModuleInfoObject));
1465 }
1466 NAPI_CALL(env, napi_set_named_property(env, result, "moduleInfos", jsArrayModuleInfo));
1467 return nullptr;
1468 }
1469
ConvertAbilityInfo(napi_env env,const AbilityInfo & abilityInfo)1470 napi_value ConvertAbilityInfo(napi_env env, const AbilityInfo &abilityInfo)
1471 {
1472 return WrapAbilityInfo(env, abilityInfo);
1473 }
1474
1475 /**
1476 * @brief GetAbilityInfo asynchronous processing function.
1477 *
1478 * @param env The environment that the Node-API call is invoked under.
1479 * @param data Point to asynchronous processing of data.
1480 */
GetAbilityInfoExecuteCB(napi_env,void * data)1481 void GetAbilityInfoExecuteCB(napi_env, void *data)
1482 {
1483 HILOG_INFO("NAPI_GetApplicationInfo, worker pool thread execute.");
1484 AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
1485 if (abilityInfoCB == nullptr) {
1486 HILOG_ERROR("NAPI_GetApplicationInfo, abilityInfoCB == nullptr");
1487 return;
1488 }
1489
1490 abilityInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1491 if (abilityInfoCB->cbBase.ability == nullptr) {
1492 HILOG_ERROR("NAPI_GetApplicationInfo, ability == nullptr");
1493 abilityInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1494 return;
1495 }
1496
1497 if (!CheckAbilityType(&abilityInfoCB->cbBase)) {
1498 HILOG_ERROR("NAPI_GetApplicationInfo,wrong ability type");
1499 abilityInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
1500 return;
1501 }
1502
1503 std::shared_ptr<AbilityInfo> abilityInfoPtr = abilityInfoCB->cbBase.ability->GetAbilityInfo();
1504 if (abilityInfoPtr != nullptr) {
1505 abilityInfoCB->abilityInfo = *abilityInfoPtr;
1506 } else {
1507 abilityInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1508 }
1509 HILOG_INFO("NAPI_GetApplicationInfo, worker pool thread execute end.");
1510 }
1511
1512 /**
1513 * @brief The callback at the end of the asynchronous callback.
1514 *
1515 * @param env The environment that the Node-API call is invoked under.
1516 * @param data Point to asynchronous processing of data.
1517 */
GetAbilityInfoAsyncCompleteCB(napi_env env,napi_status,void * data)1518 void GetAbilityInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
1519 {
1520 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete.");
1521 AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
1522 napi_value callback = nullptr;
1523 napi_value undefined = nullptr;
1524 napi_value result[ARGS_TWO] = {nullptr};
1525 napi_value callResult = nullptr;
1526 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1527 result[PARAM0] = GetCallbackErrorValue(env, abilityInfoCB->cbBase.errCode);
1528 if (abilityInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1529 result[PARAM1] = WrapAbilityInfo(env, abilityInfoCB->abilityInfo);
1530 } else {
1531 result[PARAM1] = WrapUndefinedToJS(env);
1532 }
1533 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, abilityInfoCB->cbBase.cbInfo.callback, &callback));
1534 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1535
1536 if (abilityInfoCB->cbBase.cbInfo.callback != nullptr) {
1537 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, abilityInfoCB->cbBase.cbInfo.callback));
1538 }
1539 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, abilityInfoCB->cbBase.asyncWork));
1540 delete abilityInfoCB;
1541 abilityInfoCB = nullptr;
1542 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete end.");
1543 }
1544
1545 /**
1546 * @brief The callback at the end of the Promise callback.
1547 *
1548 * @param env The environment that the Node-API call is invoked under.
1549 * @param data Point to asynchronous processing of data.
1550 */
GetAbilityInfoPromiseCompleteCB(napi_env env,napi_status,void * data)1551 void GetAbilityInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
1552 {
1553 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete.");
1554 AbilityInfoCB *abilityInfoCB = static_cast<AbilityInfoCB *>(data);
1555 napi_value result = nullptr;
1556 if (abilityInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1557 result = WrapAbilityInfo(env, abilityInfoCB->abilityInfo);
1558 napi_resolve_deferred(env, abilityInfoCB->cbBase.deferred, result);
1559 } else {
1560 result = GetCallbackErrorValue(env, abilityInfoCB->cbBase.errCode);
1561 napi_reject_deferred(env, abilityInfoCB->cbBase.deferred, result);
1562 }
1563
1564 napi_delete_async_work(env, abilityInfoCB->cbBase.asyncWork);
1565 delete abilityInfoCB;
1566 abilityInfoCB = nullptr;
1567 HILOG_INFO("NAPI_GetApplicationInfo, main event thread complete end.");
1568 }
1569
1570 /**
1571 * @brief GetAbilityInfo Async.
1572 *
1573 * @param env The environment that the Node-API call is invoked under.
1574 * @param args Indicates the arguments passed into the callback.
1575 * @param argcPromise Asynchronous data processing.
1576 * @param abilityInfoCB Process data asynchronously.
1577 *
1578 * @return Return JS data successfully, otherwise return nullptr.
1579 */
GetAbilityInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AbilityInfoCB * abilityInfoCB)1580 napi_value GetAbilityInfoAsync(napi_env env, napi_value *args, const size_t argCallback, AbilityInfoCB *abilityInfoCB)
1581 {
1582 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1583 if (args == nullptr || abilityInfoCB == nullptr) {
1584 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1585 return nullptr;
1586 }
1587 napi_value resourceName = nullptr;
1588 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1589
1590 napi_valuetype valuetype = napi_undefined;
1591 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1592 if (valuetype == napi_function) {
1593 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &abilityInfoCB->cbBase.cbInfo.callback));
1594 }
1595 NAPI_CALL(env,
1596 napi_create_async_work(env,
1597 nullptr,
1598 resourceName,
1599 GetAbilityInfoExecuteCB,
1600 GetAbilityInfoAsyncCompleteCB,
1601 static_cast<void *>(abilityInfoCB),
1602 &abilityInfoCB->cbBase.asyncWork));
1603 NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1604 napi_value result = nullptr;
1605 NAPI_CALL(env, napi_get_null(env, &result));
1606 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
1607 return result;
1608 }
1609
1610 /**
1611 * @brief GetAbilityInfo Promise.
1612 *
1613 * @param env The environment that the Node-API call is invoked under.
1614 * @param abilityInfoCB Process data asynchronously.
1615 *
1616 * @return Return JS data successfully, otherwise return nullptr.
1617 */
GetAbilityInfoPromise(napi_env env,AbilityInfoCB * abilityInfoCB)1618 napi_value GetAbilityInfoPromise(napi_env env, AbilityInfoCB *abilityInfoCB)
1619 {
1620 HILOG_INFO("%{public}s, promise.", __func__);
1621 if (abilityInfoCB == nullptr) {
1622 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1623 return nullptr;
1624 }
1625 napi_value resourceName = nullptr;
1626 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1627 napi_deferred deferred;
1628 napi_value promise = nullptr;
1629 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1630 abilityInfoCB->cbBase.deferred = deferred;
1631
1632 NAPI_CALL(env,
1633 napi_create_async_work(env,
1634 nullptr,
1635 resourceName,
1636 GetAbilityInfoExecuteCB,
1637 GetAbilityInfoPromiseCompleteCB,
1638 static_cast<void *>(abilityInfoCB),
1639 &abilityInfoCB->cbBase.asyncWork));
1640 NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1641 HILOG_INFO("%{public}s, promise end.", __func__);
1642 return promise;
1643 }
1644
1645 /**
1646 * @brief GetAbilityInfo processing function.
1647 *
1648 * @param env The environment that the Node-API call is invoked under.
1649 * @param abilityInfoCB Process data asynchronously.
1650 *
1651 * @return Return JS data successfully, otherwise return nullptr.
1652 */
GetAbilityInfoWrap(napi_env env,napi_callback_info info,AbilityInfoCB * abilityInfoCB)1653 napi_value GetAbilityInfoWrap(napi_env env, napi_callback_info info, AbilityInfoCB *abilityInfoCB)
1654 {
1655 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1656 if (abilityInfoCB == nullptr) {
1657 HILOG_ERROR("%{public}s, abilityInfoCB == nullptr.", __func__);
1658 return nullptr;
1659 }
1660
1661 size_t argcAsync = 1;
1662 const size_t argcPromise = 0;
1663 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1664 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1665 napi_value ret = nullptr;
1666
1667 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1668 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1669 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
1670 return nullptr;
1671 }
1672
1673 if (argcAsync > argcPromise) {
1674 ret = GetAbilityInfoAsync(env, args, 0, abilityInfoCB);
1675 } else {
1676 ret = GetAbilityInfoPromise(env, abilityInfoCB);
1677 }
1678 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
1679 return ret;
1680 }
1681
1682 /**
1683 * @brief Obtains information about the current ability.
1684 *
1685 * @param env The environment that the Node-API call is invoked under.
1686 * @param info The callback info passed into the callback function.
1687 *
1688 * @return The return value from NAPI C++ to JS for the module.
1689 */
NAPI_GetAbilityInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)1690 napi_value NAPI_GetAbilityInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
1691 {
1692 HILOG_INFO("%{public}s called.", __func__);
1693 AbilityInfoCB *abilityInfoCB = CreateAbilityInfoCBInfo(env);
1694 if (abilityInfoCB == nullptr) {
1695 return WrapVoidToJS(env);
1696 }
1697
1698 abilityInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1699 abilityInfoCB->cbBase.abilityType = abilityType;
1700 napi_value ret = GetAbilityInfoWrap(env, info, abilityInfoCB);
1701 if (ret == nullptr) {
1702 HILOG_ERROR("%{public}s ret == nullptr", __func__);
1703 if (abilityInfoCB != nullptr) {
1704 delete abilityInfoCB;
1705 abilityInfoCB = nullptr;
1706 }
1707 ret = WrapVoidToJS(env);
1708 }
1709 HILOG_INFO("%{public}s end.", __func__);
1710 return ret;
1711 }
1712
1713 /**
1714 * @brief Create asynchronous data.
1715 *
1716 * @param env The environment that the Node-API call is invoked under.
1717 *
1718 * @return Return a pointer to HapModuleInfoCB on success, nullptr on failure.
1719 */
CreateHapModuleInfoCBInfo(napi_env env)1720 HapModuleInfoCB *CreateHapModuleInfoCBInfo(napi_env env)
1721 {
1722 HILOG_INFO("%{public}s called.", __func__);
1723 napi_value global = nullptr;
1724 NAPI_CALL(env, napi_get_global(env, &global));
1725
1726 napi_value abilityObj = nullptr;
1727 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
1728
1729 Ability *ability = nullptr;
1730 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
1731
1732 HapModuleInfoCB *hapModuleInfoCB = new (std::nothrow) HapModuleInfoCB;
1733 if (hapModuleInfoCB == nullptr) {
1734 HILOG_ERROR("%{public}s, hapModuleInfoCB == nullptr.", __func__);
1735 return nullptr;
1736 }
1737 hapModuleInfoCB->cbBase.cbInfo.env = env;
1738 hapModuleInfoCB->cbBase.asyncWork = nullptr;
1739 hapModuleInfoCB->cbBase.deferred = nullptr;
1740 hapModuleInfoCB->cbBase.ability = ability;
1741
1742 HILOG_INFO("%{public}s end.", __func__);
1743 return hapModuleInfoCB;
1744 }
1745
WrapHapModuleInfo(napi_env env,const HapModuleInfoCB & hapModuleInfoCB)1746 napi_value WrapHapModuleInfo(napi_env env, const HapModuleInfoCB &hapModuleInfoCB)
1747 {
1748 HILOG_INFO("%{public}s called.", __func__);
1749 napi_value result = nullptr;
1750 napi_value proValue = nullptr;
1751 NAPI_CALL(env, napi_create_object(env, &result));
1752 NAPI_CALL(
1753 env, napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.name.c_str(), NAPI_AUTO_LENGTH, &proValue));
1754 NAPI_CALL(env, napi_set_named_property(env, result, "name", proValue));
1755
1756 NAPI_CALL(env,
1757 napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.description.c_str(), NAPI_AUTO_LENGTH, &proValue));
1758 NAPI_CALL(env, napi_set_named_property(env, result, "description", proValue));
1759
1760 NAPI_CALL(
1761 env, napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.iconPath.c_str(), NAPI_AUTO_LENGTH, &proValue));
1762 NAPI_CALL(env, napi_set_named_property(env, result, "icon", proValue));
1763
1764 NAPI_CALL(
1765 env, napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.label.c_str(), NAPI_AUTO_LENGTH, &proValue));
1766 NAPI_CALL(env, napi_set_named_property(env, result, "label", proValue));
1767
1768 NAPI_CALL(env,
1769 napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.backgroundImg.c_str(), NAPI_AUTO_LENGTH, &proValue));
1770 NAPI_CALL(env, napi_set_named_property(env, result, "backgroundImg", proValue));
1771
1772 NAPI_CALL(env,
1773 napi_create_string_utf8(env, hapModuleInfoCB.hapModuleInfo.moduleName.c_str(), NAPI_AUTO_LENGTH, &proValue));
1774 NAPI_CALL(env, napi_set_named_property(env, result, "moduleName", proValue));
1775
1776 NAPI_CALL(env, napi_create_int32(env, hapModuleInfoCB.hapModuleInfo.supportedModes, &proValue));
1777 NAPI_CALL(env, napi_set_named_property(env, result, "supportedModes", proValue));
1778
1779 NAPI_CALL(env, napi_create_int32(env, hapModuleInfoCB.hapModuleInfo.descriptionId, &proValue));
1780 NAPI_CALL(env, napi_set_named_property(env, result, "descriptionId", proValue));
1781
1782 NAPI_CALL(env, napi_create_int32(env, hapModuleInfoCB.hapModuleInfo.labelId, &proValue));
1783 NAPI_CALL(env, napi_set_named_property(env, result, "labelId", proValue));
1784
1785 NAPI_CALL(env, napi_create_int32(env, hapModuleInfoCB.hapModuleInfo.iconId, &proValue));
1786 NAPI_CALL(env, napi_set_named_property(env, result, "iconId", proValue));
1787
1788 NAPI_CALL(env,
1789 napi_create_string_utf8(
1790 env, hapModuleInfoCB.hapModuleInfo.mainAbility.c_str(), NAPI_AUTO_LENGTH, &proValue));
1791 NAPI_CALL(env, napi_set_named_property(env, result, "mainAbilityName", proValue));
1792
1793 NAPI_CALL(env, napi_get_boolean(env, hapModuleInfoCB.hapModuleInfo.installationFree, &proValue));
1794 NAPI_CALL(env, napi_set_named_property(env, result, "installationFree", proValue));
1795
1796 napi_value jsArrayreqCapabilities = nullptr;
1797 NAPI_CALL(env, napi_create_array(env, &jsArrayreqCapabilities));
1798 for (size_t i = 0; i < hapModuleInfoCB.hapModuleInfo.reqCapabilities.size(); i++) {
1799 proValue = nullptr;
1800 NAPI_CALL(env,
1801 napi_create_string_utf8(
1802 env, hapModuleInfoCB.hapModuleInfo.reqCapabilities.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
1803 NAPI_CALL(env, napi_set_element(env, jsArrayreqCapabilities, i, proValue));
1804 }
1805 NAPI_CALL(env, napi_set_named_property(env, result, "reqCapabilities", jsArrayreqCapabilities));
1806
1807 napi_value jsArraydeviceTypes = nullptr;
1808 NAPI_CALL(env, napi_create_array(env, &jsArraydeviceTypes));
1809 for (size_t i = 0; i < hapModuleInfoCB.hapModuleInfo.deviceTypes.size(); i++) {
1810 proValue = nullptr;
1811 NAPI_CALL(env,
1812 napi_create_string_utf8(
1813 env, hapModuleInfoCB.hapModuleInfo.deviceTypes.at(i).c_str(), NAPI_AUTO_LENGTH, &proValue));
1814 NAPI_CALL(env, napi_set_element(env, jsArraydeviceTypes, i, proValue));
1815 }
1816 NAPI_CALL(env, napi_set_named_property(env, result, "deviceTypes", jsArraydeviceTypes));
1817
1818 napi_value abilityInfos = nullptr;
1819 NAPI_CALL(env, napi_create_array(env, &abilityInfos));
1820 for (size_t i = 0; i < hapModuleInfoCB.hapModuleInfo.abilityInfos.size(); i++) {
1821 napi_value abilityInfo = nullptr;
1822 abilityInfo = WrapAbilityInfo(env, hapModuleInfoCB.hapModuleInfo.abilityInfos.at(i));
1823 NAPI_CALL(env, napi_set_element(env, abilityInfos, i, abilityInfo));
1824 }
1825 NAPI_CALL(env, napi_set_named_property(env, result, "abilityInfo", abilityInfos));
1826 HILOG_INFO("%{public}s end.", __func__);
1827 return result;
1828 }
1829
GetHapModuleInfoExecuteCB(napi_env,void * data)1830 void GetHapModuleInfoExecuteCB(napi_env, void *data)
1831 {
1832 HILOG_INFO("NAPI_GetHapModuleInfo, worker pool thread execute.");
1833 HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
1834 if (hapModuleInfoCB == nullptr) {
1835 HILOG_ERROR("NAPI_GetHapModuleInfo, hapModuleInfoCB == nullptr");
1836 return;
1837 }
1838
1839 hapModuleInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
1840 if (hapModuleInfoCB->cbBase.ability == nullptr) {
1841 HILOG_ERROR("NAPI_GetHapModuleInfo, ability == nullptr");
1842 hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
1843 return;
1844 }
1845
1846 if (!CheckAbilityType(&hapModuleInfoCB->cbBase)) {
1847 HILOG_ERROR("NAPI_GetHapModuleInfo,wrong ability type");
1848 hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
1849 return;
1850 }
1851
1852 std::shared_ptr<HapModuleInfo> hapModuleInfoPtr = hapModuleInfoCB->cbBase.ability->GetHapModuleInfo();
1853 if (hapModuleInfoPtr != nullptr) {
1854 hapModuleInfoCB->hapModuleInfo = *hapModuleInfoPtr;
1855 } else {
1856 hapModuleInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
1857 }
1858 HILOG_INFO("NAPI_GetHapModuleInfo, worker pool thread execute end.");
1859 }
1860
GetHapModuleInfoAsyncCompleteCB(napi_env env,napi_status,void * data)1861 void GetHapModuleInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
1862 {
1863 HILOG_INFO("NAPI_GetHapModuleInfo, main event thread complete.");
1864 HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
1865 napi_value callback = nullptr;
1866 napi_value undefined = nullptr;
1867 napi_value result[ARGS_TWO] = {nullptr};
1868 napi_value callResult = nullptr;
1869 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
1870 result[PARAM0] = GetCallbackErrorValue(env, hapModuleInfoCB->cbBase.errCode);
1871 if (hapModuleInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1872 result[PARAM1] = WrapHapModuleInfo(env, *hapModuleInfoCB);
1873 } else {
1874 result[PARAM1] = WrapUndefinedToJS(env);
1875 }
1876 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, hapModuleInfoCB->cbBase.cbInfo.callback, &callback));
1877 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
1878
1879 if (hapModuleInfoCB->cbBase.cbInfo.callback != nullptr) {
1880 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, hapModuleInfoCB->cbBase.cbInfo.callback));
1881 }
1882 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, hapModuleInfoCB->cbBase.asyncWork));
1883 delete hapModuleInfoCB;
1884 hapModuleInfoCB = nullptr;
1885 HILOG_INFO("NAPI_GetHapModuleInfo, main event thread complete end.");
1886 }
1887
GetHapModuleInfoPromiseCompleteCB(napi_env env,napi_status,void * data)1888 void GetHapModuleInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
1889 {
1890 HILOG_INFO("NAPI_GetHapModuleInfo, main event thread complete.");
1891 HapModuleInfoCB *hapModuleInfoCB = static_cast<HapModuleInfoCB *>(data);
1892 napi_value result = nullptr;
1893 if (hapModuleInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
1894 result = WrapHapModuleInfo(env, *hapModuleInfoCB);
1895 napi_resolve_deferred(env, hapModuleInfoCB->cbBase.deferred, result);
1896 } else {
1897 result = GetCallbackErrorValue(env, hapModuleInfoCB->cbBase.errCode);
1898 napi_reject_deferred(env, hapModuleInfoCB->cbBase.deferred, result);
1899 }
1900
1901 napi_delete_async_work(env, hapModuleInfoCB->cbBase.asyncWork);
1902 delete hapModuleInfoCB;
1903 hapModuleInfoCB = nullptr;
1904 HILOG_INFO("NAPI_GetHapModuleInfo, main event thread complete end.");
1905 }
1906
1907 /**
1908 * @brief GetHapModuleInfo Async.
1909 *
1910 * @param env The environment that the Node-API call is invoked under.
1911 * @param args Indicates the arguments passed into the callback.
1912 * @param argcPromise Asynchronous data processing.
1913 * @param hapModuleInfoCB Process data asynchronously.
1914 *
1915 * @return Return JS data successfully, otherwise return nullptr.
1916 */
GetHapModuleInfoAsync(napi_env env,napi_value * args,const size_t argCallback,HapModuleInfoCB * hapModuleInfoCB)1917 napi_value GetHapModuleInfoAsync(
1918 napi_env env, napi_value *args, const size_t argCallback, HapModuleInfoCB *hapModuleInfoCB)
1919 {
1920 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1921 if (args == nullptr || hapModuleInfoCB == nullptr) {
1922 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1923 return nullptr;
1924 }
1925 napi_value resourceName = nullptr;
1926 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1927
1928 napi_valuetype valuetype = napi_undefined;
1929 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
1930 if (valuetype == napi_function) {
1931 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &hapModuleInfoCB->cbBase.cbInfo.callback));
1932 }
1933 NAPI_CALL(env,
1934 napi_create_async_work(env,
1935 nullptr,
1936 resourceName,
1937 GetHapModuleInfoExecuteCB,
1938 GetHapModuleInfoAsyncCompleteCB,
1939 static_cast<void *>(hapModuleInfoCB),
1940 &hapModuleInfoCB->cbBase.asyncWork));
1941 NAPI_CALL(env, napi_queue_async_work_with_qos(env, hapModuleInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1942 napi_value result = nullptr;
1943 NAPI_CALL(env, napi_get_null(env, &result));
1944 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
1945 return result;
1946 }
1947
1948 /**
1949 * @brief GetHapModuleInfo Promise.
1950 *
1951 * @param env The environment that the Node-API call is invoked under.
1952 * @param hapModuleInfoCB Process data asynchronously.
1953 *
1954 * @return Return JS data successfully, otherwise return nullptr.
1955 */
GetHapModuleInfoPromise(napi_env env,HapModuleInfoCB * hapModuleInfoCB)1956 napi_value GetHapModuleInfoPromise(napi_env env, HapModuleInfoCB *hapModuleInfoCB)
1957 {
1958 HILOG_INFO("%{public}s, promise.", __func__);
1959 if (hapModuleInfoCB == nullptr) {
1960 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
1961 return nullptr;
1962 }
1963 napi_value resourceName = nullptr;
1964 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
1965 napi_deferred deferred;
1966 napi_value promise = nullptr;
1967 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1968 hapModuleInfoCB->cbBase.deferred = deferred;
1969
1970 NAPI_CALL(env,
1971 napi_create_async_work(env,
1972 nullptr,
1973 resourceName,
1974 GetHapModuleInfoExecuteCB,
1975 GetHapModuleInfoPromiseCompleteCB,
1976 static_cast<void *>(hapModuleInfoCB),
1977 &hapModuleInfoCB->cbBase.asyncWork));
1978 NAPI_CALL(env, napi_queue_async_work_with_qos(env, hapModuleInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
1979 HILOG_INFO("%{public}s, promise end.", __func__);
1980 return promise;
1981 }
1982
GetHapModuleInfoWrap(napi_env env,napi_callback_info info,HapModuleInfoCB * hapModuleInfoCB)1983 napi_value GetHapModuleInfoWrap(napi_env env, napi_callback_info info, HapModuleInfoCB *hapModuleInfoCB)
1984 {
1985 HILOG_INFO("%{public}s, asyncCallback.", __func__);
1986 if (hapModuleInfoCB == nullptr) {
1987 HILOG_ERROR("%{public}s, hapModuleInfoCB == nullptr.", __func__);
1988 return nullptr;
1989 }
1990
1991 size_t argcAsync = 1;
1992 const size_t argcPromise = 0;
1993 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
1994 napi_value args[ARGS_MAX_COUNT] = {nullptr};
1995 napi_value ret = nullptr;
1996
1997 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
1998 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
1999 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
2000 return nullptr;
2001 }
2002
2003 if (argcAsync > argcPromise) {
2004 ret = GetHapModuleInfoAsync(env, args, 0, hapModuleInfoCB);
2005 } else {
2006 ret = GetHapModuleInfoPromise(env, hapModuleInfoCB);
2007 }
2008 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2009 return ret;
2010 }
2011
2012 /**
2013 * @brief Obtains the HapModuleInfo object of the application.
2014 *
2015 * @param env The environment that the Node-API call is invoked under.
2016 * @param info The callback info passed into the callback function.
2017 *
2018 * @return The return value from NAPI C++ to JS for the module.
2019 */
NAPI_GetHapModuleInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)2020 napi_value NAPI_GetHapModuleInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
2021 {
2022 HILOG_INFO("%{public}s called.", __func__);
2023 HapModuleInfoCB *hapModuleInfoCB = CreateHapModuleInfoCBInfo(env);
2024 if (hapModuleInfoCB == nullptr) {
2025 return WrapVoidToJS(env);
2026 }
2027
2028 hapModuleInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2029 hapModuleInfoCB->cbBase.abilityType = abilityType;
2030 napi_value ret = GetHapModuleInfoWrap(env, info, hapModuleInfoCB);
2031 if (ret == nullptr) {
2032 HILOG_ERROR("%{public}s ret == nullptr", __func__);
2033 if (hapModuleInfoCB != nullptr) {
2034 delete hapModuleInfoCB;
2035 hapModuleInfoCB = nullptr;
2036 }
2037 ret = WrapVoidToJS(env);
2038 }
2039 HILOG_INFO("%{public}s end.", __func__);
2040 return ret;
2041 }
2042
2043 /**
2044 * @brief Create asynchronous data.
2045 *
2046 * @param env The environment that the Node-API call is invoked under.
2047 *
2048 * @return Return a pointer to AppVersionInfoCB on success, nullptr on failure.
2049 */
CreateAppVersionInfoCBInfo(napi_env env)2050 AppVersionInfoCB *CreateAppVersionInfoCBInfo(napi_env env)
2051 {
2052 HILOG_INFO("%{public}s called.", __func__);
2053 napi_value global = nullptr;
2054 NAPI_CALL(env, napi_get_global(env, &global));
2055
2056 napi_value abilityObj = nullptr;
2057 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
2058
2059 Ability *ability = nullptr;
2060 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
2061
2062 AppVersionInfoCB *appVersionInfoCB = new (std::nothrow) AppVersionInfoCB;
2063 if (appVersionInfoCB == nullptr) {
2064 HILOG_ERROR("%{public}s, appVersionInfoCB == nullptr.", __func__);
2065 return nullptr;
2066 }
2067 appVersionInfoCB->cbBase.cbInfo.env = env;
2068 appVersionInfoCB->cbBase.asyncWork = nullptr;
2069 appVersionInfoCB->cbBase.deferred = nullptr;
2070 appVersionInfoCB->cbBase.ability = ability;
2071
2072 HILOG_INFO("%{public}s end.", __func__);
2073 return appVersionInfoCB;
2074 }
2075
SaveAppVersionInfo(AppVersionInfo & appVersionInfo,const std::string appName,const std::string versionName,const int32_t versionCode)2076 void SaveAppVersionInfo(AppVersionInfo &appVersionInfo, const std::string appName, const std::string versionName,
2077 const int32_t versionCode)
2078 {
2079 HILOG_INFO("%{public}s called.", __func__);
2080 appVersionInfo.appName = appName;
2081 appVersionInfo.versionName = versionName;
2082 appVersionInfo.versionCode = versionCode;
2083 HILOG_INFO("%{public}s end.", __func__);
2084 }
2085
WrapAppVersionInfo(napi_env env,const AppVersionInfoCB & appVersionInfoCB)2086 napi_value WrapAppVersionInfo(napi_env env, const AppVersionInfoCB &appVersionInfoCB)
2087 {
2088 HILOG_INFO("%{public}s called.", __func__);
2089 napi_value result = nullptr;
2090 napi_value proValue = nullptr;
2091 NAPI_CALL(env, napi_create_object(env, &result));
2092 NAPI_CALL(env,
2093 napi_create_string_utf8(env, appVersionInfoCB.appVersionInfo.appName.c_str(), NAPI_AUTO_LENGTH, &proValue));
2094 NAPI_CALL(env, napi_set_named_property(env, result, "appName", proValue));
2095
2096 NAPI_CALL(env,
2097 napi_create_string_utf8(env, appVersionInfoCB.appVersionInfo.versionName.c_str(), NAPI_AUTO_LENGTH, &proValue));
2098 NAPI_CALL(env, napi_set_named_property(env, result, "versionName", proValue));
2099
2100 NAPI_CALL(env, napi_create_int32(env, appVersionInfoCB.appVersionInfo.versionCode, &proValue));
2101 NAPI_CALL(env, napi_set_named_property(env, result, "versionCode", proValue));
2102
2103 HILOG_INFO("%{public}s end.", __func__);
2104 return result;
2105 }
2106
GetAppVersionInfoExecuteCB(napi_env,void * data)2107 void GetAppVersionInfoExecuteCB(napi_env, void *data)
2108 {
2109 HILOG_INFO("NAPI_GetAppVersionInfo, worker pool thread execute.");
2110 AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
2111 if (appVersionInfoCB == nullptr) {
2112 HILOG_ERROR("NAPI_GetAppVersionInfo, appVersionInfoCB == nullptr");
2113 return;
2114 }
2115
2116 appVersionInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2117 if (appVersionInfoCB->cbBase.ability == nullptr) {
2118 HILOG_ERROR("NAPI_GetAppVersionInfo, ability == nullptr");
2119 appVersionInfoCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
2120 return;
2121 }
2122
2123 if (!CheckAbilityType(&appVersionInfoCB->cbBase)) {
2124 HILOG_ERROR("NAPI_GetAppVersionInfo,wrong ability type");
2125 appVersionInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
2126 return;
2127 }
2128
2129 std::shared_ptr<ApplicationInfo> appInfoPtr = appVersionInfoCB->cbBase.ability->GetApplicationInfo();
2130 if (appInfoPtr != nullptr) {
2131 SaveAppVersionInfo(appVersionInfoCB->appVersionInfo, appInfoPtr->name, appInfoPtr->versionName,
2132 appInfoPtr->versionCode);
2133 } else {
2134 appVersionInfoCB->cbBase.errCode = NAPI_ERR_ABILITY_CALL_INVALID;
2135 }
2136 HILOG_INFO("NAPI_GetAppVersionInfo, worker pool thread execute end.");
2137 }
2138
GetAppVersionInfoAsyncCompleteCB(napi_env env,napi_status,void * data)2139 void GetAppVersionInfoAsyncCompleteCB(napi_env env, napi_status, void *data)
2140 {
2141 HILOG_INFO("NAPI_GetAppVersionInfo, main event thread complete.");
2142 AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
2143 napi_value callback = nullptr;
2144 napi_value undefined = nullptr;
2145 napi_value result[ARGS_TWO] = {nullptr};
2146 napi_value callResult = nullptr;
2147 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2148 result[PARAM0] = GetCallbackErrorValue(env, appVersionInfoCB->cbBase.errCode);
2149 if (appVersionInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2150 result[PARAM1] = WrapAppVersionInfo(env, *appVersionInfoCB);
2151 } else {
2152 result[PARAM1] = WrapUndefinedToJS(env);
2153 }
2154 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, appVersionInfoCB->cbBase.cbInfo.callback, &callback));
2155 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
2156
2157 if (appVersionInfoCB->cbBase.cbInfo.callback != nullptr) {
2158 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, appVersionInfoCB->cbBase.cbInfo.callback));
2159 }
2160 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, appVersionInfoCB->cbBase.asyncWork));
2161 delete appVersionInfoCB;
2162 appVersionInfoCB = nullptr;
2163 HILOG_INFO("NAPI_GetAppVersionInfo, main event thread complete end.");
2164 }
2165
GetAppVersionInfoPromiseCompleteCB(napi_env env,napi_status,void * data)2166 void GetAppVersionInfoPromiseCompleteCB(napi_env env, napi_status, void *data)
2167 {
2168 HILOG_INFO("NAPI_GetAppVersionInfo, main event thread complete.");
2169 AppVersionInfoCB *appVersionInfoCB = static_cast<AppVersionInfoCB *>(data);
2170 napi_value result = nullptr;
2171 if (appVersionInfoCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2172 result = WrapAppVersionInfo(env, *appVersionInfoCB);
2173 napi_resolve_deferred(env, appVersionInfoCB->cbBase.deferred, result);
2174 } else {
2175 result = GetCallbackErrorValue(env, appVersionInfoCB->cbBase.errCode);
2176 napi_reject_deferred(env, appVersionInfoCB->cbBase.deferred, result);
2177 }
2178
2179 napi_delete_async_work(env, appVersionInfoCB->cbBase.asyncWork);
2180 delete appVersionInfoCB;
2181 appVersionInfoCB = nullptr;
2182 HILOG_INFO("NAPI_GetAppVersionInfo, main event thread complete end.");
2183 }
2184
2185 /**
2186 * @brief GetAppVersionInfo Async.
2187 *
2188 * @param env The environment that the Node-API call is invoked under.
2189 * @param args Indicates the arguments passed into the callback.
2190 * @param argcPromise Asynchronous data processing.
2191 * @param AppVersionInfoCB Process data asynchronously.
2192 *
2193 * @return Return JS data successfully, otherwise return nullptr.
2194 */
GetAppVersionInfoAsync(napi_env env,napi_value * args,const size_t argCallback,AppVersionInfoCB * appVersionInfoCB)2195 napi_value GetAppVersionInfoAsync(
2196 napi_env env, napi_value *args, const size_t argCallback, AppVersionInfoCB *appVersionInfoCB)
2197 {
2198 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2199 if (args == nullptr || appVersionInfoCB == nullptr) {
2200 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2201 return nullptr;
2202 }
2203 napi_value resourceName = nullptr;
2204 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2205
2206 napi_valuetype valuetype = napi_undefined;
2207 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
2208 if (valuetype == napi_function) {
2209 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &appVersionInfoCB->cbBase.cbInfo.callback));
2210 }
2211 NAPI_CALL(
2212 env, napi_create_async_work(env, nullptr, resourceName, GetAppVersionInfoExecuteCB,
2213 GetAppVersionInfoAsyncCompleteCB, static_cast<void *>(appVersionInfoCB),
2214 &appVersionInfoCB->cbBase.asyncWork));
2215 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appVersionInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
2216 napi_value result = nullptr;
2217 NAPI_CALL(env, napi_get_null(env, &result));
2218 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2219 return result;
2220 }
2221
2222 /**
2223 * @brief GetAppVersionInfo Promise.
2224 *
2225 * @param env The environment that the Node-API call is invoked under.
2226 * @param AppVersionInfoCB Process data asynchronously.
2227 *
2228 * @return Return JS data successfully, otherwise return nullptr.
2229 */
GetAppVersionInfoPromise(napi_env env,AppVersionInfoCB * appVersionInfoCB)2230 napi_value GetAppVersionInfoPromise(napi_env env, AppVersionInfoCB *appVersionInfoCB)
2231 {
2232 HILOG_INFO("%{public}s, promise.", __func__);
2233 if (appVersionInfoCB == nullptr) {
2234 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2235 return nullptr;
2236 }
2237 napi_value resourceName = nullptr;
2238 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2239 napi_deferred deferred;
2240 napi_value promise = nullptr;
2241 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2242 appVersionInfoCB->cbBase.deferred = deferred;
2243
2244 NAPI_CALL(
2245 env, napi_create_async_work(env, nullptr, resourceName, GetAppVersionInfoExecuteCB,
2246 GetAppVersionInfoPromiseCompleteCB, static_cast<void *>(appVersionInfoCB),
2247 &appVersionInfoCB->cbBase.asyncWork));
2248 NAPI_CALL(env, napi_queue_async_work_with_qos(env, appVersionInfoCB->cbBase.asyncWork, napi_qos_user_initiated));
2249 HILOG_INFO("%{public}s, promise end.", __func__);
2250 return promise;
2251 }
2252
GetAppVersionInfoWrap(napi_env env,napi_callback_info info,AppVersionInfoCB * appVersionInfoCB)2253 napi_value GetAppVersionInfoWrap(napi_env env, napi_callback_info info, AppVersionInfoCB *appVersionInfoCB)
2254 {
2255 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2256 if (appVersionInfoCB == nullptr) {
2257 HILOG_ERROR("%{public}s, appVersionInfoCB == nullptr.", __func__);
2258 return nullptr;
2259 }
2260
2261 size_t argcAsync = 1;
2262 const size_t argcPromise = 0;
2263 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2264 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2265 napi_value ret = nullptr;
2266
2267 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2268 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
2269 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
2270 return nullptr;
2271 }
2272
2273 if (argcAsync > argcPromise) {
2274 ret = GetAppVersionInfoAsync(env, args, 0, appVersionInfoCB);
2275 } else {
2276 ret = GetAppVersionInfoPromise(env, appVersionInfoCB);
2277 }
2278 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2279 return ret;
2280 }
2281
2282 /**
2283 * @brief Obtains the AppVersionInfo object of the application.
2284 *
2285 * @param env The environment that the Node-API call is invoked under.
2286 * @param info The callback info passed into the callback function.
2287 *
2288 * @return The return value from NAPI C++ to JS for the module.
2289 */
NAPI_GetAppVersionInfoCommon(napi_env env,napi_callback_info info,AbilityType abilityType)2290 napi_value NAPI_GetAppVersionInfoCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
2291 {
2292 HILOG_INFO("%{public}s called.", __func__);
2293 AppVersionInfoCB *appVersionInfoCB = CreateAppVersionInfoCBInfo(env);
2294 if (appVersionInfoCB == nullptr) {
2295 return WrapVoidToJS(env);
2296 }
2297
2298 appVersionInfoCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2299 appVersionInfoCB->cbBase.abilityType = abilityType;
2300 napi_value ret = GetAppVersionInfoWrap(env, info, appVersionInfoCB);
2301 if (ret == nullptr) {
2302 HILOG_ERROR("%{public}s ret == nullptr", __func__);
2303 if (appVersionInfoCB != nullptr) {
2304 delete appVersionInfoCB;
2305 appVersionInfoCB = nullptr;
2306 }
2307 ret = WrapVoidToJS(env);
2308 }
2309 HILOG_INFO("%{public}s end.", __func__);
2310 return ret;
2311 }
2312
2313 /**
2314 * @brief Create asynchronous data.
2315 *
2316 * @param env The environment that the Node-API call is invoked under.
2317 *
2318 * @return Return a pointer to AsyncCallbackInfo on success, nullptr on failure
2319 */
CreateAsyncCallbackInfo(napi_env env)2320 AsyncCallbackInfo *CreateAsyncCallbackInfo(napi_env env)
2321 {
2322 HILOG_INFO("%{public}s called.", __func__);
2323 if (env == nullptr) {
2324 HILOG_INFO("%{public}s env == nullptr.", __func__);
2325 return nullptr;
2326 }
2327
2328 napi_status ret;
2329 napi_value global = nullptr;
2330 const napi_extended_error_info *errorInfo = nullptr;
2331 ret = napi_get_global(env, &global);
2332 if (ret != napi_ok) {
2333 napi_get_last_error_info(env, &errorInfo);
2334 HILOG_ERROR("%{public}s get_global=%{public}d err:%{public}s", __func__, ret, errorInfo->error_message);
2335 }
2336
2337 napi_value abilityObj = nullptr;
2338 ret = napi_get_named_property(env, global, "ability", &abilityObj);
2339 if (ret != napi_ok) {
2340 napi_get_last_error_info(env, &errorInfo);
2341 HILOG_ERROR("%{public}s get_named_property=%{public}d err:%{public}s", __func__, ret, errorInfo->error_message);
2342 }
2343
2344 Ability *ability = nullptr;
2345 ret = napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability));
2346 if (ret != napi_ok) {
2347 napi_get_last_error_info(env, &errorInfo);
2348 HILOG_ERROR("%{public}s get_value_external=%{public}d err:%{public}s", __func__, ret, errorInfo->error_message);
2349 }
2350
2351 AsyncCallbackInfo *asyncCallbackInfo = new (std::nothrow) AsyncCallbackInfo;
2352 if (asyncCallbackInfo == nullptr) {
2353 HILOG_ERROR("%{public}s asyncCallbackInfo == nullptr", __func__);
2354 return nullptr;
2355 }
2356 asyncCallbackInfo->cbInfo.env = env;
2357 asyncCallbackInfo->asyncWork = nullptr;
2358 asyncCallbackInfo->deferred = nullptr;
2359 asyncCallbackInfo->ability = ability;
2360 asyncCallbackInfo->native_result = false;
2361 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2362 asyncCallbackInfo->abilityType = AbilityType::UNKNOWN;
2363
2364 HILOG_INFO("%{public}s end.", __func__);
2365 return asyncCallbackInfo;
2366 }
2367
GetContextAsyncExecuteCB(napi_env,void * data)2368 void GetContextAsyncExecuteCB(napi_env, void *data)
2369 {
2370 HILOG_INFO("GetContextAsync, worker pool thread execute.");
2371 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2372 if (asyncCallbackInfo == nullptr) {
2373 HILOG_ERROR("GetContextAsync, asyncCallbackInfo == nullptr");
2374 return;
2375 }
2376 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2377 if (asyncCallbackInfo->ability == nullptr) {
2378 HILOG_ERROR("GetContextAsync, ability == nullptr");
2379 asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
2380 return;
2381 }
2382
2383 if (!CheckAbilityType(asyncCallbackInfo)) {
2384 HILOG_ERROR("GetContextAsync,wrong ability type");
2385 asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
2386 return;
2387 }
2388 HILOG_INFO("GetContextAsync, worker pool thread execute end.");
2389 }
2390
GetContextAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)2391 napi_value GetContextAsync(
2392 napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
2393 {
2394 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2395 if (args == nullptr || asyncCallbackInfo == nullptr) {
2396 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2397 return nullptr;
2398 }
2399 napi_value resourceName = nullptr;
2400 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2401
2402 napi_valuetype valuetype = napi_undefined;
2403 napi_typeof(env, args[argCallback], &valuetype);
2404 if (valuetype == napi_function) {
2405 napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
2406 }
2407 napi_create_async_work(
2408 env,
2409 nullptr,
2410 resourceName,
2411 GetContextAsyncExecuteCB,
2412 [](napi_env env, napi_status, void *data) {
2413 HILOG_INFO("GetContextAsync, main event thread complete.");
2414 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2415 napi_value callback = nullptr;
2416 napi_value undefined = nullptr;
2417 napi_value result[ARGS_TWO] = {nullptr};
2418 napi_value callResult = nullptr;
2419 napi_get_undefined(env, &undefined);
2420 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
2421 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
2422 napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result[PARAM1]);
2423 } else {
2424 result[PARAM1] = WrapUndefinedToJS(env);
2425 }
2426 napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
2427 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
2428
2429 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
2430 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
2431 }
2432 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2433 delete asyncCallbackInfo;
2434 asyncCallbackInfo = nullptr;
2435 HILOG_INFO("GetContextAsync, main event thread complete end.");
2436 },
2437 static_cast<void *>(asyncCallbackInfo),
2438 &asyncCallbackInfo->asyncWork);
2439 napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
2440 napi_value result = nullptr;
2441 napi_get_null(env, &result);
2442 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2443 return result;
2444 }
2445
GetContextPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)2446 napi_value GetContextPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
2447 {
2448 HILOG_INFO("%{public}s, promise.", __func__);
2449 if (asyncCallbackInfo == nullptr) {
2450 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2451 return nullptr;
2452 }
2453 napi_value resourceName = nullptr;
2454 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2455 napi_deferred deferred;
2456 napi_value promise = nullptr;
2457 napi_create_promise(env, &deferred, &promise);
2458 asyncCallbackInfo->deferred = deferred;
2459
2460 napi_create_async_work(
2461 env,
2462 nullptr,
2463 resourceName,
2464 GetContextAsyncExecuteCB,
2465 [](napi_env env, napi_status, void *data) {
2466 HILOG_INFO("GetContextPromise, main event thread complete.");
2467 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2468 napi_value result = nullptr;
2469 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
2470 napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result);
2471 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
2472 } else {
2473 result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
2474 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
2475 }
2476
2477 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2478 delete asyncCallbackInfo;
2479 asyncCallbackInfo = nullptr;
2480 HILOG_INFO("GetContextPromise, main event thread complete end.");
2481 },
2482 static_cast<void *>(asyncCallbackInfo),
2483 &asyncCallbackInfo->asyncWork);
2484 napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
2485 HILOG_INFO("%{public}s, promise end.", __func__);
2486 return promise;
2487 }
2488
2489 /**
2490 * @brief GetContext processing function.
2491 *
2492 * @param env The environment that the Node-API call is invoked under.
2493 * @param asyncCallbackInfo Process data asynchronously.
2494 *
2495 * @return Return JS data successfully, otherwise return nullptr.
2496 */
GetContextWrap(napi_env env,napi_callback_info,AsyncCallbackInfo * asyncCallbackInfo)2497 napi_value GetContextWrap(napi_env env, napi_callback_info, AsyncCallbackInfo *asyncCallbackInfo)
2498 {
2499 HILOG_INFO("%{public}s, called.", __func__);
2500 if (asyncCallbackInfo == nullptr) {
2501 HILOG_ERROR("%{public}s, asyncCallbackInfo == nullptr.", __func__);
2502 return nullptr;
2503 }
2504
2505 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2506 if (!CheckAbilityType(asyncCallbackInfo)) {
2507 HILOG_ERROR("%{public}s,wrong ability type", __func__);
2508 asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
2509 return nullptr;
2510 }
2511
2512 napi_value result = nullptr;
2513 napi_new_instance(env, GetGlobalClassContext(env), 0, nullptr, &result);
2514 HILOG_INFO("%{public}s, end.", __func__);
2515 return result;
2516 }
2517
2518 /**
2519 * @brief Get context.
2520 *
2521 * @param env The environment that the Node-API call is invoked under.
2522 * @param info The callback info passed into the callback function.
2523 *
2524 * @return The return value from NAPI C++ to JS for the module.
2525 */
NAPI_GetContextCommon(napi_env env,napi_callback_info info,AbilityType abilityType)2526 napi_value NAPI_GetContextCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
2527 {
2528 HILOG_INFO("%{public}s, called.", __func__);
2529 AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
2530 if (asyncCallbackInfo == nullptr) {
2531 HILOG_ERROR("%{public}s asyncCallbackInfo == nullptr", __func__);
2532 return WrapVoidToJS(env);
2533 }
2534
2535 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2536 asyncCallbackInfo->abilityType = abilityType;
2537 napi_value ret = GetContextWrap(env, info, asyncCallbackInfo);
2538
2539 delete asyncCallbackInfo;
2540 asyncCallbackInfo = nullptr;
2541
2542 if (ret == nullptr) {
2543 ret = WrapVoidToJS(env);
2544 HILOG_ERROR("%{public}s ret == nullptr", __func__);
2545 } else {
2546 HILOG_INFO("%{public}s, end.", __func__);
2547 }
2548 return ret;
2549 }
2550
GetWantExecuteCB(napi_env,void * data)2551 void GetWantExecuteCB(napi_env, void *data)
2552 {
2553 HILOG_INFO("%{public}s, called.", __func__);
2554 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2555 if (asyncCallbackInfo == nullptr) {
2556 HILOG_ERROR("%{public}s, asyncCallbackInfo == nullptr", __func__);
2557 return;
2558 }
2559 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2560 if (asyncCallbackInfo->ability == nullptr) {
2561 HILOG_ERROR("%{public}s, ability == nullptr", __func__);
2562 asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
2563 return;
2564 }
2565
2566 if (!CheckAbilityType(asyncCallbackInfo)) {
2567 HILOG_ERROR("%{public}s, wrong ability type", __func__);
2568 asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
2569 return;
2570 }
2571
2572 std::shared_ptr<AAFwk::Want> ptrWant = asyncCallbackInfo->ability->GetWant();
2573 if (ptrWant != nullptr) {
2574 asyncCallbackInfo->param.want = *ptrWant;
2575 } else {
2576 asyncCallbackInfo->errCode = NAPI_ERR_ABILITY_CALL_INVALID;
2577 }
2578 HILOG_INFO("%{public}s, end.", __func__);
2579 }
2580
GetWantAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)2581 napi_value GetWantAsync(napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
2582 {
2583 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2584 if (args == nullptr || asyncCallbackInfo == nullptr) {
2585 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2586 return nullptr;
2587 }
2588 napi_value resourceName = nullptr;
2589 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2590
2591 napi_valuetype valuetype = napi_undefined;
2592 napi_typeof(env, args[argCallback], &valuetype);
2593 if (valuetype == napi_function) {
2594 napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
2595 }
2596 napi_create_async_work(
2597 env,
2598 nullptr,
2599 resourceName,
2600 GetWantExecuteCB,
2601 [](napi_env env, napi_status, void *data) {
2602 HILOG_INFO("GetWantAsync, main event thread complete.");
2603 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2604 napi_value callback = nullptr;
2605 napi_value undefined = nullptr;
2606 napi_value result[ARGS_TWO] = {nullptr};
2607 napi_value callResult = nullptr;
2608 napi_get_undefined(env, &undefined);
2609 result[PARAM0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
2610 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
2611 result[PARAM1] = WrapWant(env, asyncCallbackInfo->param.want);
2612 } else {
2613 result[PARAM1] = WrapUndefinedToJS(env);
2614 }
2615 napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
2616 napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
2617
2618 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
2619 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
2620 }
2621 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2622 delete asyncCallbackInfo;
2623 asyncCallbackInfo = nullptr;
2624 HILOG_INFO("GetWantAsync, main event thread complete end.");
2625 },
2626 static_cast<void *>(asyncCallbackInfo),
2627 &asyncCallbackInfo->asyncWork);
2628 napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
2629 napi_value result = nullptr;
2630 napi_get_null(env, &result);
2631 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2632 return result;
2633 }
2634
GetWantPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)2635 napi_value GetWantPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
2636 {
2637 HILOG_INFO("%{public}s, promise.", __func__);
2638 if (asyncCallbackInfo == nullptr) {
2639 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2640 return nullptr;
2641 }
2642 napi_value resourceName = nullptr;
2643 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2644 napi_deferred deferred;
2645 napi_value promise = nullptr;
2646 napi_create_promise(env, &deferred, &promise);
2647 asyncCallbackInfo->deferred = deferred;
2648
2649 napi_create_async_work(
2650 env,
2651 nullptr,
2652 resourceName,
2653 GetWantExecuteCB,
2654 [](napi_env env, napi_status, void *data) {
2655 HILOG_INFO("GetWantPromise, main event thread complete.");
2656 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
2657 napi_value result = nullptr;
2658 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
2659 result = WrapWant(env, asyncCallbackInfo->param.want);
2660 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
2661 } else {
2662 result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
2663 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
2664 }
2665
2666 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
2667 delete asyncCallbackInfo;
2668 asyncCallbackInfo = nullptr;
2669 HILOG_INFO("GetWantPromise, main event thread complete end.");
2670 },
2671 static_cast<void *>(asyncCallbackInfo),
2672 &asyncCallbackInfo->asyncWork);
2673 napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_user_initiated);
2674 HILOG_INFO("%{public}s, promise end.", __func__);
2675 return promise;
2676 }
2677
2678 /**
2679 * @brief GetWantWrap processing function.
2680 *
2681 * @param env The environment that the Node-API call is invoked under.
2682 * @param asyncCallbackInfo Process data asynchronously.
2683 *
2684 * @return Return JS data successfully, otherwise return nullptr.
2685 */
GetWantWrap(napi_env env,napi_callback_info info,AsyncCallbackInfo * asyncCallbackInfo)2686 napi_value GetWantWrap(napi_env env, napi_callback_info info, AsyncCallbackInfo *asyncCallbackInfo)
2687 {
2688 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2689 if (asyncCallbackInfo == nullptr) {
2690 HILOG_ERROR("%{public}s, asyncCallbackInfo == nullptr.", __func__);
2691 return nullptr;
2692 }
2693
2694 size_t argcAsync = 1;
2695 const size_t argcPromise = 0;
2696 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2697 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2698 napi_value ret = nullptr;
2699
2700 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2701 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
2702 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
2703 return nullptr;
2704 }
2705
2706 if (argcAsync > argcPromise) {
2707 ret = GetWantAsync(env, args, 0, asyncCallbackInfo);
2708 } else {
2709 ret = GetWantPromise(env, asyncCallbackInfo);
2710 }
2711 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2712 return ret;
2713 }
2714
2715 /**
2716 * @brief Get want.
2717 *
2718 * @param env The environment that the Node-API call is invoked under.
2719 * @param info The callback info passed into the callback function.
2720 *
2721 * @return The return value from NAPI C++ to JS for the module.
2722 */
NAPI_GetWantCommon(napi_env env,napi_callback_info info,AbilityType abilityType)2723 napi_value NAPI_GetWantCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
2724 {
2725 AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
2726 if (asyncCallbackInfo == nullptr) {
2727 HILOG_ERROR("%{public}s, asyncCallbackInfo == nullptr", __func__);
2728 return WrapVoidToJS(env);
2729 }
2730
2731 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
2732 asyncCallbackInfo->abilityType = abilityType;
2733 napi_value ret = GetWantWrap(env, info, asyncCallbackInfo);
2734 if (ret == nullptr) {
2735 HILOG_ERROR("%{public}s, ret == nullptr", __func__);
2736 if (asyncCallbackInfo != nullptr) {
2737 delete asyncCallbackInfo;
2738 asyncCallbackInfo = nullptr;
2739 }
2740 ret = WrapVoidToJS(env);
2741 }
2742 return ret;
2743 }
2744
2745 /**
2746 * @brief Create asynchronous data.
2747 *
2748 * @param env The environment that the Node-API call is invoked under.
2749 *
2750 * @return Return a pointer to AbilityNameCB on success, nullptr on failure.
2751 */
CreateAbilityNameCBInfo(napi_env env)2752 AbilityNameCB *CreateAbilityNameCBInfo(napi_env env)
2753 {
2754 HILOG_INFO("%{public}s, called.", __func__);
2755 napi_value global = nullptr;
2756 NAPI_CALL(env, napi_get_global(env, &global));
2757
2758 napi_value abilityObj = nullptr;
2759 NAPI_CALL(env, napi_get_named_property(env, global, "ability", &abilityObj));
2760
2761 Ability *ability = nullptr;
2762 NAPI_CALL(env, napi_get_value_external(env, abilityObj, reinterpret_cast<void **>(&ability)));
2763
2764 AbilityNameCB *abilityNameCB = new (std::nothrow) AbilityNameCB;
2765 if (abilityNameCB == nullptr) {
2766 HILOG_ERROR("%{public}s, abilityNameCB == nullptr.", __func__);
2767 return nullptr;
2768 }
2769 abilityNameCB->cbBase.cbInfo.env = env;
2770 abilityNameCB->cbBase.asyncWork = nullptr;
2771 abilityNameCB->cbBase.deferred = nullptr;
2772 abilityNameCB->cbBase.ability = ability;
2773
2774 HILOG_INFO("%{public}s, end.", __func__);
2775 return abilityNameCB;
2776 }
2777
WrapAbilityName(napi_env env,const AbilityNameCB * abilityNameCB)2778 napi_value WrapAbilityName(napi_env env, const AbilityNameCB *abilityNameCB)
2779 {
2780 HILOG_INFO("%{public}s, called.", __func__);
2781 if (abilityNameCB == nullptr) {
2782 HILOG_ERROR("%{public}s, Invalid param(abilityNameCB == nullptr)", __func__);
2783 return nullptr;
2784 }
2785 napi_value result = nullptr;
2786 NAPI_CALL(env, napi_create_string_utf8(env, abilityNameCB->name.c_str(), NAPI_AUTO_LENGTH, &result));
2787 HILOG_INFO("%{public}s, end.", __func__);
2788 return result;
2789 }
2790
2791 /**
2792 * @brief GetAbilityName asynchronous processing function.
2793 *
2794 * @param env The environment that the Node-API call is invoked under.
2795 * @param data Point to asynchronous processing of data.
2796 */
GetAbilityNameExecuteCB(napi_env,void * data)2797 void GetAbilityNameExecuteCB(napi_env, void *data)
2798 {
2799 HILOG_INFO("%{public}s, called.", __func__);
2800 AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
2801 if (abilityNameCB == nullptr) {
2802 HILOG_ERROR("%{public}s, abilityNameCB == nullptr", __func__);
2803 return;
2804 }
2805 abilityNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
2806 if (abilityNameCB->cbBase.ability == nullptr) {
2807 HILOG_ERROR("%{public}s, ability == nullptr", __func__);
2808 abilityNameCB->cbBase.errCode = NAPI_ERR_ACE_ABILITY;
2809 return;
2810 }
2811
2812 if (!CheckAbilityType(&abilityNameCB->cbBase)) {
2813 HILOG_ERROR("%{public}s, wrong ability type", __func__);
2814 abilityNameCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
2815 return;
2816 }
2817
2818 abilityNameCB->name = abilityNameCB->cbBase.ability->GetAbilityName();
2819 HILOG_INFO("%{public}s, end.", __func__);
2820 }
2821
2822 /**
2823 * @brief The callback at the end of the asynchronous callback.
2824 *
2825 * @param env The environment that the Node-API call is invoked under.
2826 * @param data Point to asynchronous processing of data.
2827 */
GetAbilityNameAsyncCompleteCB(napi_env env,napi_status,void * data)2828 void GetAbilityNameAsyncCompleteCB(napi_env env, napi_status, void *data)
2829 {
2830 HILOG_INFO("%{public}s, called.", __func__);
2831 AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
2832 napi_value callback = nullptr;
2833 napi_value undefined = nullptr;
2834 napi_value result[ARGS_TWO] = {nullptr};
2835 napi_value callResult = nullptr;
2836 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2837 result[PARAM0] = GetCallbackErrorValue(env, abilityNameCB->cbBase.errCode);
2838 if (abilityNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2839 result[PARAM1] = WrapAbilityName(env, abilityNameCB);
2840 } else {
2841 result[PARAM1] = WrapUndefinedToJS(env);
2842 }
2843 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, abilityNameCB->cbBase.cbInfo.callback, &callback));
2844 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult));
2845 if (abilityNameCB->cbBase.cbInfo.callback != nullptr) {
2846 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, abilityNameCB->cbBase.cbInfo.callback));
2847 }
2848 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, abilityNameCB->cbBase.asyncWork));
2849 delete abilityNameCB;
2850 abilityNameCB = nullptr;
2851 HILOG_INFO("%{public}s, end.", __func__);
2852 }
2853
2854 /**
2855 * @brief The callback at the end of the Promise callback.
2856 *
2857 * @param env The environment that the Node-API call is invoked under.
2858 * @param data Point to asynchronous processing of data.
2859 */
GetAbilityNamePromiseCompleteCB(napi_env env,napi_status,void * data)2860 void GetAbilityNamePromiseCompleteCB(napi_env env, napi_status, void *data)
2861 {
2862 HILOG_INFO("NAPI_GetAbilityName, main event thread complete.");
2863 AbilityNameCB *abilityNameCB = static_cast<AbilityNameCB *>(data);
2864 napi_value result = nullptr;
2865 if (abilityNameCB->cbBase.errCode == NAPI_ERR_NO_ERROR) {
2866 result = WrapAbilityName(env, abilityNameCB);
2867 napi_resolve_deferred(env, abilityNameCB->cbBase.deferred, result);
2868 } else {
2869 result = GetCallbackErrorValue(env, abilityNameCB->cbBase.errCode);
2870 napi_reject_deferred(env, abilityNameCB->cbBase.deferred, result);
2871 }
2872
2873 napi_delete_async_work(env, abilityNameCB->cbBase.asyncWork);
2874 delete abilityNameCB;
2875 abilityNameCB = nullptr;
2876 HILOG_INFO("NAPI_GetAbilityName, main event thread complete end.");
2877 }
2878
2879 /**
2880 * @brief GetAbilityName Async.
2881 *
2882 * @param env The environment that the Node-API call is invoked under.
2883 * @param args Indicates the arguments passed into the callback.
2884 * @param argcPromise Asynchronous data processing.
2885 * @param abilityNameCB Process data asynchronously.
2886 *
2887 * @return Return JS data successfully, otherwise return nullptr.
2888 */
GetAbilityNameAsync(napi_env env,napi_value * args,const size_t argCallback,AbilityNameCB * abilityNameCB)2889 napi_value GetAbilityNameAsync(napi_env env, napi_value *args, const size_t argCallback, AbilityNameCB *abilityNameCB)
2890 {
2891 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2892 if (args == nullptr || abilityNameCB == nullptr) {
2893 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2894 return nullptr;
2895 }
2896 napi_value resourceName = nullptr;
2897 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2898
2899 napi_valuetype valuetype = napi_undefined;
2900 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
2901 if (valuetype == napi_function) {
2902 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &abilityNameCB->cbBase.cbInfo.callback));
2903 }
2904 NAPI_CALL(env,
2905 napi_create_async_work(env,
2906 nullptr,
2907 resourceName,
2908 GetAbilityNameExecuteCB,
2909 GetAbilityNameAsyncCompleteCB,
2910 static_cast<void *>(abilityNameCB),
2911 &abilityNameCB->cbBase.asyncWork));
2912 NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityNameCB->cbBase.asyncWork, napi_qos_user_initiated));
2913 napi_value result = nullptr;
2914 NAPI_CALL(env, napi_get_null(env, &result));
2915 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2916 return result;
2917 }
2918
2919 /**
2920 * @brief GetAbilityName Promise.
2921 *
2922 * @param env The environment that the Node-API call is invoked under.
2923 * @param abilityNameCB Process data asynchronously.
2924 *
2925 * @return Return JS data successfully, otherwise return nullptr.
2926 */
GetAbilityNamePromise(napi_env env,AbilityNameCB * abilityNameCB)2927 napi_value GetAbilityNamePromise(napi_env env, AbilityNameCB *abilityNameCB)
2928 {
2929 HILOG_INFO("%{public}s, promise.", __func__);
2930 if (abilityNameCB == nullptr) {
2931 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
2932 return nullptr;
2933 }
2934 napi_value resourceName = nullptr;
2935 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
2936 napi_deferred deferred;
2937 napi_value promise = nullptr;
2938 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2939 abilityNameCB->cbBase.deferred = deferred;
2940
2941 NAPI_CALL(env,
2942 napi_create_async_work(env,
2943 nullptr,
2944 resourceName,
2945 GetAbilityNameExecuteCB,
2946 GetAbilityNamePromiseCompleteCB,
2947 static_cast<void *>(abilityNameCB),
2948 &abilityNameCB->cbBase.asyncWork));
2949 NAPI_CALL(env, napi_queue_async_work_with_qos(env, abilityNameCB->cbBase.asyncWork, napi_qos_user_initiated));
2950 HILOG_INFO("%{public}s, promise end.", __func__);
2951 return promise;
2952 }
2953
2954 /**
2955 * @brief GetAbilityName processing function.
2956 *
2957 * @param env The environment that the Node-API call is invoked under.
2958 * @param abilityNameCB Process data asynchronously.
2959 *
2960 * @return Return JS data successfully, otherwise return nullptr.
2961 */
GetAbilityNameWrap(napi_env env,napi_callback_info info,AbilityNameCB * abilityNameCB)2962 napi_value GetAbilityNameWrap(napi_env env, napi_callback_info info, AbilityNameCB *abilityNameCB)
2963 {
2964 HILOG_INFO("%{public}s, asyncCallback.", __func__);
2965 if (abilityNameCB == nullptr) {
2966 HILOG_ERROR("%{public}s, abilityNameCB == nullptr.", __func__);
2967 return nullptr;
2968 }
2969
2970 size_t argcAsync = 1;
2971 const size_t argcPromise = 0;
2972 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
2973 napi_value args[ARGS_MAX_COUNT] = {nullptr};
2974 napi_value ret = nullptr;
2975
2976 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, nullptr, nullptr));
2977 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
2978 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
2979 return nullptr;
2980 }
2981
2982 if (argcAsync > argcPromise) {
2983 ret = GetAbilityNameAsync(env, args, 0, abilityNameCB);
2984 } else {
2985 ret = GetAbilityNamePromise(env, abilityNameCB);
2986 }
2987 HILOG_INFO("%{public}s, asyncCallback end.", __func__);
2988 return ret;
2989 }
2990
2991 /**
2992 * @brief Obtains the class name in this ability name, without the prefixed bundle name.
2993 *
2994 * @param env The environment that the Node-API call is invoked under.
2995 * @param info The callback info passed into the callback function.
2996 *
2997 * @return The return value from NAPI C++ to JS for the module.
2998 */
NAPI_GetAbilityNameCommon(napi_env env,napi_callback_info info,AbilityType abilityType)2999 napi_value NAPI_GetAbilityNameCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
3000 {
3001 HILOG_INFO("%{public}s called.", __func__);
3002 AbilityNameCB *ablityNameCB = CreateAbilityNameCBInfo(env);
3003 if (ablityNameCB == nullptr) {
3004 HILOG_ERROR("%{public}s ablityNameCB == nullptr", __func__);
3005 return WrapVoidToJS(env);
3006 }
3007
3008 ablityNameCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
3009 ablityNameCB->cbBase.abilityType = abilityType;
3010 napi_value ret = GetAbilityNameWrap(env, info, ablityNameCB);
3011 if (ret == nullptr) {
3012 HILOG_ERROR("%{public}s ret == nullptr", __func__);
3013 if (ablityNameCB != nullptr) {
3014 delete ablityNameCB;
3015 ablityNameCB = nullptr;
3016 }
3017 ret = WrapVoidToJS(env);
3018 }
3019 HILOG_INFO("%{public}s end.", __func__);
3020 return ret;
3021 }
3022
UnwrapAbilityStartSettingForNumber(napi_env env,const std::string key,napi_value param,AAFwk::AbilityStartSetting & setting)3023 void UnwrapAbilityStartSettingForNumber(
3024 napi_env env, const std::string key, napi_value param, AAFwk::AbilityStartSetting &setting)
3025 {
3026 int32_t natValue32 = 0;
3027 double natValueDouble = 0.0;
3028 bool isReadValue32 = false;
3029 bool isReadDouble = false;
3030 if (napi_get_value_int32(env, param, &natValue32) == napi_ok) {
3031 HILOG_INFO("%{public}s called. Property value=%{private}d.", __func__, natValue32);
3032 isReadValue32 = true;
3033 }
3034
3035 if (napi_get_value_double(env, param, &natValueDouble) == napi_ok) {
3036 HILOG_INFO("%{public}s called. Property value=%{private}lf.", __func__, natValueDouble);
3037 isReadDouble = true;
3038 }
3039
3040 if (isReadValue32 && isReadDouble) {
3041 if (abs(natValueDouble - natValue32 * 1.0) > 0.0) {
3042 setting.AddProperty(key, std::to_string(natValueDouble));
3043 } else {
3044 setting.AddProperty(key, std::to_string(natValue32));
3045 }
3046 } else if (isReadValue32) {
3047 setting.AddProperty(key, std::to_string(natValue32));
3048 } else if (isReadDouble) {
3049 setting.AddProperty(key, std::to_string(natValueDouble));
3050 }
3051 }
3052
UnwrapAbilityStartSetting(napi_env env,napi_value param,AAFwk::AbilityStartSetting & setting)3053 bool UnwrapAbilityStartSetting(napi_env env, napi_value param, AAFwk::AbilityStartSetting &setting)
3054 {
3055 HILOG_INFO("%{public}s called.", __func__);
3056
3057 if (!IsTypeForNapiValue(env, param, napi_object)) {
3058 return false;
3059 }
3060
3061 napi_valuetype jsValueType = napi_undefined;
3062 napi_value jsProNameList = nullptr;
3063 uint32_t jsProCount = 0;
3064
3065 NAPI_CALL_BASE(env, napi_get_property_names(env, param, &jsProNameList), false);
3066 NAPI_CALL_BASE(env, napi_get_array_length(env, jsProNameList, &jsProCount), false);
3067 HILOG_INFO("%{public}s called. Property size=%{public}d.", __func__, jsProCount);
3068
3069 napi_value jsProName = nullptr;
3070 napi_value jsProValue = nullptr;
3071 for (uint32_t index = 0; index < jsProCount; index++) {
3072 NAPI_CALL_BASE(env, napi_get_element(env, jsProNameList, index, &jsProName), false);
3073
3074 std::string strProName = UnwrapStringFromJS(env, jsProName);
3075 HILOG_INFO("%{public}s called. Property name=%{public}s.", __func__, strProName.c_str());
3076 NAPI_CALL_BASE(env, napi_get_named_property(env, param, strProName.c_str(), &jsProValue), false);
3077 NAPI_CALL_BASE(env, napi_typeof(env, jsProValue, &jsValueType), false);
3078
3079 switch (jsValueType) {
3080 case napi_string: {
3081 std::string natValue = UnwrapStringFromJS(env, jsProValue);
3082 HILOG_INFO("%{public}s called. Property value=%{private}s.", __func__, natValue.c_str());
3083 setting.AddProperty(strProName, natValue);
3084 break;
3085 }
3086 case napi_boolean: {
3087 bool natValue = false;
3088 NAPI_CALL_BASE(env, napi_get_value_bool(env, jsProValue, &natValue), false);
3089 HILOG_INFO("%{public}s called. Property value=%{public}s.", __func__, natValue ? "true" : "false");
3090 setting.AddProperty(strProName, std::to_string(natValue));
3091 break;
3092 }
3093 case napi_number:
3094 UnwrapAbilityStartSettingForNumber(env, strProName, jsProValue, setting);
3095 break;
3096 default:
3097 break;
3098 }
3099 }
3100
3101 return true;
3102 }
3103
3104 /**
3105 * @brief Parse the parameters.
3106 *
3107 * @param param Indicates the parameters saved the parse result.
3108 * @param env The environment that the Node-API call is invoked under.
3109 * @param args Indicates the arguments passed into the callback.
3110 *
3111 * @return The return value from NAPI C++ to JS for the module.
3112 */
UnwrapParamForWant(napi_env env,napi_value args,AbilityType,CallAbilityParam & param)3113 bool UnwrapParamForWant(napi_env env, napi_value args, AbilityType, CallAbilityParam ¶m)
3114 {
3115 HILOG_INFO("%{public}s called.", __func__);
3116 bool ret = false;
3117 napi_valuetype valueType = napi_undefined;
3118 param.setting = nullptr;
3119 NAPI_CALL_BASE(env, napi_typeof(env, args, &valueType), false);
3120 if (valueType != napi_object) {
3121 HILOG_ERROR("%{public}s, Wrong argument type.", __func__);
3122 return false;
3123 }
3124
3125 napi_value jsWant = GetPropertyValueByPropertyName(env, args, "want", napi_object);
3126 if (jsWant == nullptr) {
3127 HILOG_ERROR("%{public}s, jsWant == nullptr", __func__);
3128 return false;
3129 }
3130
3131 ret = UnwrapWant(env, jsWant, param.want);
3132
3133 napi_value jsSettingObj = GetPropertyValueByPropertyName(env, args, "abilityStartSetting", napi_object);
3134 if (jsSettingObj != nullptr) {
3135 param.setting = AbilityStartSetting::GetEmptySetting();
3136 if (!UnwrapAbilityStartSetting(env, jsSettingObj, *(param.setting))) {
3137 HILOG_ERROR("%{public}s, unwrap abilityStartSetting falied.", __func__);
3138 }
3139 HILOG_INFO("%{public}s abilityStartSetting", __func__);
3140 }
3141
3142 HILOG_INFO("%{public}s end.", __func__);
3143 return ret;
3144 }
3145
UnwrapParamStopAbilityWrap(napi_env env,size_t argc,napi_value * argv,AsyncJSCallbackInfo * asyncCallbackInfo)3146 bool UnwrapParamStopAbilityWrap(napi_env env, size_t argc, napi_value *argv, AsyncJSCallbackInfo *asyncCallbackInfo)
3147 {
3148 HILOG_INFO("%{public}s called, argc=%{public}zu", __func__, argc);
3149 const size_t argcMax = 2;
3150 if (argc > argcMax || argc < argcMax - 1) {
3151 HILOG_ERROR("%{public}s, Params is invalid.", __func__);
3152 return false;
3153 }
3154
3155 if (argc == argcMax) {
3156 if (!CreateAsyncCallback(env, argv[PARAM1], asyncCallbackInfo)) {
3157 HILOG_INFO("%{public}s, the second parameter is invalid.", __func__);
3158 return false;
3159 }
3160 }
3161
3162 return UnwrapWant(env, argv[PARAM0], asyncCallbackInfo->param.want);
3163 }
3164
StopAbilityExecuteCallback(napi_env,void * data)3165 void StopAbilityExecuteCallback(napi_env, void *data)
3166 {
3167 HILOG_INFO("%{public}s called.", __func__);
3168 AsyncJSCallbackInfo *asyncCallbackInfo = static_cast<AsyncJSCallbackInfo *>(data);
3169 if (asyncCallbackInfo == nullptr) {
3170 HILOG_ERROR("%{public}s asyncCallbackInfo is null", __func__);
3171 return;
3172 }
3173
3174 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
3175 asyncCallbackInfo->native_data.data_type = NVT_NONE;
3176
3177 if (asyncCallbackInfo->ability == nullptr) {
3178 HILOG_ERROR("%{public}s ability is null", __func__);
3179 asyncCallbackInfo->error_code = NAPI_ERR_ACE_ABILITY;
3180 return;
3181 }
3182
3183 if (!CheckAbilityType(asyncCallbackInfo)) {
3184 HILOG_ERROR("%{public}s wrong ability type", __func__);
3185 asyncCallbackInfo->error_code = NAPI_ERR_ABILITY_TYPE_INVALID;
3186 asyncCallbackInfo->native_data.data_type = NVT_UNDEFINED;
3187 return;
3188 }
3189
3190 asyncCallbackInfo->native_data.data_type = NVT_BOOL;
3191 asyncCallbackInfo->native_data.bool_value = asyncCallbackInfo->ability->StopAbility(asyncCallbackInfo->param.want);
3192 HILOG_INFO("%{public}s end.", __func__);
3193 }
3194
StopAbilityWrap(napi_env env,napi_callback_info info,AsyncJSCallbackInfo * asyncCallbackInfo)3195 napi_value StopAbilityWrap(napi_env env, napi_callback_info info, AsyncJSCallbackInfo *asyncCallbackInfo)
3196 {
3197 HILOG_INFO("%{public}s called.", __func__);
3198 size_t argc = ARGS_MAX_COUNT;
3199 napi_value args[ARGS_MAX_COUNT] = {nullptr};
3200 napi_value jsthis = nullptr;
3201 void *data = nullptr;
3202
3203 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &jsthis, &data));
3204
3205 if (!UnwrapParamStopAbilityWrap(env, argc, args, asyncCallbackInfo)) {
3206 HILOG_INFO("%{public}s called. Invoke UnwrapParamStopAbility fail", __func__);
3207 return nullptr;
3208 }
3209
3210 AsyncParamEx asyncParamEx;
3211 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
3212 HILOG_INFO("%{public}s called. asyncCallback.", __func__);
3213 asyncParamEx.resource = "NAPI_StopAbilityWrapCallback";
3214 asyncParamEx.execute = StopAbilityExecuteCallback;
3215 asyncParamEx.complete = CompleteAsyncCallbackWork;
3216
3217 return ExecuteAsyncCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
3218 } else {
3219 HILOG_INFO("%{public}s called. promise.", __func__);
3220 asyncParamEx.resource = "NAPI_StopAbilityWrapPromise";
3221 asyncParamEx.execute = StopAbilityExecuteCallback;
3222 asyncParamEx.complete = CompletePromiseCallbackWork;
3223
3224 return ExecutePromiseCallbackWork(env, asyncCallbackInfo, &asyncParamEx);
3225 }
3226 }
3227
3228 /**
3229 * @brief stopAbility.
3230 *
3231 * @param env The environment that the Node-API call is invoked under.
3232 * @param info The callback info passed into the callback function.
3233 *
3234 * @return The return value from NAPI C++ to JS for the module.
3235 */
NAPI_StopAbilityCommon(napi_env env,napi_callback_info info,AbilityType abilityType)3236 napi_value NAPI_StopAbilityCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
3237 {
3238 HILOG_INFO("%{public}s called.", __func__);
3239 AsyncJSCallbackInfo *asyncCallbackInfo = CreateAsyncJSCallbackInfo(env);
3240 if (asyncCallbackInfo == nullptr) {
3241 HILOG_ERROR("%{public}s. Invoke CreateAsyncJSCallbackInfo failed.", __func__);
3242 return WrapVoidToJS(env);
3243 }
3244
3245 asyncCallbackInfo->error_code = NAPI_ERR_NO_ERROR;
3246 asyncCallbackInfo->abilityType = abilityType;
3247 napi_value ret = StopAbilityWrap(env, info, asyncCallbackInfo);
3248 if (ret == nullptr) {
3249 HILOG_ERROR("%{public}s. ret == nullptr", __func__);
3250 FreeAsyncJSCallbackInfo(&asyncCallbackInfo);
3251 ret = WrapVoidToJS(env);
3252 }
3253 HILOG_INFO("%{public}s end.", __func__);
3254 return ret;
3255 }
3256
AddConnectionCallback(std::shared_ptr<ConnectionCallback> callback)3257 void NAPIAbilityConnection::AddConnectionCallback(std::shared_ptr<ConnectionCallback> callback)
3258 {
3259 std::lock_guard<std::mutex> guard(lock_);
3260 callbacks_.emplace_back(callback);
3261 }
3262
GetConnectionState() const3263 int NAPIAbilityConnection::GetConnectionState() const
3264 {
3265 std::lock_guard<std::mutex> guard(lock_);
3266 return connectionState_;
3267 }
3268
SetConnectionState(int connectionState)3269 void NAPIAbilityConnection::SetConnectionState(int connectionState)
3270 {
3271 std::lock_guard<std::mutex> guard(lock_);
3272 connectionState_ = connectionState;
3273 }
3274
GetCallbackSize()3275 size_t NAPIAbilityConnection::GetCallbackSize()
3276 {
3277 std::lock_guard<std::mutex> guard(lock_);
3278 return callbacks_.size();
3279 }
3280
RemoveAllCallbacks(ConnectRemoveKeyType key)3281 size_t NAPIAbilityConnection::RemoveAllCallbacks(ConnectRemoveKeyType key)
3282 {
3283 size_t result = 0;
3284 std::lock_guard<std::mutex> guard(lock_);
3285 for (auto it = callbacks_.begin(); it != callbacks_.end();) {
3286 auto callback = *it;
3287 if (callback && callback->removeKey == key) {
3288 it = callbacks_.erase(it);
3289 result++;
3290 } else {
3291 ++it;
3292 }
3293 }
3294 HILOG_INFO("RemoveAllCallbacks removed size:%{public}zu, left size:%{public}zu", result, callbacks_.size());
3295 return result;
3296 }
3297
UvWorkOnAbilityConnectDone(uv_work_t * work,int status)3298 void UvWorkOnAbilityConnectDone(uv_work_t *work, int status)
3299 {
3300 HILOG_INFO("UvWorkOnAbilityConnectDone, uv_queue_work");
3301 std::unique_ptr<uv_work_t> managedWork(work);
3302 if (work == nullptr) {
3303 HILOG_ERROR("UvWorkOnAbilityConnectDone, work is null");
3304 return;
3305 }
3306 // JS Thread
3307 std::unique_ptr<ConnectAbilityCB> connectAbilityCB(static_cast<ConnectAbilityCB *>(work->data));
3308 if (connectAbilityCB == nullptr) {
3309 HILOG_ERROR("UvWorkOnAbilityConnectDone, connectAbilityCB is null");
3310 return;
3311 }
3312 CallbackInfo &cbInfo = connectAbilityCB->cbBase.cbInfo;
3313 napi_handle_scope scope = nullptr;
3314 napi_open_handle_scope(cbInfo.env, &scope);
3315 if (scope == nullptr) {
3316 HILOG_ERROR("napi_open_handle_scope failed");
3317 return;
3318 }
3319
3320 napi_value globalValue;
3321 napi_get_global(cbInfo.env, &globalValue);
3322 napi_value func;
3323 napi_get_named_property(cbInfo.env, globalValue, "requireNapi", &func);
3324
3325 napi_value rpcInfo;
3326 napi_create_string_utf8(cbInfo.env, "rpc", NAPI_AUTO_LENGTH, &rpcInfo);
3327 napi_value funcArgv[1] = { rpcInfo };
3328 napi_value returnValue;
3329 napi_call_function(cbInfo.env, globalValue, func, 1, funcArgv, &returnValue);
3330
3331 napi_value result[ARGS_TWO] = {nullptr};
3332 result[PARAM0] =
3333 WrapElementName(cbInfo.env, connectAbilityCB->abilityConnectionCB.elementName);
3334 napi_value jsRemoteObject = NAPI_ohos_rpc_CreateJsRemoteObject(
3335 cbInfo.env, connectAbilityCB->abilityConnectionCB.connection);
3336 result[PARAM1] = jsRemoteObject;
3337
3338 napi_value callback = nullptr;
3339 napi_value undefined = nullptr;
3340 napi_get_undefined(cbInfo.env, &undefined);
3341 napi_value callResult = nullptr;
3342 napi_get_reference_value(cbInfo.env, cbInfo.callback, &callback);
3343
3344 napi_call_function(
3345 cbInfo.env, undefined, callback, ARGS_TWO, &result[PARAM0], &callResult);
3346 if (cbInfo.callback != nullptr) {
3347 napi_delete_reference(cbInfo.env, cbInfo.callback);
3348 }
3349 napi_close_handle_scope(cbInfo.env, scope);
3350 HILOG_INFO("UvWorkOnAbilityConnectDone, uv_queue_work end");
3351 }
3352
HandleOnAbilityConnectDone(ConnectionCallback & callback,int resultCode)3353 void NAPIAbilityConnection::HandleOnAbilityConnectDone(ConnectionCallback &callback, int resultCode)
3354 {
3355 HILOG_INFO("%{public}s called.", __func__);
3356 uv_loop_s *loop = nullptr;
3357 napi_get_uv_event_loop(callback.env, &loop);
3358 if (loop == nullptr) {
3359 HILOG_ERROR("%{public}s, loop == nullptr.", __func__);
3360 return;
3361 }
3362
3363 uv_work_t *work = new(std::nothrow) uv_work_t;
3364 if (work == nullptr) {
3365 HILOG_ERROR("%{public}s, work == nullptr.", __func__);
3366 return;
3367 }
3368
3369 ConnectAbilityCB *connectAbilityCB = new (std::nothrow) ConnectAbilityCB;
3370 if (connectAbilityCB == nullptr) {
3371 HILOG_ERROR("%{public}s, connectAbilityCB == nullptr.", __func__);
3372 if (work != nullptr) {
3373 delete work;
3374 work = nullptr;
3375 }
3376 return;
3377 }
3378 connectAbilityCB->cbBase.cbInfo.env = callback.env;
3379 connectAbilityCB->cbBase.cbInfo.callback = callback.connectCallbackRef;
3380 callback.connectCallbackRef = nullptr;
3381 connectAbilityCB->abilityConnectionCB.elementName = element_;
3382 connectAbilityCB->abilityConnectionCB.resultCode = resultCode;
3383 connectAbilityCB->abilityConnectionCB.connection = serviceRemoteObject_;
3384 work->data = static_cast<void *>(connectAbilityCB);
3385
3386 int rev = uv_queue_work_with_qos(
3387 loop, work, [](uv_work_t *work) {}, UvWorkOnAbilityConnectDone, uv_qos_user_initiated);
3388 if (rev != 0) {
3389 if (connectAbilityCB != nullptr) {
3390 delete connectAbilityCB;
3391 connectAbilityCB = nullptr;
3392 }
3393 if (work != nullptr) {
3394 delete work;
3395 work = nullptr;
3396 }
3397 }
3398 }
3399
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)3400 void NAPIAbilityConnection::OnAbilityConnectDone(
3401 const AppExecFwk::ElementName &element, const sptr<IRemoteObject> &remoteObject, int resultCode)
3402 {
3403 HILOG_INFO("%{public}s bundleName:%{public}s abilityName:%{public}s, resultCode:%{public}d",
3404 __func__, element.GetBundleName().c_str(), element.GetAbilityName().c_str(), resultCode);
3405 if (remoteObject == nullptr) {
3406 HILOG_ERROR("%{public}s, remoteObject == nullptr.", __func__);
3407 return;
3408 }
3409 std::lock_guard<std::mutex> guard(lock_);
3410 element_ = element;
3411 serviceRemoteObject_ = remoteObject;
3412 for (const auto &callback : callbacks_) {
3413 HandleOnAbilityConnectDone(*callback, resultCode);
3414 }
3415 connectionState_ = CONNECTION_STATE_CONNECTED;
3416 HILOG_INFO("%{public}s, end.", __func__);
3417 }
3418
UvWorkOnAbilityDisconnectDone(uv_work_t * work,int status)3419 void UvWorkOnAbilityDisconnectDone(uv_work_t *work, int status)
3420 {
3421 HILOG_INFO("UvWorkOnAbilityDisconnectDone, uv_queue_work");
3422 std::unique_ptr<uv_work_t> managedWork(work);
3423 if (work == nullptr) {
3424 HILOG_ERROR("UvWorkOnAbilityDisconnectDone, work is null");
3425 return;
3426 }
3427 // JS Thread
3428 std::unique_ptr<ConnectAbilityCB> connectAbilityCB(static_cast<ConnectAbilityCB *>(work->data));
3429 if (connectAbilityCB == nullptr) {
3430 HILOG_ERROR("UvWorkOnAbilityDisconnectDone, connectAbilityCB is null");
3431 return;
3432 }
3433 CallbackInfo &cbInfo = connectAbilityCB->cbBase.cbInfo;
3434 napi_handle_scope scope = nullptr;
3435 napi_open_handle_scope(cbInfo.env, &scope);
3436 if (scope == nullptr) {
3437 HILOG_ERROR("napi_open_handle_scope failed");
3438 return;
3439 }
3440 napi_value result = WrapElementName(cbInfo.env, connectAbilityCB->abilityConnectionCB.elementName);
3441 if (cbInfo.callback != nullptr) {
3442 napi_value callback = nullptr;
3443 napi_value callResult = nullptr;
3444 napi_value undefined = nullptr;
3445 napi_get_undefined(cbInfo.env, &undefined);
3446 napi_get_reference_value(cbInfo.env, cbInfo.callback, &callback);
3447 napi_call_function(cbInfo.env, undefined, callback, ARGS_ONE, &result, &callResult);
3448 napi_delete_reference(cbInfo.env, cbInfo.callback);
3449 cbInfo.callback = nullptr;
3450 }
3451 napi_close_handle_scope(cbInfo.env, scope);
3452
3453 // release connect
3454 std::lock_guard<std::mutex> lock(g_connectionsLock_);
3455 HILOG_INFO("UvWorkOnAbilityDisconnectDone connects_.size:%{public}zu", connects_.size());
3456 std::string deviceId = connectAbilityCB->abilityConnectionCB.elementName.GetDeviceID();
3457 std::string bundleName = connectAbilityCB->abilityConnectionCB.elementName.GetBundleName();
3458 std::string abilityName = connectAbilityCB->abilityConnectionCB.elementName.GetAbilityName();
3459 auto item = std::find_if(connects_.begin(), connects_.end(),
3460 [deviceId, bundleName, abilityName](const std::map<ConnectionKey,
3461 sptr<NAPIAbilityConnection>>::value_type &obj) {
3462 return (deviceId == obj.first.want.GetDeviceId()) &&
3463 (bundleName == obj.first.want.GetBundle()) &&
3464 (abilityName == obj.first.want.GetElement().GetAbilityName());
3465 });
3466 if (item != connects_.end()) {
3467 // match deviceid & bundlename && abilityname
3468 connects_.erase(item);
3469 HILOG_INFO("UvWorkOnAbilityDisconnectDone erase connects_.size:%{public}zu", connects_.size());
3470 }
3471 HILOG_INFO("UvWorkOnAbilityDisconnectDone, uv_queue_work end");
3472 }
3473
HandleOnAbilityDisconnectDone(ConnectionCallback & callback,int resultCode)3474 void NAPIAbilityConnection::HandleOnAbilityDisconnectDone(ConnectionCallback &callback, int resultCode)
3475 {
3476 HILOG_INFO("%{public}s called.", __func__);
3477 uv_loop_s *loop = nullptr;
3478 napi_get_uv_event_loop(callback.env, &loop);
3479 if (loop == nullptr) {
3480 HILOG_ERROR("%{public}s, loop == nullptr.", __func__);
3481 return;
3482 }
3483
3484 uv_work_t *work = new(std::nothrow) uv_work_t;
3485 if (work == nullptr) {
3486 HILOG_ERROR("%{public}s, work == nullptr.", __func__);
3487 return;
3488 }
3489
3490 ConnectAbilityCB *connectAbilityCB = new (std::nothrow) ConnectAbilityCB;
3491 if (connectAbilityCB == nullptr) {
3492 HILOG_ERROR("%{public}s, connectAbilityCB == nullptr.", __func__);
3493 if (work != nullptr) {
3494 delete work;
3495 work = nullptr;
3496 }
3497 return;
3498 }
3499
3500 connectAbilityCB->cbBase.cbInfo.env = callback.env;
3501 connectAbilityCB->cbBase.cbInfo.callback = callback.disconnectCallbackRef;
3502 callback.disconnectCallbackRef = nullptr;
3503 connectAbilityCB->abilityConnectionCB.elementName = element_;
3504 connectAbilityCB->abilityConnectionCB.resultCode = resultCode;
3505 work->data = static_cast<void *>(connectAbilityCB);
3506
3507 int rev = uv_queue_work(
3508 loop, work, [](uv_work_t *work) {}, UvWorkOnAbilityDisconnectDone);
3509 if (rev != 0) {
3510 if (connectAbilityCB != nullptr) {
3511 delete connectAbilityCB;
3512 connectAbilityCB = nullptr;
3513 }
3514 if (work != nullptr) {
3515 delete work;
3516 work = nullptr;
3517 }
3518 }
3519 }
3520
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)3521 void NAPIAbilityConnection::OnAbilityDisconnectDone(const AppExecFwk::ElementName &element, int resultCode)
3522 {
3523 HILOG_INFO("%{public}s bundleName:%{public}s abilityName:%{public}s, resultCode:%{public}d",
3524 __func__, element.GetBundleName().c_str(), element.GetAbilityName().c_str(), resultCode);
3525 std::lock_guard<std::mutex> guard(lock_);
3526 element_ = element;
3527 for (const auto &callback : callbacks_) {
3528 HandleOnAbilityDisconnectDone(*callback, resultCode);
3529 }
3530 connectionState_ = CONNECTION_STATE_DISCONNECTED;
3531 HILOG_INFO("%{public}s, end.", __func__);
3532 }
3533
3534 /**
3535 * @brief AcquireDataAbilityHelper.
3536 *
3537 * @param env The environment that the Node-API call is invoked under.
3538 * @param info The callback info passed into the callback function.
3539 *
3540 * @return The return value from NAPI C++ to JS for the module.
3541 */
NAPI_AcquireDataAbilityHelperCommon(napi_env env,napi_callback_info info,AbilityType abilityType)3542 napi_value NAPI_AcquireDataAbilityHelperCommon(napi_env env, napi_callback_info info, AbilityType abilityType)
3543 {
3544 HILOG_INFO("AcquireDataAbilityHelper called");
3545 DataAbilityHelperCB *dataAbilityHelperCB = new DataAbilityHelperCB;
3546 dataAbilityHelperCB->cbBase.cbInfo.env = env;
3547 dataAbilityHelperCB->cbBase.ability = nullptr; // temporary value assignment
3548 dataAbilityHelperCB->cbBase.errCode = NAPI_ERR_NO_ERROR;
3549 dataAbilityHelperCB->cbBase.abilityType = abilityType;
3550 napi_value ret = AcquireDataAbilityHelperWrap(env, info, dataAbilityHelperCB);
3551 if (ret == nullptr) {
3552 HILOG_ERROR("%{public}s, ret == nullptr", __func__);
3553 if (dataAbilityHelperCB != nullptr) {
3554 delete dataAbilityHelperCB;
3555 dataAbilityHelperCB = nullptr;
3556 }
3557 ret = WrapVoidToJS(env);
3558 }
3559 HILOG_INFO("AcquireDataAbilityHelper end");
3560 return ret;
3561 }
3562
3563 /**
3564 * @brief acquireDataAbilityHelper processing function.
3565 *
3566 * @param env The environment that the Node-API call is invoked under.
3567 * @param dataAbilityHelperCB Process data asynchronously.
3568 *
3569 * @return Return JS data successfully, otherwise return nullptr.
3570 */
AcquireDataAbilityHelperWrap(napi_env env,napi_callback_info info,DataAbilityHelperCB * dataAbilityHelperCB)3571 napi_value AcquireDataAbilityHelperWrap(napi_env env, napi_callback_info info, DataAbilityHelperCB *dataAbilityHelperCB)
3572 {
3573 if (dataAbilityHelperCB == nullptr) {
3574 HILOG_ERROR("%{public}s,dataAbilityHelperCB == nullptr", __func__);
3575 return nullptr;
3576 }
3577
3578 size_t requireArgc = ARGS_TWO;
3579 size_t argc = ARGS_TWO;
3580 napi_value args[ARGS_TWO] = {nullptr};
3581 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
3582 if (argc > requireArgc) {
3583 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
3584 return nullptr;
3585 }
3586
3587 size_t uriIndex = PARAM0;
3588 bool stageMode = false;
3589 napi_status status = OHOS::AbilityRuntime::IsStageContext(env, args[0], stageMode);
3590 if (status == napi_ok) {
3591 uriIndex = PARAM1;
3592 HILOG_INFO("argv[0] is a context, Stage Model: %{public}d", stageMode);
3593 }
3594
3595 if (!stageMode) {
3596 auto ability = OHOS::AbilityRuntime::GetCurrentAbility(env);
3597 if (ability == nullptr) {
3598 HILOG_ERROR("Failed to get native context instance");
3599 return nullptr;
3600 }
3601 dataAbilityHelperCB->cbBase.ability = ability;
3602
3603 if (!CheckAbilityType(&dataAbilityHelperCB->cbBase)) {
3604 dataAbilityHelperCB->cbBase.errCode = NAPI_ERR_ABILITY_TYPE_INVALID;
3605 HILOG_ERROR("%{public}s ability type invalid.", __func__);
3606 return nullptr;
3607 }
3608 }
3609
3610 napi_valuetype valuetype = napi_undefined;
3611 NAPI_CALL(env, napi_typeof(env, args[uriIndex], &valuetype));
3612 if (valuetype != napi_string) {
3613 HILOG_ERROR("%{public}s, Wrong argument type.", __func__);
3614 return nullptr;
3615 }
3616
3617 napi_value result = nullptr;
3618 NAPI_CALL(env, napi_new_instance(env, GetGlobalDataAbilityHelper(env), uriIndex + 1, &args[PARAM0], &result));
3619
3620 if (!IsTypeForNapiValue(env, result, napi_object)) {
3621 HILOG_ERROR("%{public}s, IsTypeForNapiValue isn`t object", __func__);
3622 return nullptr;
3623 }
3624
3625 if (IsTypeForNapiValue(env, result, napi_null)) {
3626 HILOG_ERROR("%{public}s, IsTypeForNapiValue is null", __func__);
3627 return nullptr;
3628 }
3629
3630 if (IsTypeForNapiValue(env, result, napi_undefined)) {
3631 HILOG_ERROR("%{public}s, IsTypeForNapiValue is undefined", __func__);
3632 return nullptr;
3633 }
3634
3635 if (!GetDataAbilityHelperStatus()) {
3636 HILOG_ERROR("%{public}s, GetDataAbilityHelperStatus is false", __func__);
3637 return nullptr;
3638 }
3639
3640 delete dataAbilityHelperCB;
3641 dataAbilityHelperCB = nullptr;
3642 return result;
3643 }
3644
UnwrapParamForWantAgent(napi_env & env,napi_value & args,AbilityRuntime::WantAgent::WantAgent * & wantAgent)3645 napi_value UnwrapParamForWantAgent(napi_env &env, napi_value &args, AbilityRuntime::WantAgent::WantAgent *&wantAgent)
3646 {
3647 napi_valuetype valuetype = napi_undefined;
3648 NAPI_CALL(env, napi_typeof(env, args, &valuetype));
3649 NAPI_ASSERT(env, valuetype == napi_object, "Wrong argument type. Object expected.");
3650 napi_value wantAgentParam = nullptr;
3651 napi_value result = nullptr;
3652
3653 bool hasProperty = false;
3654 NAPI_CALL(env, napi_has_named_property(env, args, "wantAgent", &hasProperty));
3655 if (hasProperty) {
3656 napi_get_named_property(env, args, "wantAgent", &wantAgentParam);
3657 NAPI_CALL(env, napi_typeof(env, wantAgentParam, &valuetype));
3658 NAPI_ASSERT(env, valuetype == napi_object, "Wrong argument type. Object expected.");
3659 napi_unwrap(env, wantAgentParam, reinterpret_cast<void **>(&wantAgent));
3660 }
3661
3662 napi_get_null(env, &result);
3663 return result;
3664 }
3665
StartBackgroundRunningExecuteCB(napi_env env,void * data)3666 void StartBackgroundRunningExecuteCB(napi_env env, void *data)
3667 {
3668 HILOG_INFO("%{public}s called.", __func__);
3669 AsyncCallbackInfo *asyncCallbackInfo = (AsyncCallbackInfo *)data;
3670 if (asyncCallbackInfo == nullptr) {
3671 HILOG_ERROR("%{public}s asyncCallbackInfo == nullptr", __func__);
3672 return;
3673 }
3674 if (asyncCallbackInfo->errCode == NAPI_ERR_PARAM_INVALID) {
3675 HILOG_ERROR("parse input param failed");
3676 return;
3677 }
3678 if (asyncCallbackInfo->ability == nullptr) {
3679 asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
3680 HILOG_ERROR("%{public}s ability == nullptr", __func__);
3681 return;
3682 }
3683 const std::shared_ptr<AbilityInfo> info = asyncCallbackInfo->ability->GetAbilityInfo();
3684 if (info == nullptr) {
3685 HILOG_ERROR("abilityinfo is null");
3686 asyncCallbackInfo->errCode = NAPI_ERR_ACE_ABILITY;
3687 return;
3688 }
3689
3690 AbilityRuntime::WantAgent::WantAgent wantAgentObj;
3691 if (!asyncCallbackInfo->wantAgent) {
3692 HILOG_WARN("input param without wantAgent");
3693 wantAgentObj = AbilityRuntime::WantAgent::WantAgent();
3694 } else {
3695 wantAgentObj = *asyncCallbackInfo->wantAgent;
3696 }
3697 asyncCallbackInfo->errCode = asyncCallbackInfo->ability->StartBackgroundRunning(wantAgentObj);
3698
3699 HILOG_INFO("%{public}s end.", __func__);
3700 }
3701
BackgroundRunningCallbackCompletedCB(napi_env env,napi_status status,void * data)3702 void BackgroundRunningCallbackCompletedCB(napi_env env, napi_status status, void *data)
3703 {
3704 HILOG_INFO("%{public}s called.", __func__);
3705 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
3706 napi_value callback = nullptr;
3707 napi_value undefined = nullptr;
3708 napi_value result[ARGS_TWO] = {nullptr};
3709 napi_value callResult = nullptr;
3710 napi_get_undefined(env, &undefined);
3711 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
3712 result[0] = WrapUndefinedToJS(env);
3713 napi_create_int32(env, 0, &result[1]);
3714 } else {
3715 result[1] = WrapUndefinedToJS(env);
3716 result[0] = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
3717 }
3718
3719 napi_get_reference_value(env, asyncCallbackInfo->cbInfo.callback, &callback);
3720 napi_call_function(env, undefined, callback, ARGS_TWO, result, &callResult);
3721
3722 if (asyncCallbackInfo->cbInfo.callback != nullptr) {
3723 napi_delete_reference(env, asyncCallbackInfo->cbInfo.callback);
3724 }
3725 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
3726 delete asyncCallbackInfo;
3727 asyncCallbackInfo = nullptr;
3728 HILOG_INFO("%{public}s end.", __func__);
3729 }
3730
BackgroundRunningPromiseCompletedCB(napi_env env,napi_status status,void * data)3731 void BackgroundRunningPromiseCompletedCB(napi_env env, napi_status status, void *data)
3732 {
3733 HILOG_INFO("%{public}s called.", __func__);
3734 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
3735 napi_value result = nullptr;
3736 if (asyncCallbackInfo->errCode == NAPI_ERR_NO_ERROR) {
3737 napi_create_int32(env, 0, &result);
3738 napi_resolve_deferred(env, asyncCallbackInfo->deferred, result);
3739 } else {
3740 result = GetCallbackErrorValue(env, asyncCallbackInfo->errCode);
3741 napi_reject_deferred(env, asyncCallbackInfo->deferred, result);
3742 }
3743
3744 napi_delete_async_work(env, asyncCallbackInfo->asyncWork);
3745 HILOG_INFO("%{public}s, end.", __func__);
3746 delete asyncCallbackInfo;
3747 }
3748
StartBackgroundRunningAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)3749 napi_value StartBackgroundRunningAsync(
3750 napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
3751 {
3752 HILOG_INFO("%{public}s asyncCallback.", __func__);
3753 if (args == nullptr || asyncCallbackInfo == nullptr) {
3754 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
3755 return nullptr;
3756 }
3757 napi_value resourceName = nullptr;
3758 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
3759
3760 napi_valuetype valuetype = napi_undefined;
3761 NAPI_CALL(env, napi_typeof(env, args[argCallback], &valuetype));
3762 if (valuetype == napi_function) {
3763 NAPI_CALL(env, napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback));
3764 }
3765
3766 NAPI_CALL(env,
3767 napi_create_async_work(env,
3768 nullptr,
3769 resourceName,
3770 StartBackgroundRunningExecuteCB,
3771 BackgroundRunningCallbackCompletedCB,
3772 static_cast<void *>(asyncCallbackInfo),
3773 &asyncCallbackInfo->asyncWork));
3774 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_utility));
3775
3776 HILOG_INFO("%{public}s asyncCallback end.", __func__);
3777 return WrapVoidToJS(env);
3778 }
3779
StartBackgroundRunningPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)3780 napi_value StartBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
3781 {
3782 HILOG_INFO("%{public}s, promise.", __func__);
3783 if (asyncCallbackInfo == nullptr) {
3784 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
3785 return nullptr;
3786 }
3787 napi_value resourceName;
3788 NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
3789 napi_deferred deferred;
3790 napi_value promise = nullptr;
3791 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
3792 asyncCallbackInfo->deferred = deferred;
3793
3794 NAPI_CALL(env,
3795 napi_create_async_work(env,
3796 nullptr,
3797 resourceName,
3798 StartBackgroundRunningExecuteCB,
3799 BackgroundRunningPromiseCompletedCB,
3800 static_cast<void *>(asyncCallbackInfo),
3801 &asyncCallbackInfo->asyncWork));
3802 NAPI_CALL(env, napi_queue_async_work_with_qos(env, asyncCallbackInfo->asyncWork, napi_qos_utility));
3803 HILOG_INFO("%{public}s, end.", __func__);
3804 return promise;
3805 }
3806
StartBackgroundRunningWrap(napi_env & env,napi_callback_info & info,AsyncCallbackInfo * asyncCallbackInfo)3807 napi_value StartBackgroundRunningWrap(napi_env &env, napi_callback_info &info, AsyncCallbackInfo *asyncCallbackInfo)
3808 {
3809 HILOG_INFO("%{public}s called.", __func__);
3810 size_t paramNums = 3;
3811 const size_t minParamNums = 2;
3812 const size_t maxParamNums = 3;
3813 napi_value args[maxParamNums] = {nullptr};
3814 napi_value ret = nullptr;
3815
3816 NAPI_CALL(env, napi_get_cb_info(env, info, ¶mNums, args, NULL, NULL));
3817
3818 if (paramNums < minParamNums || paramNums > maxParamNums) {
3819 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
3820 return nullptr;
3821 }
3822
3823 if (UnwrapParamForWantAgent(env, args[1], asyncCallbackInfo->wantAgent) == nullptr) {
3824 asyncCallbackInfo->errCode = NAPI_ERR_PARAM_INVALID;
3825 }
3826
3827 if (paramNums == maxParamNums) {
3828 ret = StartBackgroundRunningAsync(env, args, maxParamNums - 1, asyncCallbackInfo);
3829 } else {
3830 ret = StartBackgroundRunningPromise(env, asyncCallbackInfo);
3831 }
3832
3833 HILOG_INFO("%{public}s end.", __func__);
3834 return ret;
3835 }
3836
NAPI_StartBackgroundRunningCommon(napi_env env,napi_callback_info info)3837 napi_value NAPI_StartBackgroundRunningCommon(napi_env env, napi_callback_info info)
3838 {
3839 HILOG_INFO("%{public}s called.", __func__);
3840 AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
3841 if (asyncCallbackInfo == nullptr) {
3842 HILOG_ERROR("%{public}s asyncCallbackInfo == nullpter", __func__);
3843 return WrapVoidToJS(env);
3844 }
3845
3846 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
3847 napi_value ret = StartBackgroundRunningWrap(env, info, asyncCallbackInfo);
3848 if (ret == nullptr) {
3849 HILOG_ERROR("%{public}s ret == nullpter", __func__);
3850 if (asyncCallbackInfo != nullptr) {
3851 delete asyncCallbackInfo;
3852 asyncCallbackInfo = nullptr;
3853 }
3854 ret = WrapVoidToJS(env);
3855 }
3856 HILOG_INFO("%{public}s end.", __func__);
3857 return ret;
3858 }
3859
CancelBackgroundRunningExecuteCB(napi_env env,void * data)3860 void CancelBackgroundRunningExecuteCB(napi_env env, void *data)
3861 {
3862 AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
3863 if (asyncCallbackInfo->ability != nullptr) {
3864 asyncCallbackInfo->errCode = asyncCallbackInfo->ability->StopBackgroundRunning();
3865 } else {
3866 HILOG_ERROR("NAPI_PACancelBackgroundRunning, ability == nullptr");
3867 }
3868 }
3869
CancelBackgroundRunningAsync(napi_env env,napi_value * args,const size_t argCallback,AsyncCallbackInfo * asyncCallbackInfo)3870 napi_value CancelBackgroundRunningAsync(
3871 napi_env env, napi_value *args, const size_t argCallback, AsyncCallbackInfo *asyncCallbackInfo)
3872 {
3873 HILOG_INFO("%{public}s, asyncCallback.", __func__);
3874 if (args == nullptr || asyncCallbackInfo == nullptr) {
3875 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
3876 return nullptr;
3877 }
3878 napi_value resourceName = nullptr;
3879 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3880
3881 napi_valuetype valuetype = napi_undefined;
3882 napi_typeof(env, args[argCallback], &valuetype);
3883 if (valuetype == napi_function) {
3884 napi_create_reference(env, args[argCallback], 1, &asyncCallbackInfo->cbInfo.callback);
3885 }
3886
3887 napi_create_async_work(
3888 env,
3889 nullptr,
3890 resourceName,
3891 CancelBackgroundRunningExecuteCB,
3892 BackgroundRunningCallbackCompletedCB,
3893 static_cast<void *>(asyncCallbackInfo),
3894 &asyncCallbackInfo->asyncWork);
3895 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
3896 napi_value result = nullptr;
3897 napi_get_null(env, &result);
3898 HILOG_INFO("%{public}s, asyncCallback end", __func__);
3899 return result;
3900 }
3901
CancelBackgroundRunningPromise(napi_env env,AsyncCallbackInfo * asyncCallbackInfo)3902 napi_value CancelBackgroundRunningPromise(napi_env env, AsyncCallbackInfo *asyncCallbackInfo)
3903 {
3904 HILOG_INFO("%{public}s, promise.", __func__);
3905 if (asyncCallbackInfo == nullptr) {
3906 HILOG_ERROR("%{public}s, param == nullptr.", __func__);
3907 return nullptr;
3908 }
3909 napi_value resourceName = nullptr;
3910 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
3911 napi_deferred deferred;
3912 napi_value promise = nullptr;
3913 napi_create_promise(env, &deferred, &promise);
3914
3915 asyncCallbackInfo->deferred = deferred;
3916
3917 napi_create_async_work(
3918 env,
3919 nullptr,
3920 resourceName,
3921 CancelBackgroundRunningExecuteCB,
3922 BackgroundRunningPromiseCompletedCB,
3923 static_cast<void *>(asyncCallbackInfo),
3924 &asyncCallbackInfo->asyncWork);
3925 napi_queue_async_work(env, asyncCallbackInfo->asyncWork);
3926 HILOG_INFO("%{public}s, promise end", __func__);
3927 return promise;
3928 }
3929
CancelBackgroundRunningWrap(napi_env & env,napi_callback_info & info,AsyncCallbackInfo * asyncCallbackInfo)3930 napi_value CancelBackgroundRunningWrap(napi_env &env, napi_callback_info &info, AsyncCallbackInfo *asyncCallbackInfo)
3931 {
3932 HILOG_INFO("%{public}s called.", __func__);
3933 size_t argcAsync = 1;
3934 const size_t argcPromise = 0;
3935 const size_t argCountWithAsync = argcPromise + ARGS_ASYNC_COUNT;
3936 napi_value args[ARGS_MAX_COUNT] = {nullptr};
3937 napi_value ret = nullptr;
3938
3939 NAPI_CALL(env, napi_get_cb_info(env, info, &argcAsync, args, NULL, NULL));
3940 if (argcAsync > argCountWithAsync || argcAsync > ARGS_MAX_COUNT) {
3941 HILOG_ERROR("%{public}s, Wrong argument count.", __func__);
3942 return nullptr;
3943 }
3944
3945 if (argcAsync > argcPromise) {
3946 ret = CancelBackgroundRunningAsync(env, args, 0, asyncCallbackInfo);
3947 } else {
3948 ret = CancelBackgroundRunningPromise(env, asyncCallbackInfo);
3949 }
3950
3951 HILOG_INFO("%{public}s end.", __func__);
3952 return ret;
3953 }
3954
NAPI_CancelBackgroundRunningCommon(napi_env env,napi_callback_info info)3955 napi_value NAPI_CancelBackgroundRunningCommon(napi_env env, napi_callback_info info)
3956 {
3957 HILOG_INFO("%{public}s called.", __func__);
3958 AsyncCallbackInfo *asyncCallbackInfo = CreateAsyncCallbackInfo(env);
3959 if (asyncCallbackInfo == nullptr) {
3960 HILOG_ERROR("%{public}s asyncCallbackInfo == nullpter", __func__);
3961 return WrapVoidToJS(env);
3962 }
3963
3964 asyncCallbackInfo->errCode = NAPI_ERR_NO_ERROR;
3965 napi_value ret = CancelBackgroundRunningWrap(env, info, asyncCallbackInfo);
3966 if (ret == nullptr) {
3967 HILOG_ERROR("%{public}s ret == nullpter", __func__);
3968 if (asyncCallbackInfo != nullptr) {
3969 delete asyncCallbackInfo;
3970 asyncCallbackInfo = nullptr;
3971 }
3972 ret = WrapVoidToJS(env);
3973 }
3974 HILOG_INFO("%{public}s end.", __func__);
3975 return ret;
3976 }
3977
JsNapiCommon()3978 JsNapiCommon::JsNapiCommon() : ability_(nullptr)
3979 {}
3980
~JsNapiCommon()3981 JsNapiCommon::~JsNapiCommon()
3982 {
3983 RemoveAllCallbacksLocked();
3984 }
3985
JsConnectAbility(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)3986 NativeValue* JsNapiCommon::JsConnectAbility(
3987 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
3988 {
3989 HILOG_DEBUG("%{public}s is called", __func__);
3990 if (info.argc != ARGS_TWO) {
3991 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
3992 return engine.CreateUndefined();
3993 }
3994 std::lock_guard<std::mutex> lock(g_connectionsLock_);
3995 auto env = reinterpret_cast<napi_env>(&engine);
3996 auto firstParam = reinterpret_cast<napi_value>(info.argv[PARAM0]);
3997 auto secondParam = reinterpret_cast<napi_value>(info.argv[PARAM1]);
3998 Want want;
3999 if (!UnwrapWant(env, firstParam, want)) {
4000 HILOG_ERROR("called. Invoke UnwrapWant fail");
4001 return engine.CreateUndefined();
4002 }
4003
4004 auto connectionCallback = std::make_shared<ConnectionCallback>(env, secondParam, this);
4005 bool result = false;
4006 int32_t errorVal = static_cast<int32_t>(NAPI_ERR_NO_ERROR);
4007 int64_t id = 0;
4008 sptr<NAPIAbilityConnection> abilityConnection = nullptr;
4009 if (CheckAbilityType(abilityType)) {
4010 abilityConnection = FindConnectionLocked(want, id);
4011 if (abilityConnection) {
4012 HILOG_INFO("find abilityConnection exist, current callbackSize: %{public}zu.",
4013 abilityConnection->GetCallbackSize());
4014 // Add callback to connection
4015 abilityConnection->AddConnectionCallback(connectionCallback);
4016 // Judge connection-state
4017 auto connectionState = abilityConnection->GetConnectionState();
4018 if (connectionState == CONNECTION_STATE_CONNECTED) {
4019 HILOG_INFO("Ability is connected, callback to client.");
4020 abilityConnection->HandleOnAbilityConnectDone(*connectionCallback, ERR_OK);
4021 return CreateJsValue(engine, id);
4022 } else if (connectionState == CONNECTION_STATE_CONNECTING) {
4023 HILOG_INFO("Ability is connecting, just wait callback.");
4024 return CreateJsValue(engine, id);
4025 } else {
4026 HILOG_ERROR("AbilityConnection has disconnected, erase it.");
4027 RemoveConnectionLocked(want);
4028 return engine.CreateUndefined();
4029 }
4030 } else {
4031 result = CreateConnectionAndConnectAbilityLocked(connectionCallback, want, id);
4032 }
4033 } else {
4034 errorVal = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4035 }
4036
4037 if (errorVal != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || result == false) {
4038 HILOG_ERROR("CommonJsConnectAbility failed.");
4039 // return error code in onFailed async callback
4040 napi_value callback = nullptr;
4041 napi_value undefined = nullptr;
4042 napi_value resultVal = nullptr;
4043 napi_value callResult = nullptr;
4044 int errorCode = NO_ERROR;
4045 switch (errorVal) {
4046 case NAPI_ERR_ACE_ABILITY:
4047 errorCode = ABILITY_NOT_FOUND;
4048 break;
4049 case NAPI_ERR_PARAM_INVALID:
4050 errorCode = INVALID_PARAMETER;
4051 break;
4052 default:
4053 break;
4054 }
4055 NAPI_CALL_BASE(env, napi_create_int32(env, errorCode, &resultVal), engine.CreateUndefined());
4056 NAPI_CALL_BASE(
4057 env, napi_get_reference_value(env, connectionCallback->failedCallbackRef, &callback),
4058 engine.CreateUndefined());
4059 NAPI_CALL_BASE(env, napi_call_function(env, undefined, callback, ARGS_ONE, &resultVal, &callResult),
4060 engine.CreateUndefined());
4061 connectionCallback->Reset();
4062 RemoveConnectionLocked(want);
4063 }
4064 // free failedcallback here, avoid possible multi-threading problems when disconnect success
4065 napi_delete_reference(env, connectionCallback->failedCallbackRef);
4066 connectionCallback->failedCallbackRef = nullptr;
4067 return CreateJsValue(engine, id);
4068 }
4069
JsDisConnectAbility(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4070 NativeValue* JsNapiCommon::JsDisConnectAbility(
4071 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4072 {
4073 HILOG_DEBUG("%{public}s is called", __func__);
4074 if (info.argc == ARGS_ZERO || info.argc > ARGS_TWO) {
4075 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4076 return engine.CreateUndefined();
4077 }
4078 std::lock_guard<std::mutex> lock(g_connectionsLock_);
4079 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4080 int64_t id = 0;
4081 sptr<NAPIAbilityConnection> abilityConnection = nullptr;
4082 if (!ConvertFromJsValue(engine, info.argv[PARAM0], id)) {
4083 HILOG_ERROR("input params int error");
4084 return engine.CreateUndefined();
4085 }
4086 auto item = std::find_if(connects_.begin(), connects_.end(),
4087 [&id](const std::map<ConnectionKey, sptr<NAPIAbilityConnection>>::value_type &obj) {
4088 return id == obj.first.id;
4089 });
4090 if (item != connects_.end()) {
4091 abilityConnection = item->second;
4092 HILOG_DEBUG("find conn ability exist");
4093 } else {
4094 HILOG_ERROR("there is no ability to disconnect.");
4095 return engine.CreateUndefined();
4096 }
4097 auto execute = [obj = this, value = errorVal, abilityType, abilityConnection] () {
4098 if (obj->ability_ == nullptr) {
4099 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4100 HILOG_ERROR("task execute error, the ability is nullptr.");
4101 return;
4102 }
4103 if (!obj->CheckAbilityType(abilityType)) {
4104 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4105 return;
4106 }
4107 *value = obj->ability_->DisconnectAbility(abilityConnection);
4108 };
4109 auto complete = [obj = this, value = errorVal]
4110 (NativeEngine &engine, AsyncTask &task, const int32_t status) {
4111 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR)) {
4112 task.Reject(engine, CreateJsError(engine, *value, "DisconnectAbility failed."));
4113 return;
4114 }
4115 task.Resolve(engine, CreateJsValue(engine, *value));
4116 };
4117 NativeValue *lastParam = (info.argc == ARGS_ONE) ? nullptr : info.argv[PARAM1];
4118 NativeValue *result = nullptr;
4119 AsyncTask::Schedule("JsNapiCommon::JsDisConnectAbility",
4120 engine, CreateAsyncTaskWithLastParam(engine, lastParam, std::move(execute), std::move(complete), &result));
4121 return result;
4122 }
4123
CreateConnectionAndConnectAbilityLocked(std::shared_ptr<ConnectionCallback> callback,const Want & want,int64_t & id)4124 bool JsNapiCommon::CreateConnectionAndConnectAbilityLocked(
4125 std::shared_ptr<ConnectionCallback> callback, const Want &want, int64_t &id)
4126 {
4127 HILOG_DEBUG("Create new connection");
4128 // Create connection
4129 sptr<NAPIAbilityConnection> connection(new (std::nothrow) NAPIAbilityConnection());
4130 ConnectionKey key;
4131 id = serialNumber_;
4132 key.id = id;
4133 key.want = want;
4134 connects_.emplace(key, connection);
4135 if (serialNumber_ < INT32_MAX) {
4136 serialNumber_++;
4137 } else {
4138 serialNumber_ = 0;
4139 }
4140 // Set callback
4141 connection->AddConnectionCallback(callback);
4142
4143 // connectAbility
4144 if (ability_ == nullptr) {
4145 HILOG_ERROR("ConnectAbility, the ability is nullptr");
4146 return false;
4147 }
4148 connection->SetConnectionState(CONNECTION_STATE_CONNECTING);
4149 return ability_->ConnectAbility(want, connection);
4150 }
4151
FindConnectionLocked(const Want & want,int64_t & id)4152 sptr<NAPIAbilityConnection> JsNapiCommon::FindConnectionLocked(const Want &want, int64_t &id)
4153 {
4154 HILOG_DEBUG("%{public}s uri:%{public}s", __func__, want.GetElement().GetURI().c_str());
4155 std::string deviceId = want.GetElement().GetDeviceID();
4156 std::string bundleName = want.GetBundle();
4157 std::string abilityName = want.GetElement().GetAbilityName();
4158 auto iter = std::find_if(connects_.begin(),
4159 connects_.end(), [&deviceId, &bundleName, &abilityName](const std::map<ConnectionKey,
4160 sptr<NAPIAbilityConnection>>::value_type &obj) {
4161 return (deviceId == obj.first.want.GetElement().GetDeviceID()) &&
4162 (bundleName == obj.first.want.GetBundle()) &&
4163 (abilityName == obj.first.want.GetElement().GetAbilityName());
4164 });
4165 if (iter != connects_.end()) {
4166 HILOG_DEBUG("find connection exist");
4167 auto connection = iter->second;
4168 if (connection == nullptr) {
4169 HILOG_ERROR("connection is nullptr");
4170 connects_.erase(iter);
4171 return nullptr;
4172 }
4173 id = iter->first.id;
4174 return connection;
4175 }
4176 return nullptr;
4177 }
4178
RemoveAllCallbacksLocked()4179 void JsNapiCommon::RemoveAllCallbacksLocked()
4180 {
4181 HILOG_DEBUG("RemoveAllCallbacksLocked begin");
4182 std::lock_guard<std::mutex> lock(g_connectionsLock_);
4183 for (auto it = connects_.begin(); it != connects_.end();) {
4184 auto connection = it->second;
4185 if (!connection) {
4186 HILOG_ERROR("connection is nullptr");
4187 it = connects_.erase(it);
4188 continue;
4189 }
4190 connection->RemoveAllCallbacks(this);
4191 if (connection->GetCallbackSize() == 0) {
4192 it = connects_.erase(it);
4193 } else {
4194 ++it;
4195 }
4196 }
4197 }
4198
RemoveConnectionLocked(const Want & want)4199 void JsNapiCommon::RemoveConnectionLocked(const Want &want)
4200 {
4201 std::string deviceId = want.GetElement().GetDeviceID();
4202 std::string bundleName = want.GetBundle();
4203 std::string abilityName = want.GetElement().GetAbilityName();
4204 auto iter = std::find_if(connects_.begin(),
4205 connects_.end(), [&deviceId, &bundleName, &abilityName](const std::map<ConnectionKey,
4206 sptr<NAPIAbilityConnection>>::value_type &obj) {
4207 return (deviceId == obj.first.want.GetElement().GetDeviceID()) &&
4208 (bundleName == obj.first.want.GetBundle()) &&
4209 (abilityName == obj.first.want.GetElement().GetAbilityName());
4210 });
4211 connects_.erase(iter);
4212 }
4213
JsGetContext(NativeEngine & engine,const NativeCallbackInfo & info,const AbilityType abilityType)4214 NativeValue* JsNapiCommon::JsGetContext(
4215 NativeEngine &engine, const NativeCallbackInfo &info, const AbilityType abilityType)
4216 {
4217 if (!CheckAbilityType(abilityType)) {
4218 HILOG_ERROR("ability type error");
4219 return engine.CreateUndefined();
4220 }
4221
4222 return CreateNapiJSContext(engine);
4223 }
4224
JsGetFilesDir(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4225 NativeValue* JsNapiCommon::JsGetFilesDir(NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4226 {
4227 HILOG_DEBUG("JsGetFilesDir called");
4228 if (info.argc > ARGS_ONE) {
4229 HILOG_ERROR("JsGetFilesDir input params count error, argc=%{public}zu", info.argc);
4230 return engine.CreateUndefined();
4231 }
4232
4233 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4234 std::shared_ptr<JsFilesDir> filesDir = std::make_shared<JsFilesDir>();
4235 auto execute = [obj = this, dir = filesDir, abilityType, value = errorVal] () {
4236 if (obj->ability_ == nullptr) {
4237 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4238 HILOG_ERROR("JsGetFilesDir task execute error, the ability is nullptr");
4239 return;
4240 }
4241 if (!obj->CheckAbilityType(abilityType)) {
4242 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4243 return;
4244 }
4245 auto context = obj->ability_->GetAbilityContext();
4246 if (context == nullptr) {
4247 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4248 HILOG_ERROR("JsGetFilesDir task execute error, the abilitycontext is nullptr");
4249 return;
4250 }
4251 dir->name = context->GetFilesDir();
4252 };
4253 auto complete = [obj = this, dir = filesDir, value = errorVal]
4254 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4255 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || dir == nullptr) {
4256 auto ecode = dir == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4257 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4258 return;
4259 }
4260 task.Resolve(engine, CreateJsValue(engine, dir->name));
4261 };
4262
4263 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4264 NativeValue *result = nullptr;
4265 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetFilesDir",
4266 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4267 return result;
4268 }
4269
JsIsUpdatingConfigurations(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4270 NativeValue* JsNapiCommon::JsIsUpdatingConfigurations(
4271 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4272 {
4273 HILOG_DEBUG("JsIsUpdatingConfigurations called");
4274 if (info.argc > ARGS_ONE) {
4275 HILOG_ERROR("JsIsUpdatingConfigurations input params count error, argc=%{public}zu", info.argc);
4276 return engine.CreateUndefined();
4277 }
4278
4279 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4280 std::shared_ptr<JsConfigurations> config = std::make_shared<JsConfigurations>();
4281 auto execute = [obj = this, data = config, value = errorVal, abilityType] () {
4282 if (obj->ability_ == nullptr) {
4283 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4284 HILOG_ERROR("JsIsUpdatingConfigurations task execute error, the ability is nullptr");
4285 return;
4286 }
4287 if (!obj->CheckAbilityType(abilityType)) {
4288 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4289 return;
4290 }
4291 if (data == nullptr) {
4292 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4293 HILOG_ERROR("JsIsUpdatingConfigurations task execute error, param is nullptr");
4294 return;
4295 }
4296 data->status = obj->ability_->IsUpdatingConfigurations();
4297 };
4298 auto complete = [obj = this, info = config, value = errorVal]
4299 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4300 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
4301 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4302 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4303 return;
4304 }
4305 task.Resolve(engine, engine.CreateBoolean(info->status));
4306 };
4307
4308 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4309 NativeValue *result = nullptr;
4310 AsyncTask::Schedule("JsNapiCommon::JsIsUpdatingConfigurations",
4311 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4312
4313 return result;
4314 }
4315
JsPrintDrawnCompleted(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4316 NativeValue* JsNapiCommon::JsPrintDrawnCompleted(
4317 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4318 {
4319 HILOG_DEBUG("JsPrintDrawnCompleted called");
4320 if (info.argc > ARGS_ONE) {
4321 HILOG_ERROR("JsPrintDrawnCompleted input params count error, argc=%{public}zu", info.argc);
4322 return engine.CreateUndefined();
4323 }
4324 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4325 std::shared_ptr<JsDrawnCompleted> drawComplete = std::make_shared<JsDrawnCompleted>();
4326 auto execute = [obj = this, data = drawComplete, value = errorVal, abilityType] () {
4327 if (obj->ability_ == nullptr) {
4328 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4329 HILOG_ERROR("JsPrintDrawnCompleted task execute error, the ability is nullptr");
4330 return;
4331 }
4332 if (!obj->CheckAbilityType(abilityType)) {
4333 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4334 return;
4335 }
4336 if (data == nullptr) {
4337 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4338 HILOG_ERROR("JsPrintDrawnCompleted task execute error, data is nullptr");
4339 return;
4340 }
4341 data->status = obj->ability_->PrintDrawnCompleted();
4342 };
4343 auto complete = [obj = this, draw = drawComplete, value = errorVal]
4344 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4345 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || draw == nullptr) {
4346 auto ecode = draw == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4347 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4348 return;
4349 }
4350 task.Resolve(engine, engine.CreateNull());
4351 };
4352
4353 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4354 NativeValue *result = nullptr;
4355 AsyncTask::Schedule("JsNapiCommon::JsPrintDrawnCompleted",
4356 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4357
4358 return result;
4359 }
4360
JsGetCacheDir(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4361 NativeValue* JsNapiCommon::JsGetCacheDir(NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4362 {
4363 HILOG_DEBUG("JsGetCacheDir called");
4364 if (info.argc > ARGS_ONE) {
4365 HILOG_ERROR("JsGetCacheDir input params count error, argc=%{public}zu", info.argc);
4366 return engine.CreateUndefined();
4367 }
4368 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4369 std::shared_ptr<JsCacheDir> cacheDir = std::make_shared<JsCacheDir>();
4370 auto execute = [obj = this, dir = cacheDir, value = errorVal, abilityType] () {
4371 if (obj->ability_ == nullptr) {
4372 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4373 HILOG_ERROR("JsGetCacheDir task execute error, the ability is nullptr");
4374 return;
4375 }
4376 if (!obj->CheckAbilityType(abilityType)) {
4377 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4378 return;
4379 }
4380 auto context = obj->ability_->GetAbilityContext();
4381 if (context == nullptr) {
4382 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4383 HILOG_ERROR("JsGetCacheDir task execute error, the abilitycontext is nullptr");
4384 return;
4385 }
4386 dir->name = context->GetCacheDir();
4387 };
4388 auto complete = [obj = this, dir = cacheDir, value = errorVal]
4389 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4390 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || dir == nullptr) {
4391 auto ecode = dir == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4392 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4393 return;
4394 }
4395 task.Resolve(engine, CreateJsValue(engine, dir->name));
4396 };
4397
4398 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4399 NativeValue *result = nullptr;
4400 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetCacheDir",
4401 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4402
4403 return result;
4404 }
4405
JsGetCtxAppType(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4406 NativeValue* JsNapiCommon::JsGetCtxAppType(
4407 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4408 {
4409 HILOG_DEBUG("called");
4410 if (info.argc > ARGS_ONE) {
4411 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4412 return engine.CreateUndefined();
4413 }
4414
4415 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4416 std::shared_ptr<JsCtxAppType> type = std::make_shared<JsCtxAppType>();
4417 auto execute = [obj = this, apptype = type, value = errorVal, abilityType] () {
4418 if (obj->ability_ == nullptr) {
4419 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4420 HILOG_ERROR("task execute error, the ability is nullptr");
4421 return;
4422 }
4423 if (!obj->CheckAbilityType(abilityType)) {
4424 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4425 return;
4426 }
4427 if (apptype == nullptr) {
4428 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4429 return;
4430 }
4431 apptype->name = obj->ability_->GetAppType();
4432 };
4433 auto complete = [obj = this, apptype = type, value = errorVal]
4434 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4435 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || apptype == nullptr) {
4436 auto ecode = apptype == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4437 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4438 return;
4439 }
4440 task.Resolve(engine, CreateJsValue(engine, apptype->name));
4441 };
4442
4443 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4444 NativeValue *result = nullptr;
4445 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetCtxAppType",
4446 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4447
4448 return result;
4449 }
4450
JsGetCtxHapModuleInfo(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4451 NativeValue* JsNapiCommon::JsGetCtxHapModuleInfo(
4452 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4453 {
4454 HILOG_DEBUG("called");
4455 if (info.argc > ARGS_ONE) {
4456 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4457 return engine.CreateUndefined();
4458 }
4459 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4460 std::shared_ptr<JsHapModuleInfo> infoData = std::make_shared<JsHapModuleInfo>();
4461 auto execute = [obj = this, hapMod = infoData, value = errorVal, abilityType] () {
4462 if (obj->ability_ == nullptr) {
4463 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4464 HILOG_ERROR("task execute error, the ability is nullptr");
4465 return;
4466 }
4467 if (!obj->CheckAbilityType(abilityType)) {
4468 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4469 return;
4470 }
4471 auto getInfo = obj->ability_->GetHapModuleInfo();
4472 if (getInfo != nullptr && hapMod != nullptr) {
4473 hapMod->hapModInfo = *getInfo;
4474 } else {
4475 HILOG_ERROR("GetHapModuleInfo return nullptr");
4476 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4477 }
4478 };
4479 auto complete = [obj = this, info = infoData, value = errorVal]
4480 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4481 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
4482 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4483 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4484 return;
4485 }
4486 task.Resolve(engine, obj->CreateHapModuleInfo(engine, info));
4487 };
4488
4489 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4490 NativeValue *result = nullptr;
4491 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetCtxHapModuleInfo",
4492 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4493
4494 return result;
4495 }
4496
JsGetAppVersionInfo(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4497 NativeValue* JsNapiCommon::JsGetAppVersionInfo(
4498 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4499 {
4500 HILOG_DEBUG("called");
4501 if (info.argc > ARGS_ONE) {
4502 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4503 return engine.CreateUndefined();
4504 }
4505
4506 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4507 std::shared_ptr<JsApplicationInfo> infoData = std::make_shared<JsApplicationInfo>();
4508 auto execute = [obj = this, appInfo = infoData, value = errorVal, abilityType] () {
4509 if (obj->ability_ == nullptr) {
4510 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4511 HILOG_ERROR("task execute error, the ability is nullptr");
4512 return;
4513 }
4514 if (!obj->CheckAbilityType(abilityType)) {
4515 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4516 return;
4517 }
4518 auto getInfo = obj->ability_->GetApplicationInfo();
4519 if (getInfo != nullptr && appInfo != nullptr) {
4520 appInfo->appInfo = *getInfo;
4521 } else {
4522 HILOG_ERROR("GetApplicationInfo return nullptr");
4523 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4524 }
4525 };
4526 auto complete = [obj = this, info = infoData, value = errorVal]
4527 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4528 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
4529 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4530 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4531 return;
4532 }
4533 task.Resolve(engine, obj->CreateAppVersionInfo(engine, info));
4534 };
4535
4536 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4537 NativeValue *result = nullptr;
4538 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetAppVersionInfo",
4539 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4540
4541 return result;
4542 }
4543
JsGetCtxAbilityInfo(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4544 NativeValue* JsNapiCommon::JsGetCtxAbilityInfo(
4545 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4546 {
4547 HILOG_DEBUG("called");
4548 if (info.argc > ARGS_ONE) {
4549 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4550 return engine.CreateUndefined();
4551 }
4552
4553 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4554 std::shared_ptr<JsAbilityInfoInfo> infoData = std::make_shared<JsAbilityInfoInfo>();
4555 auto execute = [obj = this, abilityInfo = infoData, value = errorVal, abilityType] () {
4556 if (obj->ability_ == nullptr) {
4557 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4558 HILOG_ERROR("task execute error, the ability is nullptr");
4559 return;
4560 }
4561 if (!obj->CheckAbilityType(abilityType)) {
4562 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4563 return;
4564 }
4565 auto getInfo = obj->ability_->GetAbilityInfo();
4566 if (getInfo != nullptr && abilityInfo != nullptr) {
4567 abilityInfo->abilityInfo = *getInfo;
4568 } else {
4569 HILOG_ERROR("GetAbilityInfo return nullptr");
4570 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
4571 }
4572 };
4573 auto complete = [obj = this, info = infoData, value = errorVal]
4574 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4575 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || info == nullptr) {
4576 auto ecode = info == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4577 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4578 return;
4579 }
4580 task.Resolve(engine, obj->CreateAbilityInfo(engine, info));
4581 };
4582
4583 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4584 NativeValue *result = nullptr;
4585 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetCtxAbilityInfo",
4586 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4587
4588 return result;
4589 }
4590
JsGetOrCreateDistributedDir(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4591 NativeValue* JsNapiCommon::JsGetOrCreateDistributedDir(
4592 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4593 {
4594 HILOG_DEBUG("called");
4595 if (info.argc > ARGS_ONE) {
4596 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4597 return engine.CreateUndefined();
4598 }
4599
4600 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4601 std::shared_ptr<JsOrCreateDistributedDir> orCreateDistributedDir = std::make_shared<JsOrCreateDistributedDir>();
4602 auto execute = [obj = this, dir = orCreateDistributedDir, value = errorVal, abilityType] () {
4603 if (obj->ability_ == nullptr) {
4604 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4605 HILOG_ERROR("task execute error, the ability is nullptr");
4606 return;
4607 }
4608 if (!obj->CheckAbilityType(abilityType)) {
4609 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4610 return;
4611 }
4612 auto context = obj->ability_->GetAbilityContext();
4613 if (context == nullptr) {
4614 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4615 HILOG_ERROR("task execute error, the abilitycontext is nullptr");
4616 return;
4617 }
4618 dir->name = context->GetDistributedFilesDir();
4619 };
4620 auto complete = [obj = this, dir = orCreateDistributedDir, value = errorVal]
4621 (NativeEngine &engine, AsyncTask &task, int32_t status) {
4622 if (*value != static_cast<int32_t>(NAPI_ERR_NO_ERROR) || dir == nullptr) {
4623 auto ecode = dir == nullptr ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
4624 task.Reject(engine, CreateJsError(engine, ecode, obj->ConvertErrorCode(ecode)));
4625 return;
4626 }
4627 task.Resolve(engine, CreateJsValue(engine, dir->name));
4628 };
4629
4630 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4631 NativeValue *result = nullptr;
4632 AsyncTask::Schedule("JsNapiCommon::JsGetOrCreateDistributedDir",
4633 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4634
4635 return result;
4636 }
4637
4638 #ifdef SUPPORT_GRAPHICS
JsGetDisplayOrientation(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)4639 NativeValue* JsNapiCommon::JsGetDisplayOrientation(
4640 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
4641 {
4642 HILOG_DEBUG("called");
4643 if (info.argc > ARGS_ONE) {
4644 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
4645 return engine.CreateUndefined();
4646 }
4647
4648 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
4649 auto execute = [obj = this, value = errorVal, abilityType] () {
4650 if (obj->ability_ == nullptr) {
4651 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
4652 HILOG_ERROR("task execute error, the ability is nullptr");
4653 return;
4654 }
4655 if (!obj->CheckAbilityType(abilityType)) {
4656 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
4657 return;
4658 }
4659 *value = obj->ability_->GetDisplayOrientation();
4660 };
4661 auto complete = [value = errorVal] (NativeEngine &engine, AsyncTask &task, int32_t status) {
4662 HILOG_DEBUG("JsGetDisplayOrientation value = %{public}d", *value);
4663 if (*value == NAPI_ERR_ACE_ABILITY) {
4664 task.Reject(engine, CreateJsError(engine, NAPI_ERR_ACE_ABILITY, "ability is nullptr"));
4665 } else if (*value == NAPI_ERR_ABILITY_TYPE_INVALID) {
4666 task.Reject(engine, CreateJsError(engine, NAPI_ERR_ABILITY_TYPE_INVALID, "ability type is invalid."));
4667 } else if (*value == NAPI_ERR_NO_WINDOW) {
4668 task.Reject(engine, CreateJsError(engine, NAPI_ERR_NO_WINDOW, "window is nullptr"));
4669 } else {
4670 task.Resolve(engine, CreateJsValue(engine, *value));
4671 }
4672 };
4673
4674 auto callback = info.argc == ARGS_ZERO ? nullptr : info.argv[PARAM0];
4675 NativeValue *result = nullptr;
4676 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetDisplayOrientation",
4677 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
4678
4679 return result;
4680 }
4681 #endif
4682
CreateProcessInfo(NativeEngine & engine,const std::shared_ptr<JsProcessInfo> & processInfo)4683 NativeValue* JsNapiCommon::CreateProcessInfo(NativeEngine &engine, const std::shared_ptr<JsProcessInfo> &processInfo)
4684 {
4685 HILOG_DEBUG("CreateProcessInfo called");
4686 CHECK_POINTER_AND_RETURN_LOG(processInfo, engine.CreateUndefined(), "input params error");
4687 auto objContext = engine.CreateObject();
4688 CHECK_POINTER_AND_RETURN_LOG(objContext, engine.CreateUndefined(), "CreateObject failed");
4689 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4690 CHECK_POINTER_AND_RETURN_LOG(object, engine.CreateUndefined(), "ConvertNativeValueTo object failed");
4691
4692 object->SetProperty("processName", CreateJsValue(engine, processInfo->processName));
4693 object->SetProperty("pid", CreateJsValue(engine, processInfo->pid));
4694
4695 return objContext;
4696 }
4697
CreateElementName(NativeEngine & engine,const std::shared_ptr<JsElementName> & elementName)4698 NativeValue* JsNapiCommon::CreateElementName(NativeEngine &engine, const std::shared_ptr<JsElementName> &elementName)
4699 {
4700 HILOG_DEBUG("CreateElementName called");
4701 CHECK_POINTER_AND_RETURN_LOG(elementName, engine.CreateUndefined(), "input params error");
4702 auto objContext = engine.CreateObject();
4703 CHECK_POINTER_AND_RETURN_LOG(objContext, engine.CreateUndefined(), "CreateObject failed");
4704 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4705 CHECK_POINTER_AND_RETURN_LOG(object, engine.CreateUndefined(), "ConvertNativeValueTo object failed");
4706
4707 object->SetProperty("deviceId", CreateJsValue(engine, elementName->deviceId));
4708 object->SetProperty("bundleName", CreateJsValue(engine, elementName->bundleName));
4709 object->SetProperty("abilityName", CreateJsValue(engine, elementName->abilityName));
4710 object->SetProperty("uri", CreateJsValue(engine, elementName->uri));
4711 object->SetProperty("shortName", CreateJsValue(engine, elementName->shortName));
4712
4713 return objContext;
4714 }
4715
CreateHapModuleInfo(NativeEngine & engine,const std::shared_ptr<JsHapModuleInfo> & hapModInfo)4716 NativeValue* JsNapiCommon::CreateHapModuleInfo(
4717 NativeEngine &engine, const std::shared_ptr<JsHapModuleInfo> &hapModInfo)
4718 {
4719 HILOG_DEBUG("CreateHapModuleInfo called");
4720 CHECK_POINTER_AND_RETURN_LOG(hapModInfo, engine.CreateUndefined(), "input params error");
4721 auto objContext = engine.CreateObject();
4722 CHECK_POINTER_AND_RETURN_LOG(objContext, engine.CreateUndefined(), "CreateObject failed");
4723 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4724 CHECK_POINTER_AND_RETURN_LOG(object, engine.CreateUndefined(), "ConvertNativeValueTo object failed");
4725
4726 object->SetProperty("name", CreateJsValue(engine, hapModInfo->hapModInfo.name));
4727 object->SetProperty("description", CreateJsValue(engine, hapModInfo->hapModInfo.description));
4728 object->SetProperty("icon", CreateJsValue(engine, hapModInfo->hapModInfo.iconPath));
4729 object->SetProperty("label", CreateJsValue(engine, hapModInfo->hapModInfo.label));
4730 object->SetProperty("backgroundImg", CreateJsValue(engine, hapModInfo->hapModInfo.backgroundImg));
4731 object->SetProperty("moduleName", CreateJsValue(engine, hapModInfo->hapModInfo.moduleName));
4732 object->SetProperty("mainAbilityName", CreateJsValue(engine, hapModInfo->hapModInfo.mainAbility));
4733 object->SetProperty("supportedModes", CreateJsValue(engine, hapModInfo->hapModInfo.supportedModes));
4734 object->SetProperty("descriptionId", CreateJsValue(engine, hapModInfo->hapModInfo.descriptionId));
4735 object->SetProperty("labelId", CreateJsValue(engine, hapModInfo->hapModInfo.labelId));
4736 object->SetProperty("iconId", CreateJsValue(engine, hapModInfo->hapModInfo.iconId));
4737 object->SetProperty("installationFree", engine.CreateBoolean(hapModInfo->hapModInfo.installationFree));
4738 object->SetProperty("reqCapabilities", CreateNativeArray(engine, hapModInfo->hapModInfo.reqCapabilities));
4739 object->SetProperty("deviceTypes", CreateNativeArray(engine, hapModInfo->hapModInfo.deviceTypes));
4740 object->SetProperty("abilityInfo", CreateAbilityInfos(engine, hapModInfo->hapModInfo.abilityInfos));
4741
4742 return objContext;
4743 }
4744
CreateModuleInfo(NativeEngine & engine,const ModuleInfo & modInfo)4745 NativeValue* JsNapiCommon::CreateModuleInfo(NativeEngine &engine, const ModuleInfo &modInfo)
4746 {
4747 auto objContext = engine.CreateObject();
4748 if (objContext == nullptr) {
4749 HILOG_ERROR("CreateObject failed");
4750 return engine.CreateUndefined();
4751 }
4752 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4753 if (object == nullptr) {
4754 HILOG_ERROR("ConvertNativeValueTo object failed");
4755 return engine.CreateUndefined();
4756 }
4757
4758 object->SetProperty("moduleName", CreateJsValue(engine, modInfo.moduleName));
4759 object->SetProperty("moduleSourceDir", CreateJsValue(engine, modInfo.moduleSourceDir));
4760
4761 return objContext;
4762 }
4763
CreateModuleInfos(NativeEngine & engine,const std::vector<ModuleInfo> & moduleInfos)4764 NativeValue* JsNapiCommon::CreateModuleInfos(NativeEngine &engine, const std::vector<ModuleInfo> &moduleInfos)
4765 {
4766 auto arrayValue = engine.CreateArray(moduleInfos.size());
4767 auto array = ConvertNativeValueTo<NativeArray>(arrayValue);
4768 if (array == nullptr) {
4769 HILOG_ERROR("CreateArray failed");
4770 return engine.CreateUndefined();
4771 }
4772 for (uint32_t i = 0; i < moduleInfos.size(); i++) {
4773 array->SetElement(i, CreateModuleInfo(engine, moduleInfos.at(i)));
4774 }
4775
4776 return arrayValue;
4777 }
4778
CreateAppInfo(NativeEngine & engine,const ApplicationInfo & appInfo)4779 NativeValue* JsNapiCommon::CreateAppInfo(NativeEngine &engine, const ApplicationInfo &appInfo)
4780 {
4781 HILOG_DEBUG("CreateAppInfo called");
4782 auto objContext = engine.CreateObject();
4783 if (objContext == nullptr) {
4784 HILOG_ERROR("CreateAppInfo, CreateObject failed");
4785 return engine.CreateUndefined();
4786 }
4787 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4788 if (object == nullptr) {
4789 HILOG_ERROR("CreateAppInfo, ConvertNativeValueTo object failed");
4790 return engine.CreateUndefined();
4791 }
4792
4793 object->SetProperty("name", CreateJsValue(engine, appInfo.name));
4794 object->SetProperty("description", CreateJsValue(engine, appInfo.description));
4795 object->SetProperty("descriptionId", CreateJsValue(engine, appInfo.descriptionId));
4796 object->SetProperty("systemApp", CreateJsValue(engine, appInfo.isSystemApp));
4797 object->SetProperty("enabled", CreateJsValue(engine, appInfo.enabled));
4798 object->SetProperty("label", CreateJsValue(engine, appInfo.label));
4799 object->SetProperty("labelId", CreateJsValue(engine, std::to_string(appInfo.labelId)));
4800 object->SetProperty("icon", CreateJsValue(engine, appInfo.iconPath));
4801 object->SetProperty("iconId", CreateJsValue(engine, std::to_string(appInfo.iconId)));
4802 object->SetProperty("process", CreateJsValue(engine, appInfo.process));
4803 object->SetProperty("entryDir", CreateJsValue(engine, appInfo.entryDir));
4804 object->SetProperty("supportedModes", CreateJsValue(engine, appInfo.supportedModes));
4805 object->SetProperty("moduleSourceDirs", CreateNativeArray(engine, appInfo.moduleSourceDirs));
4806 object->SetProperty("permissions", CreateNativeArray(engine, appInfo.permissions));
4807 object->SetProperty("moduleInfos", CreateModuleInfos(engine, appInfo.moduleInfos));
4808
4809 return objContext;
4810 }
4811
CreateAppInfo(NativeEngine & engine,const std::shared_ptr<JsApplicationInfo> & appInfo)4812 NativeValue* JsNapiCommon::CreateAppInfo(NativeEngine &engine, const std::shared_ptr<JsApplicationInfo> &appInfo)
4813 {
4814 if (appInfo == nullptr) {
4815 HILOG_ERROR("input param error");
4816 return engine.CreateUndefined();
4817 }
4818
4819 return CreateAppInfo(engine, appInfo->appInfo);
4820 }
4821
CreateAbilityInfo(NativeEngine & engine,const AbilityInfo & abilityInfo)4822 NativeValue* JsNapiCommon::CreateAbilityInfo(NativeEngine &engine, const AbilityInfo &abilityInfo)
4823 {
4824 HILOG_DEBUG("CreateAbilityInfo called");
4825 auto objContext = engine.CreateObject();
4826 if (objContext == nullptr) {
4827 HILOG_ERROR("CreateAbilityInfo, CreateObject failed");
4828 return engine.CreateUndefined();
4829 }
4830 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4831 if (object == nullptr) {
4832 HILOG_ERROR("CreateAbilityInfo, ConvertNativeValueTo object failed");
4833 return engine.CreateUndefined();
4834 }
4835
4836 object->SetProperty("bundleName", CreateJsValue(engine, abilityInfo.bundleName));
4837 object->SetProperty("name", CreateJsValue(engine, abilityInfo.name));
4838 object->SetProperty("label", CreateJsValue(engine, abilityInfo.label));
4839 object->SetProperty("description", CreateJsValue(engine, abilityInfo.description));
4840 object->SetProperty("icon", CreateJsValue(engine, abilityInfo.iconPath));
4841 object->SetProperty("moduleName", CreateJsValue(engine, abilityInfo.moduleName));
4842 object->SetProperty("process", CreateJsValue(engine, abilityInfo.process));
4843 object->SetProperty("uri", CreateJsValue(engine, abilityInfo.uri));
4844 object->SetProperty("readPermission", CreateJsValue(engine, abilityInfo.readPermission));
4845 object->SetProperty("writePermission", CreateJsValue(engine, abilityInfo.writePermission));
4846 object->SetProperty("targetAbility", CreateJsValue(engine, abilityInfo.targetAbility));
4847 object->SetProperty("type", CreateJsValue(engine, static_cast<int32_t>(abilityInfo.type)));
4848 object->SetProperty("orientation", CreateJsValue(engine, static_cast<int32_t>(abilityInfo.orientation)));
4849 object->SetProperty("launchMode", CreateJsValue(engine, static_cast<int32_t>(abilityInfo.launchMode)));
4850 object->SetProperty("labelId", CreateJsValue(engine, abilityInfo.labelId));
4851 object->SetProperty("descriptionId", CreateJsValue(engine, abilityInfo.descriptionId));
4852 object->SetProperty("iconId", CreateJsValue(engine, abilityInfo.iconId));
4853 object->SetProperty("formEntity", CreateJsValue(engine, abilityInfo.formEntity));
4854 object->SetProperty("minFormHeight", CreateJsValue(engine, abilityInfo.minFormHeight));
4855 object->SetProperty("defaultFormHeight", CreateJsValue(engine, abilityInfo.defaultFormHeight));
4856 object->SetProperty("minFormWidth", CreateJsValue(engine, abilityInfo.minFormWidth));
4857 object->SetProperty("defaultFormWidth", CreateJsValue(engine, abilityInfo.defaultFormWidth));
4858 object->SetProperty("backgroundModes", CreateJsValue(engine, abilityInfo.backgroundModes));
4859 object->SetProperty("subType", CreateJsValue(engine, static_cast<int32_t>(abilityInfo.subType)));
4860 object->SetProperty("isVisible", CreateJsValue(engine, abilityInfo.visible));
4861 object->SetProperty("formEnabled", CreateJsValue(engine, abilityInfo.formEnabled));
4862 object->SetProperty("permissions", CreateNativeArray(engine, abilityInfo.permissions));
4863 object->SetProperty("deviceCapabilities", CreateNativeArray(engine, abilityInfo.deviceCapabilities));
4864 object->SetProperty("deviceTypes", CreateNativeArray(engine, abilityInfo.deviceTypes));
4865 object->SetProperty("applicationInfo", CreateAppInfo(engine, abilityInfo.applicationInfo));
4866 return objContext;
4867 }
4868
CreateAbilityInfo(NativeEngine & engine,const std::shared_ptr<JsAbilityInfoInfo> & abilityInfo)4869 NativeValue* JsNapiCommon::CreateAbilityInfo(
4870 NativeEngine &engine, const std::shared_ptr<JsAbilityInfoInfo> &abilityInfo)
4871 {
4872 HILOG_DEBUG("called");
4873 if (abilityInfo == nullptr) {
4874 HILOG_ERROR("called");
4875 return engine.CreateUndefined();
4876 }
4877
4878 return CreateAbilityInfo(engine, abilityInfo->abilityInfo);
4879 }
4880
CreateAbilityInfos(NativeEngine & engine,const std::vector<AbilityInfo> & abilityInfos)4881 NativeValue* JsNapiCommon::CreateAbilityInfos(NativeEngine &engine, const std::vector<AbilityInfo> &abilityInfos)
4882 {
4883 auto arrayValue = engine.CreateArray(abilityInfos.size());
4884 auto array = ConvertNativeValueTo<NativeArray>(arrayValue);
4885 if (array == nullptr) {
4886 HILOG_ERROR("CreateArray failed");
4887 return engine.CreateUndefined();
4888 }
4889 for (uint32_t i = 0; i < abilityInfos.size(); i++) {
4890 array->SetElement(i, CreateAbilityInfo(engine, abilityInfos.at(i)));
4891 }
4892
4893 return arrayValue;
4894 }
4895
CheckAbilityType(const AbilityType typeWant)4896 bool JsNapiCommon::CheckAbilityType(const AbilityType typeWant)
4897 {
4898 if (ability_ == nullptr) {
4899 HILOG_ERROR("input params int error");
4900 return false;
4901 }
4902 const std::shared_ptr<AbilityInfo> info = ability_->GetAbilityInfo();
4903 if (info == nullptr) {
4904 HILOG_ERROR("get ability info error");
4905 return false;
4906 }
4907
4908 switch (typeWant) {
4909 case AbilityType::PAGE:
4910 if (static_cast<AbilityType>(info->type) == AbilityType::PAGE ||
4911 static_cast<AbilityType>(info->type) == AbilityType::DATA) {
4912 return true;
4913 }
4914 return false;
4915 default:
4916 return static_cast<AbilityType>(info->type) != AbilityType::PAGE;
4917 }
4918 return false;
4919 }
4920
CreateAppVersionInfo(NativeEngine & engine,const std::shared_ptr<JsApplicationInfo> & appInfo)4921 NativeValue* JsNapiCommon::CreateAppVersionInfo(
4922 NativeEngine &engine, const std::shared_ptr<JsApplicationInfo> &appInfo)
4923 {
4924 HILOG_DEBUG("CreateAppVersionInfo called");
4925 CHECK_POINTER_AND_RETURN_LOG(appInfo, engine.CreateUndefined(), "input params error");
4926 auto objContext = engine.CreateObject();
4927 CHECK_POINTER_AND_RETURN_LOG(objContext, engine.CreateUndefined(), "CreateObject failed");
4928 auto object = ConvertNativeValueTo<NativeObject>(objContext);
4929 CHECK_POINTER_AND_RETURN_LOG(object, engine.CreateUndefined(), "ConvertNativeValueTo object failed");
4930
4931 object->SetProperty("appName", CreateJsValue(engine, appInfo->appInfo.name));
4932 object->SetProperty("versionName", CreateJsValue(engine, appInfo->appInfo.versionName));
4933 object->SetProperty("versionCode", CreateJsValue(engine, static_cast<int32_t>(appInfo->appInfo.versionCode)));
4934
4935 return objContext;
4936 }
4937
UnwarpVerifyPermissionParams(NativeEngine & engine,NativeCallbackInfo & info,JsPermissionOptions & options)4938 bool JsNapiCommon::UnwarpVerifyPermissionParams(
4939 NativeEngine &engine, NativeCallbackInfo &info, JsPermissionOptions &options)
4940 {
4941 bool flagCall = true;
4942 if (info.argc == ARGS_ONE) {
4943 flagCall = false;
4944 } else if (info.argc == ARGS_TWO && info.argv[PARAM1]->TypeOf() != NATIVE_FUNCTION) {
4945 if (!GetPermissionOptions(engine, info.argv[PARAM1], options)) {
4946 HILOG_WARN("input params string error");
4947 }
4948 flagCall = false;
4949 } else if (info.argc == ARGS_THREE) {
4950 if (!GetPermissionOptions(engine, info.argv[PARAM1], options)) {
4951 HILOG_WARN("input params string error");
4952 }
4953 }
4954
4955 return flagCall;
4956 }
4957
GetStringsValue(NativeEngine & engine,NativeValue * object,std::vector<std::string> & strList)4958 bool JsNapiCommon::GetStringsValue(NativeEngine &engine, NativeValue *object, std::vector<std::string> &strList)
4959 {
4960 auto array = ConvertNativeValueTo<NativeArray>(object);
4961 if (array == nullptr) {
4962 HILOG_ERROR("input params error");
4963 return false;
4964 }
4965 for (uint32_t i = 0; i < array->GetLength(); i++) {
4966 std::string itemStr("");
4967 if (!ConvertFromJsValue(engine, array->GetElement(i), itemStr)) {
4968 HILOG_ERROR("GetElement from to array [%{public}u] error", i);
4969 return false;
4970 }
4971 strList.push_back(itemStr);
4972 }
4973
4974 return true;
4975 }
4976
GetPermissionOptions(NativeEngine & engine,NativeValue * object,JsPermissionOptions & options)4977 bool JsNapiCommon::GetPermissionOptions(NativeEngine &engine, NativeValue *object, JsPermissionOptions &options)
4978 {
4979 auto obj = ConvertNativeValueTo<NativeObject>(object);
4980 if (obj == nullptr) {
4981 HILOG_ERROR("input params error");
4982 return false;
4983 }
4984
4985 options.uidFlag = ConvertFromJsValue(engine, obj->GetProperty("uid"), options.uid);
4986 options.pidFlag = ConvertFromJsValue(engine, obj->GetProperty("pid"), options.pid);
4987
4988 return true;
4989 }
4990
ConvertErrorCode(int32_t errCode)4991 std::string JsNapiCommon::ConvertErrorCode(int32_t errCode)
4992 {
4993 static std::map<int32_t, std::string> errMap = {
4994 { static_cast<int32_t>(NAPI_ERR_ACE_ABILITY), std::string("get ability error") },
4995 { static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID), std::string("ability call error") },
4996 { static_cast<int32_t>(NAPI_ERR_PARAM_INVALID), std::string("input param error") },
4997 { static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID), std::string("ability type error") }
4998 };
4999 auto findECode = errMap.find(errCode);
5000 if (findECode == errMap.end()) {
5001 HILOG_ERROR("convert error code failed");
5002 return std::string("execution failed");
5003 }
5004
5005 return findECode->second;
5006 }
5007
JsGetWant(NativeEngine & engine,NativeCallbackInfo & info,const AbilityType abilityType)5008 NativeValue* JsNapiCommon::JsGetWant(
5009 NativeEngine &engine, NativeCallbackInfo &info, const AbilityType abilityType)
5010 {
5011 HILOG_DEBUG("%{public}s called", __func__);
5012 if (info.argc > ARGS_ONE) {
5013 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
5014 return engine.CreateUndefined();
5015 }
5016
5017 std::shared_ptr<JsWant> pwant = std::make_shared<JsWant>();
5018 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
5019 auto execute = [obj = this, want = pwant, value = errorVal, abilityType] () {
5020 if (obj->ability_ == nullptr) {
5021 *value = static_cast<int32_t>(NAPI_ERR_ACE_ABILITY);
5022 HILOG_ERROR("task execute error, the ability is nullptr");
5023 return;
5024 }
5025 if (!obj->CheckAbilityType(abilityType)) {
5026 HILOG_ERROR("task execute error, the abilityType is error");
5027 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_TYPE_INVALID);
5028 return;
5029 }
5030
5031 auto wantData = obj->ability_->GetWant();
5032 if (wantData == nullptr || want == nullptr) {
5033 HILOG_ERROR("wantData or want is nullptr!");
5034 *value = static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID);
5035 return;
5036 }
5037 want->want = *wantData;
5038 };
5039
5040 auto complete = [obj = this, value = errorVal, pwant]
5041 (NativeEngine &engine, AsyncTask &task, int32_t status) {
5042 if (*value == NAPI_ERR_NO_ERROR && pwant != nullptr) {
5043 task.Resolve(engine, obj->CreateWant(engine, pwant));
5044 } else {
5045 auto error = (pwant == nullptr) ? static_cast<int32_t>(NAPI_ERR_ABILITY_CALL_INVALID) : *value;
5046 task.Reject(engine, CreateJsError(engine, error, "GetAbilityInfo return nullptr"));
5047 }
5048 };
5049
5050 auto callback = (info.argc == ARGS_ZERO) ? nullptr : info.argv[PARAM0];
5051 NativeValue *result = nullptr;
5052 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetWant",
5053 engine, CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
5054 return result;
5055 }
5056
CreateWant(NativeEngine & engine,const std::shared_ptr<JsWant> & want)5057 NativeValue* JsNapiCommon::CreateWant(NativeEngine& engine, const std::shared_ptr<JsWant> &want)
5058 {
5059 HILOG_DEBUG("%{public}s,called", __func__);
5060 if (want == nullptr) {
5061 HILOG_ERROR("CreateWant error, want is nullptr.");
5062 return engine.CreateUndefined();
5063 }
5064
5065 return CreateJsWant(engine, want->want);
5066 }
5067
JsTerminateAbility(NativeEngine & engine,NativeCallbackInfo & info)5068 NativeValue* JsNapiCommon::JsTerminateAbility(NativeEngine &engine, NativeCallbackInfo &info)
5069 {
5070 HILOG_DEBUG("%{public}s called", __func__);
5071 if (info.argc > ARGS_ONE) {
5072 HILOG_ERROR("%{public}s input params count error, argc=%{public}zu", __func__, info.argc);
5073 return engine.CreateUndefined();
5074 }
5075
5076 auto complete = [obj = this](NativeEngine &engine, AsyncTask &task, int32_t status) {
5077 if (obj->ability_ != nullptr) {
5078 obj->ability_->TerminateAbility();
5079 } else {
5080 HILOG_ERROR("JsTerminateAbility ability is nullptr");
5081 }
5082 task.Resolve(engine, engine.CreateNull());
5083 };
5084
5085 auto callback = (info.argc == ARGS_ZERO) ? nullptr : info.argv[PARAM0];
5086 NativeValue* result = nullptr;
5087 AsyncTask::ScheduleHighQos("JsNapiCommon::JsTerminateAbility",
5088 engine, CreateAsyncTaskWithLastParam(engine, callback, nullptr, std::move(complete), &result));
5089 return result;
5090 }
5091
JsStartAbility(NativeEngine & engine,NativeCallbackInfo & info,AbilityType abilityType)5092 NativeValue* JsNapiCommon::JsStartAbility(NativeEngine &engine, NativeCallbackInfo &info, AbilityType abilityType)
5093 {
5094 HILOG_DEBUG("%{public}s called", __func__);
5095 auto errorVal = std::make_shared<int32_t>(static_cast<int32_t>(NAPI_ERR_NO_ERROR));
5096 auto env = reinterpret_cast<napi_env>(&engine);
5097 auto param = std::make_shared<CallAbilityParam>();
5098 if (info.argc == 0 || info.argc > ARGS_TWO) {
5099 HILOG_ERROR("input params count error, argc=%{public}zu", info.argc);
5100 *errorVal = NAPI_ERR_PARAM_INVALID;
5101 } else {
5102 auto arg0 = reinterpret_cast<napi_value>(info.argv[PARAM0]);
5103 if (!UnwrapParamForWant(env, arg0, abilityType, *param)) {
5104 HILOG_ERROR("call UnwrapParamForWant failed.");
5105 *errorVal = NAPI_ERR_PARAM_INVALID;
5106 }
5107 }
5108
5109 if ((param->want.GetFlags() & Want::FLAG_INSTALL_ON_DEMAND) == Want::FLAG_INSTALL_ON_DEMAND) {
5110 std::string startTime = std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::
5111 system_clock::now().time_since_epoch()).count());
5112 param->want.SetParam(Want::PARAM_RESV_START_TIME, startTime);
5113 }
5114
5115 auto execute = [obj = this, value = errorVal, abilityType, paramObj = param, &observer = freeInstallObserver_] () {
5116 if (*value != NAPI_ERR_NO_ERROR) {
5117 HILOG_ERROR("JsStartAbility params error!");
5118 return;
5119 }
5120
5121 if (obj->ability_ == nullptr) {
5122 *value = NAPI_ERR_ACE_ABILITY;
5123 HILOG_ERROR("task execute error, the ability is nullptr");
5124 return;
5125 }
5126
5127 if (!obj->CheckAbilityType(abilityType)) {
5128 *value = NAPI_ERR_ABILITY_TYPE_INVALID;
5129 HILOG_ERROR("task execute error, the abilityType is error");
5130 return;
5131 }
5132 #ifdef SUPPORT_GRAPHICS
5133 // inherit split mode
5134 auto windowMode = obj->ability_->GetCurrentWindowMode();
5135 if (windowMode == AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY ||
5136 windowMode == AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY) {
5137 paramObj->want.SetParam(Want::PARAM_RESV_WINDOW_MODE, windowMode);
5138 }
5139 HILOG_DEBUG("window mode is %{public}d", windowMode);
5140
5141 // follow orientation
5142 paramObj->want.SetParam("ohos.aafwk.Orientation", 0);
5143 if (windowMode != AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING) {
5144 auto orientation = obj->ability_->GetDisplayOrientation();
5145 paramObj->want.SetParam("ohos.aafwk.Orientation", orientation);
5146 HILOG_DEBUG("display orientation is %{public}d", orientation);
5147 }
5148 #endif
5149 if (paramObj->setting == nullptr) {
5150 HILOG_INFO("param.setting == nullptr call StartAbility.");
5151 *value = obj->ability_->StartAbility(paramObj->want);
5152 } else {
5153 HILOG_INFO("param.setting != nullptr call StartAbility.");
5154 *value = obj->ability_->StartAbility(paramObj->want, *(paramObj->setting));
5155 }
5156 if ((paramObj->want.GetFlags() & Want::FLAG_INSTALL_ON_DEMAND) == Want::FLAG_INSTALL_ON_DEMAND &&
5157 *value != 0 && observer != nullptr) {
5158 std::string bundleName = paramObj->want.GetElement().GetBundleName();
5159 std::string abilityName = paramObj->want.GetElement().GetAbilityName();
5160 std::string startTime = paramObj->want.GetStringParam(Want::PARAM_RESV_START_TIME);
5161 observer->OnInstallFinished(bundleName, abilityName, startTime, *value);
5162 }
5163 };
5164
5165 auto complete = [value = errorVal]
5166 (NativeEngine& engine, AsyncTask& task, int32_t status) {
5167 if (*value != NAPI_ERR_NO_ERROR) {
5168 int32_t errCode = GetStartAbilityErrorCode(*value);
5169 task.Reject(engine, CreateJsError(engine, errCode, "StartAbility Failed"));
5170 return;
5171 }
5172 task.Resolve(engine, CreateJsValue(engine, *value));
5173 };
5174
5175 auto callback = (info.argc == ARGS_ONE) ? nullptr : info.argv[PARAM1];
5176 NativeValue* result = nullptr;
5177 if ((param->want.GetFlags() & Want::FLAG_INSTALL_ON_DEMAND) == Want::FLAG_INSTALL_ON_DEMAND) {
5178 AddFreeInstallObserver(engine, param->want, callback);
5179 AsyncTask::ScheduleHighQos("JsNapiCommon::JsStartAbility", engine,
5180 CreateAsyncTaskWithLastParam(engine, nullptr, std::move(execute), nullptr, &result));
5181 } else {
5182 AsyncTask::ScheduleHighQos("JsNapiCommon::JsStartAbility", engine,
5183 CreateAsyncTaskWithLastParam(engine, callback, std::move(execute), std::move(complete), &result));
5184 }
5185
5186 return result;
5187 }
5188
JsGetExternalCacheDir(NativeEngine & engine,NativeCallbackInfo & info,AbilityType abilityType)5189 NativeValue* JsNapiCommon::JsGetExternalCacheDir(NativeEngine &engine,
5190 NativeCallbackInfo &info,
5191 AbilityType abilityType)
5192 {
5193 HILOG_DEBUG("%{public}s called", __func__);
5194 if (info.argc > ARGS_ONE) {
5195 HILOG_ERROR("%{public}s input params count error, argc=%{public}zu", __func__, info.argc);
5196 return engine.CreateUndefined();
5197 }
5198
5199 auto complete = [obj = this, abilityType](NativeEngine &engine, AsyncTask &task, int32_t status) {
5200 if (obj->ability_ == nullptr) {
5201 HILOG_ERROR("JsGetExternalCacheDir ability is nullptr");
5202 task.RejectWithCustomize(
5203 engine,
5204 CreateJsError(engine, NAPI_ERR_ACE_ABILITY, "JsGetExternalCacheDir Failed"),
5205 engine.CreateNull());
5206 return;
5207 }
5208
5209 if (!obj->CheckAbilityType(abilityType)) {
5210 HILOG_ERROR("JsGetExternalCacheDir abilityType is error");
5211 task.Reject(engine, CreateJsError(engine, NAPI_ERR_ABILITY_TYPE_INVALID, "JsGetExternalCacheDir Failed"));
5212 return;
5213 }
5214
5215 std::string result = obj->ability_->GetExternalCacheDir();
5216 task.Resolve(engine, CreateJsValue(engine, result));
5217 };
5218
5219 auto callback = (info.argc == ARGS_ZERO) ? nullptr : info.argv[PARAM0];
5220 NativeValue* result = nullptr;
5221 AsyncTask::ScheduleHighQos("JsNapiCommon::JsGetExternalCacheDir",
5222 engine, CreateAsyncTaskWithLastParam(engine, callback, nullptr, std::move(complete), &result));
5223 return result;
5224 }
5225
AddFreeInstallObserver(NativeEngine & engine,const AAFwk::Want & want,NativeValue * callback)5226 void JsNapiCommon::AddFreeInstallObserver(NativeEngine& engine, const AAFwk::Want &want, NativeValue* callback)
5227 {
5228 // adapter free install async return install and start result
5229 int ret = 0;
5230 if (freeInstallObserver_ == nullptr) {
5231 freeInstallObserver_ = new JsFreeInstallObserver(engine);
5232 ret = AAFwk::AbilityManagerClient::GetInstance()->AddFreeInstallObserver(freeInstallObserver_);
5233 }
5234
5235 if (ret != ERR_OK) {
5236 HILOG_ERROR("AddFreeInstallObserver failed.");
5237 } else {
5238 HILOG_INFO("AddJsObserverObject");
5239 // build a callback observer with last param
5240 std::string bundleName = want.GetElement().GetBundleName();
5241 std::string abilityName = want.GetElement().GetAbilityName();
5242 std::string startTime = want.GetStringParam(Want::PARAM_RESV_START_TIME);
5243 freeInstallObserver_->AddJsObserverObject(bundleName, abilityName, startTime, callback);
5244 }
5245 }
5246 } // namespace AppExecFwk
5247 } // namespace OHOS
5248