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 #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_LOGI("enter");
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 return Common::JSParaError(env, params.callback);
36 }
37 napi_value promise = nullptr;
38 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
39
40 napi_value resourceName = nullptr;
41 napi_create_string_latin1(env, "setDoNotDisturbDate", NAPI_AUTO_LENGTH, &resourceName);
42 // Asynchronous function call
43 napi_create_async_work(env,
44 nullptr, resourceName, [](napi_env env, void *data) {
45 ANS_LOGI("SetDoNotDisturbDate napi_create_async_work start");
46 AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
47 if (asynccallbackinfo) {
48 if (asynccallbackinfo->params.hasUserId) {
49 asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
50 asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
51 } else {
52 asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
53 asynccallbackinfo->params.date);
54 }
55
56 ANS_LOGI("SetDoNotDisturbDate date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
57 asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
58 asynccallbackinfo->params.hasUserId);
59 }
60 },
61 [](napi_env env, napi_status status, void *data) {
62 ANS_LOGI("SetDoNotDisturbDate napi_create_async_work end");
63 AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
64 if (asynccallbackinfo) {
65 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
66 if (asynccallbackinfo->info.callback != nullptr) {
67 napi_delete_reference(env, asynccallbackinfo->info.callback);
68 }
69 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
70 delete asynccallbackinfo;
71 asynccallbackinfo = nullptr;
72 }
73 },
74 (void *)asynccallbackinfo, &asynccallbackinfo->asyncWork);
75
76 bool isCallback = asynccallbackinfo->info.isCallback;
77 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
78 if (status != napi_ok) {
79 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
80 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
81 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
82 if (asynccallbackinfo->info.callback != nullptr) {
83 napi_delete_reference(env, asynccallbackinfo->info.callback);
84 }
85 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
86 delete asynccallbackinfo;
87 asynccallbackinfo = nullptr;
88 }
89
90 if (isCallback) {
91 return Common::NapiGetNull(env);
92 } else {
93 return promise;
94 }
95 }
96
AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env,napi_status status,void * data)97 void AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env, napi_status status, void *data)
98 {
99 ANS_LOGI("enter");
100 if (!data) {
101 ANS_LOGE("Invalid async callback data");
102 return;
103 }
104 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
105 if (asynccallbackinfo) {
106 napi_value result = Common::NapiGetNull(env);
107 if (asynccallbackinfo->info.errorCode == ERR_OK) {
108 napi_create_object(env, &result);
109 if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
110 asynccallbackinfo->info.errorCode = ERROR;
111 }
112 }
113 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
114 if (asynccallbackinfo->info.callback != nullptr) {
115 napi_delete_reference(env, asynccallbackinfo->info.callback);
116 }
117 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
118 delete asynccallbackinfo;
119 asynccallbackinfo = nullptr;
120 }
121 }
122
NapiGetDoNotDisturbDate(napi_env env,napi_callback_info info)123 napi_value NapiGetDoNotDisturbDate(napi_env env, napi_callback_info info)
124 {
125 ANS_LOGI("enter");
126
127 GetDoNotDisturbDateParams params {};
128 if (ParseParameters(env, info, params) == nullptr) {
129 Common::NapiThrow(env, ERROR_PARAM_INVALID);
130 return Common::NapiGetUndefined(env);
131 }
132
133 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo =
134 new (std::nothrow) AsyncCallbackInfoGetDoNotDisturb {.env = env, .asyncWork = nullptr, .params = params};
135 if (!asynccallbackinfo) {
136 return Common::JSParaError(env, params.callback);
137 }
138 napi_value promise = nullptr;
139 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
140
141 napi_value resourceName = nullptr;
142 napi_create_string_latin1(env, "getDoNotDisturbDate", NAPI_AUTO_LENGTH, &resourceName);
143 // Asynchronous function call
144 napi_create_async_work(env,
145 nullptr,
146 resourceName,
147 [](napi_env env, void *data) {
148 ANS_LOGI("GetDoNotDisturbDate napi_create_async_work start");
149 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
150 if (asynccallbackinfo) {
151 if (asynccallbackinfo->params.hasUserId) {
152 asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
153 asynccallbackinfo->params.userId, asynccallbackinfo->date);
154 } else {
155 asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
156 asynccallbackinfo->date);
157 }
158
159 ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
160 asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
161 asynccallbackinfo->params.hasUserId);
162 }
163 },
164 AsyncCompleteCallbackNapiGetDoNotDisturbDate,
165 (void *)asynccallbackinfo,
166 &asynccallbackinfo->asyncWork);
167
168 bool isCallback = asynccallbackinfo->info.isCallback;
169 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
170 if (status != napi_ok) {
171 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
172 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
173 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
174 if (asynccallbackinfo->info.callback != nullptr) {
175 napi_delete_reference(env, asynccallbackinfo->info.callback);
176 }
177 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
178 delete asynccallbackinfo;
179 asynccallbackinfo = nullptr;
180 }
181
182 if (isCallback) {
183 return Common::NapiGetNull(env);
184 } else {
185 return promise;
186 }
187 }
188
NapiSupportDoNotDisturbMode(napi_env env,napi_callback_info info)189 napi_value NapiSupportDoNotDisturbMode(napi_env env, napi_callback_info info)
190 {
191 ANS_LOGI("enter");
192
193 napi_ref callback = nullptr;
194 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
195 Common::NapiThrow(env, ERROR_PARAM_INVALID);
196 return Common::NapiGetUndefined(env);
197 }
198
199 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
200 new (std::nothrow) AsyncCallbackInfoSupportDoNotDisturb {
201 .env = env, .asyncWork = nullptr, .callback = callback};
202
203 if (!asynccallbackinfo) {
204 return Common::JSParaError(env, callback);
205 }
206 napi_value promise = nullptr;
207 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
208
209 napi_value resourceName = nullptr;
210 napi_create_string_latin1(env, "supportDoNotDisturbMode", NAPI_AUTO_LENGTH, &resourceName);
211 // Asynchronous function call
212 napi_create_async_work(env,
213 nullptr,
214 resourceName,
215 [](napi_env env, void *data) {
216 ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work start");
217 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
218 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
219 if (asynccallbackinfo) {
220 asynccallbackinfo->info.errorCode =
221 NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
222 ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
223 asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
224 }
225 },
226 [](napi_env env, napi_status status, void *data) {
227 ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work end");
228 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
229 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
230 if (asynccallbackinfo) {
231 napi_value result = nullptr;
232 napi_get_boolean(env, asynccallbackinfo->isSupported, &result);
233 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
234 if (asynccallbackinfo->info.callback != nullptr) {
235 napi_delete_reference(env, asynccallbackinfo->info.callback);
236 }
237 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
238 delete asynccallbackinfo;
239 asynccallbackinfo = nullptr;
240 }
241 },
242 (void *)asynccallbackinfo,
243 &asynccallbackinfo->asyncWork);
244
245 bool isCallback = asynccallbackinfo->info.isCallback;
246 napi_status status = napi_queue_async_work(env, asynccallbackinfo->asyncWork);
247 if (status != napi_ok) {
248 ANS_LOGE("napi_queue_async_work failed return: %{public}d", status);
249 asynccallbackinfo->info.errorCode = ERROR_INTERNAL_ERROR;
250 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
251 if (asynccallbackinfo->info.callback != nullptr) {
252 napi_delete_reference(env, asynccallbackinfo->info.callback);
253 }
254 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
255 delete asynccallbackinfo;
256 asynccallbackinfo = nullptr;
257 }
258
259 if (isCallback) {
260 return Common::NapiGetNull(env);
261 } else {
262 return promise;
263 }
264 }
265 } // namespace NotificationNapi
266 } // namespace OHOS