• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <string>
16 #include "securec.h"
17 #include "napi_scan_utils.h"
18 #include "scan_log.h"
19 #include "scan_callback.h"
20 #include "scan_manager_client.h"
21 #include "scan_util.h"
22 #include "napi_inner_scan.h"
23 #include "napi_scan_helper.h"
24 #include "tokenid_kit.h"
25 
26 namespace OHOS::Scan {
27 const std::string SCAN_DEVICE_FOUND = "scanDeviceFound";
28 const std::string SCAN_DEVICE_SYNC = "scanDeviceSync";
29 const std::string SCAN_DEVICE_ADD = "scanDeviceAdd";
30 const std::string SCAN_DEVICE_DEL = "scanDeviceDel";
31 
InitScan(napi_env env,napi_callback_info info)32 napi_value NapiInnerScan::InitScan(napi_env env, napi_callback_info info)
33 {
34     SCAN_HILOGD("Enter InitScan---->");
35     auto context = std::make_shared<NapiScanContext>();
36     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
37         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
38         return napi_ok;
39     };
40     auto output = [context](napi_env env, napi_value *result) -> napi_status {
41         napi_status status = napi_get_undefined(env, result);
42         return status;
43     };
44     auto exec = [context](ScanAsyncCall::Context *ctx) {
45         int32_t ret = ScanManagerClient::GetInstance()->InitScan();
46         context->result = ret == E_SCAN_NONE;
47         if (ret != E_SCAN_NONE) {
48             SCAN_HILOGE("Failed to init the scan fwk");
49             context->SetErrorIndex(ret);
50         }
51     };
52     context->SetAction(std::move(input), std::move(output));
53     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
54     return asyncCall.Call(env, exec);
55 }
56 
ExitScan(napi_env env,napi_callback_info info)57 napi_value NapiInnerScan::ExitScan(napi_env env, napi_callback_info info)
58 {
59     SCAN_HILOGD("Enter ExitScan---->");
60     auto context = std::make_shared<NapiScanContext>();
61     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
62         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
63         return napi_ok;
64     };
65     auto output = [context](napi_env env, napi_value *result) -> napi_status {
66         napi_status status = napi_get_undefined(env, result);
67         return status;
68     };
69     auto exec = [context](ScanAsyncCall::Context *ctx) {
70         int32_t ret = ScanManagerClient::GetInstance()->ExitScan();
71         context->result = ret == E_SCAN_NONE;
72         if (ret != E_SCAN_NONE) {
73             SCAN_HILOGE("Failed to exit");
74             context->SetErrorIndex(ret);
75         }
76     };
77     context->SetAction(std::move(input), std::move(output));
78     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
79     return asyncCall.Call(env, exec);
80 }
81 
GetScannerList(napi_env env,napi_callback_info info)82 napi_value NapiInnerScan::GetScannerList(napi_env env, napi_callback_info info)
83 {
84     SCAN_HILOGD("Enter GetScannerList---->");
85     auto context = std::make_shared<NapiScanContext>();
86     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
87         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
88         return napi_ok;
89     };
90     auto output = [context](napi_env env, napi_value *result) -> napi_status {
91         napi_status status = napi_get_undefined(env, result);
92         return status;
93     };
94     auto exec = [context](ScanAsyncCall::Context *ctx) {
95         auto ScanManagerClientPtr = ScanManagerClient::GetInstance();
96         if (ScanManagerClientPtr == nullptr) {
97             SCAN_HILOGE("ScanManagerClientPtr is a nullptr");
98             context->result = false;
99             context->SetErrorIndex(E_SCAN_GENERIC_FAILURE);
100             return;
101         }
102         int32_t ret = ScanManagerClientPtr->GetScannerList();
103         context->result = ret == E_SCAN_NONE;
104         if (ret != E_SCAN_NONE) {
105             SCAN_HILOGE("Failed to exit");
106             context->SetErrorIndex(ret);
107         }
108     };
109     context->SetAction(std::move(input), std::move(output));
110     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
111     return asyncCall.Call(env, exec);
112 }
113 
OpenScanner(napi_env env,napi_callback_info info)114 napi_value NapiInnerScan::OpenScanner(napi_env env, napi_callback_info info)
115 {
116     SCAN_HILOGD("start to OpenScanner");
117     auto context = std::make_shared<NapiScanContext>();
118     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
119         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
120         napi_valuetype valuetype = napi_undefined;
121         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
122         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
123         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
124         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
125         context->scannerId = scannerId;
126         return napi_ok;
127     };
128     auto output = [context](napi_env env, napi_value *result) -> napi_status {
129         napi_status status = napi_get_undefined(env, result);
130         return status;
131     };
132     auto exec = [context](ScanAsyncCall::Context *ctx) {
133         int32_t ret = ScanManagerClient::GetInstance()->OpenScanner(context->scannerId);
134         context->result = ret == E_SCAN_NONE;
135         if (ret != E_SCAN_NONE) {
136             SCAN_HILOGE("Failed to open the scanner");
137             context->SetErrorIndex(ret);
138         }
139     };
140     context->SetAction(std::move(input), std::move(output));
141     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
142     return asyncCall.Call(env, exec);
143 }
144 
CloseScanner(napi_env env,napi_callback_info info)145 napi_value NapiInnerScan::CloseScanner(napi_env env, napi_callback_info info)
146 {
147     SCAN_HILOGD("start to CloseScanner");
148     auto context = std::make_shared<NapiScanContext>();
149     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
150         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
151         napi_valuetype valuetype = napi_undefined;
152         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
153         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
154         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
155         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
156         context->scannerId = scannerId;
157         return napi_ok;
158     };
159     auto output = [context](napi_env env, napi_value *result) -> napi_status {
160         napi_status status = napi_get_undefined(env, result);
161         return status;
162     };
163     auto exec = [context](ScanAsyncCall::Context *ctx) {
164         int32_t ret = ScanManagerClient::GetInstance()->CloseScanner(context->scannerId);
165         context->result = ret == E_SCAN_NONE;
166         if (ret != E_SCAN_NONE) {
167             SCAN_HILOGE("Failed to close the scanner");
168             context->SetErrorIndex(ret);
169         }
170     };
171     context->SetAction(std::move(input), std::move(output));
172     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
173     return asyncCall.Call(env, exec);
174 }
175 
SetScanOption(napi_env env,napi_callback_info info)176 napi_value NapiInnerScan::SetScanOption(napi_env env, napi_callback_info info)
177 {
178     SCAN_HILOGD("Enter SetScanOption---->");
179     auto context = std::make_shared<NapiScanContext>();
180     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
181         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_THREE, " should 3 parameter!", napi_invalid_arg);
182 
183         napi_valuetype valuetype = napi_undefined;
184         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
185         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
186         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
187         context->scannerId = scannerId;
188 
189         valuetype = napi_undefined;
190         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
191         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
192         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
193         context->optionIndex = optionIndex;
194 
195         auto optionValue = ScanOptionValueHelper::BuildFromJs(env, argv[NapiScanUtils::INDEX_TWO]);
196         if (optionValue == nullptr) {
197             SCAN_HILOGE("Parse scan option value error!");
198             context->SetErrorIndex(E_SCAN_INVALID_PARAMETER);
199             return napi_invalid_arg;
200         }
201         context->optionValue = *optionValue;
202         return napi_ok;
203     };
204     auto output = [context](napi_env env, napi_value *result) -> napi_status {
205         napi_status status = napi_get_undefined(env, result);
206         return status;
207     };
208     auto exec = [context](ScanAsyncCall::Context *ctx) {
209         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId, context->optionIndex,
210         SCAN_ACTION_SET_VALUE, context->optionValue);
211         context->result = ret == E_SCAN_NONE;
212         if (ret != E_SCAN_NONE) {
213             SCAN_HILOGE("Failed to set the scan option");
214             context->SetErrorIndex(ret);
215         }
216     };
217     context->SetAction(std::move(input), std::move(output));
218     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
219     return asyncCall.Call(env, exec);
220 }
221 
SetScanAutoOption(napi_env env,napi_callback_info info)222 napi_value NapiInnerScan::SetScanAutoOption(napi_env env, napi_callback_info info)
223 {
224     SCAN_HILOGD("Enter SetScanAutoOption---->");
225     auto context = std::make_shared<NapiScanContext>();
226     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
227         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
228 
229         napi_valuetype valuetype = napi_undefined;
230         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
231         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
232         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
233         context->scannerId = scannerId;
234 
235         valuetype = napi_undefined;
236         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
237         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
238         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
239         context->optionIndex = optionIndex;
240 
241         return napi_ok;
242     };
243     auto output = [context](napi_env env, napi_value *result) -> napi_status {
244         napi_status status = napi_get_undefined(env, result);
245         return status;
246     };
247     auto exec = [context](ScanAsyncCall::Context *ctx) {
248         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId,
249         context->optionIndex, SCAN_ACTION_SET_AUTO, context->optionValue);
250         context->result = ret == E_SCAN_NONE;
251         if (ret != E_SCAN_NONE) {
252             SCAN_HILOGE("Failed to set the auto scan option");
253             context->SetErrorIndex(ret);
254         }
255     };
256     context->SetAction(std::move(input), std::move(output));
257     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
258     return asyncCall.Call(env, exec);
259 }
260 
GetScanOption(napi_env env,napi_callback_info info)261 napi_value NapiInnerScan::GetScanOption(napi_env env, napi_callback_info info)
262 {
263     SCAN_HILOGD("Enter GetScanOption---->");
264     auto context = std::make_shared<NapiScanContext>();
265     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
266         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
267 
268         napi_valuetype valuetype = napi_undefined;
269         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
270         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
271         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
272         context->scannerId = scannerId;
273 
274         valuetype = napi_undefined;
275         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
276         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
277         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
278         context->optionIndex = optionIndex;
279         SCAN_HILOGE("success to get the scan option");
280         return napi_ok;
281     };
282     auto output = [context](napi_env env, napi_value *result) -> napi_status {
283         *result = ScanOptionValueHelper::MakeJsObject(env, context->optionValue);
284         return napi_ok;
285     };
286     auto exec = [context](ScanAsyncCall::Context *ctx) {
287         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId,
288         context->optionIndex, SCAN_ACTION_GET_VALUE, context->optionValue);
289         context->result = ret == E_SCAN_NONE;
290         if (ret != E_SCAN_NONE) {
291             SCAN_HILOGE("Failed to get the scan option");
292             context->SetErrorIndex(ret);
293         }
294     };
295     context->SetAction(std::move(input), std::move(output));
296     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
297     return asyncCall.Call(env, exec);
298 }
299 
GetScanParameters(napi_env env,napi_callback_info info)300 napi_value NapiInnerScan::GetScanParameters(napi_env env, napi_callback_info info)
301 {
302     SCAN_HILOGD("start to GetScanParameters");
303     auto context = std::make_shared<NapiScanContext>();
304     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
305         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
306         napi_valuetype valuetype = napi_undefined;
307         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
308         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
309         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
310         context->scannerId = scannerId;
311         return napi_ok;
312     };
313     auto output = [context](napi_env env, napi_value *result) -> napi_status {
314         napi_status status = napi_create_array(env, result);
315         uint32_t index = 0;
316         for (auto desc : context->allDesc) {
317             status = napi_set_element(env, *result, index++, ScanOptionDescriptorHelper::MakeJsObject(env, desc));
318         }
319         return napi_ok;
320     };
321     auto exec = [context](ScanAsyncCall::Context *ctx) {
322         int32_t ret = NapiScanHelper::GetScannerAllPara(context->scannerId, context->allDesc);
323         if (ret != E_SCAN_NONE) {
324             SCAN_HILOGE("Failed to get the scan para count");
325             context->SetErrorIndex(ret);
326         }
327     };
328     context->SetAction(std::move(input), std::move(output));
329     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
330     return asyncCall.Call(env, exec);
331 }
332 
StartScan(napi_env env,napi_callback_info info)333 napi_value NapiInnerScan::StartScan(napi_env env, napi_callback_info info)
334 {
335     SCAN_HILOGD("start to StartScan");
336     auto context = std::make_shared<NapiScanContext>();
337     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
338         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
339         napi_valuetype valueType = napi_undefined;
340         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valueType), napi_invalid_arg);
341         SCAN_ASSERT_BASE(env, valueType == napi_string, "scannerId is not a string", napi_string_expected);
342         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
343         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
344         context->scannerId = scannerId;
345         valueType = napi_undefined;
346         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valueType), napi_invalid_arg);
347         SCAN_ASSERT_BASE(env, valueType == napi_boolean, "batchMode is not a boolean", napi_boolean_expected);
348         bool batchMode = NapiScanUtils::GetBooleanFromValue(env, argv[NapiScanUtils::INDEX_ONE]);
349         context->batchMode = batchMode;
350         return napi_ok;
351     };
352     auto output = [context](napi_env env, napi_value *result) -> napi_status {
353         napi_status status = napi_get_undefined(env, result);
354         return status;
355     };
356     auto exec = [context](ScanAsyncCall::Context *ctx) {
357         int32_t ret = ScanManagerClient::GetInstance()->StartScan(context->scannerId, context->batchMode);
358         context->result = ret == E_SCAN_NONE;
359         if (ret != E_SCAN_NONE) {
360             SCAN_HILOGE("Failed to start the scan job");
361             context->SetErrorIndex(ret);
362         }
363     };
364     context->SetAction(std::move(input), std::move(output));
365     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
366     return asyncCall.Call(env, exec);
367 }
368 
CancelScan(napi_env env,napi_callback_info info)369 napi_value NapiInnerScan::CancelScan(napi_env env, napi_callback_info info)
370 {
371     SCAN_HILOGD("start to CancelScan");
372     auto context = std::make_shared<NapiScanContext>();
373     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
374         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
375         napi_valuetype valuetype = napi_undefined;
376         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
377         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
378         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
379         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
380         context->scannerId = scannerId;
381         return napi_ok;
382     };
383     auto output = [context](napi_env env, napi_value *result) -> napi_status {
384         napi_status status = napi_get_undefined(env, result);
385         return status;
386     };
387     auto exec = [context](ScanAsyncCall::Context *ctx) {
388         int32_t ret = ScanManagerClient::GetInstance()->CancelScan(context->scannerId);
389         context->result = ret == E_SCAN_NONE;
390         if (ret != E_SCAN_NONE) {
391             SCAN_HILOGE("Failed to cancel the scan job");
392             context->SetErrorIndex(ret);
393         }
394     };
395     context->SetAction(std::move(input), std::move(output));
396     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
397     return asyncCall.Call(env, exec);
398 }
399 
On(napi_env env,napi_callback_info info)400 napi_value NapiInnerScan::On(napi_env env, napi_callback_info info)
401 {
402     SCAN_HILOGD("Enter on---->");
403     size_t argc = NapiScanUtils::MAX_ARGC;
404     napi_value argv[NapiScanUtils::MAX_ARGC] = { nullptr };
405     if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok ||
406         argc != NapiScanUtils::ARGC_TWO) {
407         SCAN_HILOGE("need 2 parameter!");
408         NapiScanUtils::NapiThrowError(env, E_SCAN_INVALID_PARAMETER);
409         return nullptr;
410     }
411     napi_valuetype valuetype = napi_undefined;
412     if (napi_typeof(env, argv[0], &valuetype) != napi_ok || valuetype != napi_string) {
413         SCAN_HILOGE("type is not a string");
414         NapiScanUtils::NapiThrowError(env, E_SCAN_INVALID_PARAMETER);
415         return nullptr;
416     }
417     std::string type = NapiScanUtils::GetStringFromValueUtf8(env, argv[0]);
418     uint32_t ret = NapiInnerScan::IsSupportType(type);
419     if (ret != E_SCAN_NONE) {
420         NapiScanUtils::NapiThrowError(env, ret);
421         return nullptr;
422     }
423     valuetype = napi_undefined;
424     if (napi_typeof(env, argv[1], &valuetype) != napi_ok || valuetype != napi_function) {
425         SCAN_HILOGE("callback is not a function");
426         NapiScanUtils::NapiThrowError(env, E_SCAN_INVALID_PARAMETER);
427         return nullptr;
428     }
429     napi_ref callbackRef = NapiScanUtils::CreateReference(env, argv[1]);
430     sptr<IScanCallback> callback = new (std::nothrow) ScanCallback(env, callbackRef);
431     if (callback == nullptr) {
432         SCAN_HILOGE("create scan callback object fail");
433         NapiScanUtils::NapiThrowError(env, E_SCAN_GENERIC_FAILURE);
434         return nullptr;
435     }
436     ret = static_cast<uint32_t>(ScanManagerClient::GetInstance()->On("", type, callback));
437     if (ret != E_SCAN_NONE) {
438         SCAN_HILOGE("Failed to register event");
439         NapiScanUtils::NapiThrowError(env, ret);
440         return nullptr;
441     }
442     return nullptr;
443 }
444 
Off(napi_env env,napi_callback_info info)445 napi_value NapiInnerScan::Off(napi_env env, napi_callback_info info)
446 {
447     SCAN_HILOGD("Enter off---->");
448     size_t argc = NapiScanUtils::MAX_ARGC;
449     napi_value argv[NapiScanUtils::MAX_ARGC] = { nullptr };
450     if (napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr) != napi_ok ||
451         argc != NapiScanUtils::ARGC_ONE) {
452         SCAN_HILOGE("need 1 parameter!");
453         NapiScanUtils::NapiThrowError(env, E_SCAN_INVALID_PARAMETER);
454         return nullptr;
455     }
456     napi_valuetype valuetype = napi_undefined;
457     if (napi_typeof(env, argv[0], &valuetype) != napi_ok || valuetype != napi_string) {
458         SCAN_HILOGE("type is not a string");
459         NapiScanUtils::NapiThrowError(env, E_SCAN_INVALID_PARAMETER);
460         return nullptr;
461     }
462     std::string type = NapiScanUtils::GetStringFromValueUtf8(env, argv[0]);
463     uint32_t ret = NapiInnerScan::IsSupportType(type);
464     if (ret != E_SCAN_NONE) {
465         NapiScanUtils::NapiThrowError(env, ret);
466         return nullptr;
467     }
468     ret = static_cast<uint32_t>(ScanManagerClient::GetInstance()->Off("", type));
469     if (ret != E_SCAN_NONE) {
470         SCAN_HILOGE("Failed to register event");
471         NapiScanUtils::NapiThrowError(env, ret);
472         return nullptr;
473     }
474     return nullptr;
475 }
476 
GetScanProgress(napi_env env,napi_callback_info info)477 napi_value NapiInnerScan::GetScanProgress(napi_env env, napi_callback_info info)
478 {
479     SCAN_HILOGI("start to GetScanProgress");
480     auto context = std::make_shared<NapiScanContext>();
481     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
482         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
483         napi_valuetype valuetype = napi_undefined;
484         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
485         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
486         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
487         context->scannerId = scannerId;
488         return napi_ok;
489     };
490     auto output = [context](napi_env env, napi_value *result) -> napi_status {
491         *result = ScanProgressHelper::MakeJsObject(env, context->prog);
492         return napi_ok;
493     };
494     auto exec = [context](ScanAsyncCall::Context *ctx) {
495         int32_t ret = ScanManagerClient::GetInstance()->GetScanProgress(context->scannerId, context->prog);
496         context->result = ret == E_SCAN_NONE;
497         if (ret != E_SCAN_NONE) {
498             SCAN_HILOGE("Failed to get the scan progress");
499             context->SetErrorIndex(ret);
500         }
501     };
502     context->SetAction(std::move(input), std::move(output));
503     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
504     return asyncCall.Call(env, exec);
505 }
506 
AddScanner(napi_env env,napi_callback_info info)507 napi_value NapiInnerScan::AddScanner(napi_env env, napi_callback_info info)
508 {
509     SCAN_HILOGD("start to AddScanner");
510     auto context = std::make_shared<NapiScanContext>();
511     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
512         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
513         napi_valuetype valuetype = napi_undefined;
514 
515         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
516         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scanner uniqueId is not a string", napi_string_expected);
517         std::string uniqueId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
518         SCAN_HILOGD("uniqueId : %{public}s", uniqueId.c_str());
519         std::string ip;
520         if (ScanUtil::ExtractIpAddresses(uniqueId, ip)) {
521             context->uniqueId = ip;
522         } else {
523             context->uniqueId = uniqueId;
524         }
525         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
526         SCAN_ASSERT_BASE(env, valuetype == napi_string, "discoverMode is not a string", napi_string_expected);
527         std::string discoverMode = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ONE]);
528         SCAN_HILOGD("discoverMode : %{public}s", discoverMode.c_str());
529         context->discoverMode = discoverMode;
530         return napi_ok;
531     };
532     auto output = [context](napi_env env, napi_value *result) -> napi_status {
533         napi_status status = napi_get_undefined(env, result);
534         return status;
535     };
536     auto exec = [context](ScanAsyncCall::Context *ctx) {
537         if (!NapiScanUtils::CheckCallerIsSystemApp()) {
538             SCAN_HILOGE("not system app");
539             context->SetErrorIndex(E_SCAN_ERROR_NOT_SYSTEM_APPLICATION);
540             return;
541         }
542         int32_t ret = ScanManagerClient::GetInstance()->AddScanner(context->uniqueId, context->discoverMode);
543         context->result = ret == E_SCAN_NONE;
544         if (ret != E_SCAN_NONE) {
545             SCAN_HILOGE("Failed to add the scanner");
546             context->SetErrorIndex(ret);
547         }
548     };
549     context->SetAction(std::move(input), std::move(output));
550     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
551     return asyncCall.Call(env, exec);
552 }
553 
DeleteScanner(napi_env env,napi_callback_info info)554 napi_value NapiInnerScan::DeleteScanner(napi_env env, napi_callback_info info)
555 {
556     SCAN_HILOGD("start to DeleteScanner");
557     auto context = std::make_shared<NapiScanContext>();
558     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
559         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
560         napi_valuetype valuetype = napi_undefined;
561 
562         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
563         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scanner uniqueId is not a string", napi_string_expected);
564         std::string uniqueId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
565         SCAN_HILOGD("uniqueId : %{public}s", uniqueId.c_str());
566         std::string ip;
567         if (ScanUtil::ExtractIpAddresses(uniqueId, ip)) {
568             context->uniqueId = ip;
569         } else {
570             context->uniqueId = uniqueId;
571         }
572 
573         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
574         SCAN_ASSERT_BASE(env, valuetype == napi_string, "discoverMode is not a string", napi_string_expected);
575         std::string discoverMode = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ONE]);
576         SCAN_HILOGD("discoverMode : %{public}s", discoverMode.c_str());
577         context->discoverMode = discoverMode;
578         return napi_ok;
579     };
580     auto output = [context](napi_env env, napi_value *result) -> napi_status {
581         napi_status status = napi_get_undefined(env, result);
582         return status;
583     };
584     auto exec = [context](ScanAsyncCall::Context *ctx) {
585         if (!NapiScanUtils::CheckCallerIsSystemApp()) {
586             SCAN_HILOGE("not system app");
587             context->SetErrorIndex(E_SCAN_ERROR_NOT_SYSTEM_APPLICATION);
588             return;
589         }
590         int32_t ret = ScanManagerClient::GetInstance()->DeleteScanner(context->uniqueId, context->discoverMode);
591         context->result = ret == E_SCAN_NONE;
592         if (ret != E_SCAN_NONE) {
593             SCAN_HILOGE("Failed to delete the scanner");
594             context->SetErrorIndex(ret);
595         }
596     };
597     context->SetAction(std::move(input), std::move(output));
598     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
599     return asyncCall.Call(env, exec);
600 }
601 
GetAddedScanner(napi_env env,napi_callback_info info)602 napi_value NapiInnerScan::GetAddedScanner(napi_env env, napi_callback_info info)
603 {
604     SCAN_HILOGD("Enter GetAddedScanner---->");
605     auto context = std::make_shared<NapiScanContext>();
606     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
607         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
608         return napi_ok;
609     };
610     auto output = [context](napi_env env, napi_value *result) -> napi_status {
611         napi_status status = napi_create_array(env, result);
612         uint32_t index = 0;
613         for (auto scanDeviceInfo : context->allAddedScanner) {
614             status = napi_set_element(env, *result, index++, ScannerInfoHelper::MakeJsObject(env, scanDeviceInfo));
615         }
616         return napi_ok;
617     };
618     auto exec = [context](ScanAsyncCall::Context *ctx) {
619         if (!NapiScanUtils::CheckCallerIsSystemApp()) {
620             SCAN_HILOGE("not system app");
621             context->SetErrorIndex(E_SCAN_ERROR_NOT_SYSTEM_APPLICATION);
622             return;
623         }
624         int32_t ret = ScanManagerClient::GetInstance()->GetAddedScanner(context->allAddedScanner);
625         context->result = ret == E_SCAN_NONE;
626         if (ret != E_SCAN_NONE) {
627             SCAN_HILOGE("Failed to get added scanner");
628             context->SetErrorIndex(ret);
629         }
630     };
631     context->SetAction(std::move(input), std::move(output));
632     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
633     return asyncCall.Call(env, exec);
634 }
635 
IsSupportType(const std::string & type)636 uint32_t NapiInnerScan::IsSupportType(const std::string& type)
637 {
638     if (type == SCAN_DEVICE_FOUND || type == SCAN_DEVICE_SYNC) {
639         return E_SCAN_NONE;
640     }
641     if (type == SCAN_DEVICE_ADD || type == SCAN_DEVICE_DEL) {
642         if (!NapiScanUtils::CheckCallerIsSystemApp()) {
643             SCAN_HILOGE("not system app");
644             return E_SCAN_ERROR_NOT_SYSTEM_APPLICATION;
645         } else {
646             return E_SCAN_NONE;
647         }
648     }
649     SCAN_HILOGE("type : %{public}s is invalid", type.c_str());
650     return E_SCAN_INVALID_PARAMETER;
651 }
652 } // namespace OHOS::Scan
653