1 /*
2 * Copyright (c) 2021-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 "reminder/publish.h"
17
18 #include "ans_log_wrapper.h"
19 #include "common.h"
20 #include "reminder_request.h"
21 #include "reminder_request_alarm.h"
22 #include "reminder_request_calendar.h"
23 #include "reminder_request_timer.h"
24 #include "securec.h"
25
26 namespace OHOS {
27 namespace ReminderAgentNapi {
28 static const int32_t PUBLISH_PARAM_LEN = 2;
29 static const int32_t CANCEL_PARAM_LEN = 2;
30 static const int32_t CANCEL_ALL_PARAM_LEN = 1;
31 static const int32_t GET_VALID_PARAM_LEN = 1;
32 static const int32_t ADD_SLOT_PARAM_LEN = 2;
33
34 struct AsyncCallbackInfo {
AsyncCallbackInfoOHOS::ReminderAgentNapi::AsyncCallbackInfo35 explicit AsyncCallbackInfo(napi_env napiEnv) : env(napiEnv) {}
~AsyncCallbackInfoOHOS::ReminderAgentNapi::AsyncCallbackInfo36 ~AsyncCallbackInfo()
37 {
38 if (asyncWork) {
39 napi_delete_async_work(env, asyncWork);
40 asyncWork = nullptr;
41 }
42 if (callback) {
43 napi_delete_reference(env, callback);
44 callback = nullptr;
45 }
46 }
47
48 napi_env env = nullptr;
49 napi_async_work asyncWork = nullptr;
50 napi_ref callback = nullptr;
51 napi_value result = nullptr;
52 int32_t reminderId = -1;
53 bool isThrow = false;
54 NotificationNapi::NotificationConstant::SlotType inType
55 = NotificationNapi::NotificationConstant::SlotType::CONTENT_INFORMATION;
56 std::shared_ptr<ReminderRequest> reminder = nullptr;
57 std::vector<sptr<ReminderRequest>> validReminders;
58 CallbackPromiseInfo info;
59 };
60
61 struct Parameters {
62 int32_t reminderId = -1;
63 int32_t errCode = ERR_OK;
64 NotificationNapi::NotificationConstant::SlotType inType
65 = NotificationNapi::NotificationConstant::SlotType::CONTENT_INFORMATION;
66 std::shared_ptr<ReminderRequest> reminder = nullptr;
67 };
68
GetCallback(const napi_env & env,const napi_value & value,AsyncCallbackInfo & asyncCallbackInfo)69 napi_value GetCallback(const napi_env &env, const napi_value &value, AsyncCallbackInfo &asyncCallbackInfo)
70 {
71 napi_valuetype valuetype = napi_undefined;
72 NAPI_CALL(env, napi_typeof(env, value, &valuetype));
73 if (valuetype != napi_function) {
74 ANSR_LOGW("Wrong argument type. Function expected.");
75 return nullptr;
76 }
77 napi_create_reference(env, value, 1, &asyncCallbackInfo.callback);
78 return NotificationNapi::Common::NapiGetNull(env);
79 }
80
SetAsynccallbackinfo(const napi_env & env,AsyncCallbackInfo & asynccallbackinfo,napi_value & promise)81 void SetAsynccallbackinfo(const napi_env &env, AsyncCallbackInfo& asynccallbackinfo, napi_value& promise)
82 {
83 ReminderCommon::PaddingCallbackPromiseInfo(
84 env, asynccallbackinfo.callback, asynccallbackinfo.info, promise);
85 }
86
ParseParameters(const napi_env & env,const napi_callback_info & info,Parameters & params,AsyncCallbackInfo & asyncCallbackInfo,bool isThrow)87 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, Parameters ¶ms,
88 AsyncCallbackInfo &asyncCallbackInfo, bool isThrow)
89 {
90 size_t argc = PUBLISH_PARAM_LEN;
91 napi_value argv[PUBLISH_PARAM_LEN] = {nullptr};
92 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
93 if (argc < 1) {
94 ANSR_LOGW("Wrong number of arguments");
95 if (isThrow) {
96 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
97 }
98 return nullptr;
99 }
100
101 // argv[1]: callback
102 if (argc >= PUBLISH_PARAM_LEN) {
103 if (GetCallback(env, argv[1], asyncCallbackInfo) == nullptr) {
104 ANSR_LOGW("[reminderAgent]GetCallbak returns nullptr");
105 if (isThrow) {
106 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
107 }
108 return nullptr;
109 }
110 }
111
112 // argv[0] : reminderRequest
113 if (ReminderCommon::GetReminderRequest(env, argv[0], params.reminder) == nullptr) {
114 ANSR_LOGW("[reminderAgent]CreateReminder returns nullptr");
115 if (isThrow) {
116 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
117 }
118 return nullptr;
119 }
120
121 return NotificationNapi::Common::NapiGetNull(env);
122 }
123
ParseSlotParameters(const napi_env & env,const napi_callback_info & info,Parameters & params,AsyncCallbackInfo & asyncCallbackInfo,bool isThrow)124 napi_value ParseSlotParameters(const napi_env &env, const napi_callback_info &info, Parameters ¶ms,
125 AsyncCallbackInfo &asyncCallbackInfo, bool isThrow)
126 {
127 size_t argc = ADD_SLOT_PARAM_LEN;
128 napi_value argv[ADD_SLOT_PARAM_LEN] = {nullptr};
129 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
130 if (argc < 1) {
131 ANSR_LOGW("Wrong number of arguments");
132 if (isThrow) {
133 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
134 }
135 return nullptr;
136 }
137
138 // argv[1]: callback
139 if (argc >= ADD_SLOT_PARAM_LEN) {
140 if (GetCallback(env, argv[1], asyncCallbackInfo) == nullptr) {
141 ANSR_LOGW("GetCallbak returns nullptr");
142 if (isThrow) {
143 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
144 }
145 return nullptr;
146 }
147 }
148
149 // argv[0] : notificationSlot
150 // slotType
151 const char* propertyKey = "type";
152 const char* propertyNewKey = "notificationType";
153 int32_t propertyVal = 0;
154 if (!ReminderCommon::GetInt32(env, argv[0], propertyKey, propertyVal, false) &&
155 !ReminderCommon::GetInt32(env, argv[0], propertyNewKey, propertyVal, false)) {
156 ANSR_LOGW("Failed to get valid slot type.");
157 params.errCode = ERR_REMINDER_INVALID_PARAM;
158 if (isThrow) {
159 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
160 }
161 return nullptr;
162 }
163
164 if (!NotificationNapi::Common::SlotTypeJSToC(NotificationNapi::SlotType(propertyVal), params.inType)) {
165 ANSR_LOGW("Failed to get valid slot type");
166 if (isThrow) {
167 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
168 }
169 return nullptr;
170 }
171 return NotificationNapi::Common::NapiGetNull(env);
172 }
173
ParseCanCelParameter(const napi_env & env,const napi_callback_info & info,Parameters & params,AsyncCallbackInfo & asyncCallbackInfo,bool isThrow)174 napi_value ParseCanCelParameter(const napi_env &env, const napi_callback_info &info, Parameters ¶ms,
175 AsyncCallbackInfo &asyncCallbackInfo, bool isThrow)
176 {
177 ANSR_LOGI("ParseCanCelParameter");
178 size_t argc = CANCEL_PARAM_LEN;
179 napi_value argv[CANCEL_PARAM_LEN] = {nullptr};
180 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
181 if (argc < 1) {
182 ANSR_LOGW("Wrong number of arguments");
183 if (isThrow) {
184 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
185 }
186 return nullptr;
187 }
188
189 // argv[1]: callback
190 if (argc >= CANCEL_PARAM_LEN) {
191 if (GetCallback(env, argv[1], asyncCallbackInfo) == nullptr) {
192 ANSR_LOGW("GetCallbak is nullptr");
193 if (isThrow) {
194 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
195 }
196 return nullptr;
197 }
198 }
199
200 // argv[0]: reminder id
201 int32_t reminderId = -1;
202 if (!ReminderCommon::GetInt32(env, argv[0], nullptr, reminderId, true)) {
203 if (isThrow) {
204 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
205 }
206 return nullptr;
207 }
208 if (reminderId < 0) {
209 ANSR_LOGW("Param id of cancels Reminder is illegal.");
210 if (isThrow) {
211 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
212 }
213 return nullptr;
214 }
215 params.reminderId = reminderId;
216
217 return NotificationNapi::Common::NapiGetNull(env);
218 }
219
ParseCanCelAllParameter(const napi_env & env,const napi_callback_info & info,Parameters & params,AsyncCallbackInfo & asyncCallbackInfo,bool isThrow)220 napi_value ParseCanCelAllParameter(const napi_env &env, const napi_callback_info &info, Parameters ¶ms,
221 AsyncCallbackInfo &asyncCallbackInfo, bool isThrow)
222 {
223 ANSR_LOGI("ParseCanCelAllParameter");
224 size_t argc = CANCEL_ALL_PARAM_LEN;
225 napi_value argv[CANCEL_ALL_PARAM_LEN] = {nullptr};
226 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
227
228 // argv[0]: callback
229 if (argc >= CANCEL_ALL_PARAM_LEN) {
230 if (GetCallback(env, argv[0], asyncCallbackInfo) == nullptr) {
231 ANSR_LOGW("getCallbak is nullptr");
232 if (isThrow) {
233 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
234 }
235 return nullptr;
236 }
237 }
238 return NotificationNapi::Common::NapiGetNull(env);
239 }
240
ParseGetValidParameter(const napi_env & env,const napi_callback_info & info,Parameters & params,AsyncCallbackInfo & asyncCallbackInfo,bool isThrow)241 napi_value ParseGetValidParameter(const napi_env &env, const napi_callback_info &info, Parameters ¶ms,
242 AsyncCallbackInfo &asyncCallbackInfo, bool isThrow)
243 {
244 size_t argc = GET_VALID_PARAM_LEN;
245 napi_value argv[GET_VALID_PARAM_LEN] = {nullptr};
246 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
247
248 // argv[0]: callback
249 if (argc >= GET_VALID_PARAM_LEN) {
250 if (GetCallback(env, argv[0], asyncCallbackInfo) == nullptr) {
251 ANSR_LOGW("getCallbak is nullptr");
252 if (isThrow) {
253 ReminderCommon::HandleErrCode(env, ERR_REMINDER_INVALID_PARAM);
254 }
255 return nullptr;
256 }
257 }
258 return NotificationNapi::Common::NapiGetNull(env);
259 }
260
DealErrorReturn(const napi_env & env,const napi_ref & callbackIn,const napi_value & result,bool isThrow)261 napi_value DealErrorReturn(const napi_env &env, const napi_ref &callbackIn, const napi_value &result, bool isThrow)
262 {
263 if (isThrow) {
264 return nullptr;
265 }
266 if (callbackIn) {
267 NotificationNapi::Common::SetCallback(env, callbackIn, ERR_REMINDER_INVALID_PARAM,
268 result, false);
269 }
270 return NotificationNapi::Common::JSParaError(env, callbackIn);
271 }
272
CancelReminderInner(napi_env env,napi_callback_info info,bool isThrow)273 napi_value CancelReminderInner(napi_env env, napi_callback_info info, bool isThrow)
274 {
275 ANSR_LOGI("Cancel reminder");
276
277 AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
278 if (!asynccallbackinfo) {
279 ANSR_LOGE("Low memory.");
280 return NotificationNapi::Common::NapiGetNull(env);
281 }
282 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
283
284 // param
285 Parameters params;
286 if (ParseCanCelParameter(env, info, params, *asynccallbackinfo, isThrow) == nullptr) {
287 return DealErrorReturn(env, asynccallbackinfo->callback, NotificationNapi::Common::NapiGetNull(env), isThrow);
288 }
289
290 // promise
291 napi_value promise = nullptr;
292 SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
293 asynccallbackinfo->reminderId = params.reminderId;
294 asynccallbackinfo->isThrow = isThrow;
295
296 // resource name
297 napi_value resourceName = nullptr;
298 napi_create_string_latin1(env, "cancelReminder", NAPI_AUTO_LENGTH, &resourceName);
299
300 // create and queue async work
301 napi_create_async_work(env,
302 nullptr,
303 resourceName,
304 [](napi_env env, void *data) {
305 ANSR_LOGI("Cancel napi_create_async_work start");
306 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
307 if (asynccallbackinfo) {
308 asynccallbackinfo->info.errorCode = ReminderHelper::CancelReminder(asynccallbackinfo->reminderId);
309 }
310 },
311 [](napi_env env, napi_status status, void *data) {
312 ANSR_LOGI("Cancel napi_create_async_work complete start");
313 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
314 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
315
316 ReminderCommon::ReturnCallbackPromise(
317 env, asynccallbackinfo->info, NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
318 ANSR_LOGI("Cancel napi_create_async_work complete end");
319 },
320 (void *)asynccallbackinfo,
321 &asynccallbackinfo->asyncWork);
322 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
323 callbackPtr.release();
324
325 if (asynccallbackinfo->info.isCallback) {
326 return NotificationNapi::Common::NapiGetNull(env);
327 } else {
328 return promise;
329 }
330 }
331
CancelReminderMgr(napi_env env,napi_callback_info info)332 napi_value CancelReminderMgr(napi_env env, napi_callback_info info)
333 {
334 return CancelReminderInner(env, info, true);
335 }
336
CancelReminder(napi_env env,napi_callback_info info)337 napi_value CancelReminder(napi_env env, napi_callback_info info)
338 {
339 return CancelReminderInner(env, info, false);
340 }
341
CancelAllRemindersInner(napi_env env,napi_callback_info info,bool isThrow)342 napi_value CancelAllRemindersInner(napi_env env, napi_callback_info info, bool isThrow)
343 {
344 ANSR_LOGI("Cancel all reminder");
345
346 AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
347 if (!asynccallbackinfo) {
348 ANSR_LOGE("Low memory.");
349 return NotificationNapi::Common::NapiGetNull(env);
350 }
351 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
352
353 // param
354 Parameters params;
355 if (ParseCanCelAllParameter(env, info, params, *asynccallbackinfo, isThrow) == nullptr) {
356 return DealErrorReturn(env, asynccallbackinfo->callback, NotificationNapi::Common::NapiGetNull(env), isThrow);
357 }
358
359 // promise
360 napi_value promise = nullptr;
361 SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
362 asynccallbackinfo->isThrow = isThrow;
363
364 // resource name
365 napi_value resourceName = nullptr;
366 napi_create_string_latin1(env, "cancelAllReminders", NAPI_AUTO_LENGTH, &resourceName);
367
368 // create and queue async work
369 napi_create_async_work(env,
370 nullptr,
371 resourceName,
372 [](napi_env env, void *data) {
373 ANSR_LOGI("CancelAll napi_create_async_work start");
374 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
375 if (asynccallbackinfo) {
376 asynccallbackinfo->info.errorCode = ReminderHelper::CancelAllReminders();
377 }
378 },
379 [](napi_env env, napi_status status, void *data) {
380 ANSR_LOGD("CancelAll napi_create_async_work complete start");
381 auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
382 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
383
384 ReminderCommon::ReturnCallbackPromise(
385 env, asynccallbackinfo->info, NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
386 ANSR_LOGD("CancelAll napi_create_async_work complete end");
387 },
388 (void *)asynccallbackinfo,
389 &asynccallbackinfo->asyncWork);
390 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
391 callbackPtr.release();
392
393 if (asynccallbackinfo->info.isCallback) {
394 return NotificationNapi::Common::NapiGetNull(env);
395 } else {
396 return promise;
397 }
398 }
399
CancelAllRemindersMgr(napi_env env,napi_callback_info info)400 napi_value CancelAllRemindersMgr(napi_env env, napi_callback_info info)
401 {
402 return CancelAllRemindersInner(env, info, true);
403 }
404
CancelAllReminders(napi_env env,napi_callback_info info)405 napi_value CancelAllReminders(napi_env env, napi_callback_info info)
406 {
407 return CancelAllRemindersInner(env, info, false);
408 }
409
ParseReminderTimer(const napi_env & env,const ReminderRequest & reminder,napi_value & result)410 void ParseReminderTimer(const napi_env &env, const ReminderRequest &reminder, napi_value &result)
411 {
412 napi_value value = nullptr;
413 ReminderRequestTimer& timer = (ReminderRequestTimer&)reminder;
414 napi_create_uint32(env, timer.GetInitInfo(), &value);
415 napi_set_named_property(env, result, TIMER_COUNT_DOWN_TIME, value);
416 }
417
ParseReminderAlarm(const napi_env & env,const ReminderRequest & reminder,napi_value & result)418 void ParseReminderAlarm(const napi_env &env, const ReminderRequest &reminder, napi_value &result)
419 {
420 // hour
421 napi_value value = nullptr;
422 ReminderRequestAlarm& alarm = (ReminderRequestAlarm&)reminder;
423 napi_create_uint32(env, static_cast<uint32_t>(alarm.GetHour()), &value);
424 napi_set_named_property(env, result, ALARM_HOUR, value);
425
426 // minute
427 napi_create_uint32(env, static_cast<uint32_t>(alarm.GetMinute()), &value);
428 napi_set_named_property(env, result, ALARM_MINUTE, value);
429
430 // daysOfWeek
431 napi_create_array(env, &value);
432 napi_set_named_property(env, result, REPEAT_DAYS_OF_WEEK, value);
433 int32_t count = 0;
434 for (auto day : reminder.GetDaysOfWeek()) {
435 if (day) {
436 napi_value napiDay = nullptr;
437 napi_create_int32(env, day, &napiDay);
438 napi_set_element(env, value, count, napiDay);
439 count++;
440 }
441 }
442 }
443
ParseReminderCalendar(const napi_env & env,const ReminderRequest & reminder,napi_value & result)444 void ParseReminderCalendar(const napi_env &env, const ReminderRequest &reminder, napi_value &result)
445 {
446 // dateTime
447 napi_value value = nullptr;
448 ReminderRequestCalendar& calendar = (ReminderRequestCalendar&)reminder;
449 napi_value dateTime = nullptr;
450 napi_create_object(env, &dateTime);
451 napi_set_named_property(env, result, CALENDAR_DATE_TIME, dateTime);
452
453 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetYear()), &value);
454 napi_set_named_property(env, dateTime, CALENDAR_YEAR, value);
455 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetMonth()), &value);
456 napi_set_named_property(env, dateTime, CALENDAR_MONTH, value);
457 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetDay()), &value);
458 napi_set_named_property(env, dateTime, CALENDAR_DAY, value);
459 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetHour()), &value);
460 napi_set_named_property(env, dateTime, CALENDAR_HOUR, value);
461 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetMinute()), &value);
462 napi_set_named_property(env, dateTime, CALENDAR_MINUTE, value);
463 napi_create_uint32(env, static_cast<uint32_t>(calendar.GetSecond()), &value);
464 napi_set_named_property(env, dateTime, CALENDAR_SECOND, value);
465
466 // repeatMonths
467 napi_create_array(env, &value);
468 napi_set_named_property(env, result, CALENDAR_REPEAT_MONTHS, value);
469 int32_t count = 0;
470 for (auto month : calendar.GetRepeatMonths()) {
471 napi_value napiDay = nullptr;
472 napi_create_int32(env, month, &napiDay);
473 napi_set_element(env, value, count, napiDay);
474 count++;
475 }
476
477 // repeatDays
478 napi_create_array(env, &value);
479 napi_set_named_property(env, result, CALENDAR_REPEAT_DAYS, value);
480 count = 0;
481 for (auto day : calendar.GetRepeatDays()) {
482 napi_value napiDay = nullptr;
483 napi_create_int32(env, day, &napiDay);
484 napi_set_element(env, value, count, napiDay);
485 count++;
486 }
487
488 // daysOfWeek
489 napi_create_array(env, &value);
490 napi_set_named_property(env, result, REPEAT_DAYS_OF_WEEK, value);
491 count = 0;
492 for (auto day : reminder.GetDaysOfWeek()) {
493 if (day) {
494 napi_value napiDay = nullptr;
495 napi_create_int32(env, day, &napiDay);
496 napi_set_element(env, value, count, napiDay);
497 count++;
498 }
499 }
500 }
501
ParseReminder(const napi_env & env,const ReminderRequest::ReminderType & type,const ReminderRequest & reminder,napi_value & result)502 void ParseReminder(
503 const napi_env &env, const ReminderRequest::ReminderType &type, const ReminderRequest &reminder, napi_value &result)
504 {
505 switch (type) {
506 case ReminderRequest::ReminderType::TIMER: {
507 ParseReminderTimer(env, reminder, result);
508 break;
509 }
510 case ReminderRequest::ReminderType::ALARM: {
511 ParseReminderAlarm(env, reminder, result);
512 break;
513 }
514 case ReminderRequest::ReminderType::CALENDAR: {
515 ParseReminderCalendar(env, reminder, result);
516 break;
517 }
518 default: {
519 break;
520 }
521 }
522 }
523
ParseArray(const napi_env & env,std::vector<std::string> & temp,napi_value & jsObject)524 napi_status ParseArray(const napi_env &env, std::vector<std::string>& temp, napi_value &jsObject)
525 {
526 if (temp.size() <= INDEX_VALUE) {
527 return napi_invalid_arg;
528 }
529 // key
530 napi_value keyInfo = nullptr;
531 napi_create_string_utf8(env, temp[INDEX_KEY].c_str(), NAPI_AUTO_LENGTH, &keyInfo);
532 // value
533 napi_value valueInfo = nullptr;
534 napi_status status = napi_ok;
535 if (temp[INDEX_TYPE] == "string") {
536 napi_create_string_utf8(env, temp[INDEX_VALUE].c_str(), NAPI_AUTO_LENGTH, &valueInfo);
537 } else if (temp[INDEX_TYPE] == "double") {
538 napi_create_double(env, std::stod(temp[INDEX_VALUE]), &valueInfo);
539 } else if (temp[INDEX_TYPE] == "bool") {
540 bool valueBool = false;
541 if (temp[INDEX_VALUE] == "1" || temp[INDEX_VALUE] == "true" || temp[INDEX_VALUE] == "True") {
542 valueBool = true;
543 }
544 napi_get_boolean(env, valueBool, &valueInfo);
545 } else if (temp[INDEX_TYPE] == "null") {
546 napi_get_null(env, &valueInfo);
547 } else if (temp[INDEX_TYPE] == "vector") {
548 std::vector<std::string> arr = ReminderRequest::StringSplit(temp[INDEX_VALUE],
549 ReminderRequest::SEP_BUTTON_VALUE_BLOB);
550 std::vector<uint8_t> value;
551 for (auto &num : arr) {
552 value.push_back(static_cast<uint8_t>(std::stoi(num)));
553 }
554 // vector<uint8_t> to napi_value
555 if (value.size() <= 0) {
556 return napi_invalid_arg;
557 }
558 void* data = nullptr;
559 napi_value buffer = nullptr;
560 status = napi_create_arraybuffer(env, value.size(), &data, &buffer);
561 if (status != napi_ok) {
562 ANSR_LOGW("create array buffer failed!");
563 return napi_invalid_arg;
564 }
565 if (memcpy_s(data, value.size(), value.data(), value.size()) != EOK) {
566 ANSR_LOGW("memcpy_s not EOK");
567 return napi_invalid_arg;
568 }
569 status = napi_create_typedarray(env, napi_uint8_array, value.size(), buffer, 0, &valueInfo);
570 if (status != napi_ok) {
571 ANSR_LOGW("napi_create_typedarray failed!");
572 return napi_invalid_arg;
573 }
574 }
575 // write keyInfo and valueInfo
576 napi_set_property(env, jsObject, keyInfo, valueInfo);
577 return status;
578 }
579
580 // parse equalTo,valueBucket
ParseValueBucket(const napi_env & env,std::vector<std::string> valueBucketVector,napi_value & result,const std::string & arrayName)581 void ParseValueBucket(const napi_env &env, std::vector<std::string> valueBucketVector,
582 napi_value &result, const std::string &arrayName)
583 {
584 // create array
585 napi_value array = nullptr;
586 napi_create_array(env, &array);
587 napi_set_named_property(env, result, arrayName.c_str(), array);
588 int32_t index = 0;
589 // write equalTo or valuesBucket
590 for (auto &str : valueBucketVector) {
591 std::vector<std::string> temp = ReminderRequest::StringSplit(str, ReminderRequest::SEP_BUTTON_VALUE);
592 if (temp.size() <= INDEX_VALUE) {
593 continue;
594 }
595 // key:value
596 napi_value jsObject = nullptr;
597 napi_create_object(env, &jsObject);
598 napi_status status = ParseArray(env, temp, jsObject);
599 if (status != napi_ok) {
600 continue;
601 }
602 // write object to array
603 napi_set_element(env, array, index++, jsObject);
604 }
605 }
606
607 // parse uri,equalTo,valuesBucket c++ -> js
ParseButtonDataShareUpdate(const napi_env & env,std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> & dataShareUpdate,napi_value & result)608 void ParseButtonDataShareUpdate(const napi_env &env,
609 std::shared_ptr<ReminderRequest::ButtonDataShareUpdate> &dataShareUpdate, napi_value &result)
610 {
611 // create obj
612 napi_value buttonDataShareUpdate = nullptr;
613 napi_create_object(env, &buttonDataShareUpdate);
614 napi_set_named_property(env, result, BUTTON_DATA_SHARE_UPDATE, buttonDataShareUpdate);
615 // uri
616 napi_value uriInfo = nullptr;
617 napi_create_string_utf8(env, dataShareUpdate->uri.c_str(), NAPI_AUTO_LENGTH, &uriInfo);
618 napi_set_named_property(env, buttonDataShareUpdate, BUTTON_DATA_SHARE_UPDATE_URI, uriInfo);
619 // equalTo
620 std::vector<std::string> equalToVector = ReminderRequest::StringSplit(dataShareUpdate->equalTo,
621 ReminderRequest::SEP_BUTTON_VALUE_TYPE);
622 ParseValueBucket(env, equalToVector, buttonDataShareUpdate, BUTTON_DATA_SHARE_UPDATE_EQUALTO);
623 // valuesBucket
624 std::vector<std::string> valuesBucketVector = ReminderRequest::StringSplit(dataShareUpdate->valuesBucket,
625 ReminderRequest::SEP_BUTTON_VALUE_TYPE);
626 ParseValueBucket(env, valuesBucketVector, buttonDataShareUpdate, BUTTON_DATA_SHARE_UPDATE_VALUE);
627 }
628
ParseActionButtons(const napi_env & env,ReminderRequest & reminder,napi_value & result)629 void ParseActionButtons(const napi_env &env, ReminderRequest &reminder, napi_value &result)
630 {
631 auto actionButtonsMap = reminder.GetActionButtons();
632
633 // create array
634 napi_value array = nullptr;
635 napi_create_array(env, &array);
636 napi_set_named_property(env, result, ACTION_BUTTON, array);
637 int32_t index = 0;
638 for (std::map<ReminderRequest::ActionButtonType, ReminderRequest::ActionButtonInfo>::iterator it
639 = actionButtonsMap.begin(); it != actionButtonsMap.end(); ++it) {
640 // create obj
641 napi_value actionButton = nullptr;
642 napi_create_object(env, &actionButton);
643
644 napi_value buttonInfo = nullptr;
645 napi_create_uint32(env, static_cast<int32_t>(it->second.type), &buttonInfo);
646 napi_set_named_property(env, actionButton, ACTION_BUTTON_TYPE, buttonInfo);
647 napi_create_string_utf8(env, (it->second.title).c_str(), NAPI_AUTO_LENGTH, &buttonInfo);
648 napi_set_named_property(env, actionButton, ACTION_BUTTON_TITLE, buttonInfo);
649 napi_create_string_utf8(env, (it->second.resource).c_str(), NAPI_AUTO_LENGTH, &buttonInfo);
650 napi_set_named_property(env, actionButton, ACTION_BUTTON_RESOURCE, buttonInfo);
651
652 // create obj
653 napi_value wantAgentInfo = nullptr;
654 napi_create_object(env, &wantAgentInfo);
655 napi_set_named_property(env, actionButton, WANT_AGENT, wantAgentInfo);
656
657 if (it->second.type == ReminderRequest::ActionButtonType::CUSTOM) {
658 napi_value info = nullptr;
659 napi_create_string_utf8(env, (it->second.wantAgent->pkgName).c_str(), NAPI_AUTO_LENGTH, &info);
660 napi_set_named_property(env, wantAgentInfo, WANT_AGENT_PKG, info);
661 napi_create_string_utf8(env, (it->second.wantAgent->abilityName).c_str(), NAPI_AUTO_LENGTH, &info);
662 napi_set_named_property(env, wantAgentInfo, WANT_AGENT_ABILITY, info);
663 napi_create_string_utf8(env, (reminder.GetCustomButtonUri()).c_str(), NAPI_AUTO_LENGTH, &info);
664 napi_set_named_property(env, wantAgentInfo, BUTTON_WANT_AGENT_URI, info);
665 }
666 // Parse ButtonDataShareUpdate
667 if (it->second.type != ReminderRequest::ActionButtonType::INVALID) {
668 ParseButtonDataShareUpdate(env, it->second.dataShareUpdate, actionButton);
669 }
670 // add obj to array
671 napi_set_element(env, array, index, actionButton);
672 index++;
673 }
674 }
675
ParseWantAgent(const napi_env & env,ReminderRequest & reminder,napi_value & result)676 void ParseWantAgent(const napi_env &env, ReminderRequest &reminder, napi_value &result)
677 {
678 // create obj
679 napi_value wantAgentInfo = nullptr;
680 napi_create_object(env, &wantAgentInfo);
681 napi_set_named_property(env, result, WANT_AGENT, wantAgentInfo);
682
683 napi_value info = nullptr;
684 napi_create_string_utf8(env, (reminder.GetWantAgentInfo()->pkgName).c_str(), NAPI_AUTO_LENGTH, &info);
685 napi_set_named_property(env, wantAgentInfo, WANT_AGENT_PKG, info);
686 napi_create_string_utf8(env, (reminder.GetWantAgentInfo()->abilityName).c_str(), NAPI_AUTO_LENGTH, &info);
687 napi_set_named_property(env, wantAgentInfo, WANT_AGENT_ABILITY, info);
688
689 napi_create_string_utf8(env, (reminder.GetWantAgentInfo()->uri).c_str(), NAPI_AUTO_LENGTH, &info);
690 napi_set_named_property(env, wantAgentInfo, WANT_AGENT_URI, info);
691 }
692
ParseMaxScreenWantAgent(const napi_env & env,ReminderRequest & reminder,napi_value & result)693 void ParseMaxScreenWantAgent(const napi_env &env, ReminderRequest &reminder, napi_value &result)
694 {
695 // create obj
696 napi_value maxScreenWantAgentInfo = nullptr;
697 napi_create_object(env, &maxScreenWantAgentInfo);
698 napi_set_named_property(env, result, MAX_SCREEN_WANT_AGENT, maxScreenWantAgentInfo);
699
700 napi_value info = nullptr;
701 napi_create_string_utf8(env, (reminder.GetMaxScreenWantAgentInfo()->pkgName).c_str(), NAPI_AUTO_LENGTH, &info);
702 napi_set_named_property(env, maxScreenWantAgentInfo, MAX_SCREEN_WANT_AGENT_PKG, info);
703 napi_create_string_utf8(env, (reminder.GetMaxScreenWantAgentInfo()->abilityName).c_str(), NAPI_AUTO_LENGTH, &info);
704 napi_set_named_property(env, maxScreenWantAgentInfo, MAX_SCREEN_WANT_AGENT_ABILITY, info);
705 }
706
SetValidReminder(const napi_env & env,ReminderRequest & reminder,napi_value & result)707 napi_value SetValidReminder(const napi_env &env, ReminderRequest &reminder, napi_value &result)
708 {
709 ANSR_LOGI("enter");
710 napi_value value = nullptr;
711
712 napi_create_string_utf8(env, reminder.Dump().c_str(), NAPI_AUTO_LENGTH, &value);
713 napi_set_named_property(env, result, "reminder", value);
714
715 // type
716 ReminderRequest::ReminderType type = reminder.GetReminderType();
717 napi_create_int32(env, static_cast<int32_t>(type), &value);
718 napi_set_named_property(env, result, REMINDER_TYPE, value);
719
720 // reminder
721 ParseReminder(env, type, reminder, result);
722
723 // title
724 napi_create_string_utf8(env, reminder.GetTitle().c_str(), NAPI_AUTO_LENGTH, &value);
725 napi_set_named_property(env, result, TITLE, value);
726
727 // content
728 napi_create_string_utf8(env, reminder.GetContent().c_str(), NAPI_AUTO_LENGTH, &value);
729 napi_set_named_property(env, result, CONTENT, value);
730
731 // expiredContent
732 napi_create_string_utf8(env, reminder.GetExpiredContent().c_str(), NAPI_AUTO_LENGTH, &value);
733 napi_set_named_property(env, result, EXPIRED_CONTENT, value);
734
735 // snoozeContent
736 napi_create_string_utf8(env, reminder.GetSnoozeContent().c_str(), NAPI_AUTO_LENGTH, &value);
737 napi_set_named_property(env, result, SNOOZE_CONTENT, value);
738
739 // ringDuration
740 napi_create_int64(env, reminder.GetRingDuration(), &value);
741 napi_set_named_property(env, result, RING_DURATION, value);
742
743 // timeInterval
744 napi_create_int64(env, reminder.GetTimeInterval(), &value);
745 napi_set_named_property(env, result, TIME_INTERVAL, value);
746
747 // notificationId
748 napi_create_int32(env, reminder.GetNotificationId(), &value);
749 napi_set_named_property(env, result, NOTIFICATION_ID, value);
750
751 // snoozeTimes
752 napi_create_int32(env, reminder.GetSnoozeTimes(), &value);
753 napi_set_named_property(env, result, SNOOZE_TIMES, value);
754
755 // tapDismissed
756 napi_get_boolean(env, reminder.IsTapDismissed(), &value);
757 napi_set_named_property(env, result, TAPDISMISSED, value);
758
759 // autoDeletedTime
760 napi_create_int64(env, reminder.GetAutoDeletedTime(), &value);
761 napi_set_named_property(env, result, AUTODELETEDTIME, value);
762
763 // slotType
764 NotificationNapi::SlotType jsSlotType;
765 NotificationNapi::Common::SlotTypeCToJS(reminder.GetSlotType(), jsSlotType);
766 napi_create_int32(env, static_cast<int32_t>(jsSlotType), &value);
767 napi_set_named_property(env, result, SLOT_TYPE, value);
768
769 // snoozeSlotType
770 NotificationNapi::SlotType jsSnoozeSlotType;
771 NotificationNapi::Common::SlotTypeCToJS(reminder.GetSnoozeSlotType(), jsSnoozeSlotType);
772 napi_create_int32(env, static_cast<int32_t>(jsSnoozeSlotType), &value);
773 napi_set_named_property(env, result, SNOOZE_SLOT_TYPE, value);
774
775 // group id
776 napi_create_string_utf8(env, reminder.GetGroupId().c_str(), NAPI_AUTO_LENGTH, &value);
777 napi_set_named_property(env, result, GROUP_ID, value);
778
779 // custom ring uri
780 napi_create_string_utf8(env, reminder.GetCustomRingUri().c_str(), NAPI_AUTO_LENGTH, &value);
781 napi_set_named_property(env, result, CUSTOM_RING_URI, value);
782
783 // wantAgent
784 ParseWantAgent(env, reminder, result);
785
786 // maxScreenWantAgent
787 ParseMaxScreenWantAgent(env, reminder, result);
788
789 // actionButtons
790 ParseActionButtons(env, reminder, result);
791
792 return NotificationNapi::Common::NapiGetBoolean(env, true);
793 }
794
GetValidRemindersInner(napi_env env,const std::vector<sptr<ReminderRequest>> & validReminders,napi_value & arr)795 void GetValidRemindersInner(napi_env env, const std::vector<sptr<ReminderRequest>>& validReminders, napi_value& arr)
796 {
797 int32_t count = 0;
798 napi_create_array(env, &arr);
799 for (auto reminder : validReminders) {
800 if (reminder == nullptr) {
801 ANSR_LOGW("reminder is null");
802 continue;
803 }
804 napi_value result = nullptr;
805 napi_create_object(env, &result);
806 if (!SetValidReminder(env, *reminder, result)) {
807 ANSR_LOGW("Set reminder object failed");
808 continue;
809 }
810 napi_set_element(env, arr, count, result);
811 count++;
812 }
813 ANSR_LOGI("GetValid reminders count = %{public}d", count);
814 }
815
InnerGetValidReminders(napi_env env,napi_callback_info info,bool isThrow)816 napi_value InnerGetValidReminders(napi_env env, napi_callback_info info, bool isThrow)
817 {
818 ANSR_LOGI("Get valid reminders");
819
820 AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
821 if (!asynccallbackinfo) {
822 ANSR_LOGE("Low memory.");
823 return NotificationNapi::Common::NapiGetNull(env);
824 }
825 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
826
827 // param
828 Parameters params;
829 if (ParseGetValidParameter(env, info, params, *asynccallbackinfo, isThrow) == nullptr) {
830 return DealErrorReturn(env, asynccallbackinfo->callback, NotificationNapi::Common::NapiGetNull(env), isThrow);
831 }
832
833 // promise
834 napi_value promise = nullptr;
835 SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
836 asynccallbackinfo->isThrow = isThrow;
837
838 // resource name
839 napi_value resourceName = nullptr;
840 napi_create_string_latin1(env, "getValidReminders", NAPI_AUTO_LENGTH, &resourceName);
841
842 // create and start async work
843 napi_create_async_work(env,
844 nullptr,
845 resourceName,
846 [](napi_env env, void *data) {
847 ANSR_LOGI("GetValid reminders napi_create_async_work start");
848 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
849 if (asynccallbackinfo) {
850 asynccallbackinfo->info.errorCode = ReminderHelper::GetValidReminders(
851 asynccallbackinfo->validReminders);
852 }
853 },
854 [](napi_env env, napi_status status, void *data) {
855 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
856 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
857
858 if (asynccallbackinfo) {
859 if (asynccallbackinfo->info.errorCode != ERR_OK) {
860 asynccallbackinfo->result = NotificationNapi::Common::NapiGetNull(env);
861 } else {
862 GetValidRemindersInner(env, asynccallbackinfo->validReminders, asynccallbackinfo->result);
863 }
864
865 ReminderCommon::ReturnCallbackPromise(
866 env, asynccallbackinfo->info, asynccallbackinfo->result, asynccallbackinfo->isThrow);
867 }
868 },
869 (void *)asynccallbackinfo,
870 &asynccallbackinfo->asyncWork);
871 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
872 callbackPtr.release();
873
874 if (asynccallbackinfo->info.isCallback) {
875 return NotificationNapi::Common::NapiGetNull(env);
876 } else {
877 return promise;
878 }
879 }
880
GetValidRemindersMgr(napi_env env,napi_callback_info info)881 napi_value GetValidRemindersMgr(napi_env env, napi_callback_info info)
882 {
883 return InnerGetValidReminders(env, info, true);
884 }
885
GetValidReminders(napi_env env,napi_callback_info info)886 napi_value GetValidReminders(napi_env env, napi_callback_info info)
887 {
888 return InnerGetValidReminders(env, info, false);
889 }
890
PublishReminderInner(napi_env env,napi_callback_info info,bool isThrow)891 napi_value PublishReminderInner(napi_env env, napi_callback_info info, bool isThrow)
892 {
893 ANSR_LOGI("PublishReminder");
894
895 AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
896 if (!asynccallbackinfo) {
897 ANSR_LOGE("Low memory.");
898 return NotificationNapi::Common::NapiGetNull(env);
899 }
900 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
901
902 // param
903 Parameters params;
904 if (ParseParameters(env, info, params, *asynccallbackinfo, isThrow) == nullptr) {
905 napi_create_int32(env, -1, &(asynccallbackinfo->result));
906 return DealErrorReturn(env, asynccallbackinfo->callback, asynccallbackinfo->result, isThrow);
907 }
908
909 // promise
910 napi_value promise = nullptr;
911 SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
912 asynccallbackinfo->reminder = params.reminder;
913 asynccallbackinfo->isThrow = isThrow;
914
915 // resource name
916 napi_value resourceName = nullptr;
917 napi_create_string_latin1(env, "publishReminder", NAPI_AUTO_LENGTH, &resourceName);
918
919 // create and start async work
920 napi_create_async_work(env,
921 nullptr,
922 resourceName,
923 [](napi_env env, void *data) {
924 ANSR_LOGI("Publish napi_create_async_work start");
925 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
926 if (asynccallbackinfo) {
927 asynccallbackinfo->info.errorCode = ReminderHelper::PublishReminder(*(asynccallbackinfo->reminder));
928 ANSR_LOGD("Return reminderId=%{public}d", asynccallbackinfo->reminder->GetReminderId());
929 }
930 },
931 [](napi_env env, napi_status status, void *data) {
932 ANSR_LOGI("Publish napi_create_async_work complete start");
933 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
934 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
935
936 // reminderId
937 if (asynccallbackinfo) {
938 if (asynccallbackinfo->info.errorCode == ERR_OK) {
939 napi_create_int32(env, asynccallbackinfo->reminder->GetReminderId(), &(asynccallbackinfo->result));
940 } else {
941 napi_create_int32(env, -1, &(asynccallbackinfo->result));
942 }
943
944 ReminderCommon::ReturnCallbackPromise(
945 env, asynccallbackinfo->info, asynccallbackinfo->result, asynccallbackinfo->isThrow);
946 ANSR_LOGI("Publish napi_create_async_work complete end");
947 }
948 },
949 (void *)asynccallbackinfo,
950 &asynccallbackinfo->asyncWork);
951
952 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
953 callbackPtr.release();
954
955 if (asynccallbackinfo->info.isCallback) {
956 return NotificationNapi::Common::NapiGetNull(env);
957 } else {
958 return promise;
959 }
960 }
961
PublishReminderMgr(napi_env env,napi_callback_info info)962 napi_value PublishReminderMgr(napi_env env, napi_callback_info info)
963 {
964 return PublishReminderInner(env, info, true);
965 }
966
PublishReminder(napi_env env,napi_callback_info info)967 napi_value PublishReminder(napi_env env, napi_callback_info info)
968 {
969 return PublishReminderInner(env, info, false);
970 }
971
AddSlotInner(napi_env env,napi_callback_info info,bool isThrow)972 napi_value AddSlotInner(napi_env env, napi_callback_info info, bool isThrow)
973 {
974 ANSR_LOGI("AddSlot");
975
976 AsyncCallbackInfo *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfo(env);
977 if (!asynccallbackinfo) {
978 ANSR_LOGE("Low memory.");
979 return NotificationNapi::Common::NapiGetNull(env);
980 }
981 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
982
983 // param
984 Parameters params;
985 if (ParseSlotParameters(env, info, params, *asynccallbackinfo, isThrow) == nullptr) {
986 return DealErrorReturn(env, asynccallbackinfo->callback, NotificationNapi::Common::NapiGetNull(env), isThrow);
987 }
988
989 // promise
990 napi_value promise = nullptr;
991 SetAsynccallbackinfo(env, *asynccallbackinfo, promise);
992 asynccallbackinfo->inType = params.inType;
993 asynccallbackinfo->info.errorCode = params.errCode;
994 asynccallbackinfo->isThrow = isThrow;
995
996 // resource name
997 napi_value resourceName = nullptr;
998 napi_create_string_latin1(env, "AddSlot", NAPI_AUTO_LENGTH, &resourceName);
999
1000 // create and start async work
1001 napi_create_async_work(env,
1002 nullptr,
1003 resourceName,
1004 [](napi_env env, void *data) {
1005 ANSR_LOGI("AddSlot napi_create_async_work start");
1006 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
1007 if (asynccallbackinfo && (asynccallbackinfo->info.errorCode == ERR_OK)) {
1008 asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
1009 }
1010 },
1011 [](napi_env env, napi_status status, void *data) {
1012 AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
1013 if (asynccallbackinfo) {
1014 std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
1015 ReminderCommon::ReturnCallbackPromise(env, asynccallbackinfo->info,
1016 NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
1017 ANSR_LOGD("AddSlot napi_create_async_work complete end.");
1018 }
1019 },
1020 (void *)asynccallbackinfo,
1021 &asynccallbackinfo->asyncWork);
1022
1023 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
1024 callbackPtr.release();
1025
1026 if (asynccallbackinfo->info.isCallback) {
1027 return NotificationNapi::Common::NapiGetNull(env);
1028 } else {
1029 return promise;
1030 }
1031 }
1032
AddSlotMgr(napi_env env,napi_callback_info info)1033 napi_value AddSlotMgr(napi_env env, napi_callback_info info)
1034 {
1035 return AddSlotInner(env, info, true);
1036 }
1037
AddSlot(napi_env env,napi_callback_info info)1038 napi_value AddSlot(napi_env env, napi_callback_info info)
1039 {
1040 return AddSlotInner(env, info, false);
1041 }
1042 }
1043 }