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