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 "distributed.h"
17 #include "ans_inner_errors.h"
18 
19 namespace OHOS {
20 namespace NotificationNapi {
21 const int ENABLED_MAX_PARA = 2;
22 const int ENABLED_MIN_PARA = 1;
23 const int ENABLED_BUNDLE_MAX_PARA = 3;
24 const int ENABLED_BUNDLE_MIN_PARA = 2;
25 const int IS_ENABLED_BUNDLE_MAX_PARA = 2;
26 const int IS_ENABLED_BUNDLE_MIN_PARA = 1;
27 const int ENABLED_SYNC_MAX_PARA = 3;
28 const int ENABLED_SYNC_MIN_PARA = 2;
29 
ParseParameters(const napi_env & env,const napi_callback_info & info,EnabledParams & params)30 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, EnabledParams &params)
31 {
32     ANS_LOGD("enter");
33 
34     size_t argc = ENABLED_MAX_PARA;
35     napi_value argv[ENABLED_MAX_PARA] = {nullptr};
36     napi_value thisVar = nullptr;
37     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
38     if (argc < ENABLED_MIN_PARA) {
39         ANS_LOGE("Wrong number of arguments.");
40         Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
41         return nullptr;
42     }
43     napi_valuetype valuetype = napi_undefined;
44 
45     // argv[0]: enable
46     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
47     if (valuetype != napi_boolean) {
48         ANS_LOGE("Wrong argument type. Bool expected.");
49         std::string msg = "Incorrect parameter types.The type of param must be boolean.";
50         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
51         return nullptr;
52     }
53     napi_get_value_bool(env, argv[PARAM0], &params.enable);
54 
55     // argv[1]:callback
56     if (argc >= ENABLED_MAX_PARA) {
57         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
58         if (valuetype != napi_function) {
59             ANS_LOGE("Callback is not function excute promise.");
60             return Common::NapiGetNull(env);
61         }
62         napi_create_reference(env, argv[PARAM1], 1, &params.callback);
63     }
64 
65     return Common::NapiGetNull(env);
66 }
67 
ParseParameters(const napi_env & env,const napi_callback_info & info,EnabledByBundleParams & params)68 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, EnabledByBundleParams &params)
69 {
70     ANS_LOGD("enter");
71 
72     size_t argc = ENABLED_BUNDLE_MAX_PARA;
73     napi_value argv[ENABLED_BUNDLE_MAX_PARA] = {nullptr};
74     napi_value thisVar = nullptr;
75     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
76     if (argc < ENABLED_BUNDLE_MIN_PARA) {
77         ANS_LOGE("Wrong number of arguments");
78         Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
79         return nullptr;
80     }
81 
82     // argv[0]: bundle
83     napi_valuetype valuetype = napi_undefined;
84     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
85     if (valuetype != napi_object) {
86         ANS_LOGE("Wrong argument type. Object expected");
87         std::string msg = "Incorrect parameter types.The type of param must be object.";
88         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
89         return nullptr;
90     }
91     auto retValue = Common::GetBundleOption(env, argv[PARAM0], params.option);
92     if (retValue == nullptr) {
93         ANS_LOGE("GetBundleOption failed");
94         Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
95         return nullptr;
96     }
97 
98     // argv[1]: enable
99     NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
100     if (valuetype != napi_boolean) {
101         ANS_LOGE("Wrong argument type. Bool expected.");
102         std::string msg = "Incorrect parameter types.The type of param must be boolean.";
103         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
104         return nullptr;
105     }
106     napi_get_value_bool(env, argv[PARAM1], &params.enable);
107 
108     // argv[2]:callback
109     if (argc >= ENABLED_BUNDLE_MAX_PARA) {
110         NAPI_CALL(env, napi_typeof(env, argv[PARAM2], &valuetype));
111         if (valuetype != napi_function) {
112             ANS_LOGE("Callback is not function excute promise.");
113             return Common::NapiGetNull(env);
114         }
115         napi_create_reference(env, argv[PARAM2], 1, &params.callback);
116     }
117 
118     return Common::NapiGetNull(env);
119 }
120 
ParseParameters(const napi_env & env,const napi_callback_info & info,IsEnabledByBundleParams & params)121 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, IsEnabledByBundleParams &params)
122 {
123     ANS_LOGD("enter");
124 
125     size_t argc = IS_ENABLED_BUNDLE_MAX_PARA;
126     napi_value argv[IS_ENABLED_BUNDLE_MAX_PARA] = {nullptr};
127     napi_value thisVar = nullptr;
128     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
129     if (argc < IS_ENABLED_BUNDLE_MIN_PARA) {
130         ANS_LOGE("Wrong number of arguments.");
131         Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
132         return nullptr;
133     }
134 
135     // argv[0]: bundle
136     napi_valuetype valuetype = napi_undefined;
137     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
138     if (valuetype != napi_object) {
139         ANS_LOGE("Parameter type error. Object expected.");
140         std::string msg = "Incorrect parameter types.The type of param must be object.";
141         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
142         return nullptr;
143     }
144     auto retValue = Common::GetBundleOption(env, argv[PARAM0], params.option);
145     if (retValue == nullptr) {
146         ANS_LOGE("GetBundleOption failed.");
147         Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
148         return nullptr;
149     }
150 
151     // argv[1]:callback or deviceType
152     if (argc >= IS_ENABLED_BUNDLE_MAX_PARA) {
153         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
154         if (valuetype == napi_string) {
155             char str[STR_MAX_SIZE] = {0};
156             size_t strLen = 0;
157             napi_get_value_string_utf8(env, argv[PARAM1], str, STR_MAX_SIZE - 1, &strLen);
158             if (std::strlen(str) == 0) {
159                 ANS_LOGE("Property deviceType is empty");
160                 Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
161                 return nullptr;
162             }
163             params.deviceType = str;
164             params.hasDeviceType = true;
165         } else if (valuetype == napi_function) {
166             napi_create_reference(env, argv[PARAM1], 1, &params.callback);
167         } else {
168             ANS_LOGE("Property is error");
169             Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
170             return nullptr;
171         }
172     }
173 
174     return Common::NapiGetNull(env);
175 }
176 
AsyncCompleteCallbackIsDistributedEnabled(napi_env env,napi_status status,void * data)177 void AsyncCompleteCallbackIsDistributedEnabled(napi_env env, napi_status status, void *data)
178 {
179     ANS_LOGD("enter");
180     if (!data) {
181         ANS_LOGE("Invalid async callback data.");
182         return;
183     }
184     ANS_LOGD("IsDistributedEnabled work complete.");
185     AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
186     if (asynccallbackinfo) {
187         napi_value result = nullptr;
188         if (asynccallbackinfo->info.errorCode != ERR_OK) {
189             result = Common::NapiGetNull(env);
190         } else {
191             napi_get_boolean(env, asynccallbackinfo->enable, &result);
192         }
193         Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
194         if (asynccallbackinfo->info.callback != nullptr) {
195             ANS_LOGD("Delete isDistributedEnabled callback reference.");
196             napi_delete_reference(env, asynccallbackinfo->info.callback);
197         }
198         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
199         delete asynccallbackinfo;
200         asynccallbackinfo = nullptr;
201     }
202 }
203 
IsDistributedEnabled(napi_env env,napi_callback_info info)204 napi_value IsDistributedEnabled(napi_env env, napi_callback_info info)
205 {
206     ANS_LOGD("enter");
207 
208     napi_ref callback = nullptr;
209     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
210         return Common::NapiGetUndefined(env);
211     }
212 
213     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnabled {.env = env, .asyncWork = nullptr};
214     if (!asynccallbackinfo) {
215         ANS_LOGD("Asynccallbackinfo is nullptr.");
216         return Common::JSParaError(env, callback);
217     }
218     napi_value promise = nullptr;
219     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
220 
221     ANS_LOGD("Create isDistributedEnabled string.");
222     napi_value resourceName = nullptr;
223     napi_create_string_latin1(env, "isDistributedEnabled", NAPI_AUTO_LENGTH, &resourceName);
224     // Asynchronous function call
225     napi_create_async_work(
226         env,
227         nullptr,
228         resourceName,
229         [](napi_env env, void *data) {
230             ANS_LOGD("IsDistributedEnabled work excute");
231             AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
232 
233             if (asynccallbackinfo) {
234                 asynccallbackinfo->info.errorCode =
235                     NotificationHelper::IsDistributedEnabled(asynccallbackinfo->enable);
236                 ANS_LOGI("IsDistributedEnabled enable = %{public}d", asynccallbackinfo->enable);
237             }
238         },
239         AsyncCompleteCallbackIsDistributedEnabled,
240         (void *)asynccallbackinfo,
241         &asynccallbackinfo->asyncWork);
242 
243     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
244 
245     if (asynccallbackinfo->info.isCallback) {
246         ANS_LOGD("isDistributedEnabled callback is nullptr.");
247         return Common::NapiGetNull(env);
248     } else {
249         return promise;
250     }
251 }
252 
EnableDistributed(napi_env env,napi_callback_info info)253 napi_value EnableDistributed(napi_env env, napi_callback_info info)
254 {
255     ANS_LOGD("enter");
256 
257     EnabledParams params {};
258     if (ParseParameters(env, info, params) == nullptr) {
259         return Common::NapiGetUndefined(env);
260     }
261 
262     AsyncCallbackInfoEnabled *asynccallbackinfo =
263         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
264     if (!asynccallbackinfo) {
265         ANS_LOGD("AsyncCallbackinfo is nullptr.");
266         return Common::JSParaError(env, params.callback);
267     }
268     napi_value promise = nullptr;
269     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
270 
271     ANS_LOGD("Create enableDistributed string.");
272     napi_value resourceName = nullptr;
273     napi_create_string_latin1(env, "enableDistributed", NAPI_AUTO_LENGTH, &resourceName);
274     // Asynchronous function call
275     napi_create_async_work(
276         env,
277         nullptr,
278         resourceName,
279         [](napi_env env, void *data) {
280             ANS_LOGD("EnableDistributed work excute.");
281             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
282             if (asynccallbackinfo) {
283                 asynccallbackinfo->info.errorCode =
284                     NotificationHelper::EnableDistributed(asynccallbackinfo->params.enable);
285             }
286         },
287         [](napi_env env, napi_status status, void *data) {
288             ANS_LOGD("EnableDistributed work complete.");
289             AsyncCallbackInfoEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabled *>(data);
290             if (asynccallbackinfo) {
291                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
292                 if (asynccallbackinfo->info.callback != nullptr) {
293                     ANS_LOGD("Delete enableDistributed callback reference.");
294                     napi_delete_reference(env, asynccallbackinfo->info.callback);
295                 }
296                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
297                 delete asynccallbackinfo;
298                 asynccallbackinfo = nullptr;
299             }
300             ANS_LOGD("EnableDistributed work complete end.");
301         },
302         (void *)asynccallbackinfo,
303         &asynccallbackinfo->asyncWork);
304 
305     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
306 
307     if (asynccallbackinfo->info.isCallback) {
308         ANS_LOGD("enableDistributed callback is nullptr.");
309         return Common::NapiGetNull(env);
310     } else {
311         return promise;
312     }
313 }
314 
EnableDistributedByBundle(napi_env env,napi_callback_info info)315 napi_value EnableDistributedByBundle(napi_env env, napi_callback_info info)
316 {
317     ANS_LOGD("enter");
318 
319     EnabledByBundleParams params {};
320     if (ParseParameters(env, info, params) == nullptr) {
321         return Common::NapiGetUndefined(env);
322     }
323 
324     AsyncCallbackInfoEnabledByBundle *asynccallbackinfo =
325         new (std::nothrow) AsyncCallbackInfoEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
326     if (!asynccallbackinfo) {
327         ANS_LOGD("AsyncCallbackinfo is nullptr.");
328         return Common::JSParaError(env, params.callback);
329     }
330     napi_value promise = nullptr;
331     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
332 
333     ANS_LOGD("Create enableDistributedByBundle string.");
334     napi_value resourceName = nullptr;
335     napi_create_string_latin1(env, "enableDistributedByBundle", NAPI_AUTO_LENGTH, &resourceName);
336     // Async function call
337     napi_create_async_work(
338         env,
339         nullptr,
340         resourceName,
341         [](napi_env env, void *data) {
342             ANS_LOGD("EnableDistributedByBundle work excute.");
343             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
344             if (asynccallbackinfo) {
345                 asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
346                     asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
347             }
348         },
349         [](napi_env env, napi_status status, void *data) {
350             ANS_LOGD("EnableDistributedByBundle work complete.");
351             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
352             if (asynccallbackinfo) {
353                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
354                 if (asynccallbackinfo->info.callback != nullptr) {
355                     ANS_LOGD("Delete enableDistributedByBundle 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("EnableDistributedByBundle work complete end.");
363         },
364         (void *)asynccallbackinfo,
365         &asynccallbackinfo->asyncWork);
366 
367     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
368 
369     if (asynccallbackinfo->info.isCallback) {
370         ANS_LOGD("enableDistributedByBundle callback is nullptr.");
371         return Common::NapiGetNull(env);
372     } else {
373         return promise;
374     }
375 }
376 
EnableDistributedSelf(napi_env env,napi_callback_info info)377 napi_value EnableDistributedSelf(napi_env env, napi_callback_info info)
378 {
379     ANS_LOGD("enter");
380 
381     EnabledParams params {};
382     if (ParseParameters(env, info, params) == nullptr) {
383         return Common::NapiGetUndefined(env);
384     }
385 
386     AsyncCallbackInfoEnabled *asynccallbackinfo =
387         new (std::nothrow) AsyncCallbackInfoEnabled {.env = env, .asyncWork = nullptr, .params = params};
388     if (!asynccallbackinfo) {
389         return Common::JSParaError(env, params.callback);
390     }
391     napi_value promise = nullptr;
392     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
393 
394     ANS_LOGI("Create enableDistributedSelf string.");
395     napi_value resourceName = nullptr;
396     napi_create_string_latin1(env, "enableDistributedSelf", NAPI_AUTO_LENGTH, &resourceName);
397     // Asynchronous function call
398     napi_create_async_work(
399         env,
400         nullptr,
401         resourceName,
402         [](napi_env env, void *data) {
403             ANS_LOGD("EnableDistributedSelf work excute.");
404             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
405             if (asynccallbackinfo) {
406                 asynccallbackinfo->info.errorCode =
407                     NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
408                 ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
409             }
410         },
411         [](napi_env env, napi_status status, void *data) {
412             ANS_LOGD("EnableDistributedSelf work complete.");
413             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
414             if (asynccallbackinfo) {
415                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
416                 if (asynccallbackinfo->info.callback != nullptr) {
417                     ANS_LOGD("Delete enableDistributedSelf callback reference");
418                     napi_delete_reference(env, asynccallbackinfo->info.callback);
419                 }
420                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
421                 delete asynccallbackinfo;
422                 asynccallbackinfo = nullptr;
423             }
424             ANS_LOGD("EnableDistributedSelf work complete end.");
425         },
426         (void *)asynccallbackinfo,
427         &asynccallbackinfo->asyncWork);
428 
429     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
430 
431     if (asynccallbackinfo->info.isCallback) {
432         ANS_LOGD("enableDistributedSelf callback is nullptr.");
433         return Common::NapiGetNull(env);
434     } else {
435         return promise;
436     }
437 }
438 
AsyncCompleteCallbackIsDistributedEnableByBundle(napi_env env,napi_status status,void * data)439 void AsyncCompleteCallbackIsDistributedEnableByBundle(napi_env env, napi_status status, void *data)
440 {
441     ANS_LOGD("enter");
442     if (!data) {
443         ANS_LOGE("Invalid async callback data");
444         return;
445     }
446     ANS_LOGD("IsDistributedEnableByBundle work complete.");
447     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
448     if (asynccallbackinfo) {
449         napi_value result = nullptr;
450         if (asynccallbackinfo->info.errorCode != ERR_OK) {
451             result = Common::NapiGetNull(env);
452         } else {
453             napi_get_boolean(env, asynccallbackinfo->enable, &result);
454         }
455         Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
456         if (asynccallbackinfo->info.callback != nullptr) {
457             ANS_LOGD("Delete isDistributedEnableByBundle callback reference");
458             napi_delete_reference(env, asynccallbackinfo->info.callback);
459         }
460         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
461         delete asynccallbackinfo;
462         asynccallbackinfo = nullptr;
463     }
464 }
465 
IsDistributedEnableByBundle(napi_env env,napi_callback_info info)466 napi_value IsDistributedEnableByBundle(napi_env env, napi_callback_info info)
467 {
468     ANS_LOGD("enter");
469 
470     IsEnabledByBundleParams params {};
471     if (ParseParameters(env, info, params) == nullptr) {
472         return Common::NapiGetUndefined(env);
473     }
474 
475     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo =
476         new (std::nothrow) AsyncCallbackInfoIsEnabledByBundle {.env = env, .asyncWork = nullptr, .params = params};
477     if (!asynccallbackinfo) {
478         ANS_LOGD("Asynccallbackinfo is nullptr.");
479         return Common::JSParaError(env, params.callback);
480     }
481     napi_value promise = nullptr;
482     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
483 
484     ANS_LOGD("Create isDistributedEnableByBundle string.");
485     napi_value resourceName = nullptr;
486     napi_create_string_latin1(env, "isDistributedEnableByBundle", NAPI_AUTO_LENGTH, &resourceName);
487     // Asynchronous function call
488     napi_create_async_work(
489         env,
490         nullptr,
491         resourceName,
492         [](napi_env env, void *data) {
493             ANS_LOGD("IsDistributedEnableByBundle work excute.");
494             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
495             if (asynccallbackinfo) {
496                 asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
497                     asynccallbackinfo->params.option, asynccallbackinfo->enable);
498             }
499         },
500         AsyncCompleteCallbackIsDistributedEnableByBundle,
501         (void *)asynccallbackinfo,
502         &asynccallbackinfo->asyncWork);
503 
504     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
505 
506     if (asynccallbackinfo->info.isCallback) {
507         ANS_LOGD("isDistributedEnableByBundle callback is nullptr.");
508         return Common::NapiGetNull(env);
509     } else {
510         return promise;
511     }
512 }
513 
AsyncCompleteCallbackGetDeviceRemindType(napi_env env,napi_status status,void * data)514 void AsyncCompleteCallbackGetDeviceRemindType(napi_env env, napi_status status, void *data)
515 {
516     ANS_LOGD("enter");
517     if (!data) {
518         ANS_LOGE("Invalidity async callback data");
519         return;
520     }
521     ANS_LOGD("GetDeviceRemindType work complete.");
522     AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
523     if (asynccallbackinfo) {
524         napi_value result = nullptr;
525         if (asynccallbackinfo->info.errorCode != ERR_OK) {
526             ANS_LOGD("errorCode is not ERR_OK.");
527             result = Common::NapiGetNull(env);
528         } else {
529             DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
530             if (!AnsEnumUtil::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
531                 asynccallbackinfo->info.errorCode = ERROR;
532                 result = Common::NapiGetNull(env);
533             }
534             napi_create_int32(env, (int32_t)outType, &result);
535         }
536         Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
537         if (asynccallbackinfo->info.callback != nullptr) {
538             ANS_LOGD("Delete getDeviceRemindType callback reference.");
539             napi_delete_reference(env, asynccallbackinfo->info.callback);
540         }
541         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
542         delete asynccallbackinfo;
543         asynccallbackinfo = nullptr;
544     }
545 }
546 
GetDeviceRemindType(napi_env env,napi_callback_info info)547 napi_value GetDeviceRemindType(napi_env env, napi_callback_info info)
548 {
549     ANS_LOGD("enter");
550 
551     napi_ref callback = nullptr;
552     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
553         return Common::NapiGetUndefined(env);
554     }
555 
556     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoGetRemindType {.env = env, .asyncWork = nullptr};
557     if (!asynccallbackinfo) {
558         ANS_LOGD("Create asynccallbackinfo fail.");
559         return Common::JSParaError(env, callback);
560     }
561     napi_value promise = nullptr;
562     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
563 
564     ANS_LOGD("Create getDeviceRemindType string.");
565     napi_value resourceName = nullptr;
566     napi_create_string_latin1(env, "getDeviceRemindType", NAPI_AUTO_LENGTH, &resourceName);
567     // Asynchronous function call
568     napi_create_async_work(
569         env,
570         nullptr,
571         resourceName,
572         [](napi_env env, void *data) {
573             ANS_LOGD("GetDeviceRemindType work excute.");
574             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
575             if (asynccallbackinfo) {
576                 asynccallbackinfo->info.errorCode =
577                     NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
578             }
579         },
580         AsyncCompleteCallbackGetDeviceRemindType,
581         (void *)asynccallbackinfo,
582         &asynccallbackinfo->asyncWork);
583 
584     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
585 
586     if (asynccallbackinfo->info.isCallback) {
587         ANS_LOGD("getDeviceRemindType callback is nullptr.");
588         return Common::NapiGetNull(env);
589     } else {
590         return promise;
591     }
592 }
593 
ParseParameters(const napi_env & env,const napi_callback_info & info,EnabledWithoutAppParams & params)594 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, EnabledWithoutAppParams &params)
595 {
596     ANS_LOGD("enter");
597 
598     size_t argc = ENABLED_SYNC_MAX_PARA;
599     napi_value argv[ENABLED_SYNC_MAX_PARA] = {nullptr};
600     napi_value thisVar = nullptr;
601     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, nullptr));
602     if (argc < ENABLED_SYNC_MIN_PARA) {
603         ANS_LOGE("Wrong number of arguments.");
604         Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
605         return nullptr;
606     }
607 
608     // argv[0]: userId
609     napi_valuetype valuetype = napi_undefined;
610     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
611     if (valuetype != napi_number) {
612         ANS_LOGE("Argument type error. Number expected.");
613         std::string msg = "Incorrect parameter types.The type of param must be number.";
614         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
615         return nullptr;
616     }
617     NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &params.userId));
618     if (params.userId <= SUBSCRIBE_USER_INIT) {
619         ANS_LOGE("Wrong userId[%{public}d].", params.userId);
620         Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
621         return nullptr;
622     }
623 
624     // argv[1]: enable
625     NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
626     if (valuetype != napi_boolean) {
627         ANS_LOGE("Wrong argument type. Bool expected.");
628         std::string msg = "Incorrect parameter types.The type of param must be boolean.";
629         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
630         return nullptr;
631     }
632     napi_get_value_bool(env, argv[PARAM1], &params.enable);
633 
634     // argv[2]:callback
635     if (argc >= ENABLED_SYNC_MAX_PARA) {
636         NAPI_CALL(env, napi_typeof(env, argv[PARAM2], &valuetype));
637         if (valuetype != napi_function) {
638             ANS_LOGE("Callback is not function excute promise.");
639             return Common::NapiGetNull(env);
640         }
641         napi_create_reference(env, argv[PARAM2], 1, &params.callback);
642     }
643 
644     return Common::NapiGetNull(env);
645 }
646 
SetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)647 napi_value SetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
648 {
649     ANS_LOGD("enter");
650 
651     EnabledWithoutAppParams params {};
652     if (ParseParameters(env, info, params) == nullptr) {
653         return Common::JSParaError(env, params.callback);
654     }
655 
656     AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
657         new (std::nothrow) AsyncCallbackInfoEnabledWithoutApp {.env = env, .asyncWork = nullptr, .params = params};
658     if (!asynccallbackinfo) {
659         ANS_LOGD("Asynccallbackinfo is nullptr.");
660         return Common::JSParaError(env, params.callback);
661     }
662     napi_value promise = nullptr;
663     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
664 
665     ANS_LOGD("Create SetSyncNotificationEnabledWithoutApp string.");
666     napi_value resourceName = nullptr;
667     napi_create_string_latin1(env, "SetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
668     // Asynchronous function call
669     napi_create_async_work(
670         env,
671         nullptr,
672         resourceName,
673         [](napi_env env, void *data) {
674             ANS_LOGD("SetSyncNotificationEnabledWithoutApp work excute.");
675             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
676                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
677             if (asynccallbackinfo) {
678                 asynccallbackinfo->info.errorCode = NotificationHelper::SetSyncNotificationEnabledWithoutApp(
679                     asynccallbackinfo->params.userId, asynccallbackinfo->params.enable);
680             }
681         },
682         [](napi_env env, napi_status status, void *data) {
683             ANS_LOGD("SetSyncNotificationEnabledWithoutApp work complete.");
684             AsyncCallbackInfoEnabledWithoutApp *asynccallbackinfo =
685                 static_cast<AsyncCallbackInfoEnabledWithoutApp *>(data);
686             if (asynccallbackinfo) {
687                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
688                 if (asynccallbackinfo->info.callback != nullptr) {
689                     ANS_LOGD("Delete setSyncNotificationEnabledWithoutApp callback reference.");
690                     napi_delete_reference(env, asynccallbackinfo->info.callback);
691                 }
692                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
693                 delete asynccallbackinfo;
694                 asynccallbackinfo = nullptr;
695             }
696         },
697         (void *)asynccallbackinfo,
698         &asynccallbackinfo->asyncWork);
699 
700     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
701 
702     if (asynccallbackinfo->info.isCallback) {
703         ANS_LOGD("setSyncNotificationEnabledWithoutApp callback is nullptr.");
704         return Common::NapiGetNull(env);
705     }
706     return promise;
707 }
708 
ParseParameters(const napi_env & env,const napi_callback_info & info,GetEnabledWithoutAppParams & params)709 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, GetEnabledWithoutAppParams &params)
710 {
711     ANS_LOGD("enter");
712 
713     size_t argc = ENABLED_SYNC_MIN_PARA;
714     napi_value argv[ENABLED_SYNC_MIN_PARA] = {nullptr};
715     napi_value thisVar = nullptr;
716     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
717     if (argc < ENABLED_SYNC_MIN_PARA - 1) {
718         ANS_LOGE("Wrong number of arguments.");
719         Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
720         return nullptr;
721     }
722 
723     // argv[0]: userId
724     napi_valuetype valuetype = napi_undefined;
725     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
726     if (valuetype != napi_number) {
727         ANS_LOGE("Wrong argument type. Number expected.");
728         std::string msg = "Incorrect parameter types.The type of param must be number.";
729         Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
730         return nullptr;
731     }
732     NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &params.userId));
733     if (params.userId <= SUBSCRIBE_USER_INIT) {
734         ANS_LOGE("Wrong userId[%{public}d].", params.userId);
735         Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
736         return nullptr;
737     }
738 
739     // argv[1]:callback
740     if (argc >= ENABLED_SYNC_MIN_PARA) {
741         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
742         if (valuetype != napi_function) {
743             ANS_LOGE("Callback is not function excute promise.");
744             return Common::NapiGetNull(env);
745         }
746         napi_create_reference(env, argv[PARAM1], 1, &params.callback);
747     }
748 
749     return Common::NapiGetNull(env);
750 }
751 
GetSyncNotificationEnabledWithoutApp(napi_env env,napi_callback_info info)752 napi_value GetSyncNotificationEnabledWithoutApp(napi_env env, napi_callback_info info)
753 {
754     ANS_LOGD("enter");
755 
756     GetEnabledWithoutAppParams params {};
757     if (ParseParameters(env, info, params) == nullptr) {
758         return Common::JSParaError(env, params.callback);
759     }
760 
761     AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
762         new (std::nothrow) AsyncCallbackInfoGetEnabledWithoutApp {
763         .env = env, .asyncWork = nullptr, .params = params};
764     if (!asynccallbackinfo) {
765         ANS_LOGD("Asynccallbackinfo is nullptr.");
766         return Common::JSParaError(env, params.callback);
767     }
768     napi_value promise = nullptr;
769     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
770 
771     ANS_LOGD("Create GetSyncNotificationEnabledWithoutApp string.");
772     napi_value resourceName = nullptr;
773     napi_create_string_latin1(env, "GetSyncNotificationEnabledWithoutApp", NAPI_AUTO_LENGTH, &resourceName);
774     // Asynchronous function call
775     napi_create_async_work(
776         env,
777         nullptr,
778         resourceName,
779         [](napi_env env, void *data) {
780             ANS_LOGD("GetSyncNotificationEnabledWithoutApp work excute.");
781             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
782                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
783             if (asynccallbackinfo) {
784                 asynccallbackinfo->info.errorCode = NotificationHelper::GetSyncNotificationEnabledWithoutApp(
785                     asynccallbackinfo->params.userId, asynccallbackinfo->enable);
786             }
787         },
788         [](napi_env env, napi_status status, void *data) {
789             ANS_LOGD("GetSyncNotificationEnabledWithoutApp work complete.");
790             AsyncCallbackInfoGetEnabledWithoutApp *asynccallbackinfo =
791                 static_cast<AsyncCallbackInfoGetEnabledWithoutApp *>(data);
792             if (asynccallbackinfo) {
793                 napi_value result = nullptr;
794                 if (asynccallbackinfo->info.errorCode != ERR_OK) {
795                     result = Common::NapiGetNull(env);
796                 } else {
797                     napi_get_boolean(env, asynccallbackinfo->enable, &result);
798                 }
799                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
800                 if (asynccallbackinfo->info.callback != nullptr) {
801                     ANS_LOGD("Delete getSyncNotificationEnabledWithoutApp callback reference.");
802                     napi_delete_reference(env, asynccallbackinfo->info.callback);
803                 }
804                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
805                 delete asynccallbackinfo;
806                 asynccallbackinfo = nullptr;
807             }
808         },
809         (void *)asynccallbackinfo,
810         &asynccallbackinfo->asyncWork);
811 
812     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
813 
814     if (asynccallbackinfo->info.isCallback) {
815         ANS_LOGD("GetSyncNotificationEnabledWithoutApp callback is nullptr.");
816         return Common::NapiGetNull(env);
817     }
818     return promise;
819 }
820 }  // namespace NotificationNapi
821 }  // namespace OHOS
822