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_cancel.h"
17
18 #include "ans_inner_errors.h"
19 #include "cancel.h"
20
21 namespace OHOS {
22 namespace NotificationNapi {
NapiCancel(napi_env env,napi_callback_info info)23 napi_value NapiCancel(napi_env env, napi_callback_info info)
24 {
25 ANS_LOGI("enter");
26 ParametersInfoCancel paras;
27 if (ParseParameters(env, info, paras) == nullptr) {
28 Common::NapiThrow(env, ERROR_PARAM_INVALID);
29 return Common::NapiGetUndefined(env);
30 }
31
32 AsyncCallbackInfoCancel *asynccallbackinfo = new (std::nothrow)
33 AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr, .id = paras.id, .label = paras.label};
34 if (!asynccallbackinfo) {
35 return Common::JSParaError(env, paras.callback);
36 }
37 napi_value promise = nullptr;
38 Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
39
40 napi_value resourceName = nullptr;
41 napi_create_string_latin1(env, "cancel", NAPI_AUTO_LENGTH, &resourceName);
42 // Asynchronous function call
43 napi_create_async_work(env,
44 nullptr,
45 resourceName,
46 [](napi_env env, void *data) {
47 ANS_LOGI("Cancel napi_create_async_work start");
48 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
49
50 if (asynccallbackinfo) {
51 asynccallbackinfo->info.errorCode =
52 NotificationHelper::CancelNotification(asynccallbackinfo->label, asynccallbackinfo->id);
53 }
54 },
55 [](napi_env env, napi_status status, void *data) {
56 ANS_LOGI("Cancel napi_create_async_work end");
57 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
58 if (asynccallbackinfo) {
59 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
60 if (asynccallbackinfo->info.callback != nullptr) {
61 napi_delete_reference(env, asynccallbackinfo->info.callback);
62 }
63 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
64 delete asynccallbackinfo;
65 asynccallbackinfo = nullptr;
66 }
67 },
68 (void *)asynccallbackinfo,
69 &asynccallbackinfo->asyncWork);
70
71 bool isCallback = asynccallbackinfo->info.isCallback;
72 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
73 if (status != napi_ok) {
74 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
75 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
76 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
77 if (asynccallbackinfo->info.callback != nullptr) {
78 napi_delete_reference(env, asynccallbackinfo->info.callback);
79 }
80 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
81 delete asynccallbackinfo;
82 asynccallbackinfo = nullptr;
83 }
84
85 if (isCallback) {
86 return Common::NapiGetNull(env);
87 } else {
88 return promise;
89 }
90 }
91
NapiCancelAll(napi_env env,napi_callback_info info)92 napi_value NapiCancelAll(napi_env env, napi_callback_info info)
93 {
94 ANS_LOGI("enter");
95 napi_ref callback = nullptr;
96 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
97 Common::NapiThrow(env, ERROR_PARAM_INVALID);
98 return Common::NapiGetUndefined(env);
99 }
100
101 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr};
102 if (!asynccallbackinfo) {
103 return Common::JSParaError(env, callback);
104 }
105 napi_value promise = nullptr;
106 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
107
108 napi_value resourceName = nullptr;
109 napi_create_string_latin1(env, "cancelAll", NAPI_AUTO_LENGTH, &resourceName);
110 // Asynchronous function call
111 napi_create_async_work(env,
112 nullptr,
113 resourceName,
114 [](napi_env env, void *data) {
115 ANS_LOGI("CancelAll napi_create_async_work start");
116 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
117 if (asynccallbackinfo) {
118 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAllNotifications();
119 }
120 },
121 [](napi_env env, napi_status status, void *data) {
122 ANS_LOGI("CancelAll napi_create_async_work end");
123 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
124 if (asynccallbackinfo) {
125 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
126 if (asynccallbackinfo->info.callback != nullptr) {
127 napi_delete_reference(env, asynccallbackinfo->info.callback);
128 }
129 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
130 delete asynccallbackinfo;
131 asynccallbackinfo = nullptr;
132 }
133 },
134 (void *)asynccallbackinfo,
135 &asynccallbackinfo->asyncWork);
136
137 bool isCallback = asynccallbackinfo->info.isCallback;
138 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
139 if (status != napi_ok) {
140 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
141 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
142 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
143 if (asynccallbackinfo->info.callback != nullptr) {
144 napi_delete_reference(env, asynccallbackinfo->info.callback);
145 }
146 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
147 delete asynccallbackinfo;
148 asynccallbackinfo = nullptr;
149 }
150
151 if (isCallback) {
152 return Common::NapiGetNull(env);
153 } else {
154 return promise;
155 }
156 }
157
NapiCancelGroup(napi_env env,napi_callback_info info)158 napi_value NapiCancelGroup(napi_env env, napi_callback_info info)
159 {
160 ANS_LOGI("enter");
161 ParametersInfoCancelGroup params {};
162 if (ParseParameters(env, info, params) == nullptr) {
163 Common::NapiThrow(env, ERROR_PARAM_INVALID);
164 return Common::NapiGetUndefined(env);
165 }
166
167 AsyncCallbackInfoCancelGroup *asynccallbackinfo = new (std::nothrow)
168 AsyncCallbackInfoCancelGroup {.env = env, .asyncWork = nullptr, .params = params};
169 if (!asynccallbackinfo) {
170 return Common::JSParaError(env, params.callback);
171 }
172 napi_value promise = nullptr;
173 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
174
175 napi_value resourceName = nullptr;
176 napi_create_string_latin1(env, "cancelGroup", NAPI_AUTO_LENGTH, &resourceName);
177 // Asynchronous function call
178 napi_create_async_work(env,
179 nullptr,
180 resourceName,
181 [](napi_env env, void *data) {
182 ANS_LOGI("CancelGroup napi_create_async_work start");
183 AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
184 if (asynccallbackinfo) {
185 ANS_LOGI("asynccallbackinfo->params.groupName = %{public}s",
186 asynccallbackinfo->params.groupName.c_str());
187 asynccallbackinfo->info.errorCode =
188 NotificationHelper::CancelGroup(asynccallbackinfo->params.groupName);
189 }
190 },
191 [](napi_env env, napi_status status, void *data) {
192 ANS_LOGI("CancelGroup napi_create_async_work end");
193 AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
194 if (asynccallbackinfo) {
195 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
196 if (asynccallbackinfo->info.callback != nullptr) {
197 napi_delete_reference(env, asynccallbackinfo->info.callback);
198 }
199 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
200 delete asynccallbackinfo;
201 asynccallbackinfo = nullptr;
202 }
203 },
204 (void *)asynccallbackinfo,
205 &asynccallbackinfo->asyncWork);
206
207 bool isCallback = asynccallbackinfo->info.isCallback;
208 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
209 if (status != napi_ok) {
210 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
211 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
212 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
213 if (asynccallbackinfo->info.callback != nullptr) {
214 napi_delete_reference(env, asynccallbackinfo->info.callback);
215 }
216 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
217 delete asynccallbackinfo;
218 asynccallbackinfo = nullptr;
219 }
220
221 if (isCallback) {
222 return Common::NapiGetNull(env);
223 } else {
224 return promise;
225 }
226 }
227
NapiCancelAsBundle(napi_env env,napi_callback_info info)228 napi_value NapiCancelAsBundle(napi_env env, napi_callback_info info)
229 {
230 ANS_LOGI("enter");
231 ParametersInfoCancelAsBundle paras;
232 if (ParseParameters(env, info, paras) == nullptr) {
233 Common::NapiThrow(env, ERROR_PARAM_INVALID);
234 return Common::NapiGetUndefined(env);
235 }
236
237 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancelAsBundle {
238 .env = env, .asyncWork = nullptr,
239 .id = paras.id,
240 .representativeBundle = paras.representativeBundle,
241 .userId = paras.userId
242 };
243 if (!asynccallbackinfo) {
244 return Common::JSParaError(env, paras.callback);
245 }
246 napi_value promise = nullptr;
247 Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
248
249 napi_value resourceName = nullptr;
250 napi_create_string_latin1(env, "cancelasbundle", NAPI_AUTO_LENGTH, &resourceName);
251 // Asynchronous function call
252 napi_create_async_work(env,
253 nullptr,
254 resourceName,
255 [](napi_env env, void *data) {
256 ANS_LOGI("Cancel napi_create_async_work start");
257 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
258
259 if (asynccallbackinfo) {
260 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAsBundle(
261 asynccallbackinfo->id, asynccallbackinfo->representativeBundle, asynccallbackinfo->userId);
262 }
263 },
264 [](napi_env env, napi_status status, void *data) {
265 ANS_LOGI("Cancel napi_create_async_work end");
266 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
267 if (asynccallbackinfo) {
268 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
269 if (asynccallbackinfo->info.callback != nullptr) {
270 napi_delete_reference(env, asynccallbackinfo->info.callback);
271 }
272 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
273 delete asynccallbackinfo;
274 asynccallbackinfo = nullptr;
275 }
276 },
277 (void *)asynccallbackinfo,
278 &asynccallbackinfo->asyncWork);
279
280 bool isCallback = asynccallbackinfo->info.isCallback;
281 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
282 if (status != napi_ok) {
283 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
284 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
285 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
286 if (asynccallbackinfo->info.callback != nullptr) {
287 napi_delete_reference(env, asynccallbackinfo->info.callback);
288 }
289 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
290 delete asynccallbackinfo;
291 asynccallbackinfo = nullptr;
292 }
293
294 if (isCallback) {
295 return Common::NapiGetNull(env);
296 } else {
297 return promise;
298 }
299 }
300 } // namespace NotificationNapi
301 } // namespace OHOS