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_slot.h"
17 
18 #include "ans_inner_errors.h"
19 #include "slot.h"
20 
21 namespace OHOS {
22 namespace NotificationNapi {
NapiAddSlot(napi_env env,napi_callback_info info)23 napi_value NapiAddSlot(napi_env env, napi_callback_info info)
24 {
25     ANS_LOGD("enter");
26     ParametersInfoAddSlot paras;
27     if (ParseParametersByAddSlot(env, info, paras) == nullptr) {
28         Common::NapiThrow(env, ERROR_PARAM_INVALID);
29         return Common::NapiGetUndefined(env);
30     }
31 
32     AsyncCallbackInfoAddSlot *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoAddSlot {
33         .env = env,
34         .asyncWork = nullptr,
35         .slot = paras.slot,
36         .inType = paras.inType,
37         .isAddSlotByType = paras.isAddSlotByType
38     };
39     if (!asynccallbackinfo) {
40         ANS_LOGD("Create asynccallbackinfo failed.");
41         return Common::JSParaError(env, paras.callback);
42     }
43     napi_value promise = nullptr;
44     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
45 
46     napi_value resourceName = nullptr;
47     napi_create_string_latin1(env, "addSlot", NAPI_AUTO_LENGTH, &resourceName);
48     // Asynchronous function call
49     napi_create_async_work(env,
50         nullptr,
51         resourceName,
52         [](napi_env env, void *data) {
53             ANS_LOGD("NapiAddSlot work excute.");
54             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
55             if (asynccallbackinfo) {
56                 if (asynccallbackinfo->isAddSlotByType) {
57                     asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
58                 } else {
59                     asynccallbackinfo->info.errorCode =
60                         NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
61                 }
62             }
63         },
64         [](napi_env env, napi_status status, void *data) {
65             ANS_LOGD("NapiAddSlot work complete.");
66             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
67             if (asynccallbackinfo) {
68                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
69                 if (asynccallbackinfo->info.callback != nullptr) {
70                     ANS_LOGD("Delete napiAddSlot callback reference.");
71                     napi_delete_reference(env, asynccallbackinfo->info.callback);
72                 }
73                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
74                 delete asynccallbackinfo;
75                 asynccallbackinfo = nullptr;
76             }
77             ANS_LOGD("NapiAddSlot work complete end.");
78         },
79         (void *)asynccallbackinfo,
80         &asynccallbackinfo->asyncWork);
81 
82     bool isCallback = asynccallbackinfo->info.isCallback;
83     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
84 
85     if (isCallback) {
86         ANS_LOGD("napiAddSlot callback is nullptr.");
87         return Common::NapiGetNull(env);
88     } else {
89         return promise;
90     }
91 }
92 
NapiAddSlots(napi_env env,napi_callback_info info)93 napi_value NapiAddSlots(napi_env env, napi_callback_info info)
94 {
95     ANS_LOGD("enter");
96     ParametersInfoAddSlots paras;
97     if (ParseParametersByAddSlots(env, info, paras) == nullptr) {
98         Common::NapiThrow(env, ERROR_PARAM_INVALID);
99         return Common::NapiGetUndefined(env);
100     }
101 
102     AsyncCallbackInfoAddSlots *asynccallbackinfo =
103         new (std::nothrow) AsyncCallbackInfoAddSlots {.env = env, .asyncWork = nullptr, .slots = paras.slots};
104     if (!asynccallbackinfo) {
105         ANS_LOGD("Asynccallbackinfo is nullptr.");
106         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
107         return Common::JSParaError(env, paras.callback);
108     }
109     napi_value promise = nullptr;
110     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
111 
112     napi_value resourceName = nullptr;
113     napi_create_string_latin1(env, "addSlots", NAPI_AUTO_LENGTH, &resourceName);
114     // Asynchronous function call
115     napi_create_async_work(env,
116         nullptr,
117         resourceName,
118         [](napi_env env, void *data) {
119             ANS_LOGD("NapiAddSlots work excute.");
120             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
121             if (asynccallbackinfo) {
122                 asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
123             }
124         },
125         [](napi_env env, napi_status status, void *data) {
126             ANS_LOGD("NapiAddSlots work complete.");
127             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
128             if (asynccallbackinfo) {
129                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
130                 if (asynccallbackinfo->info.callback != nullptr) {
131                     ANS_LOGD("Delete napiAddSlots callback reference.");
132                     napi_delete_reference(env, asynccallbackinfo->info.callback);
133                 }
134                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
135                 delete asynccallbackinfo;
136                 asynccallbackinfo = nullptr;
137             }
138             ANS_LOGD("NapiAddSlots work complete end.");
139         },
140         (void *)asynccallbackinfo,
141         &asynccallbackinfo->asyncWork);
142 
143     bool isCallback = asynccallbackinfo->info.isCallback;
144     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
145 
146     if (isCallback) {
147         ANS_LOGD("napiAddSlots callback is nullptr.");
148         return Common::NapiGetNull(env);
149     } else {
150         return promise;
151     }
152 }
153 
NapiSetSlotByBundle(napi_env env,napi_callback_info info)154 napi_value NapiSetSlotByBundle(napi_env env, napi_callback_info info)
155 {
156     ANS_LOGD("enter");
157     ParametersInfoSetSlotByBundle params {};
158     if (ParseParametersSetSlotByBundle(env, info, params) == nullptr) {
159         Common::NapiThrow(env, ERROR_PARAM_INVALID);
160         return Common::NapiGetUndefined(env);
161     }
162 
163     AsyncCallbackInfoSetSlotByBundle *asynccallbackinfo =
164         new (std::nothrow) AsyncCallbackInfoSetSlotByBundle {.env = env, .asyncWork = nullptr, .params = params};
165     if (!asynccallbackinfo) {
166         return Common::JSParaError(env, params.callback);
167     }
168     napi_value promise = nullptr;
169     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
170 
171     napi_value resourceName = nullptr;
172     napi_create_string_latin1(env, "setSlotByBundle", NAPI_AUTO_LENGTH, &resourceName);
173     // Asynchronous function call
174     napi_create_async_work(env,
175         nullptr,
176         resourceName,
177         [](napi_env env, void *data) {
178             ANS_LOGD("NapiSetSlotByBundle work excute.");
179             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
180             if (asynccallbackinfo) {
181                 asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
182                     asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
183             }
184         },
185         [](napi_env env, napi_status status, void *data) {
186             ANS_LOGD("NapiSetSlotByBundle work complete.");
187             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
188             if (asynccallbackinfo) {
189                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
190                 if (asynccallbackinfo->info.callback != nullptr) {
191                     ANS_LOGD("Delete napiSetSlotByBundle callback reference.");
192                     napi_delete_reference(env, asynccallbackinfo->info.callback);
193                 }
194                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
195                 delete asynccallbackinfo;
196                 asynccallbackinfo = nullptr;
197             }
198             ANS_LOGD("NapiSetSlotByBundle work complete end.");
199         },
200         (void *)asynccallbackinfo,
201         &asynccallbackinfo->asyncWork);
202 
203     bool isCallback = asynccallbackinfo->info.isCallback;
204     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
205 
206     if (isCallback) {
207         ANS_LOGD("napiSetSlotByBundle callback is nullptr.");
208         return Common::NapiGetNull(env);
209     } else {
210         return promise;
211     }
212 }
213 
214 
AsyncCompleteCallbackNapiGetSlot(napi_env env,napi_status status,void * data)215 void AsyncCompleteCallbackNapiGetSlot(napi_env env, napi_status status, void *data)
216 {
217     ANS_LOGI("GetSlot napi_create_async_work end");
218     if (!data) {
219         ANS_LOGE("Invalid async callback data");
220         return;
221     }
222 
223     auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
224     if (asynccallbackinfo) {
225         napi_value result = Common::NapiGetNull(env);
226         if (asynccallbackinfo->info.errorCode == ERR_OK) {
227             if (asynccallbackinfo->slot != nullptr) {
228                 napi_create_object(env, &result);
229                 if (!Common::SetNotificationSlot(env, *asynccallbackinfo->slot, result)) {
230                     asynccallbackinfo->info.errorCode = ERROR;
231                     result = Common::NapiGetNull(env);
232                 }
233             }
234         }
235         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
236         if (asynccallbackinfo->info.callback != nullptr) {
237             ANS_LOGD("Delete NapiGetSlot callback reference.");
238             napi_delete_reference(env, asynccallbackinfo->info.callback);
239         }
240         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
241         delete asynccallbackinfo;
242         asynccallbackinfo = nullptr;
243     }
244 }
245 
NapiGetSlot(napi_env env,napi_callback_info info)246 napi_value NapiGetSlot(napi_env env, napi_callback_info info)
247 {
248     ANS_LOGD("enter");
249     ParametersInfoGetSlot paras;
250     if (ParseParametersByGetSlot(env, info, paras) == nullptr) {
251         Common::NapiThrow(env, ERROR_PARAM_INVALID);
252         return Common::NapiGetUndefined(env);
253     }
254 
255     AsyncCallbackInfoGetSlot *asynccallbackinfo =
256         new (std::nothrow) AsyncCallbackInfoGetSlot {.env = env, .asyncWork = nullptr, .outType = paras.outType};
257     if (!asynccallbackinfo) {
258         return Common::JSParaError(env, paras.callback);
259     }
260     napi_value promise = nullptr;
261     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
262 
263     napi_value resourceName = nullptr;
264     napi_create_string_latin1(env, "getSlot", NAPI_AUTO_LENGTH, &resourceName);
265     // Asynchronous function call
266     napi_create_async_work(env,
267         nullptr,
268         resourceName,
269         [](napi_env env, void *data) {
270             ANS_LOGD("NapiGetSlot work excute.");
271             auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
272             if (asynccallbackinfo) {
273                 asynccallbackinfo->info.errorCode =
274                     NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
275             }
276         },
277         AsyncCompleteCallbackNapiGetSlot,
278         (void *)asynccallbackinfo,
279         &asynccallbackinfo->asyncWork);
280 
281     bool isCallback = asynccallbackinfo->info.isCallback;
282     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
283 
284     if (isCallback) {
285         ANS_LOGD("napiGetSlot callback is nullptr.");
286         return Common::NapiGetNull(env);
287     } else {
288         return promise;
289     }
290 }
291 
NapiGetSlotNumByBundle(napi_env env,napi_callback_info info)292 napi_value NapiGetSlotNumByBundle(napi_env env, napi_callback_info info)
293 {
294     ANS_LOGD("enter");
295     ParametersInfoGetSlotNumByBundle params {};
296     if (ParseParametersGetSlotNumByBundle(env, info, params) == nullptr) {
297         Common::NapiThrow(env, ERROR_PARAM_INVALID);
298         return Common::NapiGetUndefined(env);
299     }
300 
301     AsyncCallbackInfoGetSlotNumByBundle *asynccallbackinfo =
302         new (std::nothrow) AsyncCallbackInfoGetSlotNumByBundle {.env = env, .asyncWork = nullptr, .params = params};
303     if (!asynccallbackinfo) {
304         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
305         return Common::JSParaError(env, params.callback);
306     }
307     napi_value promise = nullptr;
308     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
309 
310     napi_value resourceName = nullptr;
311     napi_create_string_latin1(env, "getSlotNumByBundle", NAPI_AUTO_LENGTH, &resourceName);
312     // Asynchronous function call
313     napi_create_async_work(env,
314         nullptr,
315         resourceName,
316         [](napi_env env, void *data) {
317             ANS_LOGD("NapiGetSlotNumByBundle work excute.");
318             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
319             if (asynccallbackinfo) {
320                 asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
321                     asynccallbackinfo->params.option, asynccallbackinfo->num);
322             }
323         },
324         [](napi_env env, napi_status status, void *data) {
325             ANS_LOGD("NapiGetSlotNumByBundle work complete.");
326             auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
327             if (asynccallbackinfo) {
328                 napi_value result = nullptr;
329                 napi_create_uint32(env, asynccallbackinfo->num, &result);
330                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
331                 if (asynccallbackinfo->info.callback != nullptr) {
332                     ANS_LOGD("Delete napiGetSlotNumByBundle callback reference.");
333                     napi_delete_reference(env, asynccallbackinfo->info.callback);
334                 }
335                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
336                 delete asynccallbackinfo;
337                 asynccallbackinfo = nullptr;
338             }
339             ANS_LOGD("NapiGetSlotNumByBundle work complete end.");
340         },
341         (void *)asynccallbackinfo,
342         &asynccallbackinfo->asyncWork);
343 
344     bool isCallback = asynccallbackinfo->info.isCallback;
345     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
346 
347     if (isCallback) {
348         ANS_LOGD("napiGetSlotNumByBundle callback is nullptr.");
349         return Common::NapiGetNull(env);
350     } else {
351         return promise;
352     }
353 }
354 
AsyncCompleteCallbackNapiGetSlots(napi_env env,napi_status status,void * data)355 void AsyncCompleteCallbackNapiGetSlots(napi_env env, napi_status status, void *data)
356 {
357     ANS_LOGD("enter");
358     if (!data) {
359         ANS_LOGE("Invalid async callback data.");
360         return;
361     }
362     napi_value result = nullptr;
363     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
364     if (asynccallbackinfo) {
365         ANS_LOGD("Asynccallbackinfo conversion is success.");
366         if (asynccallbackinfo->info.errorCode != ERR_OK) {
367             result = Common::NapiGetNull(env);
368         } else {
369             napi_value arr = nullptr;
370             napi_create_array(env, &arr);
371             size_t count = 0;
372             for (auto vec : asynccallbackinfo->slots) {
373                 if (!vec) {
374                     ANS_LOGW("Invalidated NotificationSlot object ptr.");
375                     continue;
376                 }
377                 napi_value nSlot = nullptr;
378                 napi_create_object(env, &nSlot);
379                 if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
380                     ANS_LOGD("SetNotificationSlot is nullptr.");
381                     continue;
382                 }
383                 napi_set_element(env, arr, count, nSlot);
384                 count++;
385             }
386             ANS_LOGI("NapiGetSlots count : %{public}zu", count);
387             result = arr;
388             if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
389                 asynccallbackinfo->info.errorCode = ERROR;
390                 result = Common::NapiGetNull(env);
391             }
392         }
393         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
394         if (asynccallbackinfo->info.callback != nullptr) {
395             ANS_LOGD("Delete napiGetSlots callback reference.");
396             napi_delete_reference(env, asynccallbackinfo->info.callback);
397         }
398         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
399         delete asynccallbackinfo;
400         asynccallbackinfo = nullptr;
401     }
402 }
403 
NapiGetSlots(napi_env env,napi_callback_info info)404 napi_value NapiGetSlots(napi_env env, napi_callback_info info)
405 {
406     ANS_LOGD("enter");
407     napi_ref callback = nullptr;
408     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
409         Common::NapiThrow(env, ERROR_PARAM_INVALID);
410         return Common::NapiGetUndefined(env);
411     }
412 
413     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetSlots {.env = env, .asyncWork = nullptr};
414     if (!asynccallbackinfo) {
415         return Common::JSParaError(env, callback);
416     }
417     napi_value promise = nullptr;
418     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
419 
420     napi_value resourceName = nullptr;
421     napi_create_string_latin1(env, "getSlots", NAPI_AUTO_LENGTH, &resourceName);
422     // Asynchronous function call
423     napi_create_async_work(env,
424         nullptr,
425         resourceName,
426         [](napi_env env, void *data) {
427             ANS_LOGI("NapiGetSlots word excute.");
428             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
429             if (asynccallbackinfo) {
430                 asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
431             }
432         },
433         AsyncCompleteCallbackNapiGetSlots,
434         (void *)asynccallbackinfo,
435         &asynccallbackinfo->asyncWork);
436 
437     bool isCallback = asynccallbackinfo->info.isCallback;
438     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
439 
440     if (isCallback) {
441         ANS_LOGD("napiGetSlots callback is nullptr.");
442         return Common::NapiGetNull(env);
443     } else {
444         return promise;
445     }
446 }
447 
AsyncCompleteCallbackNapiGetSlotsByBundle(napi_env env,napi_status status,void * data)448 void AsyncCompleteCallbackNapiGetSlotsByBundle(napi_env env, napi_status status, void *data)
449 {
450     ANS_LOGD("enter");
451     if (!data) {
452         ANS_LOGE("Invalid async callback data.");
453         return;
454     }
455     napi_value result = nullptr;
456     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
457     if (asynccallbackinfo) {
458         if (asynccallbackinfo->info.errorCode != ERR_OK) {
459             result = Common::NapiGetNull(env);
460         } else {
461             napi_value arr = nullptr;
462             napi_create_array(env, &arr);
463             size_t count = 0;
464             for (auto vec : asynccallbackinfo->slots) {
465                 if (!vec) {
466                     ANS_LOGW("Invalid NotificationSlot object ptr.");
467                     continue;
468                 }
469                 napi_value nSlot = nullptr;
470                 napi_create_object(env, &nSlot);
471                 if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
472                     continue;
473                 }
474                 napi_set_element(env, arr, count, nSlot);
475                 count++;
476             }
477             ANS_LOGI("count = %{public}zu", count);
478             result = arr;
479             if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
480                 asynccallbackinfo->info.errorCode = ERROR;
481                 result = Common::NapiGetNull(env);
482             }
483         }
484         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
485         if (asynccallbackinfo->info.callback != nullptr) {
486             ANS_LOGD("Delete napiGetSlotsByBundle callback reference.");
487             napi_delete_reference(env, asynccallbackinfo->info.callback);
488         }
489         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
490         delete asynccallbackinfo;
491         asynccallbackinfo = nullptr;
492     }
493 }
494 
NapiGetSlotsByBundle(napi_env env,napi_callback_info info)495 napi_value NapiGetSlotsByBundle(napi_env env, napi_callback_info info)
496 {
497     ANS_LOGD("enter");
498     ParametersInfoGetSlotsByBundle params {};
499     if (ParseParametersGetSlotsByBundle(env, info, params) == nullptr) {
500         Common::NapiThrow(env, ERROR_PARAM_INVALID);
501         return Common::NapiGetUndefined(env);
502     }
503 
504     AsyncCallbackInfoGetSlotsByBundle *asynccallbackinfo =
505         new (std::nothrow) AsyncCallbackInfoGetSlotsByBundle {.env = env, .asyncWork = nullptr, .params = params};
506     if (!asynccallbackinfo) {
507         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
508         return Common::JSParaError(env, params.callback);
509     }
510     napi_value promise = nullptr;
511     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
512 
513     napi_value resourceName = nullptr;
514     napi_create_string_latin1(env, "getSlotsByBundle", NAPI_AUTO_LENGTH, &resourceName);
515     // Asynchronous function call
516     napi_create_async_work(env,
517         nullptr,
518         resourceName,
519         [](napi_env env, void *data) {
520             ANS_LOGD("NapiGetSlotsByBundle work excute.");
521             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
522             if (asynccallbackinfo) {
523                 asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(
524                     asynccallbackinfo->params.option, asynccallbackinfo->slots);
525             }
526         },
527         AsyncCompleteCallbackNapiGetSlotsByBundle,
528         (void *)asynccallbackinfo,
529         &asynccallbackinfo->asyncWork);
530 
531     bool isCallback = asynccallbackinfo->info.isCallback;
532     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
533 
534     if (isCallback) {
535         ANS_LOGD("napiGetSlotsByBundle callback is nullptr.");
536         return Common::NapiGetNull(env);
537     } else {
538         return promise;
539     }
540 }
541 
AsyncCompleteCallbackNapiGetSlotByBundle(napi_env env,napi_status status,void * data)542 void AsyncCompleteCallbackNapiGetSlotByBundle(napi_env env, napi_status status, void *data)
543 {
544     ANS_LOGD("enter");
545     if (!data) {
546         ANS_LOGE("Invalid async callback data.");
547         return;
548     }
549     napi_value result = nullptr;
550     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotByBundle *>(data);
551     if (asynccallbackinfo) {
552         if (asynccallbackinfo->info.errorCode != ERR_OK) {
553             result = Common::NapiGetNull(env);
554         } else {
555             if (asynccallbackinfo->slot != nullptr) {
556                 napi_create_object(env, &result);
557                 if (!Common::SetNotificationSlot(env, *asynccallbackinfo->slot, result)) {
558                     asynccallbackinfo->info.errorCode = ERROR;
559                     result = Common::NapiGetNull(env);
560                 }
561             }
562         }
563         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
564         if (asynccallbackinfo->info.callback != nullptr) {
565             ANS_LOGD("Delete napiGetSlotByBundle callback reference.");
566             napi_delete_reference(env, asynccallbackinfo->info.callback);
567         }
568         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
569         delete asynccallbackinfo;
570         asynccallbackinfo = nullptr;
571     }
572 }
573 
NapiGetSlotByBundle(napi_env env,napi_callback_info info)574 napi_value NapiGetSlotByBundle(napi_env env, napi_callback_info info)
575 {
576     ANS_LOGD("enter");
577     ParametersInfoGetSlotByBundle params {};
578     if (ParseParametersGetSlotByBundle(env, info, params) == nullptr) {
579         Common::NapiThrow(env, ERROR_PARAM_INVALID);
580         return Common::NapiGetUndefined(env);
581     }
582 
583     AsyncCallbackInfoGetSlotByBundle *asynccallbackinfo =
584         new (std::nothrow) AsyncCallbackInfoGetSlotByBundle {.env = env, .asyncWork = nullptr, .params = params};
585     if (!asynccallbackinfo) {
586         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
587         return Common::JSParaError(env, params.callback);
588     }
589     napi_value promise = nullptr;
590     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
591 
592     napi_value resourceName = nullptr;
593     napi_create_string_latin1(env, "getSlotByBundle", NAPI_AUTO_LENGTH, &resourceName);
594     // Asynchronous function call
595     napi_create_async_work(env,
596         nullptr,
597         resourceName,
598         [](napi_env env, void *data) {
599             ANS_LOGD("NapiGetSlotByBundle work excute.");
600             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotByBundle *>(data);
601             if (asynccallbackinfo) {
602                 asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotForBundle(
603                     asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->slot);
604             }
605         },
606         AsyncCompleteCallbackNapiGetSlotByBundle,
607         (void *)asynccallbackinfo,
608         &asynccallbackinfo->asyncWork);
609 
610     bool isCallback = asynccallbackinfo->info.isCallback;
611     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
612 
613     if (isCallback) {
614         ANS_LOGD("napiGetSlotByBundle callback is nullptr.");
615         return Common::NapiGetNull(env);
616     } else {
617         return promise;
618     }
619 }
620 
NapiRemoveSlot(napi_env env,napi_callback_info info)621 napi_value NapiRemoveSlot(napi_env env, napi_callback_info info)
622 {
623     ANS_LOGD("enter");
624     ParametersInfoRemoveSlot paras;
625     if (ParseParametersByRemoveSlot(env, info, paras) == nullptr) {
626         Common::NapiThrow(env, ERROR_PARAM_INVALID);
627         return Common::NapiGetUndefined(env);
628     }
629 
630     AsyncCallbackInfoRemoveSlot *asynccallbackinfo =
631         new (std::nothrow) AsyncCallbackInfoRemoveSlot {.env = env, .asyncWork = nullptr, .outType = paras.outType};
632     if (!asynccallbackinfo) {
633         ANS_LOGD("Asynccallbackinfo is nullptr.");
634         return Common::JSParaError(env, paras.callback);
635     }
636     napi_value promise = nullptr;
637     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
638 
639     napi_value resourceName = nullptr;
640     napi_create_string_latin1(env, "removeSlot", NAPI_AUTO_LENGTH, &resourceName);
641     // Asynchronous function call
642     napi_create_async_work(env,
643         nullptr,
644         resourceName,
645         [](napi_env env, void *data) {
646             ANS_LOGD("NapiRemoveSlot work excute.");
647             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
648             if (asynccallbackinfo) {
649                 asynccallbackinfo->info.errorCode =
650                     NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
651             }
652         },
653         [](napi_env env, napi_status status, void *data) {
654             ANS_LOGD("NapiRemoveSlot work complete.");
655             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
656             if (asynccallbackinfo) {
657                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
658                 if (asynccallbackinfo->info.callback != nullptr) {
659                     ANS_LOGD("Delete napiRemoveSlot callback reference.");
660                     napi_delete_reference(env, asynccallbackinfo->info.callback);
661                 }
662                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
663                 delete asynccallbackinfo;
664                 asynccallbackinfo = nullptr;
665             }
666             ANS_LOGD("NapiRemoveSlot work complete end.");
667         },
668         (void *)asynccallbackinfo,
669         &asynccallbackinfo->asyncWork);
670 
671     bool isCallback = asynccallbackinfo->info.isCallback;
672     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
673 
674     if (isCallback) {
675         ANS_LOGD("napiRemoveSlot callback is nullptr.");
676         return Common::NapiGetNull(env);
677     } else {
678         return promise;
679     }
680 }
681 
NapiRemoveAllSlots(napi_env env,napi_callback_info info)682 napi_value NapiRemoveAllSlots(napi_env env, napi_callback_info info)
683 {
684     ANS_LOGD("enter");
685     napi_ref callback = nullptr;
686     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
687         Common::NapiThrow(env, ERROR_PARAM_INVALID);
688         return Common::NapiGetUndefined(env);
689     }
690 
691     auto *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoRemoveAllSlots {.env = env, .asyncWork = nullptr};
692     if (!asynccallbackinfo) {
693         return Common::JSParaError(env, callback);
694     }
695     napi_value promise = nullptr;
696     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
697 
698     napi_value resourceName = nullptr;
699     napi_create_string_latin1(env, "removeAll", NAPI_AUTO_LENGTH, &resourceName);
700     // Asynchronous function call
701     napi_create_async_work(env,
702         nullptr,
703         resourceName,
704         [](napi_env env, void *data) {
705             ANS_LOGD("NapiRemoveAllSlots work excute.");
706             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
707             if (asynccallbackinfo) {
708                 asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
709             }
710         },
711         [](napi_env env, napi_status status, void *data) {
712             ANS_LOGD("NapiRemoveAllSlots work complete.");
713             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
714             if (asynccallbackinfo) {
715                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
716                 if (asynccallbackinfo->info.callback != nullptr) {
717                     ANS_LOGD("Delete napiRemoveAllSlots callback reference.");
718                     napi_delete_reference(env, asynccallbackinfo->info.callback);
719                 }
720                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
721                 delete asynccallbackinfo;
722                 asynccallbackinfo = nullptr;
723             }
724             ANS_LOGD("NapiRemoveAllSlots work complete end.");
725         },
726         (void *)asynccallbackinfo,
727         &asynccallbackinfo->asyncWork);
728 
729     bool isCallback = asynccallbackinfo->info.isCallback;
730     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
731 
732     if (isCallback) {
733         ANS_LOGD("napiRemoveAllSlots callback is nullptr.");
734         return Common::NapiGetNull(env);
735     } else {
736         return promise;
737     }
738 }
739 
NapiEnableNotificationSlot(napi_env env,napi_callback_info info)740 napi_value NapiEnableNotificationSlot(napi_env env, napi_callback_info info)
741 {
742     ANS_LOGD("enter");
743     ParametersInfoEnableSlot params {};
744     if (ParseParametersEnableSlot(env, info, params) == nullptr) {
745         Common::NapiThrow(env, ERROR_PARAM_INVALID);
746         return Common::NapiGetUndefined(env);
747     }
748 
749     AsyncCallbackInfoInfoEnableSlot *asynccallbackinfo =
750         new (std::nothrow) AsyncCallbackInfoInfoEnableSlot {.env = env, .asyncWork = nullptr, .params = params};
751     if (!asynccallbackinfo) {
752         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
753         return Common::JSParaError(env, params.callback);
754     }
755     napi_value promise = nullptr;
756     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
757 
758     napi_value resourceName = nullptr;
759     napi_create_string_latin1(env, "EnableNotificationSlot", NAPI_AUTO_LENGTH, &resourceName);
760     // Asynchronous function call
761     napi_create_async_work(env,
762         nullptr,
763         resourceName,
764         [](napi_env env, void *data) {
765             ANS_LOGD("NapiEnableNotificationSlot work excute.");
766             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
767             if (asynccallbackinfo) {
768                 asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
769                     asynccallbackinfo->params.option,
770                     asynccallbackinfo->params.outType,
771                     asynccallbackinfo->params.enable,
772                     asynccallbackinfo->params.isForceControl);
773             }
774         },
775         [](napi_env env, napi_status status, void *data) {
776             ANS_LOGD("NapiEnableNotificationSlot work complete.");
777             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
778             if (asynccallbackinfo) {
779                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
780                 if (asynccallbackinfo->info.callback != nullptr) {
781                     ANS_LOGD("Delete napiEnableNotificationSlot callback reference.");
782                     napi_delete_reference(env, asynccallbackinfo->info.callback);
783                 }
784                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
785                 delete asynccallbackinfo;
786                 asynccallbackinfo = nullptr;
787             }
788             ANS_LOGD("NapiEnableNotificationSlot work complete end.");
789         },
790         (void *)asynccallbackinfo,
791         &asynccallbackinfo->asyncWork);
792 
793     bool isCallback = asynccallbackinfo->info.isCallback;
794     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
795 
796     if (isCallback) {
797         ANS_LOGD("napiEnableNotificationSlot callback is nullptr.");
798         return Common::NapiGetNull(env);
799     } else {
800         return promise;
801     }
802 }
803 
NapiIsEnableNotificationSlot(napi_env env,napi_callback_info info)804 napi_value NapiIsEnableNotificationSlot(napi_env env, napi_callback_info info)
805 {
806     ANS_LOGD("enter");
807     ParametersInfoIsEnableSlot params {};
808     if (ParseParametersIsEnableSlot(env, info, params) == nullptr) {
809         Common::NapiThrow(env, ERROR_PARAM_INVALID);
810         return Common::NapiGetUndefined(env);
811     }
812 
813     AsyncCallbackInfoInfoIsEnableSlot *asynccallbackinfo =
814         new (std::nothrow) AsyncCallbackInfoInfoIsEnableSlot {.env = env, .asyncWork = nullptr, .params = params};
815     if (!asynccallbackinfo) {
816         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
817         return Common::JSParaError(env, params.callback);
818     }
819     napi_value promise = nullptr;
820     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
821 
822     napi_value resourceName = nullptr;
823     napi_create_string_latin1(env, "IsEnableNotificationSlot", NAPI_AUTO_LENGTH, &resourceName);
824     // Asynchronous function call
825     napi_create_async_work(env,
826         nullptr,
827         resourceName,
828         [](napi_env env, void *data) {
829             ANS_LOGD("NapiIsEnableNotificationSlot work excute.");
830             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
831             if (asynccallbackinfo) {
832                 asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
833                     asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
834             }
835         },
836         [](napi_env env, napi_status status, void *data) {
837             ANS_LOGD("NapiIsEnableNotificationSlot work complete.");
838             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
839             if (asynccallbackinfo) {
840                 napi_value result = nullptr;
841                 napi_get_boolean(env, asynccallbackinfo->isEnable, &result);
842                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
843                 if (asynccallbackinfo->info.callback != nullptr) {
844                     ANS_LOGD("Delete napiIsEnableNotificationSlot callback reference.");
845                     napi_delete_reference(env, asynccallbackinfo->info.callback);
846                 }
847                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
848                 delete asynccallbackinfo;
849                 asynccallbackinfo = nullptr;
850             }
851             ANS_LOGD("NapiIsEnableNotificationSlot work complete end.");
852         },
853         (void *)asynccallbackinfo,
854         &asynccallbackinfo->asyncWork);
855 
856     bool isCallback = asynccallbackinfo->info.isCallback;
857     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
858 
859     if (isCallback) {
860         ANS_LOGD("napiIsEnableNotificationSlot callback is nullptr.");
861         return Common::NapiGetNull(env);
862     } else {
863         return promise;
864     }
865 }
866 
NapiSetSlotFlagsByBundle(napi_env env,napi_callback_info info)867 napi_value NapiSetSlotFlagsByBundle(napi_env env, napi_callback_info info)
868 {
869     ANS_LOGD("enter");
870     ParametersInfoSetSlotFlagsByBundle params {};
871     if (ParseParametersSetSlotFlagsByBundle(env, info, params) == nullptr) {
872         Common::NapiThrow(env, ERROR_PARAM_INVALID);
873         return Common::NapiGetUndefined(env);
874     }
875 
876     AsyncCallbackInfoSetSlotFlagsByBundle *asynccallbackinfo =
877         new (std::nothrow) AsyncCallbackInfoSetSlotFlagsByBundle {.env = env, .asyncWork = nullptr, .params = params};
878     if (!asynccallbackinfo) {
879         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
880         return Common::JSParaError(env, params.callback);
881     }
882     napi_value promise = nullptr;
883     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
884 
885     napi_value resourceName = nullptr;
886     napi_create_string_latin1(env, "setSlotFlagsByBundle", NAPI_AUTO_LENGTH, &resourceName);
887     // Asynchronous function call
888     napi_create_async_work(env,
889         nullptr,
890         resourceName,
891         [](napi_env env, void *data) {
892             ANS_LOGD("NapiSetSlotFlagsByBundle work excute.");
893             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotFlagsByBundle *>(data);
894             if (asynccallbackinfo) {
895                 asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationSlotFlagsAsBundle(
896                     asynccallbackinfo->params.option, asynccallbackinfo->params.slotFlags);
897             }
898         },
899         [](napi_env env, napi_status status, void *data) {
900             ANS_LOGD("NapiSetSlotFlagsByBundle work complete.");
901             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotFlagsByBundle *>(data);
902             if (asynccallbackinfo) {
903                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
904                 if (asynccallbackinfo->info.callback != nullptr) {
905                     ANS_LOGD("Delete napiSetSlotFlagsByBundle callback reference.");
906                     napi_delete_reference(env, asynccallbackinfo->info.callback);
907                 }
908                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
909                 delete asynccallbackinfo;
910                 asynccallbackinfo = nullptr;
911             }
912             ANS_LOGD("NapiSetSlotFlagsByBundle work complete end.");
913         },
914         (void *)asynccallbackinfo,
915         &asynccallbackinfo->asyncWork);
916 
917     bool isCallback = asynccallbackinfo->info.isCallback;
918     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
919 
920     if (isCallback) {
921         ANS_LOGD("napiSetSlotFlagsByBundle callback is nullptr.");
922         return Common::NapiGetNull(env);
923     } else {
924         return promise;
925     }
926 }
927 
NapiGetSlotFlagsByBundle(napi_env env,napi_callback_info info)928 napi_value NapiGetSlotFlagsByBundle(napi_env env, napi_callback_info info)
929 {
930     ANS_LOGD("enter");
931     ParametersInfoGetSlotFlagsByBundle params {};
932     if (ParseParametersGetSlotFlagsByBundle(env, info, params) == nullptr) {
933         Common::NapiThrow(env, ERROR_PARAM_INVALID);
934         return Common::NapiGetUndefined(env);
935     }
936 
937     AsyncCallbackInfoGetSlotFlagsByBundle *asynccallbackinfo =
938         new (std::nothrow) AsyncCallbackInfoGetSlotFlagsByBundle {.env = env, .asyncWork = nullptr, .params = params};
939     if (!asynccallbackinfo) {
940         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
941         return Common::JSParaError(env, params.callback);
942     }
943     napi_value promise = nullptr;
944     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
945 
946     napi_value resourceName = nullptr;
947     napi_create_string_latin1(env, "getSlotFlagsByBundle", NAPI_AUTO_LENGTH, &resourceName);
948     // Asynchronous function call
949     napi_create_async_work(env,
950         nullptr,
951         resourceName,
952         [](napi_env env, void *data) {
953             ANS_LOGD("NapiGetSlotFlagsByBundle work excute.");
954             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotFlagsByBundle *>(data);
955             if (asynccallbackinfo) {
956                 asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotFlagsAsBundle(
957                     asynccallbackinfo->params.option, asynccallbackinfo->slotFlags);
958             }
959         },
960         [](napi_env env, napi_status status, void *data) {
961             ANS_LOGD("NapiGetSlotFlagsByBundle work complete.");
962             auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlotFlagsByBundle *>(data);
963             if (asynccallbackinfo) {
964                 napi_value result = nullptr;
965                 napi_create_uint32(env, asynccallbackinfo->slotFlags, &result);
966                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
967                 if (asynccallbackinfo->info.callback != nullptr) {
968                     ANS_LOGD("Delete napiGetSlotFlagsByBundle callback reference.");
969                     napi_delete_reference(env, asynccallbackinfo->info.callback);
970                 }
971                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
972                 delete asynccallbackinfo;
973                 asynccallbackinfo = nullptr;
974             }
975             ANS_LOGD("NapiGetSlotFlagsByBundle work complete end.");
976         },
977         (void *)asynccallbackinfo,
978         &asynccallbackinfo->asyncWork);
979 
980     bool isCallback = asynccallbackinfo->info.isCallback;
981     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
982 
983     if (isCallback) {
984         ANS_LOGD("napiGetSlotFlagsByBundle callback is nullptr.");
985         return Common::NapiGetNull(env);
986     } else {
987         return promise;
988     }
989 }
990 
991 }  // namespace NotificationNapi
992 }  // namespace OHOS
993