• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "napi_distributed.h"
17 
18 #include "ans_inner_errors.h"
19 #include "distributed.h"
20 
21 namespace OHOS {
22 namespace NotificationNapi {
AsyncCompleteCallbackNapiIsDistributedEnabled(napi_env env,napi_status status,void * data)23 void AsyncCompleteCallbackNapiIsDistributedEnabled(napi_env env, napi_status status, void *data)
24 {
25     ANS_LOGD("called");
26     if (!data) {
27         ANS_LOGE("Invalid async callback data");
28         return;
29     }
30     ANS_LOGI("IsDistributedEnabled napi_create_async_work end");
31     AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
32     if (asynccallbackinfo) {
33         napi_value result = nullptr;
34         if (asynccallbackinfo->info.errorCode != ERR_OK) {
35             result = Common::NapiGetNull(env);
36         } else {
37             napi_get_boolean(env, asynccallbackinfo->enable, &result);
38         }
39         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
40         if (asynccallbackinfo->info.callback != nullptr) {
41             ANS_LOGD("Delete napiIsDistributedEnabled callback reference.");
42             napi_delete_reference(env, asynccallbackinfo->info.callback);
43         }
44         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
45         delete asynccallbackinfo;
46         asynccallbackinfo = nullptr;
47     }
48 }
49 
DoIsDistributedEnabledWithDeviceType(napi_env env,napi_callback_info info,EnabledParams & params)50 napi_value DoIsDistributedEnabledWithDeviceType(napi_env env, napi_callback_info info, EnabledParams &params)
51 {
52     auto asynccallbackinfo = new (std::nothrow)
53         AsyncCallbackInfoIsEnabled{ .env = env, .asyncWork = nullptr, .deviceType = params.deviceType };
54     if (!asynccallbackinfo) {
55         return Common::JSParaError(env, nullptr);
56     }
57     napi_value promise = nullptr;
58     Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
59 
60     napi_value resourceName = nullptr;
61     napi_create_string_latin1(env, "isDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
62     // Asynchronous function call
63     napi_create_async_work(
64         env, nullptr, resourceName,
65         [](napi_env env, void *data) {
66             ANS_LOGD("NapiIsDistributedEnabled work excute.");
67             AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
68 
69             if (asynccallbackinfo) {
70                 asynccallbackinfo->info.errorCode =
71                     NotificationHelper::IsDistributedEnabled(asynccallbackinfo->deviceType, asynccallbackinfo->enable);
72                 ANS_LOGI("IsDistributedEnabled enable = %{public}d", asynccallbackinfo->enable);
73             }
74         },
75         AsyncCompleteCallbackNapiIsDistributedEnabled, (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
76 
77     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
78     return promise;
79 }
80 
NapiIsDistributedEnabled(napi_env env,napi_callback_info info)81 napi_value NapiIsDistributedEnabled(napi_env env, napi_callback_info info)
82 {
83     ANS_LOGD("called");
84     EnabledParams params{};
85     if (ParseIsDistributedEnabledParams(env, info, params) == nullptr) {
86         Common::NapiThrow(env, ERROR_PARAM_INVALID);
87         return Common::NapiGetUndefined(env);
88     }
89 
90     if (!params.deviceType.empty()) {
91         return DoIsDistributedEnabledWithDeviceType(env, info, params);
92     }
93 
94     napi_ref callback = params.callback;
95     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnabled {.env = env, .asyncWork = nullptr};
96     if (!asynccallbackinfo) {
97         return Common::JSParaError(env, callback);
98     }
99     napi_value promise = nullptr;
100     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
101 
102     napi_value resourceName = nullptr;
103     napi_create_string_latin1(env, "isDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
104     // Asynchronous function call
105     napi_create_async_work(
106         env,
107         nullptr,
108         resourceName,
109         [](napi_env env, void *data) {
110             ANS_LOGD("NapiIsDistributedEnabled work excute.");
111             AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
112 
113             if (asynccallbackinfo) {
114                 asynccallbackinfo->info.errorCode =
115                     NotificationHelper::IsDistributedEnabled(asynccallbackinfo->enable);
116                 ANS_LOGI("IsDistributedEnabled enable = %{public}d", asynccallbackinfo->enable);
117             }
118         },
119         AsyncCompleteCallbackNapiIsDistributedEnabled,
120         (void *)asynccallbackinfo,
121         &asynccallbackinfo->asyncWork);
122 
123     bool isCallback = asynccallbackinfo->info.isCallback;
124     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
125 
126     if (isCallback) {
127         ANS_LOGD("null isCallback");
128         return Common::NapiGetNull(env);
129     } else {
130         return promise;
131     }
132 }
133 
NapiEnableDistributed(napi_env env,napi_callback_info info)134 napi_value NapiEnableDistributed(napi_env env, napi_callback_info info)
135 {
136     ANS_LOGD("called");
137 
138     EnabledParams params {};
139     if (ParseParameters(env, info, params) == nullptr) {
140         ANS_LOGD("null ParseParameters");
141         Common::NapiThrow(env, ERROR_PARAM_INVALID);
142         return Common::NapiGetUndefined(env);
143     }
144 
145     AsyncCallbackInfoEnabled *asynccallbackinfo =
146         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
147     if (!asynccallbackinfo) {
148         ANS_LOGD("Create asyncCallbackinfo fail.");
149         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
150         return Common::JSParaError(env, params.callback);
151     }
152     napi_value promise = nullptr;
153     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
154 
155     napi_value resourceName = nullptr;
156     napi_create_string_latin1(env, "enableDistributed", NAPI_AUTO_LENGTH, &resourceName);
157     // Async function call
158     napi_create_async_work(
159         env,
160         nullptr,
161         resourceName,
162         [](napi_env env, void *data) {
163             ANS_LOGD("NapiEnableDistributed work excute.");
164             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
165 
166             if (asynccallbackinfo) {
167                 asynccallbackinfo->info.errorCode =
168                     NotificationHelper::EnableDistributed(asynccallbackinfo->params.enable);
169             }
170         },
171         [](napi_env env, napi_status status, void *data) {
172             ANS_LOGD("NapiEnableDistributed work complete.");
173             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
174             if (asynccallbackinfo) {
175                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
176                 if (asynccallbackinfo->info.callback != nullptr) {
177                     ANS_LOGD("Delete napiEnableDistributed callback reference.");
178                     napi_delete_reference(env, asynccallbackinfo->info.callback);
179                 }
180                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
181                 delete asynccallbackinfo;
182                 asynccallbackinfo = nullptr;
183             }
184             ANS_LOGD("NapiEnableDistributed work complete end.");
185         },
186         (void *)asynccallbackinfo,
187         &asynccallbackinfo->asyncWork);
188 
189     bool isCallback = asynccallbackinfo->info.isCallback;
190     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
191 
192     if (isCallback) {
193         ANS_LOGD("null isCallback");
194         return Common::NapiGetNull(env);
195     } else {
196         return promise;
197     }
198 }
199 
NapiSetDistributedEnabled(napi_env env,napi_callback_info info)200 napi_value NapiSetDistributedEnabled(napi_env env, napi_callback_info info)
201 {
202     ANS_LOGD("called");
203     EnabledParams params{};
204     if (ParseSetDistributedEnabledParams(env, info, params) == nullptr) {
205         ANS_LOGD("null ParseSetDistributedEnabledParams");
206         Common::NapiThrow(env, ERROR_PARAM_INVALID);
207         return Common::NapiGetUndefined(env);
208     }
209     AsyncCallbackInfoEnabled *asynccallbackinfo =
210         new (std::nothrow) AsyncCallbackInfoEnabled{ .env = env, .asyncWork = nullptr, .params = params };
211     if (!asynccallbackinfo) {
212         ANS_LOGD("Create asyncCallbackinfo fail.");
213         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
214         return Common::JSParaError(env, nullptr);
215     }
216     napi_value promise = nullptr;
217     Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
218     napi_value resourceName = nullptr;
219     napi_create_string_latin1(env, "setDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
220     // Async function call
221     napi_create_async_work(
222         env, nullptr, resourceName,
223         [](napi_env env, void *data) {
224             ANS_LOGD("NapiSetDistributedEnabled work excute.");
225             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
226             if (asynccallbackinfo) {
227                 asynccallbackinfo->info.errorCode = NotificationHelper::SetDistributedEnabled(
228                     asynccallbackinfo->params.deviceType, asynccallbackinfo->params.enable);
229                 ANS_LOGD("errorCode = %{public}d", asynccallbackinfo->info.errorCode);
230             }
231         },
232         [](napi_env env, napi_status status, void *data) {
233             ANS_LOGD("NapiSetDistributedEnabled work complete.");
234             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
235             if (asynccallbackinfo) {
236                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
237                 if (asynccallbackinfo->info.callback != nullptr) {
238                     ANS_LOGD("Delete napiSetDistributedEnabled callback reference.");
239                     napi_delete_reference(env, asynccallbackinfo->info.callback);
240                 }
241                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
242                 delete asynccallbackinfo;
243                 asynccallbackinfo = nullptr;
244             }
245             ANS_LOGD("NapiSetDistributedEnabled work complete end.");
246         },
247         (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
248     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
249     return promise;
250 }
251 
NapiEnableDistributedByBundle(napi_env env,napi_callback_info info)252 napi_value NapiEnableDistributedByBundle(napi_env env, napi_callback_info info)
253 {
254     ANS_LOGD("called");
255 
256     EnabledByBundleParams params {};
257     if (ParseParameters(env, info, params) == nullptr) {
258         Common::NapiThrow(env, ERROR_PARAM_INVALID);
259         return Common::NapiGetUndefined(env);
260     }
261 
262     AsyncCallbackInfoEnabledByBundle *asynccallbackinfo =
263         new (std::nothrow) AsyncCallbackInfoEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
264     if (!asynccallbackinfo) {
265         return Common::JSParaError(env, params.callback);
266     }
267     napi_value promise = nullptr;
268     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
269 
270     napi_value resourceName = nullptr;
271     napi_create_string_latin1(env, "enableDistributedByBundle", NAPI_AUTO_LENGTH, &resourceName);
272     // Asynchronous function call
273     napi_create_async_work(
274         env,
275         nullptr,
276         resourceName,
277         [](napi_env env, void *data) {
278             ANS_LOGD("NapiEnableDistributedByBundle work excute.");
279             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
280             if (asynccallbackinfo) {
281                 asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
282                     asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
283             }
284         },
285         [](napi_env env, napi_status status, void *data) {
286             ANS_LOGD("NapiEnableDistributedByBundle work complete.");
287             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
288             if (asynccallbackinfo) {
289                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
290                 if (asynccallbackinfo->info.callback != nullptr) {
291                     ANS_LOGD("Delete napiEnableDistributedByBundle callback reference.");
292                     napi_delete_reference(env, asynccallbackinfo->info.callback);
293                 }
294                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
295                 delete asynccallbackinfo;
296                 asynccallbackinfo = nullptr;
297             }
298             ANS_LOGD("NapiEnableDistributedByBundle work complete end.");
299         },
300         (void *)asynccallbackinfo,
301         &asynccallbackinfo->asyncWork);
302 
303     bool isCallback = asynccallbackinfo->info.isCallback;
304     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
305 
306     if (isCallback) {
307         ANS_LOGD("null isCallback");
308         return Common::NapiGetNull(env);
309     } else {
310         return promise;
311     }
312 }
313 
NapiEnableDistributedSelf(napi_env env,napi_callback_info info)314 napi_value NapiEnableDistributedSelf(napi_env env, napi_callback_info info)
315 {
316     ANS_LOGD("called");
317 
318     EnabledParams params {};
319     if (ParseParameters(env, info, params) == nullptr) {
320         Common::NapiThrow(env, ERROR_PARAM_INVALID);
321         return Common::NapiGetUndefined(env);
322     }
323 
324     AsyncCallbackInfoEnabled *asynccallbackinfo =
325         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
326     if (!asynccallbackinfo) {
327         ANS_LOGD("Fail to create asyncCallbackinfo.");
328         return Common::JSParaError(env, params.callback);
329     }
330     napi_value promise = nullptr;
331     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
332 
333     napi_value resourceName = nullptr;
334     napi_create_string_latin1(env, "enableDistributedSelf", NAPI_AUTO_LENGTH, &resourceName);
335     // Asynchronous function call
336     napi_create_async_work(
337         env,
338         nullptr,
339         resourceName,
340         [](napi_env env, void *data) {
341             ANS_LOGD("NapiEnableDistributedSelf work excute.");
342             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
343             if (asynccallbackinfo) {
344                 asynccallbackinfo->info.errorCode =
345                     NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
346                 ANS_LOGI("enable = %{public}d", asynccallbackinfo->params.enable);
347             }
348         },
349         [](napi_env env, napi_status status, void *data) {
350             ANS_LOGD("NapiEnableDistributedSelf work complete.");
351             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
352             if (asynccallbackinfo) {
353                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
354                 if (asynccallbackinfo->info.callback != nullptr) {
355                     ANS_LOGD("Delete napiEnableDistributedSelf callback reference.");
356                     napi_delete_reference(env, asynccallbackinfo->info.callback);
357                 }
358                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
359                 delete asynccallbackinfo;
360                 asynccallbackinfo = nullptr;
361             }
362             ANS_LOGD("NapiEnableDistributedSelf work complete end.");
363         },
364         (void *)asynccallbackinfo,
365         &asynccallbackinfo->asyncWork);
366 
367     bool isCallback = asynccallbackinfo->info.isCallback;
368     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
369 
370     if (isCallback) {
371         ANS_LOGD("null isCallback");
372         return Common::NapiGetNull(env);
373     } else {
374         return promise;
375     }
376 }
377 
AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env,napi_status status,void * data)378 void AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env, napi_status status, void *data)
379 {
380     ANS_LOGD("called");
381     if (!data) {
382         ANS_LOGE("Invalid async callback data");
383         return;
384     }
385     ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
386     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
387     if (asynccallbackinfo) {
388         napi_value result = nullptr;
389         if (asynccallbackinfo->info.errorCode != ERR_OK) {
390             result = Common::NapiGetNull(env);
391         } else {
392             napi_get_boolean(env, asynccallbackinfo->enable, &result);
393         }
394         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
395         if (asynccallbackinfo->info.callback != nullptr) {
396             ANS_LOGD("Delete napiIsDistributedEnableByBundle callback reference.");
397             napi_delete_reference(env, asynccallbackinfo->info.callback);
398         }
399         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
400         delete asynccallbackinfo;
401         asynccallbackinfo = nullptr;
402     }
403 }
404 
NapiIsDistributedEnableByBundle(napi_env env,napi_callback_info info)405 napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info)
406 {
407     ANS_LOGD("called");
408 
409     IsEnabledByBundleParams params {};
410     if (ParseParameters(env, info, params) == nullptr) {
411         Common::NapiThrow(env, ERROR_PARAM_INVALID);
412         return Common::NapiGetUndefined(env);
413     }
414 
415     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo =
416         new (std::nothrow) AsyncCallbackInfoIsEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
417     if (!asynccallbackinfo) {
418         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
419         return Common::JSParaError(env, params.callback);
420     }
421     napi_value promise = nullptr;
422     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
423 
424     napi_value resourceName = nullptr;
425     napi_create_string_latin1(env, "isDistributedEnableByBundle", NAPI_AUTO_LENGTH, &resourceName);
426     // Asynchronous function call
427     napi_create_async_work(
428         env,
429         nullptr,
430         resourceName,
431         [](napi_env env, void *data) {
432             ANS_LOGD("NapiIsDistributedEnableByBundle work excute.");
433             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
434             if (asynccallbackinfo) {
435                 if (asynccallbackinfo->params.hasDeviceType) {
436                     std::string deviceType = asynccallbackinfo->params.deviceType;
437                     asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnabledByBundle(
438                         asynccallbackinfo->params.option, deviceType, asynccallbackinfo->enable);
439                     ANS_LOGI("has deviceType errorCode = %{public}d", asynccallbackinfo->info.errorCode);
440                 } else {
441                     asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
442                         asynccallbackinfo->params.option, asynccallbackinfo->enable);
443                 }
444             }
445         },
446         AsyncCompleteCallbackNapiIsDistributedEnableByBundle,
447         (void *)asynccallbackinfo,
448         &asynccallbackinfo->asyncWork);
449 
450     bool isCallback = asynccallbackinfo->info.isCallback;
451     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
452 
453     if (isCallback) {
454         ANS_LOGD("null isCallback");
455         return Common::NapiGetNull(env);
456     } else {
457         return promise;
458     }
459 }
460 
AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env,napi_status status,void * data)461 void AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env, napi_status status, void *data)
462 {
463     ANS_LOGD("called");
464     if (!data) {
465         ANS_LOGE("Invalid async callback data");
466         return;
467     }
468     ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
469     AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
470     if (asynccallbackinfo) {
471         napi_value result = nullptr;
472         if (asynccallbackinfo->info.errorCode != ERR_OK) {
473             result = Common::NapiGetNull(env);
474         } else {
475             DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
476             if (!AnsEnumUtil::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
477                 asynccallbackinfo->info.errorCode = ERROR;
478                 result = Common::NapiGetNull(env);
479             }
480             napi_create_int32(env, (int32_t)outType, &result);
481         }
482         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
483         if (asynccallbackinfo->info.callback != nullptr) {
484             ANS_LOGD("Delete napiGetDeviceRemindType 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 
NapiGetDeviceRemindType(napi_env env,napi_callback_info info)493 napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
494 {
495     ANS_LOGD("called");
496 
497     napi_ref callback = nullptr;
498     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
499         Common::NapiThrow(env, ERROR_PARAM_INVALID);
500         return Common::NapiGetUndefined(env);
501     }
502 
503     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetRemindType {.env = env, .asyncWork = nullptr};
504     if (!asynccallbackinfo) {
505         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
506         return Common::JSParaError(env, callback);
507     }
508     napi_value promise = nullptr;
509     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
510 
511     napi_value resourceName = nullptr;
512     napi_create_string_latin1(env, "getDeviceRemindType", NAPI_AUTO_LENGTH, &resourceName);
513     // Asynchronous function call
514     napi_create_async_work(
515         env,
516         nullptr,
517         resourceName,
518         [](napi_env env, void *data) {
519             ANS_LOGD("NapiGetDeviceRemindType work excute.");
520             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
521             if (asynccallbackinfo) {
522                 asynccallbackinfo->info.errorCode =
523                     NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
524             }
525         },
526         AsyncCompleteCallbackNapiGetDeviceRemindType,
527         (void *)asynccallbackinfo,
528         &asynccallbackinfo->asyncWork);
529 
530     bool isCallback = asynccallbackinfo->info.isCallback;
531     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
532 
533     if (isCallback) {
534         ANS_LOGD("null isCallback");
535         return Common::NapiGetNull(env);
536     } else {
537         return promise;
538     }
539 }
540 
NapiSetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)541 napi_value NapiSetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
542 {
543     ANS_LOGD("called");
544 
545     EnabledWithoutAppParams params {};
546     if (ParseParameters(env, info, params) == nullptr) {
547         Common::NapiThrow(env, ERROR_PARAM_INVALID);
548         return Common::JSParaError(env, params.callback);
549     }
550 
551     AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
552         new (std::nothrow) AsyncCallbackInfoEnabledWithoutApp {.env = env, .asyncWork = nullptr, .params = params};
553     if (!asynccallbackinfo) {
554         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
555         return Common::JSParaError(env, params.callback);
556     }
557     napi_value promise = nullptr;
558     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
559 
560     napi_value resourceName = nullptr;
561     napi_create_string_latin1(env, "SetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
562     // Asynchronous function call
563     napi_create_async_work(
564         env,
565         nullptr,
566         resourceName,
567         [](napi_env env, void *data) {
568             ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work excute.");
569             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
570                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
571             if (asynccallbackinfo) {
572                 asynccallbackinfo->info.errorCode = NotificationHelper::SetSyncNotificationEnabledWithoutApp(
573                     asynccallbackinfo->params.userId, asynccallbackinfo->params.enable);
574             }
575         },
576         [](napi_env env, napi_status status, void *data) {
577             ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work complete.");
578             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
579                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
580             if (asynccallbackinfo) {
581                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
582                 if (asynccallbackinfo->info.callback != nullptr) {
583                     ANS_LOGD("Delete napiSetSyncNotificationEnabledWithoutApp callback reference.");
584                     napi_delete_reference(env, asynccallbackinfo->info.callback);
585                 }
586                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
587                 delete asynccallbackinfo;
588                 asynccallbackinfo = nullptr;
589             }
590             ANS_LOGD("NapiSetSyncNotificationEnabledWithoutApp work complete end.");
591         },
592         (void *)asynccallbackinfo,
593         &asynccallbackinfo->asyncWork);
594 
595     bool isCallback = asynccallbackinfo->info.isCallback;
596     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
597 
598     if (isCallback) {
599         ANS_LOGD("null isCallback");
600         return Common::NapiGetNull(env);
601     } else {
602         return promise;
603     }
604 }
605 
NapiGetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)606 napi_value NapiGetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
607 {
608     ANS_LOGD("called");
609 
610     GetEnabledWithoutAppParams params {};
611     if (ParseParameters(env, info, params) == nullptr) {
612         Common::NapiThrow(env, ERROR_PARAM_INVALID);
613         return Common::JSParaError(env, params.callback);
614     }
615 
616     AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
617         new (std::nothrow) AsyncCallbackInfoGetEnabledWithoutApp {
618         .env = env, .asyncWork = nullptr, .params = params};
619     if (!asynccallbackinfo) {
620         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
621         return Common::JSParaError(env, params.callback);
622     }
623     napi_value promise = nullptr;
624     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
625 
626     napi_value resourceName = nullptr;
627     napi_create_string_latin1(env, "GetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
628     // Asynchronous function call
629     napi_create_async_work(
630         env,
631         nullptr,
632         resourceName,
633         [](napi_env env, void *data) {
634             ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work excute.");
635             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
636                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
637             if (asynccallbackinfo) {
638                 asynccallbackinfo->info.errorCode = NotificationHelper::GetSyncNotificationEnabledWithoutApp(
639                     asynccallbackinfo->params.userId, asynccallbackinfo->enable);
640             }
641         },
642         [](napi_env env, napi_status status, void *data) {
643             ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work complete.");
644             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
645                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
646             if (asynccallbackinfo) {
647                 napi_value result = nullptr;
648                 if (asynccallbackinfo->info.errorCode != ERR_OK) {
649                     result = Common::NapiGetNull(env);
650                 } else {
651                     napi_get_boolean(env, asynccallbackinfo->enable, &result);
652                 }
653                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
654                 if (asynccallbackinfo->info.callback != nullptr) {
655                     ANS_LOGD("Delete napiGetSyncNotificationEnabledWithoutApp callback reference.");
656                     napi_delete_reference(env, asynccallbackinfo->info.callback);
657                 }
658                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
659                 delete asynccallbackinfo;
660                 asynccallbackinfo = nullptr;
661             }
662             ANS_LOGD("NapiGetSyncNotificationEnabledWithoutApp work complete end.");
663         },
664         (void *)asynccallbackinfo,
665         &asynccallbackinfo->asyncWork);
666 
667     bool isCallback = asynccallbackinfo->info.isCallback;
668     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
669 
670     if (isCallback) {
671         ANS_LOGD("null isCallback");
672         return Common::NapiGetNull(env);
673     } else {
674         return promise;
675     }
676 }
677 
NapiSetTargetDeviceStatus(napi_env env,napi_callback_info info)678 napi_value NapiSetTargetDeviceStatus(napi_env env, napi_callback_info info)
679 {
680     ANS_LOGD("called");
681     DeviceStatus paras;
682     if (ParseParameters(env, info, paras) == nullptr) {
683         Common::NapiThrow(env, ERROR_PARAM_INVALID);
684         return Common::NapiGetUndefined(env);
685     }
686 
687     AsynDeviceStatusConfig *asynccallbackinfo = new (std::nothrow) AsynDeviceStatusConfig {
688         .env = env, .asyncWork = nullptr, .deviceStatus = paras
689     };
690     if (!asynccallbackinfo) {
691         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
692         return Common::JSParaError(env, paras.callback);
693     }
694     napi_value promise = nullptr;
695     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
696 
697     napi_value resourceName = nullptr;
698     napi_create_string_latin1(env, "setTargetDeviceStatus", NAPI_AUTO_LENGTH, &resourceName);
699     napi_create_async_work(env,
700         nullptr,
701         resourceName,
702         [](napi_env env, void *data) {
703             ANS_LOGI("NapiSetTargetDeviceStatus work excute.");
704             AsynDeviceStatusConfig *asynccallbackinfo = static_cast<AsynDeviceStatusConfig *>(data);
705             if (asynccallbackinfo) {
706                 asynccallbackinfo->info.errorCode = NotificationHelper::SetTargetDeviceStatus(
707                     asynccallbackinfo->deviceStatus.deviceType, asynccallbackinfo->deviceStatus.status,
708                     DISTURB_DEFAULT_FLAG);
709             }
710         },
711         [](napi_env env, napi_status status, void *data) {
712             ANS_LOGD("Napi add do not disturb profiles work complete.");
713             AsynDeviceStatusConfig *asynccallbackinfo = static_cast<AsynDeviceStatusConfig *>(data);
714             if (asynccallbackinfo) {
715                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
716                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
717                 delete asynccallbackinfo;
718                 asynccallbackinfo = nullptr;
719             }
720         }, (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
721 
722     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
723 
724     if (asynccallbackinfo->info.isCallback) {
725         ANS_LOGD("null isCallback");
726         return Common::NapiGetNull(env);
727     } else {
728         return promise;
729     }
730 }
731 
AsyncCompleteCallbackNapiGetDistributedDeviceList(napi_env env,napi_status status,void * data)732 void AsyncCompleteCallbackNapiGetDistributedDeviceList(napi_env env, napi_status status, void *data)
733 {
734     ANS_LOGD("called");
735     if (!data) {
736         ANS_LOGE("null data");
737         return;
738     }
739     napi_value result = nullptr;
740     auto asynccallbackinfo = reinterpret_cast<AsynCallbackInfoGetDistributedDeviceList *>(data);
741     if (asynccallbackinfo) {
742         ANS_LOGD("Asynccallbackinfo conversion is success.");
743         if (asynccallbackinfo->info.errorCode != ERR_OK) {
744             result = Common::NapiGetNull(env);
745         } else {
746             napi_value arr = nullptr;
747             napi_create_array(env, &arr);
748             size_t count = 0;
749             for (auto vec : asynccallbackinfo->deviceList) {
750                 napi_value vecValue = nullptr;
751                 ANS_LOGI("deviceType = %{public}s", vec.c_str());
752                 napi_create_string_utf8(env, vec.c_str(), NAPI_AUTO_LENGTH, &vecValue);
753                 napi_set_element(env, arr, count, vecValue);
754                 count++;
755             }
756             result = arr;
757         }
758         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
759         if (asynccallbackinfo->info.callback != nullptr) {
760             ANS_LOGD("Delete napiGetDistributedDeviceList 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 }
768 
NapiGetDistributedDeviceList(napi_env env,napi_callback_info info)769 napi_value NapiGetDistributedDeviceList(napi_env env, napi_callback_info info)
770 {
771     ANS_LOGD("called");
772     AsynCallbackInfoGetDistributedDeviceList *asynccallbackinfo =
773         new (std::nothrow) AsynCallbackInfoGetDistributedDeviceList{ .env = env, .asyncWork = nullptr };
774     if (!asynccallbackinfo) {
775         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
776         return Common::JSParaError(env, nullptr);
777     }
778 
779     napi_value promise = nullptr;
780     Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
781     napi_value resourceName = nullptr;
782     napi_create_string_latin1(env, "getDistributedDeviceList", NAPI_AUTO_LENGTH, &resourceName);
783     // Asynchronous function call
784     napi_create_async_work(
785         env, nullptr, resourceName,
786         [](napi_env env, void *data) {
787             ANS_LOGD("NapiGetDistributedDeviceList work excute.");
788             auto asynccallbackinfo = reinterpret_cast<AsynCallbackInfoGetDistributedDeviceList *>(data);
789             if (asynccallbackinfo) {
790                 asynccallbackinfo->info.errorCode =
791                     NotificationHelper::GetDistributedDevicelist(asynccallbackinfo->deviceList);
792             }
793         },
794         AsyncCompleteCallbackNapiGetDistributedDeviceList, (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
795     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
796     return promise;
797 }
798 }  // namespace NotificationNapi
799 }  // namespace OHOS
800