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 #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 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
77
78 if (asynccallbackinfo->info.isCallback) {
79 return Common::NapiGetNull(env);
80 } else {
81 return promise;
82 }
83 }
84
AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env,napi_status status,void * data)85 void AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env, napi_status status, void *data)
86 {
87 ANS_LOGI("enter");
88 if (!data) {
89 ANS_LOGE("Invalid async callback data");
90 return;
91 }
92 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
93 if (asynccallbackinfo) {
94 napi_value result = Common::NapiGetNull(env);
95 if (asynccallbackinfo->info.errorCode == ERR_OK) {
96 napi_create_object(env, &result);
97 if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
98 asynccallbackinfo->info.errorCode = ERROR;
99 }
100 }
101 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
102 if (asynccallbackinfo->info.callback != nullptr) {
103 napi_delete_reference(env, asynccallbackinfo->info.callback);
104 }
105 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
106 delete asynccallbackinfo;
107 asynccallbackinfo = nullptr;
108 }
109 }
110
NapiGetDoNotDisturbDate(napi_env env,napi_callback_info info)111 napi_value NapiGetDoNotDisturbDate(napi_env env, napi_callback_info info)
112 {
113 ANS_LOGI("enter");
114
115 GetDoNotDisturbDateParams params {};
116 if (ParseParameters(env, info, params) == nullptr) {
117 Common::NapiThrow(env, ERROR_PARAM_INVALID);
118 return Common::NapiGetUndefined(env);
119 }
120
121 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo =
122 new (std::nothrow) AsyncCallbackInfoGetDoNotDisturb {.env = env, .asyncWork = nullptr, .params = params};
123 if (!asynccallbackinfo) {
124 return Common::JSParaError(env, params.callback);
125 }
126 napi_value promise = nullptr;
127 Common::PaddingCallbackPromiseInfo(env, params.callback, asynccallbackinfo->info, promise);
128
129 napi_value resourceName = nullptr;
130 napi_create_string_latin1(env, "getDoNotDisturbDate", NAPI_AUTO_LENGTH, &resourceName);
131 // Asynchronous function call
132 napi_create_async_work(env,
133 nullptr,
134 resourceName,
135 [](napi_env env, void *data) {
136 ANS_LOGI("GetDoNotDisturbDate napi_create_async_work start");
137 AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
138 if (asynccallbackinfo) {
139 if (asynccallbackinfo->params.hasUserId) {
140 asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
141 asynccallbackinfo->params.userId, asynccallbackinfo->date);
142 } else {
143 asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
144 asynccallbackinfo->date);
145 }
146
147 ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
148 asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
149 asynccallbackinfo->params.hasUserId);
150 }
151 },
152 AsyncCompleteCallbackNapiGetDoNotDisturbDate,
153 (void *)asynccallbackinfo,
154 &asynccallbackinfo->asyncWork);
155
156 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
157
158 if (asynccallbackinfo->info.isCallback) {
159 return Common::NapiGetNull(env);
160 } else {
161 return promise;
162 }
163 }
164
NapiSupportDoNotDisturbMode(napi_env env,napi_callback_info info)165 napi_value NapiSupportDoNotDisturbMode(napi_env env, napi_callback_info info)
166 {
167 ANS_LOGI("enter");
168
169 napi_ref callback = nullptr;
170 if (Common::ParseParaOnlyCallback(env, info, callback) == nullptr) {
171 Common::NapiThrow(env, ERROR_PARAM_INVALID);
172 return Common::NapiGetUndefined(env);
173 }
174
175 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
176 new (std::nothrow) AsyncCallbackInfoSupportDoNotDisturb {
177 .env = env, .asyncWork = nullptr, .callback = callback};
178
179 if (!asynccallbackinfo) {
180 return Common::JSParaError(env, callback);
181 }
182 napi_value promise = nullptr;
183 Common::PaddingCallbackPromiseInfo(env, callback, asynccallbackinfo->info, promise);
184
185 napi_value resourceName = nullptr;
186 napi_create_string_latin1(env, "supportDoNotDisturbMode", NAPI_AUTO_LENGTH, &resourceName);
187 // Asynchronous function call
188 napi_create_async_work(env,
189 nullptr,
190 resourceName,
191 [](napi_env env, void *data) {
192 ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work start");
193 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
194 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
195 if (asynccallbackinfo) {
196 asynccallbackinfo->info.errorCode =
197 NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
198 ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
199 asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
200 }
201 },
202 [](napi_env env, napi_status status, void *data) {
203 ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work end");
204 AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
205 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
206 if (asynccallbackinfo) {
207 napi_value result = nullptr;
208 napi_get_boolean(env, asynccallbackinfo->isSupported, &result);
209 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
210 if (asynccallbackinfo->info.callback != nullptr) {
211 napi_delete_reference(env, asynccallbackinfo->info.callback);
212 }
213 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
214 delete asynccallbackinfo;
215 asynccallbackinfo = nullptr;
216 }
217 },
218 (void *)asynccallbackinfo,
219 &asynccallbackinfo->asyncWork);
220
221 NAPI_CALL(env, napi_queue_async_work(env, asynccallbackinfo->asyncWork));
222
223 if (asynccallbackinfo->info.isCallback) {
224 return Common::NapiGetNull(env);
225 } else {
226 return promise;
227 }
228 }
229 } // namespace NotificationNapi
230 } // namespace OHOS