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_LOGI("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 napi_delete_reference(env, asynccallbackinfo->info.callback);
42 }
43 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
44 delete asynccallbackinfo;
45 asynccallbackinfo = nullptr;
46 }
47 }
48
NapiIsDistributedEnabled(napi_env env,napi_callback_info info)49 napi_value NapiIsDistributedEnabled(napi_env env, napi_callback_info info)
50 {
51 ANS_LOGI("enter");
52
53 napi_ref callback = nullptr;
54 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
55 Common::NapiThrow(env, ERROR_PARAM_INVALID);
56 return Common::NapiGetUndefined(env);
57 }
58
59 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnabled {.env = env, .asyncWork = nullptr};
60 if (!asynccallbackinfo) {
61 return Common::JSParaError(env, callback);
62 }
63 napi_value promise = nullptr;
64 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
65
66 napi_value resourceName = nullptr;
67 napi_create_string_latin1(env, "isDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
68 // Asynchronous function call
69 napi_create_async_work(
70 env,
71 nullptr,
72 resourceName,
73 [](napi_env env, void *data) {
74 ANS_LOGI("IsDistributedEnabled napi_create_async_work start");
75 AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
76
77 if (asynccallbackinfo) {
78 asynccallbackinfo->info.errorCode =
79 NotificationHelper::IsDistributedEnabled(asynccallbackinfo->enable);
80 ANS_LOGI("IsDistributedEnabled enable = %{public}d", asynccallbackinfo->enable);
81 }
82 },
83 AsyncCompleteCallbackNapiIsDistributedEnabled,
84 (void *)asynccallbackinfo,
85 &asynccallbackinfo->asyncWork);
86
87 bool isCallback = asynccallbackinfo->info.isCallback;
88 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
89 if (status != napi_ok) {
90 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
91 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
92 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
93 if (asynccallbackinfo->info.callback != nullptr) {
94 napi_delete_reference(env, asynccallbackinfo->info.callback);
95 }
96 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
97 delete asynccallbackinfo;
98 asynccallbackinfo = nullptr;
99 }
100
101 if (isCallback) {
102 return Common::NapiGetNull(env);
103 } else {
104 return promise;
105 }
106 }
107
NapiEnableDistributed(napi_env env,napi_callback_info info)108 napi_value NapiEnableDistributed(napi_env env, napi_callback_info info)
109 {
110 ANS_LOGI("enter");
111
112 EnabledParams params {};
113 if (ParseParameters(env, info, params) == nullptr) {
114 Common::NapiThrow(env, ERROR_PARAM_INVALID);
115 return Common::NapiGetUndefined(env);
116 }
117
118 AsyncCallbackInfoEnabled *asynccallbackinfo =
119 new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
120 if (!asynccallbackinfo) {
121 return Common::JSParaError(env, params.callback);
122 }
123 napi_value promise = nullptr;
124 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
125
126 napi_value resourceName = nullptr;
127 napi_create_string_latin1(env, "enableDistributed", NAPI_AUTO_LENGTH, &resourceName);
128 // Asynchronous function call
129 napi_create_async_work(
130 env,
131 nullptr,
132 resourceName,
133 [](napi_env env, void *data) {
134 ANS_LOGI("EnableDistributed napi_create_async_work start");
135 AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
136
137 if (asynccallbackinfo) {
138 asynccallbackinfo->info.errorCode =
139 NotificationHelper::EnableDistributed(asynccallbackinfo->params.enable);
140 }
141 },
142 [](napi_env env, napi_status status, void *data) {
143 ANS_LOGI("EnableDistributed napi_create_async_work end");
144 AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
145 if (asynccallbackinfo) {
146 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
147 if (asynccallbackinfo->info.callback != nullptr) {
148 napi_delete_reference(env, asynccallbackinfo->info.callback);
149 }
150 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
151 delete asynccallbackinfo;
152 asynccallbackinfo = nullptr;
153 }
154 },
155 (void *)asynccallbackinfo,
156 &asynccallbackinfo->asyncWork);
157
158 bool isCallback = asynccallbackinfo->info.isCallback;
159 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
160 if (status != napi_ok) {
161 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
162 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
163 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
164 if (asynccallbackinfo->info.callback != nullptr) {
165 napi_delete_reference(env, asynccallbackinfo->info.callback);
166 }
167 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
168 delete asynccallbackinfo;
169 asynccallbackinfo = nullptr;
170 }
171
172 if (isCallback) {
173 return Common::NapiGetNull(env);
174 } else {
175 return promise;
176 }
177 }
178
NapiEnableDistributedByBundle(napi_env env,napi_callback_info info)179 napi_value NapiEnableDistributedByBundle(napi_env env, napi_callback_info info)
180 {
181 ANS_LOGI("enter");
182
183 EnabledByBundleParams params {};
184 if (ParseParameters(env, info, params) == nullptr) {
185 Common::NapiThrow(env, ERROR_PARAM_INVALID);
186 return Common::NapiGetUndefined(env);
187 }
188
189 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo =
190 new (std::nothrow) AsyncCallbackInfoEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
191 if (!asynccallbackinfo) {
192 return Common::JSParaError(env, params.callback);
193 }
194 napi_value promise = nullptr;
195 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
196
197 napi_value resourceName = nullptr;
198 napi_create_string_latin1(env, "enableDistributedByBundle", NAPI_AUTO_LENGTH, &resourceName);
199 // Asynchronous function call
200 napi_create_async_work(
201 env,
202 nullptr,
203 resourceName,
204 [](napi_env env, void *data) {
205 ANS_LOGI("EnableDistributedByBundle napi_create_async_work start");
206 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
207 if (asynccallbackinfo) {
208 asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
209 asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
210 }
211 },
212 [](napi_env env, napi_status status, void *data) {
213 ANS_LOGI("EnableDistributedByBundle napi_create_async_work end");
214 AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
215 if (asynccallbackinfo) {
216 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
217 if (asynccallbackinfo->info.callback != nullptr) {
218 napi_delete_reference(env, asynccallbackinfo->info.callback);
219 }
220 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
221 delete asynccallbackinfo;
222 asynccallbackinfo = nullptr;
223 }
224 },
225 (void *)asynccallbackinfo,
226 &asynccallbackinfo->asyncWork);
227
228 bool isCallback = asynccallbackinfo->info.isCallback;
229 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
230 if (status != napi_ok) {
231 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
232 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
233 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
234 if (asynccallbackinfo->info.callback != nullptr) {
235 napi_delete_reference(env, asynccallbackinfo->info.callback);
236 }
237 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
238 delete asynccallbackinfo;
239 asynccallbackinfo = nullptr;
240 }
241
242 if (isCallback) {
243 return Common::NapiGetNull(env);
244 } else {
245 return promise;
246 }
247 }
248
NapiEnableDistributedSelf(napi_env env,napi_callback_info info)249 napi_value NapiEnableDistributedSelf(napi_env env, napi_callback_info info)
250 {
251 ANS_LOGI("enter");
252
253 EnabledParams params {};
254 if (ParseParameters(env, info, params) == nullptr) {
255 Common::NapiThrow(env, ERROR_PARAM_INVALID);
256 return Common::NapiGetUndefined(env);
257 }
258
259 AsyncCallbackInfoEnabled *asynccallbackinfo =
260 new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
261 if (!asynccallbackinfo) {
262 return Common::JSParaError(env, params.callback);
263 }
264 napi_value promise = nullptr;
265 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
266
267 napi_value resourceName = nullptr;
268 napi_create_string_latin1(env, "enableDistributedSelf", NAPI_AUTO_LENGTH, &resourceName);
269 // Asynchronous function call
270 napi_create_async_work(
271 env,
272 nullptr,
273 resourceName,
274 [](napi_env env, void *data) {
275 ANS_LOGI("EnableDistributedSelf napi_create_async_work start");
276 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
277 if (asynccallbackinfo) {
278 asynccallbackinfo->info.errorCode =
279 NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
280 ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
281 }
282 },
283 [](napi_env env, napi_status status, void *data) {
284 ANS_LOGI("EnableDistributedSelf napi_create_async_work end");
285 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
286 if (asynccallbackinfo) {
287 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
288 if (asynccallbackinfo->info.callback != nullptr) {
289 napi_delete_reference(env, asynccallbackinfo->info.callback);
290 }
291 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
292 delete asynccallbackinfo;
293 asynccallbackinfo = nullptr;
294 }
295 },
296 (void *)asynccallbackinfo,
297 &asynccallbackinfo->asyncWork);
298
299 bool isCallback = asynccallbackinfo->info.isCallback;
300 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
301 if (status != napi_ok) {
302 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
303 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
304 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
305 if (asynccallbackinfo->info.callback != nullptr) {
306 napi_delete_reference(env, asynccallbackinfo->info.callback);
307 }
308 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
309 delete asynccallbackinfo;
310 asynccallbackinfo = nullptr;
311 }
312
313 if (isCallback) {
314 return Common::NapiGetNull(env);
315 } else {
316 return promise;
317 }
318 }
319
AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env,napi_status status,void * data)320 void AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env, napi_status status, void *data)
321 {
322 ANS_LOGI("enter");
323 if (!data) {
324 ANS_LOGE("Invalid async callback data");
325 return;
326 }
327 ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
328 AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
329 if (asynccallbackinfo) {
330 napi_value result = nullptr;
331 if (asynccallbackinfo->info.errorCode != ERR_OK) {
332 result = Common::NapiGetNull(env);
333 } else {
334 napi_get_boolean(env, asynccallbackinfo->enable, &result);
335 }
336 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
337 if (asynccallbackinfo->info.callback != nullptr) {
338 napi_delete_reference(env, asynccallbackinfo->info.callback);
339 }
340 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
341 delete asynccallbackinfo;
342 asynccallbackinfo = nullptr;
343 }
344 }
345
NapiIsDistributedEnableByBundle(napi_env env,napi_callback_info info)346 napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info)
347 {
348 ANS_LOGI("enter");
349
350 IsEnabledByBundleParams params {};
351 if (ParseParameters(env, info, params) == nullptr) {
352 Common::NapiThrow(env, ERROR_PARAM_INVALID);
353 return Common::NapiGetUndefined(env);
354 }
355
356 AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo =
357 new (std::nothrow) AsyncCallbackInfoIsEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
358 if (!asynccallbackinfo) {
359 return Common::JSParaError(env, params.callback);
360 }
361 napi_value promise = nullptr;
362 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
363
364 napi_value resourceName = nullptr;
365 napi_create_string_latin1(env, "isDistributedEnableByBundle", NAPI_AUTO_LENGTH, &resourceName);
366 // Asynchronous function call
367 napi_create_async_work(
368 env,
369 nullptr,
370 resourceName,
371 [](napi_env env, void *data) {
372 ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work start");
373 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
374 if (asynccallbackinfo) {
375 asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
376 asynccallbackinfo->params.option, asynccallbackinfo->enable);
377 }
378 },
379 AsyncCompleteCallbackNapiIsDistributedEnableByBundle,
380 (void *)asynccallbackinfo,
381 &asynccallbackinfo->asyncWork);
382
383 bool isCallback = asynccallbackinfo->info.isCallback;
384 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
385 if (status != napi_ok) {
386 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
387 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
388 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
389 if (asynccallbackinfo->info.callback != nullptr) {
390 napi_delete_reference(env, asynccallbackinfo->info.callback);
391 }
392 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
393 delete asynccallbackinfo;
394 asynccallbackinfo = nullptr;
395 }
396
397 if (isCallback) {
398 return Common::NapiGetNull(env);
399 } else {
400 return promise;
401 }
402 }
403
AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env,napi_status status,void * data)404 void AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env, napi_status status, void *data)
405 {
406 ANS_LOGI("enter");
407 if (!data) {
408 ANS_LOGE("Invalid async callback data");
409 return;
410 }
411 ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
412 AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
413 if (asynccallbackinfo) {
414 napi_value result = nullptr;
415 if (asynccallbackinfo->info.errorCode != ERR_OK) {
416 result = Common::NapiGetNull(env);
417 } else {
418 DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
419 if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
420 asynccallbackinfo->info.errorCode = ERROR;
421 result = Common::NapiGetNull(env);
422 }
423 napi_create_int32(env, (int32_t)outType, &result);
424 }
425 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
426 if (asynccallbackinfo->info.callback != nullptr) {
427 napi_delete_reference(env, asynccallbackinfo->info.callback);
428 }
429 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
430 delete asynccallbackinfo;
431 asynccallbackinfo = nullptr;
432 }
433 }
434
NapiGetDeviceRemindType(napi_env env,napi_callback_info info)435 napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
436 {
437 ANS_LOGI("enter");
438
439 napi_ref callback = nullptr;
440 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
441 Common::NapiThrow(env, ERROR_PARAM_INVALID);
442 return Common::NapiGetUndefined(env);
443 }
444
445 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetRemindType {.env = env, .asyncWork = nullptr};
446 if (!asynccallbackinfo) {
447 return Common::JSParaError(env, callback);
448 }
449 napi_value promise = nullptr;
450 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
451
452 napi_value resourceName = nullptr;
453 napi_create_string_latin1(env, "getDeviceRemindType", NAPI_AUTO_LENGTH, &resourceName);
454 // Asynchronous function call
455 napi_create_async_work(
456 env,
457 nullptr,
458 resourceName,
459 [](napi_env env, void *data) {
460 ANS_LOGI("GetDeviceRemindType napi_create_async_work start");
461 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
462 if (asynccallbackinfo) {
463 asynccallbackinfo->info.errorCode =
464 NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
465 }
466 },
467 AsyncCompleteCallbackNapiGetDeviceRemindType,
468 (void *)asynccallbackinfo,
469 &asynccallbackinfo->asyncWork);
470
471 bool isCallback = asynccallbackinfo->info.isCallback;
472 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
473 if (status != napi_ok) {
474 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
475 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
476 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
477 if (asynccallbackinfo->info.callback != nullptr) {
478 napi_delete_reference(env, asynccallbackinfo->info.callback);
479 }
480 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
481 delete asynccallbackinfo;
482 asynccallbackinfo = nullptr;
483 }
484
485 if (isCallback) {
486 return Common::NapiGetNull(env);
487 } else {
488 return promise;
489 }
490 }
491
NapiSetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)492 napi_value NapiSetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
493 {
494 ANS_LOGI("enter");
495
496 EnabledWithoutAppParams params {};
497 if (ParseParameters(env, info, params) == nullptr) {
498 Common::NapiThrow(env, ERROR_PARAM_INVALID);
499 return Common::JSParaError(env, params.callback);
500 }
501
502 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
503 new (std::nothrow) AsyncCallbackInfoEnabledWithoutApp {.env = env, .asyncWork = nullptr, .params = params};
504 if (!asynccallbackinfo) {
505 return Common::JSParaError(env, params.callback);
506 }
507 napi_value promise = nullptr;
508 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
509
510 napi_value resourceName = nullptr;
511 napi_create_string_latin1(env, "SetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
512 // Asynchronous function call
513 napi_create_async_work(
514 env,
515 nullptr,
516 resourceName,
517 [](napi_env env, void *data) {
518 ANS_LOGI("SetSyncNotificationEnabledWithoutApp napi_create_async_work start");
519 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
520 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
521 if (asynccallbackinfo) {
522 asynccallbackinfo->info.errorCode = NotificationHelper::SetSyncNotificationEnabledWithoutApp(
523 asynccallbackinfo->params.userId, asynccallbackinfo->params.enable);
524 }
525 },
526 [](napi_env env, napi_status status, void *data) {
527 ANS_LOGI("SetSyncNotificationEnabledWithoutApp napi_create_async_work end");
528 AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
529 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
530 if (asynccallbackinfo) {
531 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
532 if (asynccallbackinfo->info.callback != nullptr) {
533 napi_delete_reference(env, asynccallbackinfo->info.callback);
534 }
535 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
536 delete asynccallbackinfo;
537 asynccallbackinfo = nullptr;
538 }
539 },
540 (void *)asynccallbackinfo,
541 &asynccallbackinfo->asyncWork);
542
543 bool isCallback = asynccallbackinfo->info.isCallback;
544 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
545 if (status != napi_ok) {
546 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
547 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
548 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
549 if (asynccallbackinfo->info.callback != nullptr) {
550 napi_delete_reference(env, asynccallbackinfo->info.callback);
551 }
552 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
553 delete asynccallbackinfo;
554 asynccallbackinfo = nullptr;
555 }
556
557 if (isCallback) {
558 return Common::NapiGetNull(env);
559 } else {
560 return promise;
561 }
562 }
563
NapiGetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)564 napi_value NapiGetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
565 {
566 ANS_LOGI("enter");
567
568 GetEnabledWithoutAppParams params {};
569 if (ParseParameters(env, info, params) == nullptr) {
570 Common::NapiThrow(env, ERROR_PARAM_INVALID);
571 return Common::JSParaError(env, params.callback);
572 }
573
574 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
575 new (std::nothrow) AsyncCallbackInfoGetEnabledWithoutApp {
576 .env = env, .asyncWork = nullptr, .params = params};
577 if (!asynccallbackinfo) {
578 return Common::JSParaError(env, params.callback);
579 }
580 napi_value promise = nullptr;
581 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
582
583 napi_value resourceName = nullptr;
584 napi_create_string_latin1(env, "GetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
585 // Asynchronous function call
586 napi_create_async_work(
587 env,
588 nullptr,
589 resourceName,
590 [](napi_env env, void *data) {
591 ANS_LOGI("GetSyncNotificationEnabledWithoutApp napi_create_async_work start");
592 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
593 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
594 if (asynccallbackinfo) {
595 asynccallbackinfo->info.errorCode = NotificationHelper::GetSyncNotificationEnabledWithoutApp(
596 asynccallbackinfo->params.userId, asynccallbackinfo->enable);
597 }
598 },
599 [](napi_env env, napi_status status, void *data) {
600 ANS_LOGI("GetSyncNotificationEnabledWithoutApp napi_create_async_work end");
601 AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
602 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
603 if (asynccallbackinfo) {
604 napi_value result = nullptr;
605 if (asynccallbackinfo->info.errorCode != ERR_OK) {
606 result = Common::NapiGetNull(env);
607 } else {
608 napi_get_boolean(env, asynccallbackinfo->enable, &result);
609 }
610 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
611 if (asynccallbackinfo->info.callback != nullptr) {
612 napi_delete_reference(env, asynccallbackinfo->info.callback);
613 }
614 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
615 delete asynccallbackinfo;
616 asynccallbackinfo = nullptr;
617 }
618 },
619 (void *)asynccallbackinfo,
620 &asynccallbackinfo->asyncWork);
621
622 bool isCallback = asynccallbackinfo->info.isCallback;
623 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
624 if (status != napi_ok) {
625 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
626 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
627 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
628 if (asynccallbackinfo->info.callback != nullptr) {
629 napi_delete_reference(env, asynccallbackinfo->info.callback);
630 }
631 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
632 delete asynccallbackinfo;
633 asynccallbackinfo = nullptr;
634 }
635
636 if (isCallback) {
637 return Common::NapiGetNull(env);
638 } else {
639 return promise;
640 }
641 }
642 } // namespace NotificationNapi
643 } // namespace OHOS