1 /*
2 * Copyright (c) 2024 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 <set>
16 #include <map>
17 #include <cstring>
18 #include <string>
19 #include <thread>
20 #include "securec.h"
21 #include "refbase.h"
22 #include "scan_callback.h"
23 #include "scan_manager_client.h"
24 #include "scan_constant.h"
25 #include "scan_log.h"
26 #include "scan_util.h"
27 #include "scanner_info.h"
28 #include "scan_option_value.h"
29 #include "scan_context.h"
30 #include "ohscan.h"
31
32 using namespace OHOS::Scan;
33
OH_Scan_Init()34 int32_t OH_Scan_Init()
35 {
36 SCAN_HILOGI("Enter OH_Scan_Init");
37 auto client = ScanManagerClient::GetInstance();
38 if (client == nullptr) {
39 SCAN_HILOGE("client is a nullptr");
40 return SCAN_ERROR_GENERIC_FAILURE;
41 }
42 int32_t ret = client->InitScan();
43 if (ret != SCAN_ERROR_NONE) {
44 SCAN_HILOGE("InitScan failed, ErrorCode: [%{public}d]", ret);
45 return ScanContext::StatusConvert(ret);
46 } else {
47 SCAN_HILOGI("InitScan successfully");
48 return SCAN_ERROR_NONE;
49 }
50 }
51
OH_Scan_StartScannerDiscovery(Scan_ScannerDiscoveryCallback callback)52 int32_t OH_Scan_StartScannerDiscovery(Scan_ScannerDiscoveryCallback callback)
53 {
54 if (callback == nullptr) {
55 SCAN_HILOGE("callback is a nullptr");
56 return SCAN_ERROR_INVALID_PARAMETER;
57 }
58 auto& context = ScanContext::GetInstance();
59 context.SetDiscoverCallback(callback);
60 auto client = ScanManagerClient::GetInstance();
61 if (client == nullptr) {
62 SCAN_HILOGE("client is a nullptr");
63 return SCAN_ERROR_GENERIC_FAILURE;
64 }
65 int32_t ret = SCAN_ERROR_NONE;
66 auto scannerDiscoveryCallback = [](std::vector<ScanDeviceInfo> &infos) {
67 ScanContext::GetInstance().ExecuteCallback(infos);
68 };
69 OHOS::sptr<IScanCallback> call = new (std::nothrow) ScanCallback(scannerDiscoveryCallback);
70 if (call == nullptr) {
71 SCAN_HILOGE("call is null");
72 return SCAN_ERROR_GENERIC_FAILURE;
73 }
74 ret = client->On("", context.GetRegisterType(), call);
75 if (ret != SCAN_ERROR_NONE) {
76 SCAN_HILOGE("Failed to register event");
77 return ScanContext::StatusConvert(ret);
78 }
79 ret = client->GetScannerList();
80 if (ret != SCAN_ERROR_NONE) {
81 SCAN_HILOGE("Failed to GetScannerList");
82 return ScanContext::StatusConvert(ret);
83 }
84 return SCAN_ERROR_NONE;
85 }
86
OH_Scan_OpenScanner(const char * scannerId)87 int32_t OH_Scan_OpenScanner(const char* scannerId)
88 {
89 if (scannerId == nullptr) {
90 SCAN_HILOGE("Invalid parameter.");
91 return SCAN_ERROR_INVALID_PARAMETER;
92 }
93 auto client = ScanManagerClient::GetInstance();
94 if (client == nullptr) {
95 SCAN_HILOGE("client is a nullptr");
96 return SCAN_ERROR_GENERIC_FAILURE;
97 }
98 int32_t ret = client->OpenScanner(std::string(scannerId));
99 if (ret != SCAN_ERROR_NONE) {
100 SCAN_HILOGE("OpenScanner failed, ErrorCode: [%{public}d]", ret);
101 return ScanContext::StatusConvert(ret);
102 } else {
103 SCAN_HILOGI("OpenScanner successfully");
104 return SCAN_ERROR_NONE;
105 }
106 }
107
OH_Scan_CloseScanner(const char * scannerId)108 int32_t OH_Scan_CloseScanner(const char* scannerId)
109 {
110 if (scannerId == nullptr) {
111 SCAN_HILOGE("Invalid parameter.");
112 return SCAN_ERROR_INVALID_PARAMETER;
113 }
114 auto client = ScanManagerClient::GetInstance();
115 if (client == nullptr) {
116 SCAN_HILOGE("client is a nullptr");
117 return SCAN_ERROR_GENERIC_FAILURE;
118 }
119 int32_t ret = client->CloseScanner(std::string(scannerId));
120 if (ret != SCAN_ERROR_NONE) {
121 SCAN_HILOGE("CloseScanner failed, ErrorCode: [%{public}d]", ret);
122 return ScanContext::StatusConvert(ret);
123 } else {
124 SCAN_HILOGI("CloseScanner successfully");
125 return SCAN_ERROR_NONE;
126 }
127 }
128
OH_Scan_GetScannerParameter(const char * scannerId,int32_t * errorCode)129 Scan_ScannerOptions* OH_Scan_GetScannerParameter(const char* scannerId, int32_t* errorCode)
130 {
131 if (scannerId == nullptr || errorCode == nullptr) {
132 SCAN_HILOGE("Invalid parameter.");
133 return nullptr;
134 }
135 auto& context = ScanContext::GetInstance();
136 std::string deviceId(scannerId);
137 auto cachedOptions = context.GetScannerOptions(deviceId);
138 if (cachedOptions != nullptr) {
139 SCAN_HILOGI("Device parameters have been obtained.");
140 *errorCode = SCAN_ERROR_NONE;
141 return cachedOptions;
142 }
143 int32_t scannerParaCount = 0;
144 int32_t status = context.GetScannerParaCount(deviceId, scannerParaCount);
145 if (status != SCAN_ERROR_NONE) {
146 SCAN_HILOGE("Failed to get scanner GetScannerParaCount value.");
147 *errorCode = status;
148 return nullptr;
149 }
150 std::unique_ptr<ScanParaTable> paraTable = std::make_unique<ScanParaTable>();
151 if (paraTable == nullptr) {
152 SCAN_HILOGE("paraTable is a nullptr");
153 *errorCode = SCAN_ERROR_GENERIC_FAILURE;
154 return nullptr;
155 }
156 status = context.GetScannerParameter(deviceId, scannerParaCount, *paraTable);
157 if (status != SCAN_ERROR_NONE) {
158 SCAN_HILOGE("Failed to get scanner GetScannerParameter paraTable.");
159 *errorCode = status;
160 return nullptr;
161 }
162 Scan_ScannerOptions* scaParaOptions = context.ConvertToScannerOptions(*paraTable);
163 if (scaParaOptions == nullptr) {
164 *errorCode = SCAN_ERROR_GENERIC_FAILURE;
165 return nullptr;
166 }
167 context.SetScanParaTable(scannerId, std::move(paraTable));
168 context.SetScannerOptions(deviceId, scaParaOptions);
169 *errorCode = SCAN_ERROR_NONE;
170 return scaParaOptions;
171 }
172
OH_Scan_SetScannerParameter(const char * scannerId,const int32_t option,const char * value)173 int32_t OH_Scan_SetScannerParameter(const char* scannerId, const int32_t option, const char* value)
174 {
175 if (scannerId == nullptr || value == nullptr) {
176 SCAN_HILOGE("Invalid parameter.");
177 return SCAN_ERROR_INVALID_PARAMETER;
178 }
179 std::string deviceId(scannerId);
180 ScanOptionValue optionValue;
181 auto& context = ScanContext::GetInstance();
182 int32_t ret = context.GetOptionValueFromTable(deviceId, option, value, optionValue);
183 if (ret != SCAN_ERROR_NONE) {
184 SCAN_HILOGE("GetOptionValueFromTable error");
185 return ret;
186 }
187 auto client = ScanManagerClient::GetInstance();
188 if (client == nullptr) {
189 SCAN_HILOGE("client is a nullptr");
190 return SCAN_ERROR_GENERIC_FAILURE;
191 }
192 int32_t innerOption = option;
193 if (!context.ParaIndexConvert(option, innerOption, deviceId)) {
194 SCAN_HILOGE("index [%{private}d] is error", option);
195 return SCAN_ERROR_INVALID_PARAMETER;
196 }
197 ret = client->OpScanOptionValue(deviceId, innerOption,
198 SCAN_ACTION_SET_VALUE, optionValue);
199 if (ret != SCAN_ERROR_NONE) {
200 SCAN_HILOGE("SetScannerParameter failed, ErrorCode: [%{public}d]", ret);
201 return ScanContext::StatusConvert(ret);
202 }
203 return SCAN_ERROR_NONE;
204 }
205
OH_Scan_StartScan(const char * scannerId,bool batchMode)206 int32_t OH_Scan_StartScan(const char* scannerId, bool batchMode)
207 {
208 if (scannerId == nullptr) {
209 SCAN_HILOGE("Invalid parameter.");
210 return SCAN_ERROR_INVALID_PARAMETER;
211 }
212 auto client = ScanManagerClient::GetInstance();
213 if (client == nullptr) {
214 SCAN_HILOGE("client is a nullptr");
215 return SCAN_ERROR_GENERIC_FAILURE;
216 }
217 int32_t ret = client->StartScan(std::string(scannerId), batchMode);
218 if (ret != SCAN_ERROR_NONE) {
219 SCAN_HILOGE("StartScan failed, ErxrorCode: [%{public}d]", ret);
220 return ScanContext::StatusConvert(ret);
221 } else {
222 SCAN_HILOGI("StartScan successfully");
223 return SCAN_ERROR_NONE;
224 }
225 }
226
OH_Scan_CancelScan(const char * scannerId)227 int32_t OH_Scan_CancelScan(const char* scannerId)
228 {
229 if (scannerId == nullptr) {
230 SCAN_HILOGE("Invalid parameter.");
231 return SCAN_ERROR_INVALID_PARAMETER;
232 }
233 auto client = ScanManagerClient::GetInstance();
234 if (client == nullptr) {
235 SCAN_HILOGE("client is a nullptr");
236 return SCAN_ERROR_GENERIC_FAILURE;
237 }
238 int32_t ret = client->CancelScan(std::string(scannerId));
239 if (ret != SCAN_ERROR_NONE) {
240 SCAN_HILOGE("CancelScan failed, ErxrorCode: [%{public}d]", ret);
241 return ScanContext::StatusConvert(ret);
242 } else {
243 SCAN_HILOGI("CancelScan successfully");
244 return SCAN_ERROR_NONE;
245 }
246 }
247
OH_Scan_GetPictureScanProgress(const char * scannerId,Scan_PictureScanProgress * prog)248 int32_t OH_Scan_GetPictureScanProgress(const char* scannerId, Scan_PictureScanProgress* prog)
249 {
250 if (prog == nullptr) {
251 SCAN_HILOGE("Invalid parameter.");
252 return SCAN_ERROR_INVALID_PARAMETER;
253 }
254 ScanProgress scanProg;
255 auto client = ScanManagerClient::GetInstance();
256 if (client == nullptr) {
257 SCAN_HILOGE("client is a nullptr");
258 return SCAN_ERROR_GENERIC_FAILURE;
259 }
260 int32_t ret = client->GetScanProgress(std::string(scannerId), scanProg);
261 if (ret != SCAN_ERROR_NONE) {
262 SCAN_HILOGE("GetScanProgress failed, ErrorCode: [%{public}d]", ret);
263 return ScanContext::StatusConvert(ret);
264 } else {
265 prog->progress = scanProg.GetScanProgress();
266 prog->fd = scanProg.GetScanPictureFd();
267 prog->isFinal = scanProg.GetIsFinal();
268 SCAN_HILOGI("GetScanProgress successfully");
269 return SCAN_ERROR_NONE;
270 }
271 }
272
OH_Scan_Exit()273 int32_t OH_Scan_Exit()
274 {
275 auto& context = ScanContext::GetInstance();
276 auto client = ScanManagerClient::GetInstance();
277 if (client == nullptr) {
278 SCAN_HILOGE("client is a nullptr");
279 return SCAN_ERROR_GENERIC_FAILURE;
280 }
281 int32_t ret = client->ExitScan();
282 if (ret != SCAN_ERROR_NONE) {
283 SCAN_HILOGE("ExitScan failed, ErrorCode: [%{public}d]", ret);
284 return ScanContext::StatusConvert(ret);
285 }
286 client->Off("", context.GetRegisterType());
287 context.Clear();
288 SCAN_HILOGI("ExitScan successfully");
289 return SCAN_ERROR_NONE;
290 }