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_distributed_enable.h"
17
18 #include "ans_inner_errors.h"
19 #include "js_native_api.h"
20 #include "js_native_api_types.h"
21
22 namespace OHOS {
23 namespace NotificationNapi {
24 const int SET_DISTRIBUTED_ENABLE_MAX_PARA = 3;
25 const int SET_DISTRIBUTED_ENABLE_MIN_PARA = 2;
26 const int SET_SMART_REMINDER_ENABLE_MAX_PARA = 2;
27 const int SET_SMART_REMINDER_ENABLE_MIN_PARA = 1;
ParseParameters(const napi_env & env,const napi_callback_info & info,DistributedEnableParams & params)28 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, DistributedEnableParams ¶ms)
29 {
30 ANS_LOGD("enter");
31
32 size_t argc = SET_DISTRIBUTED_ENABLE_MAX_PARA;
33 napi_value argv[SET_DISTRIBUTED_ENABLE_MAX_PARA] = {nullptr};
34 napi_value thisVar = nullptr;
35 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
36 if (argc < SET_DISTRIBUTED_ENABLE_MIN_PARA) {
37 ANS_LOGW("Wrong number of arguments.");
38 Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
39 return nullptr;
40 }
41
42 // argv[0]: bundleOption
43 napi_valuetype valuetype = napi_undefined;
44 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
45 if (valuetype != napi_object) {
46 ANS_LOGW("Parameter type error. Object expected.");
47 std::string msg = "Incorrect parameter types.The type of param must be object.";
48 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
49 return nullptr;
50 }
51 auto retValue = Common::GetBundleOption(env, argv[PARAM0], params.option);
52 if (retValue == nullptr) {
53 ANS_LOGE("GetBundleOption failed.");
54 Common::NapiThrow(env, ERROR_PARAM_INVALID, PARAMETER_VERIFICATION_FAILED);
55 return nullptr;
56 }
57
58 // argv[1]: deviceType
59 NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
60 if (valuetype != napi_string) {
61 ANS_LOGW("Wrong argument type. Bool expected.");
62 std::string msg = "Incorrect parameter types.The type of param must be boolean.";
63 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
64 return nullptr;
65 }
66 char str[STR_MAX_SIZE] = {0};
67 size_t strLen = 0;
68 napi_get_value_string_utf8(env, argv[PARAM1], str, STR_MAX_SIZE - 1, &strLen);
69 if (std::strlen(str) == 0) {
70 ANS_LOGE("Property deviceType is empty");
71 Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
72 return nullptr;
73 }
74 params.deviceType = str;
75
76 if (argc > SET_DISTRIBUTED_ENABLE_MIN_PARA) {
77 // argv[2]: enable
78 NAPI_CALL(env, napi_typeof(env, argv[PARAM2], &valuetype));
79 if (valuetype != napi_boolean) {
80 ANS_LOGW("Wrong argument type. Bool expected.");
81 std::string msg = "Incorrect parameter types.The type of param must be boolean.";
82 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
83 return nullptr;
84 }
85 napi_get_value_bool(env, argv[PARAM2], ¶ms.enable);
86 }
87
88 return Common::NapiGetNull(env);
89 }
90
AsyncCompleteCallbackNapiSetDistributedEnabledByBundle(napi_env env,napi_status status,void * data)91 void AsyncCompleteCallbackNapiSetDistributedEnabledByBundle(napi_env env, napi_status status, void *data)
92 {
93 ANS_LOGD("enter");
94 if (!data) {
95 ANS_LOGE("Invalid async callback data");
96 return;
97 }
98 AsyncCallbackDistributedEnable *asynccallbackinfo = static_cast<AsyncCallbackDistributedEnable *>(data);
99 if (asynccallbackinfo) {
100 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
101 if (asynccallbackinfo->info.callback != nullptr) {
102 ANS_LOGD("Delete NapiSetDistributedEnableByBundle callback reference.");
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
NapiSetDistributedEnabledByBundle(napi_env env,napi_callback_info info)111 napi_value NapiSetDistributedEnabledByBundle(napi_env env, napi_callback_info info)
112 {
113 ANS_LOGD("enter");
114 DistributedEnableParams params {};
115 if (ParseParameters(env, info, params) == nullptr) {
116 Common::NapiThrow(env, ERROR_PARAM_INVALID);
117 return Common::NapiGetUndefined(env);
118 }
119
120 AsyncCallbackDistributedEnable *asynccallbackinfo =
121 new (std::nothrow) AsyncCallbackDistributedEnable {.env = env, .asyncWork = nullptr, .params = params};
122 if (!asynccallbackinfo) {
123 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
124 return Common::JSParaError(env, nullptr);
125 }
126 napi_value promise = nullptr;
127 Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
128
129 napi_value resourceName = nullptr;
130 napi_create_string_latin1(env, "distributedEnableByBundle", 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_LOGD("NapiSetDistributedEnableByBundle work excute.");
137 AsyncCallbackDistributedEnable *asynccallbackinfo = static_cast<AsyncCallbackDistributedEnable *>(data);
138 if (asynccallbackinfo) {
139 std::string deviceType = asynccallbackinfo->params.deviceType;
140 asynccallbackinfo->info.errorCode = NotificationHelper::SetDistributedEnabledByBundle(
141 asynccallbackinfo->params.option, deviceType, asynccallbackinfo->params.enable);
142 ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
143 }
144 },
145 AsyncCompleteCallbackNapiSetDistributedEnabledByBundle,
146 (void *)asynccallbackinfo,
147 &asynccallbackinfo->asyncWork);
148
149 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
150
151 return promise;
152 }
153
AsyncCompleteCallbackNapiSetSmartReminderEnabled(napi_env env,napi_status status,void * data)154 void AsyncCompleteCallbackNapiSetSmartReminderEnabled(napi_env env, napi_status status, void *data)
155 {
156 ANS_LOGD("enter");
157 if (!data) {
158 ANS_LOGE("Invalid async callback data");
159 return;
160 }
161 AsyncCallbackSmartReminderEnabled *asynccallbackinfo = static_cast<AsyncCallbackSmartReminderEnabled *>(data);
162 if (asynccallbackinfo) {
163 Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
164 if (asynccallbackinfo->info.callback != nullptr) {
165 ANS_LOGD("Delete NapiSetSmartReminderEnabled callback reference.");
166 napi_delete_reference(env, asynccallbackinfo->info.callback);
167 }
168 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
169 delete asynccallbackinfo;
170 asynccallbackinfo = nullptr;
171 }
172 }
173
ParseParameters(const napi_env & env,const napi_callback_info & info,SmartReminderEnabledParams & params)174 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, SmartReminderEnabledParams ¶ms)
175 {
176 ANS_LOGD("enter");
177
178 size_t argc = SET_SMART_REMINDER_ENABLE_MAX_PARA;
179 napi_value argv[SET_SMART_REMINDER_ENABLE_MAX_PARA] = {nullptr};
180 napi_value thisVar = nullptr;
181 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, NULL));
182 if (argc < SET_SMART_REMINDER_ENABLE_MIN_PARA) {
183 ANS_LOGW("Wrong number of arguments.");
184 Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
185 return nullptr;
186 }
187
188 napi_valuetype valuetype = napi_undefined;
189 // argv[0]: deviceType
190 NAPI_CALL(env, napi_typeof(env, argv[PARAM0], &valuetype));
191 if (valuetype != napi_string) {
192 ANS_LOGW("Wrong argument type. String expected.");
193 std::string msg = "Incorrect parameter types.The type of param must be string.";
194 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
195 return nullptr;
196 }
197 char str[STR_MAX_SIZE] = {0};
198 size_t strLen = 0;
199 napi_get_value_string_utf8(env, argv[PARAM0], str, STR_MAX_SIZE - 1, &strLen);
200 if (std::strlen(str) == 0) {
201 ANS_LOGE("Property deviceType is empty");
202 Common::NapiThrow(env, ERROR_PARAM_INVALID, MANDATORY_PARAMETER_ARE_LEFT_UNSPECIFIED);
203 return nullptr;
204 }
205 params.deviceType = str;
206
207 if (argc > SET_SMART_REMINDER_ENABLE_MIN_PARA) {
208 // argv[1]: enable
209 NAPI_CALL(env, napi_typeof(env, argv[PARAM1], &valuetype));
210 if (valuetype != napi_boolean) {
211 ANS_LOGW("Wrong argument type. Bool expected.");
212 std::string msg = "Incorrect parameter types.The type of param must be boolean.";
213 Common::NapiThrow(env, ERROR_PARAM_INVALID, msg);
214 return nullptr;
215 }
216 napi_get_value_bool(env, argv[PARAM1], ¶ms.enable);
217 }
218
219 return Common::NapiGetNull(env);
220 }
221
NapiSetSmartReminderEnabled(napi_env env,napi_callback_info info)222 napi_value NapiSetSmartReminderEnabled(napi_env env, napi_callback_info info)
223 {
224 ANS_LOGD("enter");
225 SmartReminderEnabledParams params {};
226 if (ParseParameters(env, info, params) == nullptr) {
227 Common::NapiThrow(env, ERROR_PARAM_INVALID);
228 return Common::NapiGetUndefined(env);
229 }
230
231 AsyncCallbackSmartReminderEnabled *asynccallbackinfo =
232 new (std::nothrow) AsyncCallbackSmartReminderEnabled {.env = env, .asyncWork = nullptr, .params = params};
233 if (!asynccallbackinfo) {
234 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
235 return Common::JSParaError(env, nullptr);
236 }
237 napi_value promise = nullptr;
238 Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
239
240 napi_value resourceName = nullptr;
241 napi_create_string_latin1(env, "setSmartReminderEnabled", NAPI_AUTO_LENGTH, &resourceName);
242 // Asynchronous function call
243 napi_create_async_work(env,
244 nullptr,
245 resourceName,
246 [](napi_env env, void *data) {
247 ANS_LOGD("NapiSetSmartReminderEnabled work excute.");
248 AsyncCallbackSmartReminderEnabled *asynccallbackinfo =
249 static_cast<AsyncCallbackSmartReminderEnabled *>(data);
250 if (asynccallbackinfo) {
251 asynccallbackinfo->info.errorCode = NotificationHelper::SetSmartReminderEnabled(
252 asynccallbackinfo->params.deviceType, asynccallbackinfo->params.enable);
253 ANS_LOGD("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
254 }
255 },
256 AsyncCompleteCallbackNapiSetSmartReminderEnabled,
257 (void *)asynccallbackinfo,
258 &asynccallbackinfo->asyncWork);
259
260 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
261 return promise;
262 }
263
AsyncCompleteCallbackNapiIsSmartReminderEnabled(napi_env env,napi_status status,void * data)264 void AsyncCompleteCallbackNapiIsSmartReminderEnabled(napi_env env, napi_status status, void *data)
265 {
266 ANS_LOGD("enter");
267 if (!data) {
268 ANS_LOGE("Invalid async callback data");
269 return;
270 }
271 ANS_LOGI("IsSmartReminderEnabled napi_create_async_work end");
272 AsyncCallbackSmartReminderEnabled *asynccallbackinfo = static_cast<AsyncCallbackSmartReminderEnabled *>(data);
273 if (asynccallbackinfo) {
274 napi_value result = nullptr;
275 if (asynccallbackinfo->info.errorCode != ERR_OK) {
276 result = Common::NapiGetNull(env);
277 } else {
278 napi_get_boolean(env, asynccallbackinfo->params.enable, &result);
279 }
280 Common::CreateReturnValue(env, asynccallbackinfo->info, result);
281 if (asynccallbackinfo->info.callback != nullptr) {
282 ANS_LOGD("Delete NapiIsSmartReminderEnabled callback reference.");
283 napi_delete_reference(env, asynccallbackinfo->info.callback);
284 }
285 napi_delete_async_work(env, asynccallbackinfo->asyncWork);
286 delete asynccallbackinfo;
287 asynccallbackinfo = nullptr;
288 }
289 }
290
NapiIsSmartReminderEnabled(napi_env env,napi_callback_info info)291 napi_value NapiIsSmartReminderEnabled(napi_env env, napi_callback_info info)
292 {
293 ANS_LOGD("enter");
294 SmartReminderEnabledParams params {};
295 if (ParseParameters(env, info, params) == nullptr) {
296 Common::NapiThrow(env, ERROR_PARAM_INVALID);
297 return Common::NapiGetUndefined(env);
298 }
299
300 AsyncCallbackSmartReminderEnabled *asynccallbackinfo =
301 new (std::nothrow) AsyncCallbackSmartReminderEnabled {.env = env, .asyncWork = nullptr, .params = params};
302 if (!asynccallbackinfo) {
303 Common::NapiThrow(env, ERROR_INTERNAL_ERROR);
304 return Common::JSParaError(env, nullptr);
305 }
306 napi_value promise = nullptr;
307 Common::PaddingCallbackPromiseInfo(env, nullptr, asynccallbackinfo->info, promise);
308
309 napi_value resourceName = nullptr;
310 napi_create_string_latin1(env, "isSmartReminderEnabled", NAPI_AUTO_LENGTH, &resourceName);
311 // Asynchronous function call
312 napi_create_async_work(env,
313 nullptr,
314 resourceName,
315 [](napi_env env, void *data) {
316 ANS_LOGD("NapiIsSmartReminderEnabled work excute.");
317 AsyncCallbackSmartReminderEnabled *asynccallbackinfo =
318 static_cast<AsyncCallbackSmartReminderEnabled *>(data);
319 if (asynccallbackinfo) {
320 asynccallbackinfo->info.errorCode = NotificationHelper::IsSmartReminderEnabled(
321 asynccallbackinfo->params.deviceType, asynccallbackinfo->params.enable);
322 ANS_LOGD("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
323 }
324 },
325 AsyncCompleteCallbackNapiIsSmartReminderEnabled,
326 (void *)asynccallbackinfo,
327 &asynccallbackinfo->asyncWork);
328
329 napi_queue_async_work_with_qos(env, asynccallbackinfo->asyncWork, napi_qos_user_initiated);
330 return promise;
331 }
332 } // namespace NotificationNapi
333 } // namespace OHOS
334