• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-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 "get_active.h"
17 
18 namespace OHOS {
19 namespace NotificationNapi {
AsyncCompleteCallbackGetAllActiveNotifications(napi_env env,napi_status status,void * data)20 void AsyncCompleteCallbackGetAllActiveNotifications(napi_env env, napi_status status, void *data)
21 {
22     ANS_LOGI("GetAllActiveNotifications napi_create_async_work end");
23 
24     if (!data) {
25         ANS_LOGE("Invalid async callback data");
26         return;
27     }
28 
29     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
30     if (asynccallbackinfo) {
31         napi_value result = nullptr;
32         if (asynccallbackinfo->info.errorCode != ERR_OK) {
33             result = Common::NapiGetNull(env);
34         } else {
35             napi_value arr = nullptr;
36             int32_t count = 0;
37             napi_create_array(env, &arr);
38             for (auto vec : asynccallbackinfo->notifications) {
39                 if (!vec) {
40                     ANS_LOGW("Invalid Notification object ptr");
41                     continue;
42                 }
43                 napi_value notificationResult = nullptr;
44                 napi_create_object(env, &notificationResult);
45                 if (!Common::SetNotification(env, vec.GetRefPtr(), notificationResult)) {
46                     ANS_LOGW("Set Notification object failed");
47                     continue;
48                 }
49                 napi_set_element(env, arr, count, notificationResult);
50                 count++;
51             }
52             ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
53             result = arr;
54             if ((count == 0) && (asynccallbackinfo->notifications.size() > 0)) {
55                 asynccallbackinfo->info.errorCode = ERROR;
56                 result = Common::NapiGetNull(env);
57             }
58         }
59         Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
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 
GetAllActiveNotifications(napi_env env,napi_callback_info info)69 napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
70 {
71     ANS_LOGI("enter");
72 
73     napi_ref callback = nullptr;
74     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
75         return Common::NapiGetUndefined(env);
76     }
77 
78     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
79     if (!asynccallbackinfo) {
80         return Common::JSParaError(env, callback);
81     }
82     napi_value promise = nullptr;
83     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
84 
85     napi_value resourceName = nullptr;
86     napi_create_string_latin1(env, "getAllActiveNotifications", NAPI_AUTO_LENGTH, &resourceName);
87     // Asynchronous function call
88     napi_create_async_work(
89         env,
90         nullptr,
91         resourceName,
92         [](napi_env env, void *data) {
93             ANS_LOGI("GetAllActiveNotifications napi_create_async_work start");
94             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
95             if (asynccallbackinfo) {
96                 asynccallbackinfo->info.errorCode =
97                     NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
98             }
99         },
100         AsyncCompleteCallbackGetAllActiveNotifications,
101         (void *)asynccallbackinfo,
102         &asynccallbackinfo->asyncWork);
103 
104     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
105 
106     if (asynccallbackinfo->info.isCallback) {
107         return Common::NapiGetNull(env);
108     } else {
109         return promise;
110     }
111 }
112 
AsyncCompleteCallbackGetActiveNotifications(napi_env env,napi_status status,void * data)113 void AsyncCompleteCallbackGetActiveNotifications(napi_env env, napi_status status, void *data)
114 {
115     ANS_LOGI("GetActiveNotifications napi_create_async_work end");
116 
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::ReturnCallbackPromise(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 
GetActiveNotifications(napi_env env,napi_callback_info info)162 napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
163 {
164     ANS_LOGI("enter");
165 
166     napi_ref callback = nullptr;
167     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
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         AsyncCompleteCallbackGetActiveNotifications,
194         (void *)asynccallbackinfo,
195         &asynccallbackinfo->asyncWork);
196 
197     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
198 
199     if (asynccallbackinfo->info.isCallback) {
200         return Common::NapiGetNull(env);
201     } else {
202         return promise;
203     }
204 }
205 
AsyncCompleteCallbackGetActiveNotificationCount(napi_env env,napi_status status,void * data)206 void AsyncCompleteCallbackGetActiveNotificationCount(napi_env env, napi_status status, void *data)
207 {
208     ANS_LOGI("GetActiveNotificationCount napi_create_async_work end");
209 
210     if (!data) {
211         ANS_LOGE("Invalid async callback data");
212         return;
213     }
214 
215     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
216     if (asynccallbackinfo) {
217         napi_value result = nullptr;
218         if (asynccallbackinfo->info.errorCode != ERR_OK) {
219             result = Common::NapiGetNull(env);
220         } else {
221             napi_create_uint32(env, asynccallbackinfo->num, &result);
222         }
223         Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
224         if (asynccallbackinfo->info.callback != nullptr) {
225             napi_delete_reference(env, asynccallbackinfo->info.callback);
226         }
227         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
228         delete asynccallbackinfo;
229         asynccallbackinfo = nullptr;
230     }
231 }
232 
GetActiveNotificationCount(napi_env env,napi_callback_info info)233 napi_value GetActiveNotificationCount(napi_env env, napi_callback_info info)
234 {
235     ANS_LOGI("enter");
236 
237     napi_ref callback = nullptr;
238     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
239         return Common::NapiGetUndefined(env);
240     }
241 
242     auto asynccallbackinfo = new (std::nothrow) AsyncCallbackInfoActive {.env = env, .asyncWork = nullptr};
243     if (!asynccallbackinfo) {
244         return Common::JSParaError(env, callback);
245     }
246     napi_value promise = nullptr;
247     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
248 
249     napi_value resourceName = nullptr;
250     napi_create_string_latin1(env, "getActiveNotificationCount", NAPI_AUTO_LENGTH, &resourceName);
251     // Asynchronous function call
252     napi_create_async_work(
253         env,
254         nullptr,
255         resourceName,
256         [](napi_env env, void *data) {
257             ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
258             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
259             if (asynccallbackinfo) {
260                 asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(
261                     asynccallbackinfo->num);
262                 ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
263             }
264         },
265         AsyncCompleteCallbackGetActiveNotificationCount,
266         (void *)asynccallbackinfo,
267         &asynccallbackinfo->asyncWork);
268 
269     NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
270 
271     if (asynccallbackinfo->info.isCallback) {
272         return Common::NapiGetNull(env);
273     } else {
274         return promise;
275     }
276 }
277 }  // namespace NotificationNapi
278 }  // namespace OHOS