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