• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "cancel.h"
17 
18 namespace OHOS {
19 namespace NotificationNapi {
20 constexpr int8_t CANCEL_MAX_PARA = 3;
21 constexpr int8_t CANCEL_GROUP_MAX_PARA = 2;
22 constexpr int8_t CANCEL_GROUP_MIN_PARA = 1;
23 constexpr int8_t CANCEL_AS_BUNDLE_MAX_PARA = 4;
24 
ParseParameters(const napi_env & env,const napi_callback_info & info,ParametersInfoCancel & paras)25 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, ParametersInfoCancel &paras)
26 {
27     ANS_LOGI("enter");
28 
29     size_t argc = CANCEL_MAX_PARA;
30     napi_value argv[CANCEL_MAX_PARA] = {nullptr};
31     napi_value thisVar = nullptr;
32     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
33     if (argc < 1) {
34         ANS_LOGW("Wrong number of arguments");
35         return nullptr;
36     }
37 
38     napi_valuetype valuetype = napi_undefined;
39     // argv[0]: id: number
40     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
41     if (valuetype != napi_number) {
42         ANS_LOGW("Wrong argument type. Number expected.");
43         return nullptr;
44     }
45     NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &paras.id));
46 
47     // argv[1]: label: string / callback
48     if (argc >= CANCEL_MAX_PARA - 1) {
49         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
50         if (valuetype != napi_string && valuetype != napi_function) {
51             ANS_LOGW("Wrong argument type. String or function expected.");
52             return nullptr;
53         }
54         if (valuetype == napi_string) {
55             char str[STR_MAX_SIZE] = {0};
56             size_t strLen = 0;
57             NAPI_CALL(env, napi_get_value_string_utf8(env, argv[PARAM1], str, STR_MAX_SIZE - 1, &strLen));
58             paras.label = str;
59         } else {
60             napi_create_reference(env, argv[PARAM1], 1, &paras.callback);
61         }
62     }
63 
64     // argv[2]: callback
65     if (argc >= CANCEL_MAX_PARA) {
66         NAPI_CALL(env, napi_typeof(env, argv[PARAM2], &valuetype));
67         if (valuetype != napi_function) {
68             ANS_LOGW("Wrong argument type. Function expected.");
69             return nullptr;
70         }
71         napi_create_reference(env, argv[PARAM2], 1, &paras.callback);
72     }
73 
74     return Common::NapiGetNull(env);
75 }
76 
ParseParameters(const napi_env & env,const napi_callback_info & info,ParametersInfoCancelGroup & paras)77 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, ParametersInfoCancelGroup &paras)
78 {
79     ANS_LOGI("enter");
80 
81     size_t argc = CANCEL_GROUP_MAX_PARA;
82     napi_value argv[CANCEL_GROUP_MAX_PARA] = {nullptr};
83     napi_value thisVar = nullptr;
84     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
85     if (argc < CANCEL_GROUP_MIN_PARA) {
86         ANS_LOGW("Wrong number of arguments");
87         return nullptr;
88     }
89 
90     napi_valuetype valuetype = napi_undefined;
91     // argv[0]: groupName: string
92     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
93     if (valuetype != napi_string) {
94         ANS_LOGW("Wrong argument type. String expected.");
95         return nullptr;
96     }
97     char str[STR_MAX_SIZE] = {0};
98     size_t strLen = 0;
99     NAPI_CALL(env, napi_get_value_string_utf8(env, argv[PARAM0], str, STR_MAX_SIZE - 1, &strLen));
100     paras.groupName = str;
101 
102     // argv[1]: callback
103     if (argc >= CANCEL_GROUP_MAX_PARA) {
104         NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
105         if (valuetype != napi_function) {
106             ANS_LOGW("Wrong argument type. Function expected.");
107             return nullptr;
108         }
109         napi_create_reference(env, argv[PARAM1], 1, &paras.callback);
110     }
111 
112     return Common::NapiGetNull(env);
113 }
114 
Cancel(napi_env env,napi_callback_info info)115 napi_value Cancel(napi_env env, napi_callback_info info)
116 {
117     ANS_LOGI("enter");
118 
119     ParametersInfoCancel paras;
120     if (ParseParameters(env, info, paras) == nullptr) {
121         return Common::NapiGetUndefined(env);
122     }
123 
124     AsyncCallbackInfoCancel *asynccallbackinfo = new (std::nothrow)
125         AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr, .id = paras.id, .label = paras.label};
126     if (!asynccallbackinfo) {
127         return Common::JSParaError(env, paras.callback);
128     }
129     napi_value promise = nullptr;
130     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
131 
132     napi_value resourceName = nullptr;
133     napi_create_string_latin1(env, "cancel", NAPI_AUTO_LENGTH, &resourceName);
134     // Asynchronous function call
135     napi_create_async_work(env,
136         nullptr,
137         resourceName,
138         [](napi_env env, void *data) {
139             ANS_LOGI("Cancel napi_create_async_work start");
140             AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
141 
142             if (asynccallbackinfo) {
143                 asynccallbackinfo->info.errorCode =
144                     NotificationHelper::CancelNotification(asynccallbackinfo->label, asynccallbackinfo->id);
145             }
146         },
147         [](napi_env env, napi_status status, void *data) {
148             ANS_LOGI("Cancel napi_create_async_work end");
149             AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
150             if (asynccallbackinfo) {
151                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
152                 if (asynccallbackinfo->info.callback != nullptr) {
153                     napi_delete_reference(env, asynccallbackinfo->info.callback);
154                 }
155                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
156                 delete asynccallbackinfo;
157                 asynccallbackinfo = nullptr;
158             }
159         },
160         (void *)asynccallbackinfo,
161         &asynccallbackinfo->asyncWork);
162 
163     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
164 
165     if (asynccallbackinfo->info.isCallback) {
166         return Common::NapiGetNull(env);
167     } else {
168         return promise;
169     }
170 }
171 
CancelAll(napi_env env,napi_callback_info info)172 napi_value CancelAll(napi_env env, napi_callback_info info)
173 {
174     ANS_LOGI("enter");
175 
176     napi_ref callback = nullptr;
177     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
178         return Common::NapiGetUndefined(env);
179     }
180 
181     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr};
182     if (!asynccallbackinfo) {
183         return Common::JSParaError(env, callback);
184     }
185     napi_value promise = nullptr;
186     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
187 
188     napi_value resourceName = nullptr;
189     napi_create_string_latin1(env, "cancelAll", NAPI_AUTO_LENGTH, &resourceName);
190     // Asynchronous function call
191     napi_create_async_work(env,
192         nullptr,
193         resourceName,
194         [](napi_env env, void *data) {
195             ANS_LOGI("CancelAll napi_create_async_work start");
196             AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
197             if (asynccallbackinfo) {
198                 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAllNotifications();
199             }
200         },
201         [](napi_env env, napi_status status, void *data) {
202             ANS_LOGI("CancelAll napi_create_async_work end");
203             AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
204             if (asynccallbackinfo) {
205                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
206                 if (asynccallbackinfo->info.callback != nullptr) {
207                     napi_delete_reference(env, asynccallbackinfo->info.callback);
208                 }
209                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
210                 delete asynccallbackinfo;
211                 asynccallbackinfo = nullptr;
212             }
213         },
214         (void *)asynccallbackinfo,
215         &asynccallbackinfo->asyncWork);
216 
217     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
218 
219     if (asynccallbackinfo->info.isCallback) {
220         return Common::NapiGetNull(env);
221     } else {
222         return promise;
223     }
224 }
225 
CancelGroup(napi_env env,napi_callback_info info)226 napi_value CancelGroup(napi_env env, napi_callback_info info)
227 {
228     ANS_LOGI("enter");
229 
230     ParametersInfoCancelGroup params {};
231     if (ParseParameters(env, info, params) == nullptr) {
232         return Common::NapiGetUndefined(env);
233     }
234 
235     AsyncCallbackInfoCancelGroup *asynccallbackinfo = new (std::nothrow)
236         AsyncCallbackInfoCancelGroup {.env = env, .asyncWork = nullptr, .params = params};
237     if (!asynccallbackinfo) {
238         return Common::JSParaError(env, params.callback);
239     }
240     napi_value promise = nullptr;
241     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
242 
243     napi_value resourceName = nullptr;
244     napi_create_string_latin1(env, "cancelGroup", NAPI_AUTO_LENGTH, &resourceName);
245     // Asynchronous function call
246     napi_create_async_work(env,
247         nullptr,
248         resourceName,
249         [](napi_env env, void *data) {
250             ANS_LOGI("CancelGroup napi_create_async_work start");
251             AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
252             if (asynccallbackinfo) {
253                 ANS_LOGI("asynccallbackinfo->params.groupName = %{public}s",
254                     asynccallbackinfo->params.groupName.c_str());
255                 asynccallbackinfo->info.errorCode =
256                     NotificationHelper::CancelGroup(asynccallbackinfo->params.groupName);
257             }
258         },
259         [](napi_env env, napi_status status, void *data) {
260             ANS_LOGI("CancelGroup napi_create_async_work end");
261             AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
262             if (asynccallbackinfo) {
263                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
264                 if (asynccallbackinfo->info.callback != nullptr) {
265                     napi_delete_reference(env, asynccallbackinfo->info.callback);
266                 }
267                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
268                 delete asynccallbackinfo;
269                 asynccallbackinfo = nullptr;
270             }
271         },
272         (void *)asynccallbackinfo,
273         &asynccallbackinfo->asyncWork);
274 
275     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
276 
277     if (asynccallbackinfo->info.isCallback) {
278         return Common::NapiGetNull(env);
279     } else {
280         return promise;
281     }
282 }
283 
ParseParameters(const napi_env & env,const napi_callback_info & info,ParametersInfoCancelAsBundle & paras)284 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, ParametersInfoCancelAsBundle &paras)
285 {
286     ANS_LOGI("enter");
287 
288     size_t argc = CANCEL_AS_BUNDLE_MAX_PARA;
289     napi_value argv[CANCEL_AS_BUNDLE_MAX_PARA] = {nullptr};
290     napi_value thisVar = nullptr;
291     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
292     if (argc < 1) {
293         ANS_LOGW("Wrong number of arguments");
294         return nullptr;
295     }
296 
297     napi_valuetype valuetype = napi_undefined;
298     // argv[0]: id: number
299     NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
300     if (valuetype != napi_number) {
301         ANS_LOGW("Wrong argument type. Number expected.");
302         return nullptr;
303     }
304     NAPI_CALL(env, napi_get_value_int32(env, argv[PARAM0], &paras.id));
305 
306     // argv[1]: representativeBundle: string
307     NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
308     if (valuetype != napi_string) {
309         ANS_LOGW("Wrong argument type. String expected.");
310         return nullptr;
311     }
312 
313     char str[STR_MAX_SIZE] = {0};
314     size_t strLen = 0;
315     napi_get_value_string_utf8(env, argv[PARAM1], str, STR_MAX_SIZE - 1, &strLen);
316     paras.representativeBundle = str;
317 
318     // argv[2] : userId
319     NAPI_CALL(env, napi_typeof(env, argv[PARAM2], &valuetype));
320     if (valuetype != napi_number) {
321         ANS_LOGW("Wrong argument type. Number expected.");
322         return nullptr;
323     }
324     napi_get_value_int32(env, argv[PARAM2], &paras.userId);
325 
326     // argv[3]: callback
327     if (argc >= CANCEL_AS_BUNDLE_MAX_PARA) {
328         NAPI_CALL(env, napi_typeof(env, argv[PARAM3], &valuetype));
329         if (valuetype != napi_function) {
330             ANS_LOGW("Wrong argument type. Function expected.");
331             return nullptr;
332         }
333         napi_create_reference(env, argv[PARAM3], 1, &paras.callback);
334     }
335 
336     return Common::NapiGetNull(env);
337 }
338 
CancelAsBundle(napi_env env,napi_callback_info info)339 napi_value CancelAsBundle(napi_env env, napi_callback_info info)
340 {
341     ANS_LOGI("enter");
342 
343     ParametersInfoCancelAsBundle paras;
344     if (ParseParameters(env, info, paras) == nullptr) {
345         return Common::NapiGetUndefined(env);
346     }
347 
348     AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancelAsBundle {
349         .env = env, .asyncWork = nullptr,
350         .id = paras.id,
351         .representativeBundle = paras.representativeBundle,
352         .userId = paras.userId
353     };
354     if (!asynccallbackinfo) {
355         return Common::JSParaError(env, paras.callback);
356     }
357     napi_value promise = nullptr;
358     Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
359 
360     napi_value resourceName = nullptr;
361     napi_create_string_latin1(env, "cancelasbundle", NAPI_AUTO_LENGTH, &resourceName);
362     // Asynchronous function call
363     napi_create_async_work(env,
364         nullptr,
365         resourceName,
366         [](napi_env env, void *data) {
367             ANS_LOGI("Cancel napi_create_async_work start");
368             AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
369 
370             if (asynccallbackinfo) {
371                 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAsBundle(
372                     asynccallbackinfo->id, asynccallbackinfo->representativeBundle, asynccallbackinfo->userId);
373             }
374         },
375         [](napi_env env, napi_status status, void *data) {
376             ANS_LOGI("Cancel napi_create_async_work end");
377             AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
378             if (asynccallbackinfo) {
379                 Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
380                 if (asynccallbackinfo->info.callback != nullptr) {
381                     napi_delete_reference(env, asynccallbackinfo->info.callback);
382                 }
383                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
384                 delete asynccallbackinfo;
385                 asynccallbackinfo = nullptr;
386             }
387         },
388         (void *)asynccallbackinfo,
389         &asynccallbackinfo->asyncWork);
390 
391     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
392 
393     if (asynccallbackinfo->info.isCallback) {
394         return Common::NapiGetNull(env);
395     } else {
396         return promise;
397     }
398 }
399 }  // namespace NotificationNapi
400 }  // namespace OHOS