• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
88 
89     if (asynccallbackinfo->info.isCallback) {
90         return Common::NapiGetNull(env);
91     } else {
92         return promise;
93     }
94 }
95 
NapiEnableDistributed(napi_env env,napi_callback_info info)96 napi_value NapiEnableDistributed(napi_env env, napi_callback_info info)
97 {
98     ANS_LOGI("enter");
99 
100     EnabledParams params {};
101     if (ParseParameters(env, info, params) == nullptr) {
102         Common::NapiThrow(env, ERROR_PARAM_INVALID);
103         return Common::NapiGetUndefined(env);
104     }
105 
106     AsyncCallbackInfoEnabled *asynccallbackinfo =
107         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
108     if (!asynccallbackinfo) {
109         return Common::JSParaError(env, params.callback);
110     }
111     napi_value promise = nullptr;
112     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
113 
114     napi_value resourceName = nullptr;
115     napi_create_string_latin1(env, "enableDistributed", NAPI_AUTO_LENGTH, &resourceName);
116     // Asynchronous function call
117     napi_create_async_work(
118         env,
119         nullptr,
120         resourceName,
121         [](napi_env env, void *data) {
122             ANS_LOGI("EnableDistributed napi_create_async_work start");
123             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
124 
125             if (asynccallbackinfo) {
126                 asynccallbackinfo->info.errorCode =
127                     NotificationHelper::EnableDistributed(asynccallbackinfo->params.enable);
128             }
129         },
130         [](napi_env env, napi_status status, void *data) {
131             ANS_LOGI("EnableDistributed napi_create_async_work end");
132             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
133             if (asynccallbackinfo) {
134                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
135                 if (asynccallbackinfo->info.callback != nullptr) {
136                     napi_delete_reference(env, asynccallbackinfo->info.callback);
137                 }
138                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
139                 delete asynccallbackinfo;
140                 asynccallbackinfo = nullptr;
141             }
142         },
143         (void *)asynccallbackinfo,
144         &asynccallbackinfo->asyncWork);
145 
146     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
147 
148     if (asynccallbackinfo->info.isCallback) {
149         return Common::NapiGetNull(env);
150     } else {
151         return promise;
152     }
153 }
154 
NapiEnableDistributedByBundle(napi_env env,napi_callback_info info)155 napi_value NapiEnableDistributedByBundle(napi_env env, napi_callback_info info)
156 {
157     ANS_LOGI("enter");
158 
159     EnabledByBundleParams params {};
160     if (ParseParameters(env, info, params) == nullptr) {
161         Common::NapiThrow(env, ERROR_PARAM_INVALID);
162         return Common::NapiGetUndefined(env);
163     }
164 
165     AsyncCallbackInfoEnabledByBundle *asynccallbackinfo =
166         new (std::nothrow) AsyncCallbackInfoEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
167     if (!asynccallbackinfo) {
168         return Common::JSParaError(env, params.callback);
169     }
170     napi_value promise = nullptr;
171     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
172 
173     napi_value resourceName = nullptr;
174     napi_create_string_latin1(env, "enableDistributedByBundle", NAPI_AUTO_LENGTH, &resourceName);
175     // Asynchronous function call
176     napi_create_async_work(
177         env,
178         nullptr,
179         resourceName,
180         [](napi_env env, void *data) {
181             ANS_LOGI("EnableDistributedByBundle napi_create_async_work start");
182             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
183             if (asynccallbackinfo) {
184                 asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
185                     asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
186             }
187         },
188         [](napi_env env, napi_status status, void *data) {
189             ANS_LOGI("EnableDistributedByBundle napi_create_async_work end");
190             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
191             if (asynccallbackinfo) {
192                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
193                 if (asynccallbackinfo->info.callback != nullptr) {
194                     napi_delete_reference(env, asynccallbackinfo->info.callback);
195                 }
196                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
197                 delete asynccallbackinfo;
198                 asynccallbackinfo = nullptr;
199             }
200         },
201         (void *)asynccallbackinfo,
202         &asynccallbackinfo->asyncWork);
203 
204     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
205 
206     if (asynccallbackinfo->info.isCallback) {
207         return Common::NapiGetNull(env);
208     } else {
209         return promise;
210     }
211 }
212 
NapiEnableDistributedSelf(napi_env env,napi_callback_info info)213 napi_value NapiEnableDistributedSelf(napi_env env, napi_callback_info info)
214 {
215     ANS_LOGI("enter");
216 
217     EnabledParams params {};
218     if (ParseParameters(env, info, params) == nullptr) {
219         Common::NapiThrow(env, ERROR_PARAM_INVALID);
220         return Common::NapiGetUndefined(env);
221     }
222 
223     AsyncCallbackInfoEnabled *asynccallbackinfo =
224         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
225     if (!asynccallbackinfo) {
226         return Common::JSParaError(env, params.callback);
227     }
228     napi_value promise = nullptr;
229     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
230 
231     napi_value resourceName = nullptr;
232     napi_create_string_latin1(env, "enableDistributedSelf", NAPI_AUTO_LENGTH, &resourceName);
233     // Asynchronous function call
234     napi_create_async_work(
235         env,
236         nullptr,
237         resourceName,
238         [](napi_env env, void *data) {
239             ANS_LOGI("EnableDistributedSelf napi_create_async_work start");
240             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
241             if (asynccallbackinfo) {
242                 asynccallbackinfo->info.errorCode =
243                     NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
244                 ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
245             }
246         },
247         [](napi_env env, napi_status status, void *data) {
248             ANS_LOGI("EnableDistributedSelf napi_create_async_work end");
249             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
250             if (asynccallbackinfo) {
251                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
252                 if (asynccallbackinfo->info.callback != nullptr) {
253                     napi_delete_reference(env, asynccallbackinfo->info.callback);
254                 }
255                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
256                 delete asynccallbackinfo;
257                 asynccallbackinfo = nullptr;
258             }
259         },
260         (void *)asynccallbackinfo,
261         &asynccallbackinfo->asyncWork);
262 
263     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
264 
265     if (asynccallbackinfo->info.isCallback) {
266         return Common::NapiGetNull(env);
267     } else {
268         return promise;
269     }
270 }
271 
AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env,napi_status status,void * data)272 void AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env, napi_status status, void *data)
273 {
274     ANS_LOGI("enter");
275     if (!data) {
276         ANS_LOGE("Invalid async callback data");
277         return;
278     }
279     ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
280     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
281     if (asynccallbackinfo) {
282         napi_value result = nullptr;
283         if (asynccallbackinfo->info.errorCode != ERR_OK) {
284             result = Common::NapiGetNull(env);
285         } else {
286             napi_get_boolean(env, asynccallbackinfo->enable, &result);
287         }
288         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
289         if (asynccallbackinfo->info.callback != nullptr) {
290             napi_delete_reference(env, asynccallbackinfo->info.callback);
291         }
292         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
293         delete asynccallbackinfo;
294         asynccallbackinfo = nullptr;
295     }
296 }
297 
NapiIsDistributedEnableByBundle(napi_env env,napi_callback_info info)298 napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info)
299 {
300     ANS_LOGI("enter");
301 
302     IsEnabledByBundleParams params {};
303     if (ParseParameters(env, info, params) == nullptr) {
304         Common::NapiThrow(env, ERROR_PARAM_INVALID);
305         return Common::NapiGetUndefined(env);
306     }
307 
308     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo =
309         new (std::nothrow) AsyncCallbackInfoIsEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
310     if (!asynccallbackinfo) {
311         return Common::JSParaError(env, params.callback);
312     }
313     napi_value promise = nullptr;
314     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
315 
316     napi_value resourceName = nullptr;
317     napi_create_string_latin1(env, "isDistributedEnableByBundle", NAPI_AUTO_LENGTH, &resourceName);
318     // Asynchronous function call
319     napi_create_async_work(
320         env,
321         nullptr,
322         resourceName,
323         [](napi_env env, void *data) {
324             ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work start");
325             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
326             if (asynccallbackinfo) {
327                 asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
328                     asynccallbackinfo->params.option, asynccallbackinfo->enable);
329             }
330         },
331         AsyncCompleteCallbackNapiIsDistributedEnableByBundle,
332         (void *)asynccallbackinfo,
333         &asynccallbackinfo->asyncWork);
334 
335     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
336 
337     if (asynccallbackinfo->info.isCallback) {
338         return Common::NapiGetNull(env);
339     } else {
340         return promise;
341     }
342 }
343 
AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env,napi_status status,void * data)344 void AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env, napi_status status, void *data)
345 {
346     ANS_LOGI("enter");
347     if (!data) {
348         ANS_LOGE("Invalid async callback data");
349         return;
350     }
351     ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
352     AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
353     if (asynccallbackinfo) {
354         napi_value result = nullptr;
355         if (asynccallbackinfo->info.errorCode != ERR_OK) {
356             result = Common::NapiGetNull(env);
357         } else {
358             DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
359             if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
360                 asynccallbackinfo->info.errorCode = ERROR;
361                 result = Common::NapiGetNull(env);
362             }
363             napi_create_int32(env, (int32_t)outType, &result);
364         }
365         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
366         if (asynccallbackinfo->info.callback != nullptr) {
367             napi_delete_reference(env, asynccallbackinfo->info.callback);
368         }
369         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
370         delete asynccallbackinfo;
371         asynccallbackinfo = nullptr;
372     }
373 }
374 
NapiGetDeviceRemindType(napi_env env,napi_callback_info info)375 napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
376 {
377     ANS_LOGI("enter");
378 
379     napi_ref callback = nullptr;
380     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
381         Common::NapiThrow(env, ERROR_PARAM_INVALID);
382         return Common::NapiGetUndefined(env);
383     }
384 
385     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetRemindType {.env = env, .asyncWork = nullptr};
386     if (!asynccallbackinfo) {
387         return Common::JSParaError(env, callback);
388     }
389     napi_value promise = nullptr;
390     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
391 
392     napi_value resourceName = nullptr;
393     napi_create_string_latin1(env, "getDeviceRemindType", NAPI_AUTO_LENGTH, &resourceName);
394     // Asynchronous function call
395     napi_create_async_work(
396         env,
397         nullptr,
398         resourceName,
399         [](napi_env env, void *data) {
400             ANS_LOGI("GetDeviceRemindType napi_create_async_work start");
401             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
402             if (asynccallbackinfo) {
403                 asynccallbackinfo->info.errorCode =
404                     NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
405             }
406         },
407         AsyncCompleteCallbackNapiGetDeviceRemindType,
408         (void *)asynccallbackinfo,
409         &asynccallbackinfo->asyncWork);
410 
411     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
412 
413     if (asynccallbackinfo->info.isCallback) {
414         return Common::NapiGetNull(env);
415     } else {
416         return promise;
417     }
418 }
419 
NapiSetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)420 napi_value NapiSetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
421 {
422     ANS_LOGI("enter");
423 
424     EnabledWithoutAppParams params {};
425     if (ParseParameters(env, info, params) == nullptr) {
426         Common::NapiThrow(env, ERROR_PARAM_INVALID);
427         return Common::JSParaError(env, params.callback);
428     }
429 
430     AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
431         new (std::nothrow) AsyncCallbackInfoEnabledWithoutApp {.env = env, .asyncWork = nullptr, .params = params};
432     if (!asynccallbackinfo) {
433         return Common::JSParaError(env, params.callback);
434     }
435     napi_value promise = nullptr;
436     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
437 
438     napi_value resourceName = nullptr;
439     napi_create_string_latin1(env, "SetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
440     // Asynchronous function call
441     napi_create_async_work(
442         env,
443         nullptr,
444         resourceName,
445         [](napi_env env, void *data) {
446             ANS_LOGI("SetSyncNotificationEnabledWithoutApp napi_create_async_work start");
447             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
448                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
449             if (asynccallbackinfo) {
450                 asynccallbackinfo->info.errorCode = NotificationHelper::SetSyncNotificationEnabledWithoutApp(
451                     asynccallbackinfo->params.userId, asynccallbackinfo->params.enable);
452             }
453         },
454         [](napi_env env, napi_status status, void *data) {
455             ANS_LOGI("SetSyncNotificationEnabledWithoutApp napi_create_async_work end");
456             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
457                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
458             if (asynccallbackinfo) {
459                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
460                 if (asynccallbackinfo->info.callback != nullptr) {
461                     napi_delete_reference(env, asynccallbackinfo->info.callback);
462                 }
463                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
464                 delete asynccallbackinfo;
465                 asynccallbackinfo = nullptr;
466             }
467         },
468         (void *)asynccallbackinfo,
469         &asynccallbackinfo->asyncWork);
470 
471     if (napi_queue_async_work(env, asynccallbackinfo->asyncWork) != napi_ok) {
472         napi_delete_reference(env, asynccallbackinfo->info.callback);
473         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
474         delete asynccallbackinfo;
475         asynccallbackinfo = nullptr;
476         return Common::JSParaError(env, params.callback);
477     }
478 
479     if (asynccallbackinfo->info.isCallback) {
480         return Common::NapiGetNull(env);
481     }
482     return promise;
483 }
484 
NapiGetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)485 napi_value NapiGetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
486 {
487     ANS_LOGI("enter");
488 
489     GetEnabledWithoutAppParams params {};
490     if (ParseParameters(env, info, params) == nullptr) {
491         Common::NapiThrow(env, ERROR_PARAM_INVALID);
492         return Common::JSParaError(env, params.callback);
493     }
494 
495     AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
496         new (std::nothrow) AsyncCallbackInfoGetEnabledWithoutApp {
497         .env = env, .asyncWork = nullptr, .params = params};
498     if (!asynccallbackinfo) {
499         return Common::JSParaError(env, params.callback);
500     }
501     napi_value promise = nullptr;
502     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
503 
504     napi_value resourceName = nullptr;
505     napi_create_string_latin1(env, "GetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
506     // Asynchronous function call
507     napi_create_async_work(
508         env,
509         nullptr,
510         resourceName,
511         [](napi_env env, void *data) {
512             ANS_LOGI("GetSyncNotificationEnabledWithoutApp napi_create_async_work start");
513             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
514                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
515             if (asynccallbackinfo) {
516                 asynccallbackinfo->info.errorCode = NotificationHelper::GetSyncNotificationEnabledWithoutApp(
517                     asynccallbackinfo->params.userId, asynccallbackinfo->enable);
518             }
519         },
520         [](napi_env env, napi_status status, void *data) {
521             ANS_LOGI("GetSyncNotificationEnabledWithoutApp napi_create_async_work end");
522             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
523                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
524             if (asynccallbackinfo) {
525                 napi_value result = nullptr;
526                 if (asynccallbackinfo->info.errorCode != ERR_OK) {
527                     result = Common::NapiGetNull(env);
528                 } else {
529                     napi_get_boolean(env, asynccallbackinfo->enable, &result);
530                 }
531                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
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     if (napi_queue_async_work(env, asynccallbackinfo->asyncWork) != napi_ok) {
544         napi_delete_reference(env, asynccallbackinfo->info.callback);
545         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
546         delete asynccallbackinfo;
547         asynccallbackinfo = nullptr;
548         return Common::JSParaError(env, params.callback);
549     }
550 
551     if (asynccallbackinfo->info.isCallback) {
552         return Common::NapiGetNull(env);
553     }
554     return promise;
555 }
556 }  // namespace NotificationNapi
557 }  // namespace OHOS