1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "napi_distributed.h"
17
18 #include "ans_inner_errors.h"
19 #include "distributed.h"
20
21 namespace OHOS {
22 namespace NotificationNapi {
AsyncCompleteCallbackNapiIsDistributedEnabled(napi_env env,napi_status status,void * data)23 void AsyncCompleteCallbackNapiIsDistributedEnabled(napi_env env, napi_status status, void *data)
24 {
25 ANS_LOGD("enter");
26 if (!data) {
27 ANS_LOGE("Invalid async callback data");
28 return;
29 }
30 ANS_LOGI("IsDistributedEnabled napi_create_async_work end");
31 AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
32 if (asynccallbackinfo) {
33 napi_value result = nullptr;
34 if (asynccallbackinfo->info.errorCode != ERR_OK) {
35 result = Common::NapiGetNull(env);
36 } else {
37 napi_get_boolean(env, asynccallbackinfo->enable, &result);
38 }
39 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
40 if (asynccallbackinfo->info.callback != nullptr) {
41 ANS_LOGD("Delete napiIsDistributedEnabled callback reference.");
42 napi_delete_reference(env, asynccallbackinfo->info.callback);
43 }
44 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
45 delete asynccallbackinfo;
46 asynccallbackinfo = nullptr;
47 }
48 }
49
NapiIsDistributedEnabled(napi_env env,napi_callback_info info)50 napi_value NapiIsDistributedEnabled(napi_env env, napi_callback_info info)
51 {
52 ANS_LOGD("enter");
53
54 napi_ref callback = nullptr;
55 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
56 Common::NapiThrow(env, ERROR_PARAM_INVALID);
57 return Common::NapiGetUndefined(env);
58 }
59
60 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnabled {.env = env, .asyncWork = nullptr};
61 if (!asynccallbackinfo) {
62 return Common::JSParaError(env, callback);
63 }
64 napi_value promise = nullptr;
65 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
66
67 napi_value resourceName = nullptr;
68 napi_create_string_latin1(env, "isDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
69 // Asynchronous function call
70 napi_create_async_work(
71 env,
72 nullptr,
73 resourceName,
74 [](napi_env env, void *data) {
75 ANS_LOGD("NapiIsDistributedEnabled work excute.");
76 AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
77
78 if (asynccallbackinfo) {
79 asynccallbackinfo->info.errorCode =
80 NotificationHelper::IsDistributedEnabled(asynccallbackinfo->enable);
81 ANS_LOGI("IsDistributedEnabled enable = %{public}d", asynccallbackinfo->enable);
82 }
83 },
84 AsyncCompleteCallbackNapiIsDistributedEnabled,
85 (void *)asynccallbackinfo,
86 &asynccallbackinfo->asyncWork);
87
88 bool isCallback = asynccallbackinfo->info.isCallback;
89 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
90
91 if (isCallback) {
92 ANS_LOGD("napiIsDistributedEnabled callback is nullptr.");
93 return Common::NapiGetNull(env);
94 } else {
95 return promise;
96 }
97 }
98
NapiEnableDistributed(napi_env env,napi_callback_info info)99 napi_value NapiEnableDistributed(napi_env env, napi_callback_info info)
100 {
101 ANS_LOGD("enter");
102
103 EnabledParams params {};
104 if (ParseParameters(env, info, params) == nullptr) {
105 ANS_LOGD("ParseParameters is nullptr.");
106 Common::NapiThrow(env, ERROR_PARAM_INVALID);
107 return Common::NapiGetUndefined(env);
108 }
109
110 AsyncCallbackInfoEnabled *asynccallbackinfo =
111 new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
112 if (!asynccallbackinfo) {
113 ANS_LOGD("Create asyncCallbackinfo fail.");
114 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
115 return Common::JSParaError(env, params.callback);
116 }
117 napi_value promise = nullptr;
118 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
119
120 napi_value resourceName = nullptr;
121 napi_create_string_latin1(env, "enableDistributed", NAPI_AUTO_LENGTH, &resourceName);
122 // Async function call
123 napi_create_async_work(
124 env,
125 nullptr,
126 resourceName,
127 [](napi_env env, void *data) {
128 ANS_LOGD("NapiEnableDistributed work excute.");
129 AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
130
131 if (asynccallbackinfo) {
132 asynccallbackinfo->info.errorCode =
133 NotificationHelper::EnableDistributed(asynccallbackinfo->params.enable);
134 }
135 },
136 [](napi_env env, napi_status status, void *data) {
137 ANS_LOGD("NapiEnableDistributed work complete.");
138 AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
139 if (asynccallbackinfo) {
140 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
141 if (asynccallbackinfo->info.callback != nullptr) {
142 ANS_LOGD("Delete napiEnableDistributed callback reference.");
143 napi_delete_reference(env, asynccallbackinfo->info.callback);
144 }
145 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
146 delete asynccallbackinfo;
147 asynccallbackinfo = nullptr;
148 }
149 ANS_LOGD("NapiEnableDistributed work complete end.");
150 },
151 (void *)asynccallbackinfo,
152 &asynccallbackinfo->asyncWork);
153
154 bool isCallback = asynccallbackinfo->info.isCallback;
155 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
156
157 if (isCallback) {
158 ANS_LOGD("napiEnableDistributed callback is nullptr.");
159 return Common::NapiGetNull(env);
160 } else {
161 return promise;
162 }
163 }
164
NapiEnableDistributedByBundle(napi_env env,napi_callback_info info)165 napi_value NapiEnableDistributedByBundle(napi_env env, napi_callback_info info)
166 {
167 ANS_LOGD("enter");
168
169 EnabledByBundleParams params {};
170 if (ParseParameters(env, info, params) == nullptr) {
171 Common::NapiThrow(env, ERROR_PARAM_INVALID);
172 return Common::NapiGetUndefined(env);
173 }
174
175 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo =
176 new (std::nothrow) AsyncCallbackInfoEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
177 if (!asynccallbackinfo) {
178 return Common::JSParaError(env, params.callback);
179 }
180 napi_value promise = nullptr;
181 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
182
183 napi_value resourceName = nullptr;
184 napi_create_string_latin1(env, "enableDistributedByBundle", NAPI_AUTO_LENGTH, &resourceName);
185 // Asynchronous function call
186 napi_create_async_work(
187 env,
188 nullptr,
189 resourceName,
190 [](napi_env env, void *data) {
191 ANS_LOGD("NapiEnableDistributedByBundle work excute.");
192 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
193 if (asynccallbackinfo) {
194 asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
195 asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
196 }
197 },
198 [](napi_env env, napi_status status, void *data) {
199 ANS_LOGD("NapiEnableDistributedByBundle work complete.");
200 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
201 if (asynccallbackinfo) {
202 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
203 if (asynccallbackinfo->info.callback != nullptr) {
204 ANS_LOGD("Delete napiEnableDistributedByBundle callback reference.");
205 napi_delete_reference(env, asynccallbackinfo->info.callback);
206 }
207 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
208 delete asynccallbackinfo;
209 asynccallbackinfo = nullptr;
210 }
211 ANS_LOGD("NapiEnableDistributedByBundle work complete end.");
212 },
213 (void *)asynccallbackinfo,
214 &asynccallbackinfo->asyncWork);
215
216 bool isCallback = asynccallbackinfo->info.isCallback;
217 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
218
219 if (isCallback) {
220 ANS_LOGD("napiEnableDistributedByBundle callback is nullptr.");
221 return Common::NapiGetNull(env);
222 } else {
223 return promise;
224 }
225 }
226
NapiEnableDistributedSelf(napi_env env,napi_callback_info info)227 napi_value NapiEnableDistributedSelf(napi_env env, napi_callback_info info)
228 {
229 ANS_LOGD("enter");
230
231 EnabledParams params {};
232 if (ParseParameters(env, info, params) == nullptr) {
233 Common::NapiThrow(env, ERROR_PARAM_INVALID);
234 return Common::NapiGetUndefined(env);
235 }
236
237 AsyncCallbackInfoEnabled *asynccallbackinfo =
238 new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
239 if (!asynccallbackinfo) {
240 ANS_LOGD("Fail to create asyncCallbackinfo.");
241 return Common::JSParaError(env, params.callback);
242 }
243 napi_value promise = nullptr;
244 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
245
246 napi_value resourceName = nullptr;
247 napi_create_string_latin1(env, "enableDistributedSelf", NAPI_AUTO_LENGTH, &resourceName);
248 // Asynchronous function call
249 napi_create_async_work(
250 env,
251 nullptr,
252 resourceName,
253 [](napi_env env, void *data) {
254 ANS_LOGD("NapiEnableDistributedSelf work excute.");
255 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
256 if (asynccallbackinfo) {
257 asynccallbackinfo->info.errorCode =
258 NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
259 ANS_LOGI("enable = %{public}d", asynccallbackinfo->params.enable);
260 }
261 },
262 [](napi_env env, napi_status status, void *data) {
263 ANS_LOGD("NapiEnableDistributedSelf work complete.");
264 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
265 if (asynccallbackinfo) {
266 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
267 if (asynccallbackinfo->info.callback != nullptr) {
268 ANS_LOGD("Delete napiEnableDistributedSelf callback reference.");
269 napi_delete_reference(env, asynccallbackinfo->info.callback);
270 }
271 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
272 delete asynccallbackinfo;
273 asynccallbackinfo = nullptr;
274 }
275 ANS_LOGD("NapiEnableDistributedSelf work complete end.");
276 },
277 (void *)asynccallbackinfo,
278 &asynccallbackinfo->asyncWork);
279
280 bool isCallback = asynccallbackinfo->info.isCallback;
281 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
282
283 if (isCallback) {
284 ANS_LOGD("napiEnableDistributedSelf callback is nullptr.");
285 return Common::NapiGetNull(env);
286 } else {
287 return promise;
288 }
289 }
290
AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env,napi_status status,void * data)291 void AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env, napi_status status, void *data)
292 {
293 ANS_LOGD("enter");
294 if (!data) {
295 ANS_LOGE("Invalid async callback data");
296 return;
297 }
298 ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
299 AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
300 if (asynccallbackinfo) {
301 napi_value result = nullptr;
302 if (asynccallbackinfo->info.errorCode != ERR_OK) {
303 result = Common::NapiGetNull(env);
304 } else {
305 napi_get_boolean(env, asynccallbackinfo->enable, &result);
306 }
307 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
308 if (asynccallbackinfo->info.callback != nullptr) {
309 ANS_LOGD("Delete napiIsDistributedEnableByBundle callback reference.");
310 napi_delete_reference(env, asynccallbackinfo->info.callback);
311 }
312 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
313 delete asynccallbackinfo;
314 asynccallbackinfo = nullptr;
315 }
316 }
317
NapiIsDistributedEnableByBundle(napi_env env,napi_callback_info info)318 napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info)
319 {
320 ANS_LOGD("enter");
321
322 IsEnabledByBundleParams params {};
323 if (ParseParameters(env, info, params) == nullptr) {
324 Common::NapiThrow(env, ERROR_PARAM_INVALID);
325 return Common::NapiGetUndefined(env);
326 }
327
328 AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo =
329 new (std::nothrow) AsyncCallbackInfoIsEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
330 if (!asynccallbackinfo) {
331 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
332 return Common::JSParaError(env, params.callback);
333 }
334 napi_value promise = nullptr;
335 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
336
337 napi_value resourceName = nullptr;
338 napi_create_string_latin1(env, "isDistributedEnableByBundle", NAPI_AUTO_LENGTH, &resourceName);
339 // Asynchronous function call
340 napi_create_async_work(
341 env,
342 nullptr,
343 resourceName,
344 [](napi_env env, void *data) {
345 ANS_LOGD("NapiIsDistributedEnableByBundle work excute.");
346 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
347 if (asynccallbackinfo) {
348 if (asynccallbackinfo->params.hasDeviceType) {
349 std::string deviceType = asynccallbackinfo->params.deviceType;
350 asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnabledByBundle(
351 asynccallbackinfo->params.option, deviceType, asynccallbackinfo->enable);
352 ANS_LOGI("has deviceType errorCode = %{public}d", asynccallbackinfo->info.errorCode);
353 } else {
354 asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
355 asynccallbackinfo->params.option, asynccallbackinfo->enable);
356 }
357 }
358 },
359 AsyncCompleteCallbackNapiIsDistributedEnableByBundle,
360 (void *)asynccallbackinfo,
361 &asynccallbackinfo->asyncWork);
362
363 bool isCallback = asynccallbackinfo->info.isCallback;
364 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
365
366 if (isCallback) {
367 ANS_LOGD("napiIsDistributedEnableByBundle callback is nullptr.");
368 return Common::NapiGetNull(env);
369 } else {
370 return promise;
371 }
372 }
373
AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env,napi_status status,void * data)374 void AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env, napi_status status, void *data)
375 {
376 ANS_LOGD("enter");
377 if (!data) {
378 ANS_LOGE("Invalid async callback data");
379 return;
380 }
381 ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
382 AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
383 if (asynccallbackinfo) {
384 napi_value result = nullptr;
385 if (asynccallbackinfo->info.errorCode != ERR_OK) {
386 result = Common::NapiGetNull(env);
387 } else {
388 DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
389 if (!AnsEnumUtil::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
390 asynccallbackinfo->info.errorCode = ERROR;
391 result = Common::NapiGetNull(env);
392 }
393 napi_create_int32(env, (int32_t)outType, &result);
394 }
395 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
396 if (asynccallbackinfo->info.callback != nullptr) {
397 ANS_LOGD("Delete napiGetDeviceRemindType callback reference.");
398 napi_delete_reference(env, asynccallbackinfo->info.callback);
399 }
400 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
401 delete asynccallbackinfo;
402 asynccallbackinfo = nullptr;
403 }
404 }
405
NapiGetDeviceRemindType(napi_env env,napi_callback_info info)406 napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
407 {
408 ANS_LOGD("enter");
409
410 napi_ref callback = nullptr;
411 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
412 Common::NapiThrow(env, ERROR_PARAM_INVALID);
413 return Common::NapiGetUndefined(env);
414 }
415
416 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetRemindType {.env = env, .asyncWork = nullptr};
417 if (!asynccallbackinfo) {
418 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
419 return Common::JSParaError(env, callback);
420 }
421 napi_value promise = nullptr;
422 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
423
424 napi_value resourceName = nullptr;
425 napi_create_string_latin1(env, "getDeviceRemindType", NAPI_AUTO_LENGTH, &resourceName);
426 // Asynchronous function call
427 napi_create_async_work(
428 env,
429 nullptr,
430 resourceName,
431 [](napi_env env, void *data) {
432 ANS_LOGD("NapiGetDeviceRemindType work excute.");
433 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
434 if (asynccallbackinfo) {
435 asynccallbackinfo->info.errorCode =
436 NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
437 }
438 },
439 AsyncCompleteCallbackNapiGetDeviceRemindType,
440 (void *)asynccallbackinfo,
441 &asynccallbackinfo->asyncWork);
442
443 bool isCallback = asynccallbackinfo->info.isCallback;
444 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
445
446 if (isCallback) {
447 ANS_LOGD("napiGetDeviceRemindType callback is nullptr.");
448 return Common::NapiGetNull(env);
449 } else {
450 return promise;
451 }
452 }
453
NapiSetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)454 napi_value NapiSetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
455 {
456 ANS_LOGD("enter");
457
458 EnabledWithoutAppParams params {};
459 if (ParseParameters(env, info, params) == nullptr) {
460 Common::NapiThrow(env, ERROR_PARAM_INVALID);
461 return Common::JSParaError(env, params.callback);
462 }
463
464 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
465 new (std::nothrow) AsyncCallbackInfoEnabledWithoutApp {.env = env, .asyncWork = nullptr, .params = params};
466 if (!asynccallbackinfo) {
467 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
468 return Common::JSParaError(env, params.callback);
469 }
470 napi_value promise = nullptr;
471 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
472
473 napi_value resourceName = nullptr;
474 napi_create_string_latin1(env, "SetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
475 // Asynchronous function call
476 napi_create_async_work(
477 env,
478 nullptr,
479 resourceName,
480 [](napi_env env, void *data) {
481 ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work excute.");
482 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
483 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
484 if (asynccallbackinfo) {
485 asynccallbackinfo->info.errorCode = NotificationHelper::SetSyncNotificationEnabledWithoutApp(
486 asynccallbackinfo->params.userId, asynccallbackinfo->params.enable);
487 }
488 },
489 [](napi_env env, napi_status status, void *data) {
490 ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work complete.");
491 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
492 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
493 if (asynccallbackinfo) {
494 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
495 if (asynccallbackinfo->info.callback != nullptr) {
496 ANS_LOGD("Delete napiSetSyncNotificationEnabledWithoutApp callback reference.");
497 napi_delete_reference(env, asynccallbackinfo->info.callback);
498 }
499 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
500 delete asynccallbackinfo;
501 asynccallbackinfo = nullptr;
502 }
503 ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work complete end.");
504 },
505 (void *)asynccallbackinfo,
506 &asynccallbackinfo->asyncWork);
507
508 bool isCallback = asynccallbackinfo->info.isCallback;
509 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
510
511 if (isCallback) {
512 ANS_LOGD("napiSetSyncNotificationEnabledWithoutApp callback is nullptr.");
513 return Common::NapiGetNull(env);
514 } else {
515 return promise;
516 }
517 }
518
NapiGetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)519 napi_value NapiGetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
520 {
521 ANS_LOGD("enter");
522
523 GetEnabledWithoutAppParams params {};
524 if (ParseParameters(env, info, params) == nullptr) {
525 Common::NapiThrow(env, ERROR_PARAM_INVALID);
526 return Common::JSParaError(env, params.callback);
527 }
528
529 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
530 new (std::nothrow) AsyncCallbackInfoGetEnabledWithoutApp {
531 .env = env, .asyncWork = nullptr, .params = params};
532 if (!asynccallbackinfo) {
533 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
534 return Common::JSParaError(env, params.callback);
535 }
536 napi_value promise = nullptr;
537 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
538
539 napi_value resourceName = nullptr;
540 napi_create_string_latin1(env, "GetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
541 // Asynchronous function call
542 napi_create_async_work(
543 env,
544 nullptr,
545 resourceName,
546 [](napi_env env, void *data) {
547 ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work excute.");
548 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
549 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
550 if (asynccallbackinfo) {
551 asynccallbackinfo->info.errorCode = NotificationHelper::GetSyncNotificationEnabledWithoutApp(
552 asynccallbackinfo->params.userId, asynccallbackinfo->enable);
553 }
554 },
555 [](napi_env env, napi_status status, void *data) {
556 ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work complete.");
557 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
558 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
559 if (asynccallbackinfo) {
560 napi_value result = nullptr;
561 if (asynccallbackinfo->info.errorCode != ERR_OK) {
562 result = Common::NapiGetNull(env);
563 } else {
564 napi_get_boolean(env, asynccallbackinfo->enable, &result);
565 }
566 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
567 if (asynccallbackinfo->info.callback != nullptr) {
568 ANS_LOGD("Delete napiGetSyncNotificationEnabledWithoutApp callback reference.");
569 napi_delete_reference(env, asynccallbackinfo->info.callback);
570 }
571 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
572 delete asynccallbackinfo;
573 asynccallbackinfo = nullptr;
574 }
575 ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work complete end.");
576 },
577 (void *)asynccallbackinfo,
578 &asynccallbackinfo->asyncWork);
579
580 bool isCallback = asynccallbackinfo->info.isCallback;
581 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
582
583 if (isCallback) {
584 ANS_LOGD("napiGetSyncNotificationEnabledWithoutApp callback is nullptr.");
585 return Common::NapiGetNull(env);
586 } else {
587 return promise;
588 }
589 }
590 } // namespace NotificationNapi
591 } // namespace OHOS
592