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