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