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