1 /*
2 * Copyright (c) 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 "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 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
72 if (asynccallbackinfo->info.isCallback) {
73 return Common::NapiGetNull(env);
74 } else {
75 return promise;
76 }
77 }
78
NapiCancelAll(napi_env env,napi_callback_info info)79 napi_value NapiCancelAll(napi_env env, napi_callback_info info)
80 {
81 ANS_LOGI("enter");
82 napi_ref callback = nullptr;
83 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
84 Common::NapiThrow(env, ERROR_PARAM_INVALID);
85 return Common::NapiGetUndefined(env);
86 }
87
88 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancel {.env = env, .asyncWork = nullptr};
89 if (!asynccallbackinfo) {
90 return Common::JSParaError(env, callback);
91 }
92 napi_value promise = nullptr;
93 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
94
95 napi_value resourceName = nullptr;
96 napi_create_string_latin1(env, "cancelAll", NAPI_AUTO_LENGTH, &resourceName);
97 // Asynchronous function call
98 napi_create_async_work(env,
99 nullptr,
100 resourceName,
101 [](napi_env env, void *data) {
102 ANS_LOGI("CancelAll napi_create_async_work start");
103 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
104 if (asynccallbackinfo) {
105 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAllNotifications();
106 }
107 },
108 [](napi_env env, napi_status status, void *data) {
109 ANS_LOGI("CancelAll napi_create_async_work end");
110 AsyncCallbackInfoCancel *asynccallbackinfo = static_cast<AsyncCallbackInfoCancel *>(data);
111 if (asynccallbackinfo) {
112 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
113 if (asynccallbackinfo->info.callback != nullptr) {
114 napi_delete_reference(env, asynccallbackinfo->info.callback);
115 }
116 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
117 delete asynccallbackinfo;
118 asynccallbackinfo = nullptr;
119 }
120 },
121 (void *)asynccallbackinfo,
122 &asynccallbackinfo->asyncWork);
123
124 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
125 if (asynccallbackinfo->info.isCallback) {
126 return Common::NapiGetNull(env);
127 } else {
128 return promise;
129 }
130 }
131
NapiCancelGroup(napi_env env,napi_callback_info info)132 napi_value NapiCancelGroup(napi_env env, napi_callback_info info)
133 {
134 ANS_LOGI("enter");
135 ParametersInfoCancelGroup params {};
136 if (ParseParameters(env, info, params) == nullptr) {
137 Common::NapiThrow(env, ERROR_PARAM_INVALID);
138 return Common::NapiGetUndefined(env);
139 }
140
141 AsyncCallbackInfoCancelGroup *asynccallbackinfo = new (std::nothrow)
142 AsyncCallbackInfoCancelGroup {.env = env, .asyncWork = nullptr, .params = params};
143 if (!asynccallbackinfo) {
144 return Common::JSParaError(env, params.callback);
145 }
146 napi_value promise = nullptr;
147 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
148
149 napi_value resourceName = nullptr;
150 napi_create_string_latin1(env, "cancelGroup", NAPI_AUTO_LENGTH, &resourceName);
151 // Asynchronous function call
152 napi_create_async_work(env,
153 nullptr,
154 resourceName,
155 [](napi_env env, void *data) {
156 ANS_LOGI("CancelGroup napi_create_async_work start");
157 AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
158 if (asynccallbackinfo) {
159 ANS_LOGI("asynccallbackinfo->params.groupName = %{public}s",
160 asynccallbackinfo->params.groupName.c_str());
161 asynccallbackinfo->info.errorCode =
162 NotificationHelper::CancelGroup(asynccallbackinfo->params.groupName);
163 }
164 },
165 [](napi_env env, napi_status status, void *data) {
166 ANS_LOGI("CancelGroup napi_create_async_work end");
167 AsyncCallbackInfoCancelGroup *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelGroup *>(data);
168 if (asynccallbackinfo) {
169 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
170 if (asynccallbackinfo->info.callback != nullptr) {
171 napi_delete_reference(env, asynccallbackinfo->info.callback);
172 }
173 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
174 delete asynccallbackinfo;
175 asynccallbackinfo = nullptr;
176 }
177 },
178 (void *)asynccallbackinfo,
179 &asynccallbackinfo->asyncWork);
180
181 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
182 if (asynccallbackinfo->info.isCallback) {
183 return Common::NapiGetNull(env);
184 } else {
185 return promise;
186 }
187 }
188
NapiCancelAsBundle(napi_env env,napi_callback_info info)189 napi_value NapiCancelAsBundle(napi_env env, napi_callback_info info)
190 {
191 ANS_LOGI("enter");
192 ParametersInfoCancelAsBundle paras;
193 if (ParseParameters(env, info, paras) == nullptr) {
194 Common::NapiThrow(env, ERROR_PARAM_INVALID);
195 return Common::NapiGetUndefined(env);
196 }
197
198 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoCancelAsBundle {
199 .env = env, .asyncWork = nullptr,
200 .id = paras.id,
201 .representativeBundle = paras.representativeBundle,
202 .userId = paras.userId
203 };
204 if (!asynccallbackinfo) {
205 return Common::JSParaError(env, paras.callback);
206 }
207 napi_value promise = nullptr;
208 Common::PaddingCallbackPromiseInfo(env, paras.callback, asynccallbackinfo->info, promise);
209
210 napi_value resourceName = nullptr;
211 napi_create_string_latin1(env, "cancelasbundle", NAPI_AUTO_LENGTH, &resourceName);
212 // Asynchronous function call
213 napi_create_async_work(env,
214 nullptr,
215 resourceName,
216 [](napi_env env, void *data) {
217 ANS_LOGI("Cancel napi_create_async_work start");
218 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
219
220 if (asynccallbackinfo) {
221 asynccallbackinfo->info.errorCode = NotificationHelper::CancelAsBundle(
222 asynccallbackinfo->id, asynccallbackinfo->representativeBundle, asynccallbackinfo->userId);
223 }
224 },
225 [](napi_env env, napi_status status, void *data) {
226 ANS_LOGI("Cancel napi_create_async_work end");
227 AsyncCallbackInfoCancelAsBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoCancelAsBundle *>(data);
228 if (asynccallbackinfo) {
229 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
230 if (asynccallbackinfo->info.callback != nullptr) {
231 napi_delete_reference(env, asynccallbackinfo->info.callback);
232 }
233 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
234 delete asynccallbackinfo;
235 asynccallbackinfo = nullptr;
236 }
237 },
238 (void *)asynccallbackinfo,
239 &asynccallbackinfo->asyncWork);
240
241 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
242 if (asynccallbackinfo->info.isCallback) {
243 return Common::NapiGetNull(env);
244 } else {
245 return promise;
246 }
247 }
248 } // namespace NotificationNapi
249 } // namespace OHOS