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