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_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 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
80 if (asynccallbackinfo->info.isCallback) {
81 return Common::NapiGetNull(env);
82 } else {
83 return promise;
84 }
85 }
86
AsyncCompleteCallbackNapiIsNotificationEnabled(napi_env env,napi_status status,void * data)87 void AsyncCompleteCallbackNapiIsNotificationEnabled(napi_env env, napi_status status, void *data)
88 {
89 ANS_LOGI("enter");
90 if (!data) {
91 ANS_LOGE("Invalid async callback data");
92 return;
93 }
94 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
95 if (asynccallbackinfo) {
96 napi_value result = nullptr;
97 napi_get_boolean(env, asynccallbackinfo->allowed, &result);
98 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
99 if (asynccallbackinfo->info.callback != nullptr) {
100 napi_delete_reference(env, asynccallbackinfo->info.callback);
101 }
102 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
103 delete asynccallbackinfo;
104 asynccallbackinfo = nullptr;
105 }
106 }
107
NapiIsNotificationEnabled(napi_env env,napi_callback_info info)108 napi_value NapiIsNotificationEnabled(napi_env env, napi_callback_info info)
109 {
110 ANS_LOGI("enter");
111 IsEnableParams params {};
112 if (ParseParameters(env, info, params) == nullptr) {
113 Common::NapiThrow(env, ERROR_PARAM_INVALID);
114 return Common::NapiGetUndefined(env);
115 }
116
117 AsyncCallbackInfoIsEnable *asynccallbackinfo =
118 new (std::nothrow) AsyncCallbackInfoIsEnable {.env = env, .asyncWork = nullptr, .params = params};
119 if (!asynccallbackinfo) {
120 return Common::JSParaError(env, params.callback);
121 }
122 napi_value promise = nullptr;
123 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
124
125 napi_value resourceName = nullptr;
126 napi_create_string_latin1(env, "isNotificationEnabled", NAPI_AUTO_LENGTH, &resourceName);
127 // Asynchronous function call
128 napi_create_async_work(env,
129 nullptr,
130 resourceName,
131 [](napi_env env, void *data) {
132 ANS_LOGI("IsNotificationEnabled napi_create_async_work start");
133 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
134 if (asynccallbackinfo) {
135 if (asynccallbackinfo->params.hasBundleOption) {
136 ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
137 asynccallbackinfo->params.option.GetBundleName().c_str(),
138 asynccallbackinfo->params.option.GetUid());
139 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(
140 asynccallbackinfo->params.option, asynccallbackinfo->allowed);
141 } else if (asynccallbackinfo->params.hasUserId) {
142 ANS_LOGI("userId = %{public}d", asynccallbackinfo->params.userId);
143 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(
144 asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
145 } else {
146 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(
147 asynccallbackinfo->allowed);
148 }
149 ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
150 asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
151 }
152 },
153 AsyncCompleteCallbackNapiIsNotificationEnabled,
154 (void *)asynccallbackinfo,
155 &asynccallbackinfo->asyncWork);
156
157 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
158 if (asynccallbackinfo->info.isCallback) {
159 return Common::NapiGetNull(env);
160 } else {
161 return promise;
162 }
163 }
164
NapiIsNotificationEnabledSelf(napi_env env,napi_callback_info info)165 napi_value NapiIsNotificationEnabledSelf(napi_env env, napi_callback_info info)
166 {
167 ANS_LOGI("enter");
168 IsEnableParams params {};
169 if (ParseParameters(env, info, params) == nullptr) {
170 Common::NapiThrow(env, ERROR_PARAM_INVALID);
171 return Common::NapiGetUndefined(env);
172 }
173
174 AsyncCallbackInfoIsEnable *asynccallbackinfo =
175 new (std::nothrow) AsyncCallbackInfoIsEnable {.env = env, .asyncWork = nullptr, .params = params};
176 if (!asynccallbackinfo) {
177 return Common::JSParaError(env, params.callback);
178 }
179 napi_value promise = nullptr;
180 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
181
182 napi_value resourceName = nullptr;
183 napi_create_string_latin1(env, "IsNotificationEnabledSelf", NAPI_AUTO_LENGTH, &resourceName);
184 // Asynchronous function call
185 napi_create_async_work(env,
186 nullptr,
187 resourceName,
188 [](napi_env env, void *data) {
189 ANS_LOGI("IsNotificationEnabledSelf napi_create_async_work start");
190 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
191 if (asynccallbackinfo) {
192 if (asynccallbackinfo->params.hasBundleOption) {
193 ANS_LOGE("Not allowed to query another application");
194 } else {
195 asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(
196 asynccallbackinfo->allowed);
197 }
198 ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
199 asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
200 }
201 },
202 AsyncCompleteCallbackNapiIsNotificationEnabled,
203 (void *)asynccallbackinfo,
204 &asynccallbackinfo->asyncWork);
205
206 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
207 if (asynccallbackinfo->info.isCallback) {
208 return Common::NapiGetNull(env);
209 } else {
210 return promise;
211 }
212 }
213
NapiRequestEnableNotification(napi_env env,napi_callback_info info)214 napi_value NapiRequestEnableNotification(napi_env env, napi_callback_info info)
215 {
216 ANS_LOGI("enter");
217 IsEnableParams params {};
218 if (ParseParameters(env, info, params) == nullptr) {
219 Common::NapiThrow(env, ERROR_PARAM_INVALID);
220 return Common::NapiGetUndefined(env);
221 }
222
223 AsyncCallbackInfoIsEnable *asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoIsEnable {
224 .env = env, .params = params, .newInterface = true};
225 if (!asynccallbackinfo) {
226 return Common::JSParaError(env, params.callback);
227 }
228 napi_value promise = nullptr;
229 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
230
231 napi_value resourceName = nullptr;
232 napi_create_string_latin1(env, "RequestEnableNotification", NAPI_AUTO_LENGTH, &resourceName);
233 // Asynchronous function call
234 napi_create_async_work(env, nullptr, resourceName,
235 [](napi_env env, void *data) {
236 ANS_LOGI("RequestEnableNotification napi_create_async_work start");
237 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
238 if (asynccallbackinfo) {
239 std::string deviceId {""};
240 asynccallbackinfo->info.errorCode =
241 NotificationHelper::RequestEnableNotification(deviceId);
242 }
243 },
244 [](napi_env env, napi_status status, void *data) {
245 AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
246 if (asynccallbackinfo) {
247 AsyncCompleteCallbackNapiIsNotificationEnabled(env, status, data);
248 }
249 },
250 (void *)asynccallbackinfo,
251 &asynccallbackinfo->asyncWork);
252
253 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
254 if (asynccallbackinfo->info.isCallback) {
255 return Common::NapiGetNull(env);
256 } else {
257 return promise;
258 }
259 }
260 } // namespace NotificationNapi
261 } // namespace OHOS