• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2024 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 #include "napi_disturb_mode.h"
16 
17 #include "ans_inner_errors.h"
18 #include "disturb_mode.h"
19 
20 namespace OHOS {
21 namespace NotificationNapi {
NapiSetDoNotDisturbDate(napi_env env,napi_callback_info info)22 napi_value NapiSetDoNotDisturbDate(napi_env env, napi_callback_info info)
23 {
24     ANS_LOGD("called");
25 
26     SetDoNotDisturbDateParams params {};
27     if (ParseParameters(env, info, params) == nullptr) {
28         Common::NapiThrow(env, ERROR_PARAM_INVALID);
29         return Common::NapiGetUndefined(env);
30     }
31 
32     AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo =
33         new (std::nothrow) AsyncCallbackInfoSetDoNotDisturb {.env = env, .asyncWork = nullptr, .params = params};
34     if (!asynccallbackinfo) {
35         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
36         return Common::JSParaError(env, params.callback);
37     }
38     napi_value promise = nullptr;
39     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
40 
41     napi_value resourceName = nullptr;
42     napi_create_string_latin1(env, "setDoNotDisturbDate", NAPI_AUTO_LENGTH, &resourceName);
43     // Asynchronous function call
44     napi_create_async_work(env,
45         nullptr, resourceName, [](napi_env env, void *data) {
46             ANS_LOGD("NapiSetDoNotDisturbDate work excute.");
47             AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
48             if (asynccallbackinfo) {
49                 if (asynccallbackinfo->params.hasUserId) {
50                     asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
51                         asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
52                 } else {
53                     asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
54                         asynccallbackinfo->params.date);
55                 }
56 
57                 ANS_LOGI("date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
58                     asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
59                     asynccallbackinfo->params.hasUserId);
60             }
61         },
62         [](napi_env env, napi_status status, void *data) {
63             ANS_LOGD("NapiSetDoNotDisturbDate work complete.");
64             AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
65             if (asynccallbackinfo) {
66                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
67                 if (asynccallbackinfo->info.callback != nullptr) {
68                     ANS_LOGD("Delete napiSetDoNotDisturbDate callback reference.");
69                     napi_delete_reference(env, asynccallbackinfo->info.callback);
70                 }
71                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
72                 delete asynccallbackinfo;
73                 asynccallbackinfo = nullptr;
74             }
75         },
76         (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
77 
78     bool isCallback = asynccallbackinfo->info.isCallback;
79     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
80 
81     if (isCallback) {
82         ANS_LOGD("null isCallback");
83         return Common::NapiGetNull(env);
84     } else {
85         return promise;
86     }
87 }
88 
NapiAddDoNotDisturbProfiles(napi_env env,napi_callback_info info)89 napi_value NapiAddDoNotDisturbProfiles(napi_env env, napi_callback_info info)
90 {
91     ANS_LOGD("called");
92     std::vector<sptr<NotificationDoNotDisturbProfile>> profiles;
93     if (!ParseProfilesParameters(env, info, profiles)) {
94         Common::NapiThrow(env, ERROR_PARAM_INVALID);
95         return Common::NapiGetUndefined(env);
96     }
97     AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
98         new (std::nothrow) AsyncCallbackInfoDoNotDisturbProfile{.env = env, .asyncWork = nullptr, .profiles = profiles};
99     if (!asynccallbackinfo) {
100         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
101         return Common::JSParaError(env, nullptr);
102     }
103     napi_value promise = nullptr;
104     Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
105     napi_value resourceName = nullptr;
106     napi_create_string_latin1(env, "AddDoNotDisturbProfiles", NAPI_AUTO_LENGTH, &resourceName);
107     // Asynchronous function call
108     napi_create_async_work(env,
109         nullptr, resourceName, [](napi_env env, void *data) {
110             ANS_LOGD("Napi add do not disturb profiles work excute.");
111             AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
112                 static_cast<AsyncCallbackInfoDoNotDisturbProfile *>(data);
113             if (asynccallbackinfo) {
114                 asynccallbackinfo->info.errorCode =
115                     NotificationHelper::AddDoNotDisturbProfiles(asynccallbackinfo->profiles);
116             }
117         },
118         [](napi_env env, napi_status status, void *data) {
119             ANS_LOGD("Napi add do not disturb profiles work complete.");
120             AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
121                 static_cast<AsyncCallbackInfoDoNotDisturbProfile *>(data);
122             if (asynccallbackinfo) {
123                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
124                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
125                 delete asynccallbackinfo;
126                 asynccallbackinfo = nullptr;
127             }
128         },
129         (void *)asynccallbackinfo,
130         &asynccallbackinfo->asyncWork);
131     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
132     return promise;
133 }
134 
NapiRemoveDoNotDisturbProfiles(napi_env env,napi_callback_info info)135 napi_value NapiRemoveDoNotDisturbProfiles(napi_env env, napi_callback_info info)
136 {
137     ANS_LOGD("called");
138     std::vector<sptr<NotificationDoNotDisturbProfile>> profiles;
139     if (!ParseProfilesParameters(env, info, profiles)) {
140         Common::NapiThrow(env, ERROR_PARAM_INVALID);
141         return Common::NapiGetUndefined(env);
142     }
143     AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
144         new (std::nothrow) AsyncCallbackInfoDoNotDisturbProfile{.env = env, .asyncWork = nullptr, .profiles = profiles};
145     if (!asynccallbackinfo) {
146         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
147         return Common::JSParaError(env, nullptr);
148     }
149     napi_value promise = nullptr;
150     Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
151     napi_value resourceName = nullptr;
152     napi_create_string_latin1(env, "RemoveDoNotDisturbProfiles", NAPI_AUTO_LENGTH, &resourceName);
153     // Asynchronous function call
154     napi_create_async_work(env,
155         nullptr, resourceName, [](napi_env env, void *data) {
156             ANS_LOGD("Napi remove do not disturb profiles work excute.");
157             AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
158                 static_cast<AsyncCallbackInfoDoNotDisturbProfile *>(data);
159             if (asynccallbackinfo) {
160                 asynccallbackinfo->info.errorCode =
161                     NotificationHelper::RemoveDoNotDisturbProfiles(asynccallbackinfo->profiles);
162             }
163         },
164         [](napi_env env, napi_status status, void *data) {
165             ANS_LOGD("Napi remove do not disturb profiles work complete.");
166             AsyncCallbackInfoDoNotDisturbProfile *asynccallbackinfo =
167                 static_cast<AsyncCallbackInfoDoNotDisturbProfile *>(data);
168             if (asynccallbackinfo) {
169                 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
170                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
171                 delete asynccallbackinfo;
172                 asynccallbackinfo = nullptr;
173             }
174         },
175         (void *)asynccallbackinfo,
176         &asynccallbackinfo->asyncWork);
177     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
178     return promise;
179 }
180 
AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env,napi_status status,void * data)181 void AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env, napi_status status, void *data)
182 {
183     ANS_LOGD("called");
184     if (!data) {
185         ANS_LOGE("Invalid async callback data");
186         return;
187     }
188     AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
189     if (asynccallbackinfo) {
190         napi_value result = Common::NapiGetNull(env);
191         if (asynccallbackinfo->info.errorCode == ERR_OK) {
192             napi_create_object(env, &result);
193             if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
194                 asynccallbackinfo->info.errorCode = ERROR;
195             }
196         }
197         Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
198         if (asynccallbackinfo->info.callback != nullptr) {
199             napi_delete_reference(env, asynccallbackinfo->info.callback);
200         }
201         napi_delete_async_work(env, asynccallbackinfo->asyncWork);
202         delete asynccallbackinfo;
203         asynccallbackinfo = nullptr;
204     }
205 }
206 
NapiGetDoNotDisturbDate(napi_env env,napi_callback_info info)207 napi_value NapiGetDoNotDisturbDate(napi_env env, napi_callback_info info)
208 {
209     ANS_LOGD("called");
210 
211     GetDoNotDisturbDateParams params {};
212     if (ParseParameters(env, info, params) == nullptr) {
213         Common::NapiThrow(env, ERROR_PARAM_INVALID);
214         return Common::NapiGetUndefined(env);
215     }
216 
217     AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo =
218         new (std::nothrow) AsyncCallbackInfoGetDoNotDisturb {.env = env, .asyncWork = nullptr, .params = params};
219     if (!asynccallbackinfo) {
220         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
221         return Common::JSParaError(env, params.callback);
222     }
223     napi_value promise = nullptr;
224     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
225 
226     napi_value resourceName = nullptr;
227     napi_create_string_latin1(env, "getDoNotDisturbDate", NAPI_AUTO_LENGTH, &resourceName);
228     // Asynchronous function call
229     napi_create_async_work(env,
230         nullptr,
231         resourceName,
232         [](napi_env env, void *data) {
233             ANS_LOGD("NapiGetDoNotDisturbDate work excute.");
234             AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo =
235                 static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
236             if (asynccallbackinfo) {
237                 if (asynccallbackinfo->params.hasUserId) {
238                     asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
239                         asynccallbackinfo->params.userId, asynccallbackinfo->date);
240                 } else {
241                     asynccallbackinfo->info.errorCode =
242                         NotificationHelper::GetDoNotDisturbDate(asynccallbackinfo->date);
243                 }
244 
245                 ANS_LOGI("errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
246                     asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
247                     asynccallbackinfo->params.hasUserId);
248             }
249         },
250         AsyncCompleteCallbackNapiGetDoNotDisturbDate,
251         (void *)asynccallbackinfo,
252         &asynccallbackinfo->asyncWork);
253 
254     bool isCallback = asynccallbackinfo->info.isCallback;
255     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
256 
257     if (isCallback) {
258         ANS_LOGD("null isCallback");
259         return Common::NapiGetNull(env);
260     } else {
261         return promise;
262     }
263 }
264 
NapiSupportDoNotDisturbMode(napi_env env,napi_callback_info info)265 napi_value NapiSupportDoNotDisturbMode(napi_env env, napi_callback_info info)
266 {
267     ANS_LOGD("called");
268 
269     napi_ref callback = nullptr;
270     if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
271         Common::NapiThrow(env, ERROR_PARAM_INVALID);
272         return Common::NapiGetUndefined(env);
273     }
274 
275     AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
276         new (std::nothrow) AsyncCallbackInfoSupportDoNotDisturb {
277         .env = env, .asyncWork = nullptr, .callback = callback};
278 
279     if (!asynccallbackinfo) {
280         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
281         return Common::JSParaError(env, callback);
282     }
283     napi_value promise = nullptr;
284     Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
285 
286     napi_value resourceName = nullptr;
287     napi_create_string_latin1(env, "supportDoNotDisturbMode", NAPI_AUTO_LENGTH, &resourceName);
288     // Asynchronous function call
289     napi_create_async_work(env,
290         nullptr,
291         resourceName,
292         [](napi_env env, void *data) {
293             ANS_LOGD("NapiSupportDoNotDisturbMode work excute.");
294             AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
295                 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
296             if (asynccallbackinfo) {
297                 asynccallbackinfo->info.errorCode =
298                     NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
299                 ANS_LOGI("errorCode=%{public}d isSupported=%{public}d",
300                     asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
301             }
302         },
303         [](napi_env env, napi_status status, void *data) {
304             ANS_LOGD("NapiSupportDoNotDisturbMode work complete.");
305             AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
306                 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
307             if (asynccallbackinfo) {
308                 napi_value result = nullptr;
309                 napi_get_boolean(env, asynccallbackinfo->isSupported, &result);
310                 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
311                 if (asynccallbackinfo->info.callback != nullptr) {
312                     ANS_LOGD("Delete napiSupportDoNotDisturbMode callback reference.");
313                     napi_delete_reference(env, asynccallbackinfo->info.callback);
314                 }
315                 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
316                 delete asynccallbackinfo;
317                 asynccallbackinfo = nullptr;
318             }
319             ANS_LOGD("NapiSupportDoNotDisturbMode work complete end.");
320         },
321         (void *)asynccallbackinfo,
322         &asynccallbackinfo->asyncWork);
323 
324     bool isCallback = asynccallbackinfo->info.isCallback;
325     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
326 
327     if (isCallback) {
328         ANS_LOGD("null isCallback");
329         return Common::NapiGetNull(env);
330     } else {
331         return promise;
332     }
333 }
334 
AsyncCompleteCallbackNapiGetDoNotDisturbProfile(napi_env env,napi_status status,void * data)335 void AsyncCompleteCallbackNapiGetDoNotDisturbProfile(napi_env env, napi_status status, void *data)
336 {
337     ANS_LOGD("called");
338     if (!data) {
339         ANS_LOGE("Invalid async callback data.");
340         return;
341     }
342     napi_value result = nullptr;
343     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetDoNotDisturbProfile *>(data);
344     if (asynccallbackinfo == nullptr) {
345         return;
346     }
347 
348     if (asynccallbackinfo->info.errorCode != ERR_OK) {
349         result = Common::NapiGetNull(env);
350     } else {
351         if (asynccallbackinfo->data != nullptr) {
352             napi_create_object(env, &result);
353             if (!Common::SetDoNotDisturbProfile(env, *asynccallbackinfo->data, result)) {
354                 asynccallbackinfo->info.errorCode = ERROR;
355                 result = Common::NapiGetNull(env);
356             }
357         }
358     }
359     Common::CreateReturnValue(env, asynccallbackinfo->info, result);
360     if (asynccallbackinfo->info.callback != nullptr) {
361         ANS_LOGD("Delete getDoNotDisturbProfile callback reference.");
362         napi_delete_reference(env, asynccallbackinfo->info.callback);
363     }
364     napi_delete_async_work(env, asynccallbackinfo->asyncWork);
365     delete asynccallbackinfo;
366     asynccallbackinfo = nullptr;
367 }
368 
NapiGetDoNotDisturbProfile(napi_env env,napi_callback_info info)369 napi_value NapiGetDoNotDisturbProfile(napi_env env, napi_callback_info info)
370 {
371     ANS_LOGD("called");
372     GetDoNotDisturbProfileParams params {};
373     if (ParseParameters(env, info, params) == nullptr) {
374         Common::NapiThrow(env, ERROR_PARAM_INVALID);
375         return Common::NapiGetUndefined(env);
376     }
377 
378     AsyncCallbackInfoGetDoNotDisturbProfile *asynccallbackinfo =
379         new (std::nothrow) AsyncCallbackInfoGetDoNotDisturbProfile {.env = env, .asyncWork = nullptr, .params = params};
380     if (!asynccallbackinfo) {
381         Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
382         return Common::JSParaError(env, params.callback);
383     }
384     napi_value promise = nullptr;
385     Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
386 
387     napi_value resourceName = nullptr;
388     napi_create_string_latin1(env, "getDoNotDisturbProfile", NAPI_AUTO_LENGTH, &resourceName);
389     // Asynchronous function call
390     napi_create_async_work(env,
391         nullptr,
392         resourceName,
393         [](napi_env env, void *data) {
394             ANS_LOGD("NapiGetDoNotDisturbProfile work excute.");
395             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetDoNotDisturbProfile *>(data);
396             if (asynccallbackinfo) {
397                 asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbProfile(
398                     asynccallbackinfo->params.profileId, asynccallbackinfo->data);
399             }
400         },
401         AsyncCompleteCallbackNapiGetDoNotDisturbProfile,
402         (void *)asynccallbackinfo,
403         &asynccallbackinfo->asyncWork);
404 
405     bool isCallback = asynccallbackinfo->info.isCallback;
406     napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
407 
408     if (isCallback) {
409         ANS_LOGD("null isCallback");
410         return Common::NapiGetNull(env);
411     } else {
412         return promise;
413     }
414 }
415 }  // namespace NotificationNapi
416 }  // namespace OHOS
417