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 
24 
25 namespace OHOS::Scan {
26 const std::string GET_FRAME_RES_EVENT_TYPE = "getFrameResult";
27 const std::string SCAN_DEVICE_FOUND_TCP = "scanDeviceFoundTCP";
28 const std::string SCAN_DEVICE_FOUND = "scanDeviceFound";
29 const std::string SCAN_DEVICE_SYNC = "scanDeviceSync";
30 const std::string SCAN_DEVICE_ADD = "scanDeviceAdd";
31 const std::string SCAN_DEVICE_DEL = "scanDeviceDel";
32 const std::string SCAN_INIT_EVENT = "scanInitEvent";
33 
InitScan(napi_env env,napi_callback_info info)34 napi_value NapiInnerScan::InitScan(napi_env env, napi_callback_info info)
35 {
36     SCAN_HILOGE("Enter InitScan---->");
37     auto context = std::make_shared<NapiScanContext>();
38     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
39         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
40         return napi_ok;
41     };
42     auto output = [context](napi_env env, napi_value *result) -> napi_status {
43         napi_status status = napi_create_int32(env, context->scanVersion, result);
44         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
45         return status;
46     };
47     auto exec = [context](ScanAsyncCall::Context *ctx) {
48         int32_t ret = ScanManagerClient::GetInstance()->InitScan(context->scanVersion);
49         context->result = ret == E_SCAN_NONE;
50         if (ret != E_SCAN_NONE) {
51             SCAN_HILOGE("Failed to init the scan fwk");
52             context->SetErrorIndex(ret);
53         }
54     };
55     context->SetAction(std::move(input), std::move(output));
56     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
57     return asyncCall.Call(env, exec);
58 }
59 
ExitScan(napi_env env,napi_callback_info info)60 napi_value NapiInnerScan::ExitScan(napi_env env, napi_callback_info info)
61 {
62     SCAN_HILOGD("Enter ExitScan---->");
63     auto context = std::make_shared<NapiScanContext>();
64     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
65         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
66         return napi_ok;
67     };
68     auto output = [context](napi_env env, napi_value *result) -> napi_status {
69         napi_status status = napi_get_boolean(env, context->result, result);
70         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
71         return status;
72     };
73     auto exec = [context](ScanAsyncCall::Context *ctx) {
74         int32_t ret = ScanManagerClient::GetInstance()->ExitScan();
75         context->result = ret == E_SCAN_NONE;
76         if (ret != E_SCAN_NONE) {
77             SCAN_HILOGE("Failed to exit");
78             context->SetErrorIndex(ret);
79         }
80     };
81     context->SetAction(std::move(input), std::move(output));
82     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
83     return asyncCall.Call(env, exec);
84 }
85 
GetScannerList(napi_env env,napi_callback_info info)86 napi_value NapiInnerScan::GetScannerList(napi_env env, napi_callback_info info)
87 {
88     SCAN_HILOGD("Enter GetScannerList---->");
89     auto context = std::make_shared<NapiScanContext>();
90     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
91         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
92         return napi_ok;
93     };
94     auto output = [context](napi_env env, napi_value *result) -> napi_status {
95         napi_status status = napi_get_boolean(env, context->result, result);
96         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
97         return status;
98     };
99     auto exec = [context](ScanAsyncCall::Context *ctx) {
100         auto ScanManagerClientPtr = ScanManagerClient::GetInstance();
101         if (ScanManagerClientPtr == nullptr) {
102             SCAN_HILOGE("ScanManagerClientPtr is a nullptr");
103             context->result = false;
104             context->SetErrorIndex(E_SCAN_GENERIC_FAILURE);
105             return;
106         }
107         int32_t ret = ScanManagerClientPtr->GetScannerList();
108         context->result = ret == E_SCAN_NONE;
109         if (ret != E_SCAN_NONE) {
110             SCAN_HILOGE("Failed to exit");
111             context->SetErrorIndex(ret);
112         }
113     };
114     context->SetAction(std::move(input), std::move(output));
115     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
116     return asyncCall.Call(env, exec);
117 }
118 
StopDiscover(napi_env env,napi_callback_info info)119 napi_value NapiInnerScan::StopDiscover(napi_env env, napi_callback_info info)
120 {
121     SCAN_HILOGE("Enter StopDiscover---->");
122     auto context = std::make_shared<NapiScanContext>();
123     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
124         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
125         return napi_ok;
126     };
127     auto output = [context](napi_env env, napi_value *result) -> napi_status {
128         napi_status status = napi_create_int32(env, context->scanVersion, result);
129         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
130         return status;
131     };
132     auto exec = [context](ScanAsyncCall::Context *ctx) {
133         int32_t ret = ScanManagerClient::GetInstance()->StopDiscover();
134         context->result = ret == E_SCAN_NONE;
135         if (ret != E_SCAN_NONE) {
136             SCAN_HILOGE("Failed to StopDiscover");
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 
OpenScanner(napi_env env,napi_callback_info info)145 napi_value NapiInnerScan::OpenScanner(napi_env env, napi_callback_info info)
146 {
147     SCAN_HILOGD("start to OpenScanner");
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_boolean(env, context->result, result);
161         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
162         return status;
163     };
164     auto exec = [context](ScanAsyncCall::Context *ctx) {
165         int32_t ret = ScanManagerClient::GetInstance()->OpenScanner(context->scannerId);
166         context->result = ret == E_SCAN_NONE;
167         if (ret != E_SCAN_NONE) {
168             SCAN_HILOGE("Failed to open the scanner");
169             context->SetErrorIndex(ret);
170         }
171     };
172     context->SetAction(std::move(input), std::move(output));
173     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
174     return asyncCall.Call(env, exec);
175 }
176 
CloseScanner(napi_env env,napi_callback_info info)177 napi_value NapiInnerScan::CloseScanner(napi_env env, napi_callback_info info)
178 {
179     SCAN_HILOGD("start to CloseScanner");
180     auto context = std::make_shared<NapiScanContext>();
181     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
182         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
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         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
188         context->scannerId = scannerId;
189         return napi_ok;
190     };
191     auto output = [context](napi_env env, napi_value *result) -> napi_status {
192         napi_status status = napi_get_boolean(env, context->result, result);
193         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
194         return status;
195     };
196     auto exec = [context](ScanAsyncCall::Context *ctx) {
197         int32_t ret = ScanManagerClient::GetInstance()->CloseScanner(context->scannerId);
198         context->result = ret == E_SCAN_NONE;
199         if (ret != E_SCAN_NONE) {
200             SCAN_HILOGE("Failed to close the scanner");
201             context->SetErrorIndex(ret);
202         }
203     };
204     context->SetAction(std::move(input), std::move(output));
205     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
206     return asyncCall.Call(env, exec);
207 }
208 
GetScanOptionDesc(napi_env env,napi_callback_info info)209 napi_value NapiInnerScan::GetScanOptionDesc(napi_env env, napi_callback_info info)
210 {
211     SCAN_HILOGD("start to GetScanOptionDesc");
212     auto context = std::make_shared<NapiScanContext>();
213     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
214         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
215         napi_valuetype valuetype = napi_undefined;
216         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
217         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
218         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
219 
220         valuetype = napi_undefined;
221         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
222         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
223         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
224         context->scannerId = scannerId;
225         context->optionIndex = optionIndex;
226         return napi_ok;
227     };
228     auto output = [context](napi_env env, napi_value *result) -> napi_status {
229         *result = ScanOptionDescriptorHelper::MakeJsObject(env, context->desc);
230         return napi_ok;
231     };
232     auto exec = [context](ScanAsyncCall::Context *ctx) {
233         int32_t ret = ScanManagerClient::GetInstance()->GetScanOptionDesc(context->scannerId, context->optionIndex,\
234             context->desc);
235         context->result = ret == E_SCAN_NONE;
236         if (ret != E_SCAN_NONE) {
237             SCAN_HILOGE("Failed to get the scan option description");
238             context->SetErrorIndex(ret);
239         }
240     };
241     context->SetAction(std::move(input), std::move(output));
242     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
243     return asyncCall.Call(env, exec);
244 }
245 
SetScanOption(napi_env env,napi_callback_info info)246 napi_value NapiInnerScan::SetScanOption(napi_env env, napi_callback_info info)
247 {
248     SCAN_HILOGD("Enter SetScanOption---->");
249     auto context = std::make_shared<NapiScanContext>();
250     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
251         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_THREE, " should 3 parameter!", napi_invalid_arg);
252 
253         napi_valuetype valuetype = napi_undefined;
254         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
255         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
256         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
257         context->scannerId = scannerId;
258 
259         valuetype = napi_undefined;
260         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
261         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
262         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
263         context->optionIndex = optionIndex;
264 
265         auto optionValue = ScanOptionValueHelper::BuildFromJs(env, argv[NapiScanUtils::INDEX_TWO]);
266         if (optionValue == nullptr) {
267             SCAN_HILOGE("Parse scan option value error!");
268             context->SetErrorIndex(E_SCAN_INVALID_PARAMETER);
269             return napi_invalid_arg;
270         }
271         context->optionValue = *optionValue;
272         return napi_ok;
273     };
274     auto output = [context](napi_env env, napi_value *result) -> napi_status {
275         napi_status status = napi_create_int32(env, context->info, result);
276         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
277         return status;
278     };
279     auto exec = [context](ScanAsyncCall::Context *ctx) {
280         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId, context->optionIndex,
281         SCAN_ACTION_SET_VALUE, context->optionValue, context->info);
282         context->result = ret == E_SCAN_NONE;
283         if (ret != E_SCAN_NONE) {
284             SCAN_HILOGE("Failed to set the scan option");
285             context->SetErrorIndex(ret);
286         }
287     };
288     context->SetAction(std::move(input), std::move(output));
289     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
290     return asyncCall.Call(env, exec);
291 }
292 
SetScanAutoOption(napi_env env,napi_callback_info info)293 napi_value NapiInnerScan::SetScanAutoOption(napi_env env, napi_callback_info info)
294 {
295     SCAN_HILOGD("Enter SetScanAutoOption---->");
296     auto context = std::make_shared<NapiScanContext>();
297     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
298         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
299 
300         napi_valuetype valuetype = napi_undefined;
301         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
302         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
303         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
304         context->scannerId = scannerId;
305 
306         valuetype = napi_undefined;
307         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
308         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
309         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
310         context->optionIndex = optionIndex;
311 
312         return napi_ok;
313     };
314     auto output = [context](napi_env env, napi_value *result) -> napi_status {
315         napi_status status = napi_create_int32(env, context->result, result);
316         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
317         return status;
318     };
319     auto exec = [context](ScanAsyncCall::Context *ctx) {
320         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId,
321         context->optionIndex, SCAN_ACTION_SET_AUTO, context->optionValue, context->info);
322         context->result = ret == E_SCAN_NONE;
323         if (ret != E_SCAN_NONE) {
324             SCAN_HILOGE("Failed to set the auto scan option");
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 
GetScanOption(napi_env env,napi_callback_info info)333 napi_value NapiInnerScan::GetScanOption(napi_env env, napi_callback_info info)
334 {
335     SCAN_HILOGD("Enter GetScanOption---->");
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_FOUR, " should 4 parameter!", napi_invalid_arg);
339 
340         napi_valuetype valuetype = napi_undefined;
341         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
342         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
343         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
344         context->scannerId = scannerId;
345 
346         valuetype = napi_undefined;
347         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
348         SCAN_ASSERT_BASE(env, valuetype == napi_number, "optionIndex is not a number", napi_number_expected);
349         int32_t optionIndex = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
350         context->optionIndex = optionIndex;
351 
352         valuetype = napi_undefined;
353         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_TWO], &valuetype), napi_invalid_arg);
354         SCAN_ASSERT_BASE(env, valuetype == napi_number, "valueType is not a number", napi_number_expected);
355         uint32_t valueType = NapiScanUtils::GetUint32FromValue(env, argv[NapiScanUtils::INDEX_TWO]);
356         context->optionValue.SetScanOptionValueType((ScanOptionValueType)valueType);
357 
358         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_THREE], &valuetype), napi_invalid_arg);
359         SCAN_ASSERT_BASE(env, valuetype == napi_number, "valueSize is not a number", napi_number_expected);
360         int32_t valueSize = NapiScanUtils::GetInt32FromValue(env, argv[NapiScanUtils::INDEX_THREE]);
361         context->optionValue.SetValueSize(valueSize);
362 
363         context->optionValue.Dump();
364         SCAN_HILOGE("success to get the scan option");
365         return napi_ok;
366     };
367     auto output = [context](napi_env env, napi_value *result) -> napi_status {
368         *result = ScanOptionValueHelper::MakeJsObject(env, context->optionValue);
369         return napi_ok;
370     };
371     auto exec = [context](ScanAsyncCall::Context *ctx) {
372         int32_t ret = ScanManagerClient::GetInstance()->OpScanOptionValue(context->scannerId,
373         context->optionIndex, SCAN_ACTION_GET_VALUE, context->optionValue, context->info);
374         context->result = ret == E_SCAN_NONE;
375         if (ret != E_SCAN_NONE) {
376             SCAN_HILOGE("Failed to get the scan option");
377             context->SetErrorIndex(ret);
378         }
379     };
380     context->SetAction(std::move(input), std::move(output));
381     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
382     return asyncCall.Call(env, exec);
383 }
384 
GetScanParameters(napi_env env,napi_callback_info info)385 napi_value NapiInnerScan::GetScanParameters(napi_env env, napi_callback_info info)
386 {
387     SCAN_HILOGD("start to GetScanParameters");
388     auto context = std::make_shared<NapiScanContext>();
389     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
390         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
391         napi_valuetype valuetype = napi_undefined;
392         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
393         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
394         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
395         context->scannerId = scannerId;
396         return napi_ok;
397     };
398     auto output = [context](napi_env env, napi_value *result) -> napi_status {
399         *result = ScanParametersHelper::MakeJsObject(env, context->para);
400         return napi_ok;
401     };
402     auto exec = [context](ScanAsyncCall::Context *ctx) {
403         int32_t ret = ScanManagerClient::GetInstance()->GetScanParameters(context->scannerId, context->para);
404         context->result = ret == E_SCAN_NONE;
405         if (ret != E_SCAN_NONE) {
406             SCAN_HILOGE("Failed to get the scan parameters description");
407             context->SetErrorIndex(ret);
408         }
409     };
410     context->SetAction(std::move(input), std::move(output));
411     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
412     return asyncCall.Call(env, exec);
413 }
414 
StartScan(napi_env env,napi_callback_info info)415 napi_value NapiInnerScan::StartScan(napi_env env, napi_callback_info info)
416 {
417     SCAN_HILOGD("start to StartScan");
418     auto context = std::make_shared<NapiScanContext>();
419     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
420         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
421         napi_valuetype valueType = napi_undefined;
422         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valueType), napi_invalid_arg);
423         SCAN_ASSERT_BASE(env, valueType == napi_string, "scannerId is not a string", napi_string_expected);
424         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
425         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
426         context->scannerId = scannerId;
427         valueType = napi_undefined;
428         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valueType), napi_invalid_arg);
429         SCAN_ASSERT_BASE(env, valueType == napi_boolean, "batchMode is not a boolean", napi_boolean_expected);
430         bool batchMode = NapiScanUtils::GetBooleanFromValue(env, argv[NapiScanUtils::INDEX_ONE]);
431         context->batchMode = batchMode;
432         return napi_ok;
433     };
434     auto output = [context](napi_env env, napi_value *result) -> napi_status {
435         napi_status status = napi_get_boolean(env, context->result, result);
436         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
437         return status;
438     };
439     auto exec = [context](ScanAsyncCall::Context *ctx) {
440         int32_t ret = ScanManagerClient::GetInstance()->StartScan(context->scannerId, context->batchMode);
441         context->result = ret == E_SCAN_NONE;
442         if (ret != E_SCAN_NONE) {
443             SCAN_HILOGE("Failed to start the scan job");
444             context->SetErrorIndex(ret);
445         }
446     };
447     context->SetAction(std::move(input), std::move(output));
448     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
449     return asyncCall.Call(env, exec);
450 }
451 
GetSingleFrameFD(napi_env env,napi_callback_info info)452 napi_value NapiInnerScan::GetSingleFrameFD(napi_env env, napi_callback_info info)
453 {
454     SCAN_HILOGD("start to GetSingleFrameFD");
455     auto context = std::make_shared<NapiScanContext>();
456     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
457         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
458         napi_valuetype valuetype = napi_undefined;
459         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
460         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
461         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
462         valuetype = napi_undefined;
463         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
464         SCAN_ASSERT_BASE(env, valuetype == napi_number, "fd is not a number", napi_number_expected);
465         uint32_t fd = NapiScanUtils::GetUint32FromValue(env, argv[NapiScanUtils::INDEX_ONE]);
466         SCAN_HILOGE("scannerId : %{public}s, fd: %{public}u", scannerId.c_str(), fd);
467         context->scannerId = scannerId;
468         context->image_fd = fd;
469         return napi_ok;
470     };
471     auto output = [context](napi_env env, napi_value *result) -> napi_status {
472         napi_status status = napi_create_int32(env, context->frameSize, result);
473         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
474         return status;
475     };
476     auto exec = [context](ScanAsyncCall::Context *ctx) {
477         int32_t ret = ScanManagerClient::GetInstance()->GetSingleFrameFD(
478             context->scannerId, context->frameSize, context->image_fd);
479         context->result = ret == E_SCAN_NONE;
480         if (ret != E_SCAN_NONE) {
481             SCAN_HILOGE("Failed to get a single frame");
482             context->SetErrorIndex(ret);
483         }
484     };
485     context->SetAction(std::move(input), std::move(output));
486     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
487     return asyncCall.Call(env, exec);
488 }
489 
CancelScan(napi_env env,napi_callback_info info)490 napi_value NapiInnerScan::CancelScan(napi_env env, napi_callback_info info)
491 {
492     SCAN_HILOGD("start to CancelScan");
493     auto context = std::make_shared<NapiScanContext>();
494     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
495         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
496         napi_valuetype valuetype = napi_undefined;
497         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
498         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
499         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
500         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
501         context->scannerId = scannerId;
502         return napi_ok;
503     };
504     auto output = [context](napi_env env, napi_value *result) -> napi_status {
505         napi_status status = napi_get_boolean(env, context->result, result);
506         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
507         return status;
508     };
509     auto exec = [context](ScanAsyncCall::Context *ctx) {
510         int32_t ret = ScanManagerClient::GetInstance()->CancelScan(context->scannerId);
511         context->result = ret == E_SCAN_NONE;
512         if (ret != E_SCAN_NONE) {
513             SCAN_HILOGE("Failed to cancel the scan job");
514             context->SetErrorIndex(ret);
515         }
516     };
517     context->SetAction(std::move(input), std::move(output));
518     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
519     return asyncCall.Call(env, exec);
520 }
521 
SetScanIOMode(napi_env env,napi_callback_info info)522 napi_value NapiInnerScan::SetScanIOMode(napi_env env, napi_callback_info info)
523 {
524     SCAN_HILOGD("start to SetScanIOMode");
525     auto context = std::make_shared<NapiScanContext>();
526     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
527         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
528         napi_valuetype valuetype = napi_undefined;
529         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
530         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
531 
532         valuetype = napi_undefined;
533         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
534         SCAN_ASSERT_BASE(env, valuetype == napi_boolean, "isNonBlocking is not a boolean", napi_boolean_expected);
535         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
536         bool isNonBlocking = NapiScanUtils::GetBooleanFromValue(env, argv[NapiScanUtils::INDEX_ONE]);
537         SCAN_HILOGD("scannerId : %{public}s, isNonBlocking : %{public}d", scannerId.c_str(), isNonBlocking);
538         context->scannerId = scannerId;
539         context->isNonBlocking = isNonBlocking;
540         return napi_ok;
541     };
542     auto output = [context](napi_env env, napi_value *result) -> napi_status {
543         napi_status status = napi_get_boolean(env, context->result, result);
544         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
545         return status;
546     };
547     auto exec = [context](ScanAsyncCall::Context *ctx) {
548         int32_t ret = ScanManagerClient::GetInstance()->SetScanIOMode(context->scannerId, context->isNonBlocking);
549         context->result = ret == E_SCAN_NONE;
550         if (ret != E_SCAN_NONE) {
551             SCAN_HILOGE("Failed to set the scan IO mode");
552             context->SetErrorIndex(ret);
553         }
554     };
555     context->SetAction(std::move(input), std::move(output));
556     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
557     return asyncCall.Call(env, exec);
558 }
559 
GetScanSelectFd(napi_env env,napi_callback_info info)560 napi_value NapiInnerScan::GetScanSelectFd(napi_env env, napi_callback_info info)
561 {
562     SCAN_HILOGD("start to GetScanSelectFd");
563     auto context = std::make_shared<NapiScanContext>();
564     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
565         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
566         napi_valuetype valuetype = napi_undefined;
567         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
568         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
569         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
570         SCAN_HILOGD("scannerId : %{public}s", scannerId.c_str());
571         context->scannerId = scannerId;
572         return napi_ok;
573     };
574     auto output = [context](napi_env env, napi_value *result) -> napi_status {
575         napi_status status = napi_create_int32(env, context->fd, result);
576         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
577         return status;
578     };
579     auto exec = [context](ScanAsyncCall::Context *ctx) {
580         int32_t ret = ScanManagerClient::GetInstance()->GetScanSelectFd(context->scannerId, context->fd);
581         context->result = ret == E_SCAN_NONE;
582         if (ret != E_SCAN_NONE) {
583             SCAN_HILOGE("Failed to get the scan select fd");
584             context->SetErrorIndex(ret);
585         }
586     };
587     context->SetAction(std::move(input), std::move(output));
588     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
589     return asyncCall.Call(env, exec);
590 }
591 
On(napi_env env,napi_callback_info info)592 napi_value NapiInnerScan::On(napi_env env, napi_callback_info info)
593 {
594     SCAN_HILOGD("Enter on---->");
595     size_t argc = NapiScanUtils::MAX_ARGC;
596     napi_value argv[NapiScanUtils::MAX_ARGC] = { nullptr };
597     napi_value thisVal = nullptr;
598     void *data = nullptr;
599     SCAN_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVal, &data));
600     SCAN_ASSERT(env, argc == NapiScanUtils::ARGC_TWO, "need 2 parameter!");
601 
602     napi_valuetype valuetype = napi_undefined;
603     SCAN_CALL(env, napi_typeof(env, argv[0], &valuetype));
604     SCAN_ASSERT(env, valuetype == napi_string, "type is not a string");
605     std::string type = NapiScanUtils::GetStringFromValueUtf8(env, argv[0]);
606     SCAN_HILOGD("type : %{public}s", type.c_str());
607 
608     if (!NapiInnerScan::IsSupportType(type)) {
609         SCAN_HILOGE("Event On type : %{public}s not support", type.c_str());
610         return nullptr;
611     }
612 
613     valuetype = napi_undefined;
614     napi_typeof(env, argv[1], &valuetype);
615     SCAN_ASSERT(env, valuetype == napi_function, "callback is not a function");
616 
617     napi_ref callbackRef = NapiScanUtils::CreateReference(env, argv[1]);
618     sptr<IScanCallback> callback = new (std::nothrow) ScanCallback(env, callbackRef);
619     if (callback == nullptr) {
620         SCAN_HILOGE("create scan callback object fail");
621         return nullptr;
622     }
623     int32_t ret = ScanManagerClient::GetInstance()->On("", type, callback);
624     if (ret != E_SCAN_NONE) {
625         SCAN_HILOGE("Failed to register event");
626         return nullptr;
627     }
628     return nullptr;
629 }
630 
Off(napi_env env,napi_callback_info info)631 napi_value NapiInnerScan::Off(napi_env env, napi_callback_info info)
632 {
633     SCAN_HILOGD("Enter OFF---->");
634     return nullptr;
635 }
636 
GetScannerState(napi_env env,napi_callback_info info)637 napi_value NapiInnerScan::GetScannerState(napi_env env, napi_callback_info info)
638 {
639     SCAN_HILOGD("Enter GetScannerState---->");
640     auto context = std::make_shared<NapiScanContext>();
641     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
642         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
643         return napi_ok;
644     };
645     auto output = [context](napi_env env, napi_value *result) -> napi_status {
646         napi_status status = napi_create_int32(env, context->scannerState, result);
647         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
648         return status;
649     };
650     auto exec = [context](ScanAsyncCall::Context *ctx) {
651         int32_t ret = ScanManagerClient::GetInstance()->GetScannerState(context->scannerState);
652         context->result = ret == E_SCAN_NONE;
653         if (ret != E_SCAN_NONE) {
654             SCAN_HILOGE("Failed to init the scan fwk");
655             context->SetErrorIndex(ret);
656         }
657     };
658     context->SetAction(std::move(input), std::move(output));
659     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
660     return asyncCall.Call(env, exec);
661 }
662 
GetScanProgress(napi_env env,napi_callback_info info)663 napi_value NapiInnerScan::GetScanProgress(napi_env env, napi_callback_info info)
664 {
665     SCAN_HILOGI("start to GetScanProgress");
666     auto context = std::make_shared<NapiScanContext>();
667     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
668         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ONE, " should 1 parameter!", napi_invalid_arg);
669         napi_valuetype valuetype = napi_undefined;
670         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
671         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scannerId is not a string", napi_string_expected);
672         std::string scannerId = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
673         context->scannerId = scannerId;
674         return napi_ok;
675     };
676     auto output = [context](napi_env env, napi_value *result) -> napi_status {
677         *result = ScanProgressHelper::MakeJsObject(env, context->prog);
678         return napi_ok;
679     };
680     auto exec = [context](ScanAsyncCall::Context *ctx) {
681         int32_t ret = ScanManagerClient::GetInstance()->GetScanProgress(context->scannerId, context->prog);
682         context->result = ret == E_SCAN_NONE;
683         if (ret != E_SCAN_NONE) {
684             SCAN_HILOGE("Failed to get the scan progress");
685             context->SetErrorIndex(ret);
686         }
687     };
688     context->SetAction(std::move(input), std::move(output));
689     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
690     return asyncCall.Call(env, exec);
691 }
692 
AddScanner(napi_env env,napi_callback_info info)693 napi_value NapiInnerScan::AddScanner(napi_env env, napi_callback_info info)
694 {
695     SCAN_HILOGD("start to AddScanner");
696     auto context = std::make_shared<NapiScanContext>();
697     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
698         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
699         napi_valuetype valuetype = napi_undefined;
700 
701         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
702         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scanner serialNumber is not a string", napi_string_expected);
703         std::string serialNumber = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
704         SCAN_HILOGD("serialNumber : %{public}s", serialNumber.c_str());
705         std::string ip;
706         if (ScanUtil::ExtractIpAddresses(serialNumber, ip)) {
707             context->serialNumber = ip;
708         } else {
709             context->serialNumber = serialNumber;
710         }
711         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
712         SCAN_ASSERT_BASE(env, valuetype == napi_string, "discoverMode is not a string", napi_string_expected);
713         std::string discoverMode = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ONE]);
714         SCAN_HILOGD("discoverMode : %{public}s", discoverMode.c_str());
715         context->discoverMode = discoverMode;
716         return napi_ok;
717     };
718     auto output = [context](napi_env env, napi_value *result) -> napi_status {
719         napi_status status = napi_get_boolean(env, context->result, result);
720         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
721         return status;
722     };
723     auto exec = [context](ScanAsyncCall::Context *ctx) {
724         int32_t ret = ScanManagerClient::GetInstance()->AddScanner(context->serialNumber, context->discoverMode);
725         context->result = ret == E_SCAN_NONE;
726         if (ret != E_SCAN_NONE) {
727             SCAN_HILOGE("Failed to add the scanner");
728             context->SetErrorIndex(ret);
729         }
730     };
731     context->SetAction(std::move(input), std::move(output));
732     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
733     return asyncCall.Call(env, exec);
734 }
735 
DeleteScanner(napi_env env,napi_callback_info info)736 napi_value NapiInnerScan::DeleteScanner(napi_env env, napi_callback_info info)
737 {
738     SCAN_HILOGD("start to DeleteScanner");
739     auto context = std::make_shared<NapiScanContext>();
740     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
741         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_TWO, " should 2 parameter!", napi_invalid_arg);
742         napi_valuetype valuetype = napi_undefined;
743 
744         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
745         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scanner serialNumber is not a string", napi_string_expected);
746         std::string serialNumber = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
747         SCAN_HILOGD("serialNumber : %{public}s", serialNumber.c_str());
748         std::string ip;
749         if (ScanUtil::ExtractIpAddresses(serialNumber, ip)) {
750             context->serialNumber = ip;
751         } else {
752             context->serialNumber = serialNumber;
753         }
754 
755         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
756         SCAN_ASSERT_BASE(env, valuetype == napi_string, "discoverMode is not a string", napi_string_expected);
757         std::string discoverMode = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ONE]);
758         SCAN_HILOGD("discoverMode : %{public}s", discoverMode.c_str());
759         context->discoverMode = discoverMode;
760         return napi_ok;
761     };
762     auto output = [context](napi_env env, napi_value *result) -> napi_status {
763         napi_status status = napi_get_boolean(env, context->result, result);
764         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
765         return status;
766     };
767     auto exec = [context](ScanAsyncCall::Context *ctx) {
768         int32_t ret = ScanManagerClient::GetInstance()->DeleteScanner(context->serialNumber, context->discoverMode);
769         context->result = ret == E_SCAN_NONE;
770         if (ret != E_SCAN_NONE) {
771             SCAN_HILOGE("Failed to delete the scanner");
772             context->SetErrorIndex(ret);
773         }
774     };
775     context->SetAction(std::move(input), std::move(output));
776     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
777     return asyncCall.Call(env, exec);
778 }
779 
GetAddedScanner(napi_env env,napi_callback_info info)780 napi_value NapiInnerScan::GetAddedScanner(napi_env env, napi_callback_info info)
781 {
782     SCAN_HILOGE("Enter GetAddedScanner---->");
783     auto context = std::make_shared<NapiScanContext>();
784     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
785         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_ZERO, " should 0 parameter!", napi_invalid_arg);
786         return napi_ok;
787     };
788     auto output = [context](napi_env env, napi_value *result) -> napi_status {
789         napi_status status = napi_create_array(env, result);
790         uint32_t index = 0;
791         for (auto scanDeviceInfo : context->allAddedScanner) {
792             status = napi_set_element(env, *result, index++, ScannerInfoHelper::MakeJsObject(env, scanDeviceInfo));
793         }
794         return napi_ok;
795     };
796     auto exec = [context](ScanAsyncCall::Context *ctx) {
797         int32_t ret = ScanManagerClient::GetInstance()->GetAddedScanner(context->allAddedScanner);
798         context->result = ret == E_SCAN_NONE;
799         if (ret != E_SCAN_NONE) {
800             SCAN_HILOGE("Failed to get added scanner");
801             context->SetErrorIndex(ret);
802         }
803     };
804     context->SetAction(std::move(input), std::move(output));
805     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
806     return asyncCall.Call(env, exec);
807 }
808 
UpdateScannerName(napi_env env,napi_callback_info info)809 napi_value NapiInnerScan::UpdateScannerName(napi_env env, napi_callback_info info)
810 {
811     SCAN_HILOGD("start to UpdateScannerName");
812     auto context = std::make_shared<NapiScanContext>();
813     auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status {
814         SCAN_ASSERT_BASE(env, argc == NapiScanUtils::ARGC_THREE, " should 3 parameter!", napi_invalid_arg);
815         napi_valuetype valuetype = napi_undefined;
816 
817         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ZERO], &valuetype), napi_invalid_arg);
818         SCAN_ASSERT_BASE(env, valuetype == napi_string, "scanner serialNumber is not a string", napi_string_expected);
819         std::string serialNumber = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ZERO]);
820         SCAN_HILOGD("serialNumber : %{public}s", serialNumber.c_str());
821         std::string ip;
822         if (ScanUtil::ExtractIpAddresses(serialNumber, ip)) {
823             context->serialNumber = ip;
824         } else {
825             context->serialNumber = serialNumber;
826         }
827 
828         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_ONE], &valuetype), napi_invalid_arg);
829         SCAN_ASSERT_BASE(env, valuetype == napi_string, "discoverMode is not a string", napi_string_expected);
830         std::string discoverMode = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_ONE]);
831         SCAN_HILOGD("discoverMode : %{public}s", discoverMode.c_str());
832         context->discoverMode = discoverMode;
833 
834         SCAN_CALL_BASE(env, napi_typeof(env, argv[NapiScanUtils::INDEX_TWO], &valuetype), napi_invalid_arg);
835         SCAN_ASSERT_BASE(env, valuetype == napi_string, "deviceName is not a string", napi_string_expected);
836         std::string deviceName = NapiScanUtils::GetStringFromValueUtf8(env, argv[NapiScanUtils::INDEX_TWO]);
837         SCAN_HILOGD("deviceName : %{public}s", deviceName.c_str());
838         context->deviceName = deviceName;
839         return napi_ok;
840     };
841     auto output = [context](napi_env env, napi_value *result) -> napi_status {
842         napi_status status = napi_get_boolean(env, context->result, result);
843         SCAN_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status);
844         return status;
845     };
846     auto exec = [context](ScanAsyncCall::Context *ctx) {
847         int32_t ret = ScanManagerClient::GetInstance()->UpdateScannerName(context->serialNumber,
848             context->discoverMode, context->deviceName);
849         context->result = ret == E_SCAN_NONE;
850         if (ret != E_SCAN_NONE) {
851             SCAN_HILOGE("Failed to update scanner name");
852             context->SetErrorIndex(ret);
853         }
854     };
855     context->SetAction(std::move(input), std::move(output));
856     ScanAsyncCall asyncCall(env, info, std::dynamic_pointer_cast<ScanAsyncCall::Context>(context));
857     return asyncCall.Call(env, exec);
858 }
859 
IsSupportType(const std::string & type)860 bool NapiInnerScan::IsSupportType(const std::string& type)
861 {
862     if (type == GET_FRAME_RES_EVENT_TYPE || type == SCAN_DEVICE_FOUND_TCP|| type == SCAN_DEVICE_FOUND
863     || type == SCAN_DEVICE_SYNC || type == SCAN_DEVICE_ADD || type == SCAN_DEVICE_DEL || type == SCAN_INIT_EVENT) {
864         return true;
865     }
866     return false;
867 }
868 } // namespace OHOS::Scan
869