• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_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, &notificationResult);
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     bool isCallback = asynccallbackinfo->info.isCallback;
107     napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
108     if (status != napi_ok) {
109         ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
110         asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
111         Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
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     if (isCallback) {
121         return Common::NapiGetNull(env);
122     } else {
123         return promise;
124     }
125 }
126 
AsyncCompleteCallbackNapiGetActiveNotifications(napi_env env,napi_status status,void * data)127 void AsyncCompleteCallbackNapiGetActiveNotifications(napi_env env, napi_status status, void *data)
128 {
129     ANS_LOGI("GetActiveNotifications callback");
130     if (!data) {
131         ANS_LOGE("Invalid async callback data");
132         return;
133     }
134 
135     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
136     if (asynccallbackinfo) {
137         napi_value result = nullptr;
138         if (asynccallbackinfo->info.errorCode != ERR_OK) {
139             result = Common::NapiGetNull(env);
140         } else {
141             napi_value arr = nullptr;
142             int32_t count = 0;
143             napi_create_array(env, &arr);
144             for (auto vec : asynccallbackinfo->requests) {
145                 if (!vec) {
146                     ANS_LOGW("Invalid NotificationRequest object ptr");
147                     continue;
148                 }
149                 napi_value requestResult = nullptr;
150                 napi_create_object(env, &requestResult);
151                 if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), requestResult)) {
152                     ANS_LOGW("Set NotificationRequest object failed");
153                     continue;
154                 }
155                 napi_set_element(env, arr, count, requestResult);
156                 count++;
157             }
158             ANS_LOGI("GetActiveNotifications count = %{public}d", count);
159             result = arr;
160             if ((count == 0) && (asynccallbackinfo->requests.size() > 0)) {
161                 asynccallbackinfo->info.errorCode = ERROR;
162                 result = Common::NapiGetNull(env);
163             }
164         }
165         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
166         if (asynccallbackinfo->info.callback != nullptr) {
167             napi_delete_reference(env, asynccallbackinfo->info.callback);
168         }
169         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
170         delete asynccallbackinfo;
171         asynccallbackinfo = nullptr;
172     }
173 }
174 
NapiGetActiveNotifications(napi_env env,napi_callback_info info)175 napi_value NapiGetActiveNotifications(napi_env env, napi_callback_info info)
176 {
177     ANS_LOGI("enter");
178     napi_ref callback = nullptr;
179     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
180         Common::NapiThrow(env, ERROR_PARAM_INVALID);
181         return Common::NapiGetUndefined(env);
182     }
183 
184     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
185     if (!asynccallbackinfo) {
186         return Common::JSParaError(env, callback);
187     }
188     napi_value promise = nullptr;
189     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
190 
191     napi_value resourceName = nullptr;
192     napi_create_string_latin1(env, "getActiveNotifications", NAPI_AUTO_LENGTH, &resourceName);
193     // Asynchronous function call
194     napi_create_async_work(
195         env,
196         nullptr,
197         resourceName,
198         [](napi_env env, void *data) {
199             ANS_LOGI("GetActiveNotifications napi_create_async_work start");
200             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
201             if (asynccallbackinfo) {
202                 asynccallbackinfo->info.errorCode =
203                     NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
204             }
205         },
206         AsyncCompleteCallbackNapiGetActiveNotifications,
207         (void *)asynccallbackinfo,
208         &asynccallbackinfo->asyncWork);
209 
210     bool isCallback = asynccallbackinfo->info.isCallback;
211     napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
212     if (status != napi_ok) {
213         ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
214         asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
215         Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
216         if (asynccallbackinfo->info.callback != nullptr) {
217             napi_delete_reference(env, asynccallbackinfo->info.callback);
218         }
219         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
220         delete asynccallbackinfo;
221         asynccallbackinfo = nullptr;
222     }
223 
224     if (isCallback) {
225         return Common::NapiGetNull(env);
226     } else {
227         return promise;
228     }
229 }
230 
AsyncCompleteCallbackNapiGetActiveNotificationCount(napi_env env,napi_status status,void * data)231 void AsyncCompleteCallbackNapiGetActiveNotificationCount(napi_env env, napi_status status, void *data)
232 {
233     ANS_LOGI("GetActiveNotificationCount callback");
234     if (!data) {
235         ANS_LOGE("Invalid async callback data");
236         return;
237     }
238 
239     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
240     if (asynccallbackinfo) {
241         napi_value result = nullptr;
242         if (asynccallbackinfo->info.errorCode != ERR_OK) {
243             result = Common::NapiGetNull(env);
244         } else {
245             napi_create_uint32(env, asynccallbackinfo->num, &result);
246         }
247         Common::CreateReturnValue(env, asynccallbackinfo->info, result);
248         if (asynccallbackinfo->info.callback != nullptr) {
249             napi_delete_reference(env, asynccallbackinfo->info.callback);
250         }
251         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
252         delete asynccallbackinfo;
253         asynccallbackinfo = nullptr;
254     }
255 }
256 
NapiGetActiveNotificationCount(napi_env env,napi_callback_info info)257 napi_value NapiGetActiveNotificationCount(napi_env env, napi_callback_info info)
258 {
259     ANS_LOGI("enter");
260     napi_ref callback = nullptr;
261     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
262         Common::NapiThrow(env, ERROR_PARAM_INVALID);
263         return Common::NapiGetUndefined(env);
264     }
265 
266     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
267     if (!asynccallbackinfo) {
268         return Common::JSParaError(env, callback);
269     }
270     napi_value promise = nullptr;
271     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
272 
273     napi_value resourceName = nullptr;
274     napi_create_string_latin1(env, "getActiveNotificationCount", NAPI_AUTO_LENGTH, &resourceName);
275     // Asynchronous function call
276     napi_create_async_work(
277         env,
278         nullptr,
279         resourceName,
280         [](napi_env env, void *data) {
281             ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
282             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
283             if (asynccallbackinfo) {
284                 asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(
285                     asynccallbackinfo->num);
286                 ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
287             }
288         },
289         AsyncCompleteCallbackNapiGetActiveNotificationCount,
290         (void *)asynccallbackinfo,
291         &asynccallbackinfo->asyncWork);
292 
293     bool isCallback = asynccallbackinfo->info.isCallback;
294     napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
295     if (status != napi_ok) {
296         ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
297         asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
298         Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
299         if (asynccallbackinfo->info.callback != nullptr) {
300             napi_delete_reference(env, asynccallbackinfo->info.callback);
301         }
302         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
303         delete asynccallbackinfo;
304         asynccallbackinfo = nullptr;
305     }
306 
307     if (isCallback) {
308         return Common::NapiGetNull(env);
309     } else {
310         return promise;
311     }
312 }
313 }  // namespace NotificationNapi
314 }  // namespace OHOS