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_get_active.h"
17
18 #include "ans_inner_errors.h"
19 #include "get_active.h"
20
21 namespace OHOS {
22 namespace NotificationNapi {
AsyncCompleteCallbackNapiGetAllActiveNotifications(napi_env env,napi_status status,void * data)23 void AsyncCompleteCallbackNapiGetAllActiveNotifications(napi_env env, napi_status status, void *data)
24 {
25 ANS_LOGI("GetAllActiveNotifications callback");
26 if (!data) {
27 ANS_LOGE("Invalid async callback data");
28 return;
29 }
30
31 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
32 if (asynccallbackinfo) {
33 napi_value result = nullptr;
34 if (asynccallbackinfo->info.errorCode != ERR_OK) {
35 result = Common::NapiGetNull(env);
36 } else {
37 napi_value arr = nullptr;
38 int32_t count = 0;
39 napi_create_array(env, &arr);
40 for (auto vec : asynccallbackinfo->notifications) {
41 if (!vec) {
42 ANS_LOGW("Invalid Notification object ptr");
43 continue;
44 }
45 napi_value notificationResult = nullptr;
46 napi_create_object(env, ¬ificationResult);
47 if (!Common::SetNotification(env, vec.GetRefPtr(), notificationResult)) {
48 ANS_LOGW("Set Notification object failed");
49 continue;
50 }
51 napi_set_element(env, arr, count, notificationResult);
52 count++;
53 }
54 ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
55 result = arr;
56 if ((count == 0) && (asynccallbackinfo->notifications.size() > 0)) {
57 asynccallbackinfo->info.errorCode = ERROR;
58 result = Common::NapiGetNull(env);
59 }
60 }
61 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
62 if (asynccallbackinfo->info.callback != nullptr) {
63 napi_delete_reference(env, asynccallbackinfo->info.callback);
64 }
65 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
66 delete asynccallbackinfo;
67 asynccallbackinfo = nullptr;
68 }
69 }
70
NapiGetAllActiveNotifications(napi_env env,napi_callback_info info)71 napi_value NapiGetAllActiveNotifications(napi_env env, napi_callback_info info)
72 {
73 ANS_LOGI("enter");
74 napi_ref callback = nullptr;
75 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
76 Common::NapiThrow(env, ERROR_PARAM_INVALID);
77 return Common::NapiGetUndefined(env);
78 }
79
80 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
81 if (!asynccallbackinfo) {
82 return Common::JSParaError(env, callback);
83 }
84 napi_value promise = nullptr;
85 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
86
87 napi_value resourceName = nullptr;
88 napi_create_string_latin1(env, "getAllActiveNotifications", NAPI_AUTO_LENGTH, &resourceName);
89 // Asynchronous function call
90 napi_create_async_work(
91 env,
92 nullptr,
93 resourceName,
94 [](napi_env env, void *data) {
95 ANS_LOGI("GetAllActiveNotifications napi_create_async_work start");
96 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
97 if (asynccallbackinfo) {
98 asynccallbackinfo->info.errorCode =
99 NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
100 }
101 },
102 AsyncCompleteCallbackNapiGetAllActiveNotifications,
103 (void *)asynccallbackinfo,
104 &asynccallbackinfo->asyncWork);
105
106 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
107 if (asynccallbackinfo->info.isCallback) {
108 return Common::NapiGetNull(env);
109 } else {
110 return promise;
111 }
112 }
113
AsyncCompleteCallbackNapiGetActiveNotifications(napi_env env,napi_status status,void * data)114 void AsyncCompleteCallbackNapiGetActiveNotifications(napi_env env, napi_status status, void *data)
115 {
116 ANS_LOGI("GetActiveNotifications callback");
117 if (!data) {
118 ANS_LOGE("Invalid async callback data");
119 return;
120 }
121
122 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
123 if (asynccallbackinfo) {
124 napi_value result = nullptr;
125 if (asynccallbackinfo->info.errorCode != ERR_OK) {
126 result = Common::NapiGetNull(env);
127 } else {
128 napi_value arr = nullptr;
129 int32_t count = 0;
130 napi_create_array(env, &arr);
131 for (auto vec : asynccallbackinfo->requests) {
132 if (!vec) {
133 ANS_LOGW("Invalid NotificationRequest object ptr");
134 continue;
135 }
136 napi_value requestResult = nullptr;
137 napi_create_object(env, &requestResult);
138 if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), requestResult)) {
139 ANS_LOGW("Set NotificationRequest object failed");
140 continue;
141 }
142 napi_set_element(env, arr, count, requestResult);
143 count++;
144 }
145 ANS_LOGI("GetActiveNotifications count = %{public}d", count);
146 result = arr;
147 if ((count == 0) && (asynccallbackinfo->requests.size() > 0)) {
148 asynccallbackinfo->info.errorCode = ERROR;
149 result = Common::NapiGetNull(env);
150 }
151 }
152 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
153 if (asynccallbackinfo->info.callback != nullptr) {
154 napi_delete_reference(env, asynccallbackinfo->info.callback);
155 }
156 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
157 delete asynccallbackinfo;
158 asynccallbackinfo = nullptr;
159 }
160 }
161
NapiGetActiveNotifications(napi_env env,napi_callback_info info)162 napi_value NapiGetActiveNotifications(napi_env env, napi_callback_info info)
163 {
164 ANS_LOGI("enter");
165 napi_ref callback = nullptr;
166 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
167 Common::NapiThrow(env, ERROR_PARAM_INVALID);
168 return Common::NapiGetUndefined(env);
169 }
170
171 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
172 if (!asynccallbackinfo) {
173 return Common::JSParaError(env, callback);
174 }
175 napi_value promise = nullptr;
176 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
177
178 napi_value resourceName = nullptr;
179 napi_create_string_latin1(env, "getActiveNotifications", NAPI_AUTO_LENGTH, &resourceName);
180 // Asynchronous function call
181 napi_create_async_work(
182 env,
183 nullptr,
184 resourceName,
185 [](napi_env env, void *data) {
186 ANS_LOGI("GetActiveNotifications napi_create_async_work start");
187 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
188 if (asynccallbackinfo) {
189 asynccallbackinfo->info.errorCode =
190 NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
191 }
192 },
193 AsyncCompleteCallbackNapiGetActiveNotifications,
194 (void *)asynccallbackinfo,
195 &asynccallbackinfo->asyncWork);
196
197 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
198 if (asynccallbackinfo->info.isCallback) {
199 return Common::NapiGetNull(env);
200 } else {
201 return promise;
202 }
203 }
204
AsyncCompleteCallbackNapiGetActiveNotificationCount(napi_env env,napi_status status,void * data)205 void AsyncCompleteCallbackNapiGetActiveNotificationCount(napi_env env, napi_status status, void *data)
206 {
207 ANS_LOGI("GetActiveNotificationCount callback");
208 if (!data) {
209 ANS_LOGE("Invalid async callback data");
210 return;
211 }
212
213 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
214 if (asynccallbackinfo) {
215 napi_value result = nullptr;
216 if (asynccallbackinfo->info.errorCode != ERR_OK) {
217 result = Common::NapiGetNull(env);
218 } else {
219 napi_create_uint32(env, asynccallbackinfo->num, &result);
220 }
221 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
222 if (asynccallbackinfo->info.callback != nullptr) {
223 napi_delete_reference(env, asynccallbackinfo->info.callback);
224 }
225 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
226 delete asynccallbackinfo;
227 asynccallbackinfo = nullptr;
228 }
229 }
230
NapiGetActiveNotificationCount(napi_env env,napi_callback_info info)231 napi_value NapiGetActiveNotificationCount(napi_env env, napi_callback_info info)
232 {
233 ANS_LOGI("enter");
234 napi_ref callback = nullptr;
235 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
236 Common::NapiThrow(env, ERROR_PARAM_INVALID);
237 return Common::NapiGetUndefined(env);
238 }
239
240 auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
241 if (!asynccallbackinfo) {
242 return Common::JSParaError(env, callback);
243 }
244 napi_value promise = nullptr;
245 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
246
247 napi_value resourceName = nullptr;
248 napi_create_string_latin1(env, "getActiveNotificationCount", NAPI_AUTO_LENGTH, &resourceName);
249 // Asynchronous function call
250 napi_create_async_work(
251 env,
252 nullptr,
253 resourceName,
254 [](napi_env env, void *data) {
255 ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
256 auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
257 if (asynccallbackinfo) {
258 asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(
259 asynccallbackinfo->num);
260 ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
261 }
262 },
263 AsyncCompleteCallbackNapiGetActiveNotificationCount,
264 (void *)asynccallbackinfo,
265 &asynccallbackinfo->asyncWork);
266
267 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
268 if (asynccallbackinfo->info.isCallback) {
269 return Common::NapiGetNull(env);
270 } else {
271 return promise;
272 }
273 }
274 } // namespace NotificationNapi
275 } // namespace OHOS