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 "scan_service_ability.h"
16
17 #include <cerrno>
18 #include <ctime>
19 #include <string>
20 #include <sys/time.h>
21 #include <thread>
22 #include <unistd.h>
23 #include <fstream>
24 #include <fcntl.h>
25 #include <iostream>
26 #include <iomanip>
27 #include <chrono>
28 #include <random>
29 #include <condition_variable>
30 #include <regex>
31
32 #include "accesstoken_kit.h"
33 #include "array_wrapper.h"
34 #include "file_ex.h"
35 #include "int_wrapper.h"
36 #include "ipc_skeleton.h"
37 #include "iservice_registry.h"
38 #include "napi_scan_utils.h"
39 #include "scan_constant.h"
40 #include "scan_log.h"
41 #include "scan_util.h"
42 #include "scanner_info.h"
43 #include "string_wrapper.h"
44 #include "system_ability.h"
45 #include "system_ability_definition.h"
46 #include "want_params_wrapper.h"
47 #include "scan_usb_manager.h"
48 #include "common_event_data.h"
49 #include "common_event_manager.h"
50 #include "common_event_support.h"
51 #include "scan_system_data.h"
52 #include "sane_manager_client.h"
53 #include "sane_option_descriptor.h"
54 #include "sane_device.h"
55 #include "sane_control_param.h"
56 #include "sane_picture_data.h"
57 #include "scan_log.h"
58
59 namespace OHOS::Scan {
60 namespace {
GetElapsedSeconds(const SteadyTimePoint & preTime)61 static int32_t GetElapsedSeconds(const SteadyTimePoint& preTime)
62 {
63 auto nowTime = std::chrono::steady_clock::now();
64 auto elapsedTime = std::chrono::duration_cast<std::chrono::seconds>(nowTime - preTime);
65 return elapsedTime.count();
66 }
67
GetRandomNumber(const int32_t & lowerBoundary,const int32_t & upperBoundary)68 static int32_t GetRandomNumber(const int32_t& lowerBoundary, const int32_t& upperBoundary)
69 {
70 std::random_device rd;
71 std::mt19937 gen(rd());
72 std::uniform_int_distribution<> dis(lowerBoundary, upperBoundary);
73 return dis(gen);
74 }
75
GetLastWord(const std::string & str)76 static std::string GetLastWord(const std::string& str)
77 {
78 size_t pos = str.find_last_of(' ');
79 if (pos == std::string::npos) {
80 return str;
81 }
82 return str.substr(pos + 1);
83 }
84 };
85 using namespace std;
86 using namespace OHOS::HiviewDFX;
87 using namespace Security::AccessToken;
88 using SteadyTimePoint = std::chrono::steady_clock::time_point;
89
90 constexpr int ONE_KB = 1024; // default buffersize 1KB
91 constexpr int SCAN_PROGRESS_100 = 100;
92 constexpr int SCAN_PROGRESS_10 = 10;
93 constexpr int SCAN_PROGRESS_19 = 19;
94 constexpr int SCAN_PROGRESS_80 = 80;
95 constexpr int JPEG_QUALITY_SEVENTY_FIVE = 75;
96 constexpr int CHANNEL_ONE = 1;
97 constexpr int CHANNEL_THREE = 3;
98 const int64_t INIT_INTERVAL = 5000L;
99 const uint32_t ASYNC_CMD_DELAY = 10;
100 const int64_t UNLOAD_SYSTEMABILITY_DELAY = 1000 * 30;
101 constexpr int32_t INVALID_USER_ID = -1;
102 constexpr int32_t START_USER_ID = 100;
103 constexpr int32_t MAX_USER_ID = 1099;
104
105 static int32_t g_scannerState = SCANNER_READY;
106 static bool g_hasIoFaild = false;
107 static bool g_isJpegWriteSuccess = false;
108 static const std::string PERMISSION_NAME_SCAN = "ohos.permission.SCAN";
109 static const std::string PERMISSION_NAME_SCAN_JOB = "ohos.permission.MANAGE_SCAN_JOB";
110 static const std::string PERMISSION_NAME_PRINT = "ohos.permission.PRINT";
111 static const std::string SCAN_DEVICE_FOUND_TCP = "scanDeviceFoundTCP";
112 static const std::string SCAN_DEVICE_FOUND = "scanDeviceFound";
113 static const std::string SCAN_DEVICE_SYNC = "scanDeviceSync";
114 static const std::string SCAN_DEVICE_ADD = "scanDeviceAdd";
115 static const std::string SCAN_DEVICE_DEL = "scanDeviceDel";
116 static const std::string SCAN_INIT_EVENT = "scanInitEvent";
117
118 static const std::string DEVICE_EVENT_TYPE = "deviceStateChange";
119 static const std::string GET_SCANNER_DEVICE_LIST = "GET_SCANNER_DEVICE_LIST";
120
121 std::map<std::string, sptr<IScanCallback>> OHOS::Scan::ScanServiceAbility::registeredListeners_;
122
123 REGISTER_SYSTEM_ABILITY_BY_ID(ScanServiceAbility, SCAN_SERVICE_ID, true);
124
125 int32_t ScanServiceAbility::appCount_ = 0;
126 std::mutex ScanServiceAbility::instanceLock_;
127 sptr<ScanServiceAbility> ScanServiceAbility::instance_;
128 std::shared_ptr<AppExecFwk::EventHandler> ScanServiceAbility::serviceHandler_;
129 std::map<std::string, ScanDeviceInfo> ScanServiceAbility::saneGetUsbDeviceInfoMap;
130 std::map<std::string, ScanDeviceInfo> ScanServiceAbility::saneGetTcpDeviceInfoMap;
131 std::map<std::string, std::string> ScanServiceAbility::usbSnMap;
132
ScanServiceAbility(int32_t systemAbilityId,bool runOnCreate)133 ScanServiceAbility::ScanServiceAbility(int32_t systemAbilityId, bool runOnCreate)
134 : SystemAbility(systemAbilityId, runOnCreate), state_(ServiceRunningState::STATE_NOT_START),
135 currentJobId_(SCAN_CONSTRAINT_NONE), currentUseScannerUserId_(INVALID_USER_ID)
136 {
137 constexpr int32_t oneHundred = 100;
138 buffer_size = ONE_KB * oneHundred;
139 saneReadBuf = static_cast<uint8_t *>(malloc(buffer_size));
140 cinfoPtr = new (std::nothrow) jpeg_compress_struct();
141 if (cinfoPtr == nullptr) {
142 SCAN_HILOGE("cinfoPtr allocated failed");
143 return;
144 }
145 cinfoPtr->comps_in_scan = 0;
146 }
147
~ScanServiceAbility()148 ScanServiceAbility::~ScanServiceAbility()
149 {
150 FREE_AND_NULLPTR(saneReadBuf);
151 DELETE_ARRAY_AND_NULLIFY(jpegbuf)
152 DELETE_AND_NULLIFY(cinfoPtr);
153 DELETE_AND_NULLIFY(ofp);
154 SCAN_HILOGD("~ScanServiceAbility state_ is %{public}d.", static_cast<int>(state_));
155 }
156
GetInstance()157 sptr<ScanServiceAbility> ScanServiceAbility::GetInstance()
158 {
159 if (instance_ == nullptr) {
160 std::lock_guard<std::mutex> autoLock(instanceLock_);
161 if (instance_ == nullptr) {
162 instance_ = new ScanServiceAbility(SCAN_SERVICE_ID, true);
163 }
164 }
165 return instance_;
166 }
167
ServiceInit()168 int32_t ScanServiceAbility::ServiceInit()
169 {
170 bool ret = Publish(ScanServiceAbility::GetInstance());
171 if (!ret) {
172 SCAN_HILOGE("ScanServiceAbility Publish failed.");
173 return E_SCAN_SERVER_FAILURE;
174 }
175 state_ = ServiceRunningState::STATE_RUNNING;
176 SCAN_HILOGD("state_ is %{public}d.", static_cast<int>(state_));
177 SCAN_HILOGI("Init ScanServiceAbility success.");
178 return ERR_OK;
179 }
180
OnStart()181 void ScanServiceAbility::OnStart()
182 {
183 SCAN_HILOGI("ScanServiceAbility::Enter OnStart.");
184 if (instance_ == nullptr) {
185 instance_ = this;
186 }
187 if (state_ == ServiceRunningState::STATE_RUNNING) {
188 SCAN_HILOGI("ScanServiceAbility is already running.");
189 return;
190 }
191
192 InitServiceHandler();
193 int32_t ret = ServiceInit();
194 if (ret != ERR_OK) {
195 auto callback = [=]() { ServiceInit(); };
196 serviceHandler_->PostTask(callback, INIT_INTERVAL);
197 SCAN_HILOGE("ScanServiceAbility Init failed. Try again 5s later");
198 return;
199 }
200 state_ = ServiceRunningState::STATE_RUNNING;
201 return;
202 }
203
InitServiceHandler()204 void ScanServiceAbility::InitServiceHandler()
205 {
206 SCAN_HILOGI("InitServiceHandler started.");
207 if (serviceHandler_ != nullptr) {
208 SCAN_HILOGI("InitServiceHandler already init.");
209 return;
210 }
211 std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create("ScanServiceAbility");
212 serviceHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
213 SCAN_HILOGI("InitServiceHandler succeeded.");
214 }
215
ManualStart()216 void ScanServiceAbility::ManualStart()
217 {
218 if (state_ != ServiceRunningState::STATE_RUNNING) {
219 SCAN_HILOGI("ScanServiceAbility restart.");
220 OnStart();
221 }
222 }
223
OnStop()224 void ScanServiceAbility::OnStop()
225 {
226 SCAN_HILOGI("OnStop started.");
227 if (state_ != ServiceRunningState::STATE_RUNNING) {
228 SCAN_HILOGW("service is not running");
229 return;
230 }
231 serviceHandler_ = nullptr;
232 state_ = ServiceRunningState::STATE_NOT_START;
233 SCAN_HILOGI("OnStop end.");
234 }
UnloadSystemAbility()235 void ScanServiceAbility::UnloadSystemAbility()
236 {
237 SCAN_HILOGI("appCount_= %{public}d", appCount_);
238 auto unloadTask = [this]() {
239 if (ScanServiceAbility::appCount_ != 0) {
240 SCAN_HILOGW("appCount is not equal to zerro");
241 return;
242 }
243 this->ExitScan();
244 SaneManagerClient::GetInstance()->UnloadSystemAbility();
245 ScanMdnsService::OnStopDiscoverService();
246 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
247 if (samgrProxy == nullptr) {
248 SCAN_HILOGE("get samgr failed");
249 return;
250 }
251 int32_t ret = samgrProxy->UnloadSystemAbility(SCAN_SERVICE_ID);
252 if (ret != ERR_OK) {
253 SCAN_HILOGE("unload system ability failed");
254 return;
255 }
256 SCAN_HILOGI("unload system ability successfully");
257 };
258 serviceHandler_->PostTask(unloadTask, UNLOAD_SYSTEMABILITY_DELAY);
259 }
260
InitScan(int32_t & scanVersion)261 int32_t ScanServiceAbility::InitScan(int32_t &scanVersion)
262 {
263 ManualStart();
264 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
265 SCAN_HILOGE("no permission to access scan service");
266 return E_SCAN_NO_PERMISSION;
267 }
268 ExitScan();
269 SCAN_HILOGI("ScanServiceAbility InitScan start");
270 SaneStatus status = SaneManagerClient::GetInstance()->SaneInit();
271 if (status != SANE_STATUS_GOOD) {
272 SCAN_HILOGE("SaneInit failed, status: [%{public}u]", status);
273 return ScanUtil::ConvertErro(status);
274 }
275 DelayedSingleton<ScanUsbManager>::GetInstance()->Init();
276 ScanSystemData::GetInstance().Init();
277 ScanMdnsService::OnStartDiscoverService();
278 SCAN_HILOGI("ScanServiceAbility InitScan end, scanVersion = [%{public}d]", scanVersion);
279 return E_SCAN_NONE;
280 }
281
ExitScan()282 int32_t ScanServiceAbility::ExitScan()
283 {
284 ManualStart();
285 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
286 SCAN_HILOGE("no permission to access scan service");
287 return E_SCAN_NO_PERMISSION;
288 }
289 SCAN_HILOGI("ScanServiceAbility ExitScan start");
290 std::lock_guard<std::mutex> autoLock(lock_);
291 for (const auto& scannerId : openedScannerList_) {
292 SaneManagerClient::GetInstance()->SaneCancel(scannerId);
293 SaneManagerClient::GetInstance()->SaneClose(scannerId);
294 }
295 openedScannerList_.clear();
296 SaneManagerClient::GetInstance()->SaneExit();
297 g_scannerState = SCANNER_READY;
298 std::queue<int32_t> empty;
299 scanQueue.swap(empty);
300 scanTaskMap.clear();
301 for (const auto& [imagePath, fd] : imageFdMap_) {
302 constexpr int32_t INVALID_FILE_DESCRIPTOR = -1;
303 if (fd != INVALID_FILE_DESCRIPTOR) {
304 fdsan_close_with_tag(fd, SCAN_LOG_DOMAIN);
305 }
306 if (FileExists(imagePath)) {
307 unlink(imagePath.c_str());
308 }
309 }
310 imageFdMap_.clear();
311 SCAN_HILOGI("ScanServiceAbility ExitScan end");
312 return E_SCAN_NONE;
313 }
314
ReInitScan()315 int32_t ScanServiceAbility::ReInitScan()
316 {
317 ManualStart();
318 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
319 SCAN_HILOGE("no permission to access scan service");
320 return E_SCAN_NO_PERMISSION;
321 }
322 SCAN_HILOGD("ScanServiceAbility ReInitScan start");
323 SaneManagerClient::GetInstance()->SaneExit();
324 openedScannerList_.clear();
325 g_scannerState = SCANNER_READY;
326 std::queue<int32_t> empty;
327 scanQueue.swap(empty);
328 scanTaskMap.clear();
329 SaneStatus status = SaneManagerClient::GetInstance()->SaneInit();
330 if (status != SANE_STATUS_GOOD) {
331 SCAN_HILOGE("SaneInit failed, status: [%{public}u]", status);
332 return ScanUtil::ConvertErro(status);
333 }
334
335 DelayedSingleton<ScanUsbManager>::GetInstance()->Init();
336 return E_SCAN_NONE;
337 }
338
GetUsbDevicePort(const std::string & deviceId,std::string & firstId,std::string & secondId)339 bool ScanServiceAbility::GetUsbDevicePort(const std::string &deviceId, std::string &firstId, std::string &secondId)
340 {
341 static const std::regex pattern(R"(([a-zA-Z0-9_]+):(libusb):([0-9]{3}):([0-9]{3}))");
342 std::smatch match;
343 constexpr size_t STRING_POS_THREE = 3;
344 constexpr size_t STRING_POS_FOUR = 4;
345 if (!std::regex_match(deviceId, match, pattern) || match.size() <= STRING_POS_FOUR) {
346 SCAN_HILOGE("In USB mode, the deviceId string format does not match");
347 return false;
348 }
349 const std::string firstIdTmp = match[STRING_POS_THREE].str();
350 const std::string secondIdTmp = match[STRING_POS_FOUR].str();
351 int32_t firstNumTmp = 0;
352 int32_t secondNumTmp = 0;
353 if (!ScanUtil::ConvertToInt(firstIdTmp, firstNumTmp) ||
354 !ScanUtil::ConvertToInt(secondIdTmp, secondNumTmp)) {
355 SCAN_HILOGE("parse [%{public}s]:[%{public}s] fail", firstIdTmp.c_str(), secondIdTmp.c_str());
356 return false;
357 }
358 firstId = std::to_string(firstNumTmp);
359 secondId = std::to_string(secondNumTmp);
360 return true;
361 }
362
GetTcpDeviceIp(const std::string & deviceId,std::string & ip)363 bool ScanServiceAbility::GetTcpDeviceIp(const std::string &deviceId, std::string &ip)
364 {
365 static const std::regex pattern(R"(([^ ]+) (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) ([^ ]+))");
366 std::smatch match;
367 if (std::regex_match(deviceId, match, pattern)) {
368 constexpr size_t STRING_POS_TWO = 2;
369 ip = match[STRING_POS_TWO];
370 return true;
371 } else {
372 SCAN_HILOGE("In TCP mode, the deviceId string format does not match");
373 return false;
374 }
375 }
376
SetScannerSerialNumberByTCP(ScanDeviceInfo & info)377 void ScanServiceAbility::SetScannerSerialNumberByTCP(ScanDeviceInfo &info)
378 {
379 info.discoverMode = "TCP";
380 std::string ip;
381 if (!GetTcpDeviceIp(info.deviceId, ip)) {
382 SCAN_HILOGE("cannot get device's ip");
383 return;
384 }
385 int32_t count = 0;
386 constexpr int32_t MAX_WAIT_COUNT = 5;
387 constexpr int32_t WAIT_TIME = 1;
388 ScanDeviceInfoTCP netScannerInfo;
389 bool findNetScannerInfoByIp = ScanMdnsService::FindNetScannerInfoByIp(ip, netScannerInfo);
390 do {
391 sleep(WAIT_TIME);
392 SCAN_HILOGW("wait a second");
393 findNetScannerInfoByIp = ScanMdnsService::FindNetScannerInfoByIp(ip, netScannerInfo);
394 count++;
395 } while (!findNetScannerInfoByIp && count < MAX_WAIT_COUNT);
396 info.uniqueId = ip;
397 if (findNetScannerInfoByIp) {
398 info.serialNumber = GetLastWord(netScannerInfo.deviceName);
399 info.uuid = netScannerInfo.uuid;
400 info.deviceName = netScannerInfo.deviceName;
401 } else {
402 info.deviceName = info.manufacturer + "-" + info.model;
403 }
404 }
405
SetScannerSerialNumberByUSB(ScanDeviceInfo & info)406 void ScanServiceAbility::SetScannerSerialNumberByUSB(ScanDeviceInfo &info)
407 {
408 info.discoverMode = "USB";
409 std::string firstId;
410 std::string secondId;
411 if (!GetUsbDevicePort(info.deviceId, firstId, secondId)) {
412 SCAN_HILOGE("cannot get usb's port");
413 return;
414 }
415 std::string usbScannerPort = firstId + "-" + secondId;
416 DelayedSingleton<ScanUsbManager>::GetInstance()->RefreshUsbDevice();
417 auto it = usbSnMap.find(usbScannerPort);
418 if (it != usbSnMap.end() && it->second != "") {
419 SCAN_HILOGD("set serialNumber [%{private}s]", it->second.c_str());
420 info.serialNumber = it->second;
421 info.uniqueId = it->second;
422 } else {
423 SCAN_HILOGE("usb can't find serialNumber");
424 }
425 info.deviceName = info.manufacturer + "-" + info.model + "-" + info.serialNumber;
426 }
427
SetScannerSerialNumber(ScanDeviceInfo & info)428 void ScanServiceAbility::SetScannerSerialNumber(ScanDeviceInfo &info)
429 {
430 if (info.deviceId.find(":tcp") != info.deviceId.npos) {
431 SetScannerSerialNumberByTCP(info);
432 } else if (info.deviceId.find(":libusb") != info.deviceId.npos) {
433 SetScannerSerialNumberByUSB(info);
434 } else {
435 SCAN_HILOGE("Unknown scanner connect method");
436 }
437 }
438
AddFoundScanner(ScanDeviceInfo & info)439 void ScanServiceAbility::AddFoundScanner(ScanDeviceInfo& info)
440 {
441 std::lock_guard<std::mutex> autoLock(clearMapLock_);
442 if (info.discoverMode != "USB" && info.discoverMode != "TCP") {
443 SCAN_HILOGE("discoverMode is invalid:[%{public}s]", info.discoverMode.c_str());
444 return;
445 }
446 if (info.uniqueId.empty() && info.serialNumber.empty()) {
447 SCAN_HILOGE("uniqueId and serialNumber are null");
448 return;
449 }
450 std::string uniqueId = info.discoverMode + info.uniqueId;
451 ScanSystemData& scanData = ScanSystemData::GetInstance();
452 if (info.discoverMode == "USB") {
453 scanData.UpdateScannerInfoByUniqueId(uniqueId, info);
454 } else {
455 scanData.UpdateNetScannerByUuid(info.uuid, info.uniqueId);
456 }
457 scanData.SaveScannerMap();
458 std::map<std::string, ScanDeviceInfo>& deviceMap = info.discoverMode == "USB" ?
459 saneGetUsbDeviceInfoMap : saneGetTcpDeviceInfoMap;
460 deviceMap[info.serialNumber] = info;
461 deviceMap[info.uniqueId] = info;
462 }
463
SaneGetScanner()464 void ScanServiceAbility::SaneGetScanner()
465 {
466 std::lock_guard<std::mutex> autoLock(lock_);
467 clearMapLock_.lock();
468 saneGetTcpDeviceInfoMap.clear();
469 saneGetUsbDeviceInfoMap.clear();
470 clearMapLock_.unlock();
471 g_scannerState = SCANNER_SEARCHING;
472 std::vector<SaneDevice> deviceInfos;
473 SaneStatus status = SaneManagerClient::GetInstance()->SaneGetDevices(deviceInfos);
474 if (status != SANE_STATUS_GOOD) {
475 SCAN_HILOGE("SaneGetDevices failed, ret: [%{public}u]", status);
476 g_scannerState = SCANNER_READY;
477 return;
478 }
479 for (const auto& device: deviceInfos) {
480 ScanDeviceInfo info;
481 info.deviceId = device.name_;
482 info.manufacturer = device.vendor_;
483 info.model = device.model_;
484 info.deviceType = device.type_;
485 SetScannerSerialNumber(info);
486 AddFoundScanner(info);
487 }
488 clearMapLock_.lock();
489 for (auto &t : saneGetUsbDeviceInfoMap) {
490 SendDeviceInfo(t.second, SCAN_DEVICE_FOUND);
491 deviceInfos_.emplace_back(t.second);
492 }
493 for (auto &t : saneGetTcpDeviceInfoMap) {
494 SendDeviceInfo(t.second, SCAN_DEVICE_FOUND);
495 deviceInfos_.emplace_back(t.second);
496 }
497 clearMapLock_.unlock();
498 g_scannerState = SCANNER_READY;
499 }
500
GetScannerList()501 int32_t ScanServiceAbility::GetScannerList()
502 {
503 ManualStart();
504 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
505 return E_SCAN_NO_PERMISSION;
506 }
507 if (g_scannerState != SCANNER_READY) {
508 SCAN_HILOGW("is working");
509 return E_SCAN_DEVICE_BUSY;
510 }
511 int32_t version = 0;
512 InitScan(version);
513 SCAN_HILOGD("ScanServiceAbility GetScannerList start");
514 std::lock_guard<std::mutex> autoLock(lock_);
515 auto exec_sane_getscaner = [=]() {
516 deviceInfos_.clear();
517 SaneGetScanner();
518 std::string message = "EOF";
519 SendDeviceSearchEnd(message, SCAN_DEVICE_FOUND);
520 SendDeviceList(deviceInfos_, GET_SCANNER_DEVICE_LIST);
521 };
522 serviceHandler_->PostTask(exec_sane_getscaner, ASYNC_CMD_DELAY);
523 SCAN_HILOGD("ScanServiceAbility GetScannerList end");
524 return E_SCAN_NONE;
525 }
526
StopDiscover()527 int32_t ScanServiceAbility::StopDiscover()
528 {
529 ManualStart();
530 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
531 SCAN_HILOGE("no permission to access scan service");
532 return E_SCAN_NO_PERMISSION;
533 }
534 SCAN_HILOGD("ScanServiceAbility StopDiscover start");
535
536 if (ScanMdnsService::OnStopDiscoverService()) {
537 SCAN_HILOGD("ScanServiceAbility StopDiscover end successful.");
538 return E_SCAN_NONE;
539 } else {
540 SCAN_HILOGE("ScanServiceAbility StopDiscover fail.");
541 return E_SCAN_SERVER_FAILURE;
542 }
543 }
544
OpenScanner(const std::string scannerId)545 int32_t ScanServiceAbility::OpenScanner(const std::string scannerId)
546 {
547 ManualStart();
548 std::lock_guard<std::mutex> autoLock(lock_);
549 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
550 SCAN_HILOGE("no permission to access scan service");
551 return E_SCAN_NO_PERMISSION;
552 }
553 SCAN_HILOGI("ScanServiceAbility OpenScanner start");
554 if (scannerId.empty()) {
555 SCAN_HILOGE("OpenScanner scannerId is empty");
556 return E_SCAN_INVALID_PARAMETER;
557 }
558 if (openedScannerList_.find(scannerId) != openedScannerList_.end()) {
559 SCAN_HILOGD("scannerId %{public}s is already opened", scannerId.c_str());
560 return E_SCAN_NONE;
561 }
562 SaneStatus status = SaneManagerClient::GetInstance()->SaneOpen(scannerId);
563 if (status != SANE_STATUS_GOOD) {
564 SCAN_HILOGE("sane_open failed, ret: [%{public}u], retry one times", status);
565 status = SaneManagerClient::GetInstance()->SaneOpen(scannerId);
566 }
567
568 if (status != SANE_STATUS_GOOD) {
569 SCAN_HILOGE("SaneOpen failed, status: [%{public}u]", status);
570 return ScanUtil::ConvertErro(status);
571 }
572 openedScannerList_.insert(scannerId);
573 SCAN_HILOGI("ScanServiceAbility OpenScanner end");
574 return E_SCAN_NONE;
575 }
576
CloseScanner(const std::string scannerId)577 int32_t ScanServiceAbility::CloseScanner(const std::string scannerId)
578 {
579 ManualStart();
580 std::lock_guard<std::mutex> autoLock(lock_);
581 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
582 SCAN_HILOGE("no permission to access scan service");
583 return E_SCAN_NO_PERMISSION;
584 }
585 SCAN_HILOGI("ScanServiceAbility CloseScanner start");
586 scanTaskMap.clear();
587 std::queue<int32_t> emptyQueue;
588 scanQueue.swap(emptyQueue);
589 SaneStatus status = SaneManagerClient::GetInstance()->SaneClose(scannerId);
590 if (status != SANE_STATUS_GOOD) {
591 SCAN_HILOGE("SaneClose failed, status: [%{public}u]", status);
592 return ScanUtil::ConvertErro(status);
593 }
594 openedScannerList_.erase(scannerId);
595 SCAN_HILOGI("ScanServiceAbility CloseScanner end");
596 return E_SCAN_NONE;
597 }
598
GetScanOptionDesc(const std::string scannerId,const int32_t optionIndex,ScanOptionDescriptor & desc)599 int32_t ScanServiceAbility::GetScanOptionDesc(
600 const std::string scannerId, const int32_t optionIndex, ScanOptionDescriptor &desc)
601 {
602 ManualStart();
603 std::lock_guard<std::mutex> autoLock(lock_);
604 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
605 SCAN_HILOGE("no permission to access scan service");
606 return E_SCAN_NO_PERMISSION;
607 }
608 SCAN_HILOGI("ScanServiceAbility GetScanOptionDesc start");
609 SCAN_HILOGD("optionIndex [%{public}d]", optionIndex);
610 SaneOptionDescriptor saneDesc;
611 SaneStatus status = SaneManagerClient::GetInstance()->SaneGetOptionDescriptor(scannerId, optionIndex, saneDesc);
612 if (status != SANE_STATUS_GOOD) {
613 SCAN_HILOGE("SaneGetOptionDescriptor failed, status: [%{public}u]", status);
614 return ScanUtil::ConvertErro(status);
615 }
616 desc.SetOptionName(saneDesc.optionName_);
617 desc.SetOptionTitle(saneDesc.optionTitle_);
618 desc.SetOptionDesc(saneDesc.optionDesc_);
619 desc.SetOptionType(saneDesc.optionType_);
620 desc.SetOptionUnit(saneDesc.optionUnit_);
621 desc.SetOptionSize(saneDesc.optionSize_);
622 desc.SetOptionCap(saneDesc.optionCap_);
623 desc.SetOptionConstraintType(saneDesc.optionConstraintType_);
624 if (saneDesc.optionConstraintType_ == SANE_CONSTRAINT_RANGE) {
625 ScanRange scanRange;
626 scanRange.SetMinValue(saneDesc.minValue_);
627 scanRange.SetMaxValue(saneDesc.maxValue_);
628 scanRange.SetQuantValue(saneDesc.quantValue_);
629 desc.SetOptionConstraintRange(scanRange);
630 } else if (saneDesc.optionConstraintType_ == SANE_CONSTRAINT_WORD_LIST) {
631 std::vector<int32_t> optionConstraintNumber;
632 for (const auto& number : saneDesc.optionConstraintNumber_) {
633 SCAN_HILOGD("SANE_CONSTRAINT_WORD_LIST : %{public}d", number);
634 optionConstraintNumber.push_back(number);
635 }
636 desc.SetOptionConstraintNumber(optionConstraintNumber);
637 } else if (saneDesc.optionConstraintType_ == SANE_CONSTRAINT_STRING_LIST) {
638 std::vector<std::string> optionConstraintString;
639 std::vector<std::string>& stringList = saneDesc.optionConstraintString_;
640 for (auto& str : stringList) {
641 SCAN_HILOGD("SANE_CONSTRAINT_STRING_LIST %{public}s", str.c_str());
642 optionConstraintString.push_back(str);
643 }
644 desc.SetOptionConstraintString(optionConstraintString);
645 }
646 desc.Dump();
647 SCAN_HILOGI("ScanServiceAbility GetScanOptionDesc end");
648 return E_SCAN_NONE;
649 }
650
ActionSetAuto(const std::string & scannerId,const int32_t & optionIndex)651 int32_t ScanServiceAbility::ActionSetAuto(const std::string &scannerId, const int32_t &optionIndex)
652 {
653 SCAN_HILOGD("Set OpScanOptionValue SCAN_ACTION_SET_AUTO");
654 SaneStatus status = SANE_STATUS_GOOD;
655 SaneControlParam controlParam;
656 controlParam.option_ = optionIndex;
657 controlParam.action_ = static_cast<SaneAction>(SANE_ACTION_SET_AUTO);
658 SaneOutParam outParam;
659 status = SaneManagerClient::GetInstance()->SaneControlOption(scannerId, controlParam, outParam);
660 if (status != SANE_STATUS_GOOD) {
661 SCAN_HILOGE("SaneControlOption failed, status: [%{public}d]", status);
662 return ScanUtil::ConvertErro(status);
663 }
664 return E_SCAN_NONE;
665 }
666
ActionGetValue(const std::string & scannerId,ScanOptionValue & value,const int32_t & optionIndex)667 int32_t ScanServiceAbility::ActionGetValue(const std::string &scannerId, ScanOptionValue &value,
668 const int32_t &optionIndex)
669 {
670 SCAN_HILOGD("Set OpScanOptionValue SCAN_ACTION_GET_VALUE");
671 SaneStatus status = SANE_STATUS_GOOD;
672 ScanOptionValueType valueType = value.GetScanOptionValueType();
673 SaneControlParam controlParam;
674 controlParam.option_ = optionIndex;
675 controlParam.action_ = SANE_ACTION_GET_VALUE;
676 controlParam.valueType_ = static_cast<int32_t>(valueType);
677 controlParam.valueSize_ = value.GetValueSize();
678 SaneOutParam outParam;
679 status = SaneManagerClient::GetInstance()->SaneControlOption(scannerId, controlParam, outParam);
680 if (status != SANE_STATUS_GOOD) {
681 SCAN_HILOGE("sane_control_option failed, status: [%{public}d]", status);
682 return ScanUtil::ConvertErro(status);
683 }
684 if (valueType == SCAN_VALUE_NUM) {
685 value.SetNumValue(outParam.valueNumber_);
686 } else if (valueType == SCAN_VALUE_NUM_LIST) {
687 std::vector<int32_t> numListValue = outParam.valueNumList_;
688 value.SetNumListValue(numListValue);
689 } else if (valueType == SCAN_VALUE_STR) {
690 value.SetStrValue(outParam.valueStr_);
691 } else if (valueType == SCAN_VALUE_BOOL) {
692 value.SetBoolValue(outParam.valueBool_);
693 }
694 return E_SCAN_NONE;
695 }
696
ActionSetValue(const std::string & scannerId,ScanOptionValue & value,const int32_t & optionIndex,int32_t & info)697 int32_t ScanServiceAbility::ActionSetValue(const std::string &scannerId, ScanOptionValue &value,
698 const int32_t &optionIndex, int32_t &info)
699 {
700 SCAN_HILOGI("Set OpScanOptionValue SCAN_ACTION_SET_VALUE");
701 SaneStatus status = SANE_STATUS_GOOD;
702 SaneControlParam controlParam;
703 controlParam.option_ = optionIndex;
704 controlParam.action_ = static_cast<SaneAction>(SANE_ACTION_SET_VALUE);
705 controlParam.valueType_ = static_cast<int32_t>(value.GetScanOptionValueType());
706 int32_t numValue = value.GetNumValue();
707 controlParam.valueNumber_ = numValue;
708 constexpr int32_t MAX_PICTURE_DPI = 3000;
709 dpi = numValue > 0 && numValue < MAX_PICTURE_DPI ? numValue : dpi;
710 controlParam.valueStr_ = value.GetStrValue();
711 SaneOutParam outParam;
712 status = SaneManagerClient::GetInstance()->SaneControlOption(scannerId, controlParam, outParam);
713 if (status != SANE_STATUS_GOOD) {
714 SCAN_HILOGE("SaneControlOption failed, ret = [%{public}d]", status);
715 return status;
716 }
717 info = outParam.info_;
718 return status;
719 }
720
OpScanOptionValue(const std::string scannerId,const int32_t optionIndex,const ScanOptionOpType op,ScanOptionValue & value,int32_t & info)721 int32_t ScanServiceAbility::OpScanOptionValue(const std::string scannerId, const int32_t optionIndex,
722 const ScanOptionOpType op, ScanOptionValue &value, int32_t &info)
723 {
724 SCAN_HILOGD("ScanServiceAbility OpScanOptionValue start");
725 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
726 SCAN_HILOGE("no permission to access scan service");
727 return E_SCAN_NO_PERMISSION;
728 }
729 SCAN_HILOGI("optionIndex [%{public}d]", optionIndex);
730 int32_t state = E_SCAN_NONE;
731
732 if (g_hasIoFaild) {
733 SCAN_HILOGI("OpScanOptionValue try to reOpenScanner start");
734 int32_t openRet = SaneManagerClient::GetInstance()->SaneOpen(scannerId);
735 if (openRet != E_SCAN_NONE) {
736 SCAN_HILOGE("OpScanOptionValue try to reOpenScanner failed");
737 return E_SCAN_DEVICE_BUSY;
738 }
739 g_hasIoFaild = false;
740 }
741
742 std::lock_guard<std::mutex> autoLock(lock_);
743
744 SCAN_HILOGD("ScanServiceAbility OpScanOptionValue start to dump value");
745 value.Dump();
746 switch (op) {
747 case SCAN_ACTION_SET_AUTO:
748 state = ActionSetAuto(scannerId, optionIndex);
749 break;
750 case SCAN_ACTION_GET_VALUE:
751 state = ActionGetValue(scannerId, value, optionIndex);
752 break;
753 case SCAN_ACTION_SET_VALUE:
754 state = ActionSetValue(scannerId, value, optionIndex, info);
755 break;
756 default:
757 SCAN_HILOGE("ScanServiceAbility OpScanOptionValue not find ScanOptionOpType");
758 break;
759 }
760
761 if (state != E_SCAN_NONE) {
762 SCAN_HILOGE("ScanServiceAbility::OpScanOptionValue error exit");
763 }
764
765 SCAN_HILOGD("ScanServiceAbility OpScanOptionValue start to dump value");
766 value.Dump();
767 SCAN_HILOGD("ScanServiceAbility OpScanOptionValue end");
768 return state;
769 }
770
771
GetScanParameters(const std::string scannerId,ScanParameters & para)772 int32_t ScanServiceAbility::GetScanParameters(const std::string scannerId, ScanParameters ¶)
773 {
774 ManualStart();
775 std::lock_guard<std::mutex> autoLock(lock_);
776 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
777 SCAN_HILOGE("no permission to access scan service");
778 return E_SCAN_NO_PERMISSION;
779 }
780 SCAN_HILOGD("ScanServiceAbility GetScanParameters start");
781 SaneParameters saneParams;
782 SaneStatus status = SaneManagerClient::GetInstance()->SaneGetParameters(scannerId, saneParams);
783 if (status != SANE_STATUS_GOOD) {
784 SCAN_HILOGE("SaneGetParameters failed, status: [%{public}u]", status);
785 return ScanUtil::ConvertErro(status);
786 }
787 para.SetFormat(static_cast<ScanFrame>(saneParams.format_));
788 para.SetLastFrame(saneParams.lastFrame_);
789 para.SetBytesPerLine(saneParams.bytesPerLine_);
790 para.SetPixelsPerLine(saneParams.pixelsPerLine_);
791 para.SetLines(saneParams.lines_);
792 para.SetDepth(saneParams.depth_);
793 para.Dump();
794 SCAN_HILOGD("ScanServiceAbility GetScanParameters end");
795 return E_SCAN_NONE;
796 }
797
GetSingleFrameFD(const std::string scannerId,uint32_t & size,uint32_t fd)798 int32_t ScanServiceAbility::GetSingleFrameFD(const std::string scannerId, uint32_t &size, uint32_t fd)
799 {
800 ManualStart();
801 std::lock_guard<std::mutex> autoLock(lock_);
802 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
803 SCAN_HILOGE("no permission to access scan service");
804 return E_SCAN_NO_PERMISSION;
805 }
806 SCAN_HILOGD("ScanServiceAbility GetSingleFrameFD start");
807 SCAN_HILOGD("ScanServiceAbility GetSingleFrameFD end");
808 return E_SCAN_NONE;
809 }
810
CancelScan(const std::string scannerId)811 int32_t ScanServiceAbility::CancelScan(const std::string scannerId)
812 {
813 ManualStart();
814 std::lock_guard<std::mutex> autoLock(lock_);
815 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
816 SCAN_HILOGE("no permission to access scan service");
817 return E_SCAN_NO_PERMISSION;
818 }
819 SCAN_HILOGI("ScanServiceAbility CancelScan start");
820 SaneStatus saneStatus = SaneManagerClient::GetInstance()->SaneCancel(scannerId);
821 if (saneStatus != SANE_STATUS_GOOD) {
822 SCAN_HILOGE("SaneCancel failed, status: [%{public}u]", saneStatus);
823 return ScanUtil::ConvertErro(saneStatus);
824 }
825 std::queue<int32_t> emptyQueue;
826 scanQueue.swap(emptyQueue);
827 if (g_scannerState == SCANNER_SCANING) {
828 SCAN_HILOGW("ScannerState change to SCANNER_CANCELING");
829 g_scannerState = SCANNER_CANCELING;
830 }
831 SCAN_HILOGI("ScanServiceAbility CancelScan end");
832 return E_SCAN_NONE;
833 }
834
SetScanIOMode(const std::string scannerId,const bool isNonBlocking)835 int32_t ScanServiceAbility::SetScanIOMode(const std::string scannerId, const bool isNonBlocking)
836 {
837 ManualStart();
838 std::lock_guard<std::mutex> autoLock(lock_);
839 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
840 SCAN_HILOGE("no permission to access scan service");
841 return E_SCAN_NO_PERMISSION;
842 }
843 SCAN_HILOGD("ScanServiceAbility SetScanIOMode start");
844 SCAN_HILOGE("ScanServiceAbility SetScanIOMode end");
845 return E_SCAN_NONE;
846 }
847
GetScanSelectFd(const std::string scannerId,int32_t & fd)848 int32_t ScanServiceAbility::GetScanSelectFd(const std::string scannerId, int32_t &fd)
849 {
850 ManualStart();
851 std::lock_guard<std::mutex> autoLock(lock_);
852 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
853 SCAN_HILOGE("no permission to access scan service");
854 return E_SCAN_NO_PERMISSION;
855 }
856 SCAN_HILOGD("ScanServiceAbility GetScanSelectFd start");
857 return E_SCAN_NONE;
858 }
859
On(const std::string taskId,const std::string & type,const sptr<IScanCallback> & listener)860 int32_t ScanServiceAbility::On(const std::string taskId, const std::string &type, const sptr<IScanCallback> &listener)
861 {
862 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
863 SCAN_HILOGE("no permission to access scan service");
864 return E_SCAN_NO_PERMISSION;
865 }
866 int32_t userId = GetCurrentUserId();
867 int32_t callerPid = IPCSkeleton::GetCallingPid();
868 std::string eventType = NapiScanUtils::GetTaskEventId(taskId, type, userId, callerPid);
869
870 SCAN_HILOGD("ScanServiceAbility::On started. type=%{public}s", eventType.c_str());
871 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
872 constexpr int32_t MAX_LISTENERS_COUNT = 1000;
873 if (registeredListeners_.size() > MAX_LISTENERS_COUNT) {
874 SCAN_HILOGE("Exceeded the maximum number of registration.");
875 return E_SCAN_GENERIC_FAILURE;
876 }
877 auto it = registeredListeners_.find(eventType);
878 if (it == registeredListeners_.end()) {
879 const auto temp = registeredListeners_.insert(std::make_pair(eventType, listener));
880 if (!temp.second) {
881 SCAN_HILOGE("ScanServiceAbility::On insert type=%{public}s object fail.", eventType.c_str());
882 return E_SCAN_SERVER_FAILURE;
883 }
884 } else {
885 SCAN_HILOGD("ScanServiceAbility::On Replace listener.");
886 it->second = listener;
887 }
888 SCAN_HILOGD("ScanServiceAbility::On end.");
889 return E_SCAN_NONE;
890 }
891
Off(const std::string taskId,const std::string & type)892 int32_t ScanServiceAbility::Off(const std::string taskId, const std::string &type)
893 {
894 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
895 SCAN_HILOGE("no permission to access scan service");
896 return E_SCAN_NO_PERMISSION;
897 }
898 int32_t userId = GetCurrentUserId();
899 int32_t callerPid = IPCSkeleton::GetCallingPid();
900 std::string eventType = NapiScanUtils::GetTaskEventId(taskId, type, userId, callerPid);
901 SCAN_HILOGD("ScanServiceAbility::Off started. type=%{public}s", eventType.c_str());
902 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
903 auto iter = registeredListeners_.find(eventType);
904 if (iter != registeredListeners_.end()) {
905 SCAN_HILOGD("ScanServiceAbility::Off delete type=%{public}s object message.", eventType.c_str());
906 registeredListeners_.erase(iter);
907 return E_SCAN_NONE;
908 }
909 return E_SCAN_INVALID_PARAMETER;
910 }
911
SendDeviceInfoTCP(const ScanDeviceInfoTCP & info,std::string event)912 void ScanServiceAbility::SendDeviceInfoTCP(const ScanDeviceInfoTCP &info, std::string event)
913 {
914 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
915
916 if (event.empty()) {
917 SCAN_HILOGE("SendDeviceInfoTCP parm has nullptr");
918 return;
919 }
920
921 for (auto [eventType, listener] : registeredListeners_) {
922 std::string type;
923 NapiScanUtils::EncodeTaskEventId(eventType, type);
924 if (type == event && listener != nullptr) {
925 listener->OnCallback(info.GetDeviceState(), info);
926 }
927 }
928 }
929
SendDeviceInfo(const ScanDeviceInfo & info,std::string event)930 void ScanServiceAbility::SendDeviceInfo(const ScanDeviceInfo &info, std::string event)
931 {
932 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
933
934 if (event.empty()) {
935 SCAN_HILOGE("SendDeviceInfo parm has nullptr");
936 return;
937 }
938
939 for (auto [eventType, listener] : registeredListeners_) {
940 std::string type;
941 NapiScanUtils::EncodeTaskEventId(eventType, type);
942 if (type == event && listener != nullptr) {
943 listener->OnCallback(info.GetDeviceState(), info);
944 }
945 }
946 }
947
SendDeviceList(std::vector<ScanDeviceInfo> & infos,std::string event)948 void ScanServiceAbility::SendDeviceList(std::vector<ScanDeviceInfo> &infos, std::string event)
949 {
950 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
951
952 if (event.empty()) {
953 SCAN_HILOGE("SendDeviceInfo parm has nullptr");
954 return;
955 }
956
957 for (auto [eventType, listener] : registeredListeners_) {
958 std::string type;
959 NapiScanUtils::EncodeTaskEventId(eventType, type);
960 if (type == event && listener != nullptr) {
961 listener->OnGetDevicesList(infos);
962 }
963 }
964 }
965
SendDeviceInfoSync(const ScanDeviceInfoSync & info,std::string event)966 void ScanServiceAbility::SendDeviceInfoSync(const ScanDeviceInfoSync &info, std::string event)
967 {
968 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
969
970 if (event.empty()) {
971 SCAN_HILOGE("SendDeviceInfoSync parm has nullptr");
972 return;
973 }
974
975 for (auto [eventType, listener] : registeredListeners_) {
976 std::string type;
977 NapiScanUtils::EncodeTaskEventId(eventType, type);
978 if (type == event && listener != nullptr) {
979 listener->OnCallbackSync(info.GetDeviceState(), info);
980 }
981 }
982 }
983
DisConnectUsbScanner(std::string serialNumber,std::string deviceId)984 void ScanServiceAbility::DisConnectUsbScanner(std::string serialNumber, std::string deviceId)
985 {
986 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
987 SCAN_HILOGE("no permission to access scan service");
988 return;
989 }
990 SCAN_HILOGD("DisConnectUsbScanner start deviceId:%{public}s", deviceId.c_str());
991 ScanDeviceInfoSync scanDeviceInfoSync;
992 scanDeviceInfoSync.serialNumber = serialNumber;
993 scanDeviceInfoSync.deviceId = deviceId;
994 scanDeviceInfoSync.discoverMode = "USB";
995 scanDeviceInfoSync.syncMode = "delete";
996 scanDeviceInfoSync.deviceState = 0;
997 SendDeviceInfoSync(scanDeviceInfoSync, SCAN_DEVICE_SYNC);
998 #ifdef DEBUG_ENABLE
999 SCAN_HILOGD("GetScannerList delete end serialNumber:%{private}s newDeviceId:%{public}s",
1000 serialNumber.c_str(), deviceId.c_str());
1001 #endif
1002 }
1003
UpdateScannerId(const ScanDeviceInfoSync & syncInfo)1004 void ScanServiceAbility::UpdateScannerId(const ScanDeviceInfoSync& syncInfo)
1005 {
1006 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1007 SCAN_HILOGE("no permission to access scan service");
1008 return;
1009 }
1010 SCAN_HILOGD("UpdateScannerId start newDeviceId:[%{private}s]", syncInfo.deviceId.c_str());
1011 ScanDeviceInfoSync scanDeviceInfoSync = syncInfo;
1012 std::lock_guard<std::mutex> autoLock(clearMapLock_);
1013 if (scanDeviceInfoSync.discoverMode == "USB") {
1014 auto it = saneGetUsbDeviceInfoMap.find(scanDeviceInfoSync.serialNumber);
1015 if (it != saneGetUsbDeviceInfoMap.end()) {
1016 it->second.deviceId = syncInfo.deviceId;
1017 }
1018 SendDeviceInfoSync(scanDeviceInfoSync, SCAN_DEVICE_SYNC);
1019 } else if (scanDeviceInfoSync.discoverMode == "TCP") {
1020 std::string oldIp;
1021 ScanUtil::ExtractIpAddresses(scanDeviceInfoSync.oldDeviceId, oldIp);
1022 auto it = saneGetTcpDeviceInfoMap.find(oldIp);
1023 if (it != saneGetTcpDeviceInfoMap.end()) {
1024 auto info = it->second;
1025 saneGetTcpDeviceInfoMap.erase(it);
1026 info.deviceId = scanDeviceInfoSync.deviceId;
1027 saneGetTcpDeviceInfoMap.insert(std::make_pair(scanDeviceInfoSync.uniqueId, info));
1028 }
1029 SendDeviceInfoSync(scanDeviceInfoSync, SCAN_DEVICE_SYNC);
1030 } else {
1031 SCAN_HILOGE("invalid discover mode %{public}s", scanDeviceInfoSync.discoverMode.c_str());
1032 }
1033 #ifdef DEBUG_ENABLE
1034 SCAN_HILOGD("GetScannerList UpdateUsbScannerId serialNumber:%{private}s newDeviceId:%{private}s",
1035 serialNumber.c_str(), newDeviceId.c_str());
1036 #endif
1037 }
1038
SendInitEvent(int32_t & scanVersion,std::string event)1039 void ScanServiceAbility::SendInitEvent(int32_t &scanVersion, std::string event)
1040 {
1041 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
1042
1043 if (event.empty()) {
1044 SCAN_HILOGE("SendInitEvent parm has nullptr");
1045 return;
1046 }
1047
1048 auto eventIt = registeredListeners_.find(event);
1049 if (eventIt == registeredListeners_.end() || eventIt->second == nullptr) {
1050 SCAN_HILOGE("InitScan SendInitEvent event not register");
1051 return;
1052 }
1053 eventIt->second->OnScanInitCallback(scanVersion);
1054 }
1055
SendDeviceSearchEnd(std::string & message,std::string event)1056 void ScanServiceAbility::SendDeviceSearchEnd(std::string &message, std::string event)
1057 {
1058 std::lock_guard<std::recursive_mutex> lock(apiMutex_);
1059
1060 if (message.empty() || event.empty()) {
1061 SCAN_HILOGE("SendDeviceSearchEnd parm has nullptr");
1062 return;
1063 }
1064
1065 auto eventIt = registeredListeners_.find(event);
1066 if (eventIt == registeredListeners_.end() || eventIt->second == nullptr) {
1067 SCAN_HILOGE("SCAN_DEVICE_FOUND event not register");
1068 return;
1069 }
1070 eventIt->second->OnSendSearchMessage(message);
1071 }
1072
CheckPermission(const std::string & permissionName)1073 bool ScanServiceAbility::CheckPermission(const std::string &permissionName)
1074 {
1075 AccessTokenID tokenId = IPCSkeleton::GetCallingTokenID();
1076 TypeATokenTypeEnum tokenType = AccessTokenKit::GetTokenTypeFlag(tokenId);
1077 if (tokenType == TOKEN_INVALID) {
1078 SCAN_HILOGE("invalid token id");
1079 return false;
1080 }
1081 int result = AccessTokenKit::VerifyAccessToken(tokenId, permissionName);
1082 if (result != PERMISSION_GRANTED) {
1083 if (permissionName == PERMISSION_NAME_PRINT) {
1084 result = AccessTokenKit::VerifyAccessToken(tokenId, PERMISSION_NAME_PRINT);
1085 }
1086 SCAN_HILOGE("Current tokenId permission is %{public}d", result);
1087 }
1088 return result == PERMISSION_GRANTED;
1089 }
1090
GetScannerState(int32_t & scannerState)1091 int32_t ScanServiceAbility::GetScannerState(int32_t &scannerState)
1092 {
1093 ManualStart();
1094 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1095 SCAN_HILOGE("no permission to access scan service");
1096 return E_SCAN_NO_PERMISSION;
1097 }
1098 SCAN_HILOGD("ScanServiceAbility GetScannerState start");
1099 scannerState = g_scannerState;
1100 SCAN_HILOGD("ScanServiceAbility GetScannerState end, scannerState = [%{public}d]", scannerState);
1101 return E_SCAN_NONE;
1102 }
1103
GetScanProgress(const std::string scannerId,ScanProgress & prog)1104 int32_t ScanServiceAbility::GetScanProgress(const std::string scannerId, ScanProgress &prog)
1105 {
1106 ManualStart();
1107 std::lock_guard<std::mutex> autoLock(lock_);
1108 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1109 SCAN_HILOGE("no permission to access scan service");
1110 return E_SCAN_NO_PERMISSION;
1111 }
1112
1113 if (scanQueue.empty()) {
1114 SCAN_HILOGE("Not exist scan progress");
1115 if (g_hasIoFaild) {
1116 return E_SCAN_INVALID_PARAMETER;
1117 }
1118 return E_SCAN_GENERIC_FAILURE;
1119 }
1120 int32_t frontPicId = scanQueue.front();
1121 SCAN_HILOGD("frontPicId : [%{public}d]", frontPicId);
1122 auto frontProg = scanTaskMap[frontPicId];
1123 auto taskCode = frontProg.GetTaskCode();
1124 if (taskCode != E_SCAN_GOOD) {
1125 SCAN_HILOGE("scanprogress exception occurred:[%{public}u]", taskCode);
1126 scanQueue.pop();
1127 return taskCode;
1128 }
1129 auto scanProgress = frontProg.GetScanProgress();
1130 if (scanProgress == SCAN_PROGRESS_100) {
1131 SCAN_HILOGI("get scan picture successfully!");
1132 prog = frontProg;
1133 int32_t fd = open(prog.GetImageRealPath().c_str(), O_RDONLY);
1134 fdsan_exchange_owner_tag(fd, 0, SCAN_LOG_DOMAIN);
1135 prog.SetScanPictureFd(fd);
1136 imageFdMap_[prog.GetImageRealPath()] = fd;
1137 prog.Dump();
1138 scanQueue.pop();
1139 return E_SCAN_NONE;
1140 }
1141 int32_t randomNumber = GetRandomNumber(SCAN_PROGRESS_10, SCAN_PROGRESS_19);
1142 auto preTime = scanTaskMap[frontPicId].GetScanTime();
1143 if (GetElapsedSeconds(preTime) >= 1 && scanProgress < SCAN_PROGRESS_80) {
1144 scanTaskMap[frontPicId].SetScanProgress(scanProgress + randomNumber);
1145 scanTaskMap[frontPicId].SetScanTime(std::chrono::steady_clock::now());
1146 }
1147 prog = scanTaskMap[frontPicId];
1148 prog.Dump();
1149 return E_SCAN_NONE;
1150 }
1151
AddScanner(const std::string & serialNumber,const std::string & discoverMode)1152 int32_t ScanServiceAbility::AddScanner(const std::string& serialNumber, const std::string& discoverMode)
1153 {
1154 ManualStart();
1155 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1156 SCAN_HILOGE("no permission to access scan service");
1157 return E_SCAN_NO_PERMISSION;
1158 }
1159 if (discoverMode != "USB" && discoverMode != "TCP") {
1160 SCAN_HILOGE("discoverMode is a invalid parameter.");
1161 return E_SCAN_INVALID_PARAMETER;
1162 }
1163 auto addScannerExe = [=]() {
1164 std::string uniqueId = discoverMode + serialNumber;
1165 ScanSystemData &scanData = ScanSystemData::GetInstance();
1166 std::lock_guard<std::mutex> autoLock(clearMapLock_);
1167 if (discoverMode == "USB") {
1168 auto usbIt = saneGetUsbDeviceInfoMap.find(serialNumber);
1169 if (usbIt == saneGetUsbDeviceInfoMap.end() || scanData.IsContainScanner(uniqueId)) {
1170 SCAN_HILOGE("Failed to add usb scanner.");
1171 return;
1172 }
1173 scanData.InsertScannerInfo(uniqueId, usbIt->second);
1174 if (!scanData.SaveScannerMap()) {
1175 SCAN_HILOGE("ScanServiceAbility AddScanner SaveScannerMap fail");
1176 return;
1177 }
1178 SendDeviceInfo(usbIt->second, SCAN_DEVICE_ADD);
1179 } else if (discoverMode == "TCP") {
1180 auto tcpIt = saneGetTcpDeviceInfoMap.find(serialNumber);
1181 if (tcpIt == saneGetTcpDeviceInfoMap.end() || scanData.IsContainScanner(uniqueId)) {
1182 SCAN_HILOGE("Failed to add tcp scanner.");
1183 return;
1184 }
1185 scanData.InsertScannerInfo(uniqueId, tcpIt->second);
1186 if (!scanData.SaveScannerMap()) {
1187 SCAN_HILOGE("ScanServiceAbility AddScanner SaveScannerMap fail");
1188 return;
1189 }
1190 SendDeviceInfo(tcpIt->second, SCAN_DEVICE_ADD);
1191 } else {
1192 SCAN_HILOGE("discoverMode is invalid.");
1193 }
1194 };
1195 serviceHandler_->PostTask(addScannerExe, ASYNC_CMD_DELAY);
1196 return E_SCAN_NONE;
1197 }
1198
DeleteScanner(const std::string & serialNumber,const std::string & discoverMode)1199 int32_t ScanServiceAbility::DeleteScanner(const std::string& serialNumber, const std::string& discoverMode)
1200 {
1201 ManualStart();
1202 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1203 SCAN_HILOGE("no permission to access scan service");
1204 return E_SCAN_NO_PERMISSION;
1205 }
1206 SCAN_HILOGI("ScanServiceAbility DeleteScanner start");
1207
1208 std::string uniqueId = discoverMode + serialNumber;
1209 ScanDeviceInfo scannerInfo;
1210 if (!ScanSystemData::GetInstance().QueryScannerInfoByUniqueId(uniqueId, scannerInfo)) {
1211 SCAN_HILOGE("ScanServiceAbility DeleteScanner QueryScannerInfoByUniqueId fail");
1212 return E_SCAN_INVALID_PARAMETER;
1213 }
1214 if (!ScanSystemData::GetInstance().DeleteScannerInfo(uniqueId)) {
1215 SCAN_HILOGE("ScanServiceAbility DeleteScanner DeleteScannerInfo fail");
1216 return E_SCAN_INVALID_PARAMETER;
1217 }
1218 if (!ScanSystemData::GetInstance().SaveScannerMap()) {
1219 SCAN_HILOGE("ScanServiceAbility DeleteScanner SaveScannerMap fail");
1220 return E_SCAN_GENERIC_FAILURE;
1221 }
1222 SendDeviceInfo(scannerInfo, SCAN_DEVICE_DEL);
1223 SCAN_HILOGI("ScanServiceAbility DeleteScanner end");
1224 return E_SCAN_NONE;
1225 }
1226
GetAddedScanner(std::vector<ScanDeviceInfo> & allAddedScanner)1227 int32_t ScanServiceAbility::GetAddedScanner(std::vector<ScanDeviceInfo>& allAddedScanner)
1228 {
1229 ManualStart();
1230 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1231 SCAN_HILOGE("no permission to access scan service");
1232 return E_SCAN_NO_PERMISSION;
1233 }
1234 SCAN_HILOGI("ScanServiceAbility GetAddedScanner start");
1235 ScanSystemData::GetInstance().GetAddedScannerInfoList(allAddedScanner);
1236 SCAN_HILOGI("ScanServiceAbility GetAddedScanner end");
1237 return E_SCAN_NONE;
1238 }
1239
UpdateScannerName(const std::string & serialNumber,const std::string & discoverMode,const std::string & deviceName)1240 int32_t ScanServiceAbility::UpdateScannerName(const std::string& serialNumber,
1241 const std::string& discoverMode, const std::string& deviceName)
1242 {
1243 ManualStart();
1244 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1245 SCAN_HILOGE("no permission to access scan service");
1246 return E_SCAN_NO_PERMISSION;
1247 }
1248 SCAN_HILOGI("ScanServiceAbility UpdateScannerName start");
1249
1250 std::string uniqueId = discoverMode + serialNumber;
1251 if (!ScanSystemData::GetInstance().UpdateScannerNameByUniqueId(uniqueId, deviceName)) {
1252 SCAN_HILOGW("ScanServiceAbility UpdateScannerNameByUniqueId fail");
1253 return E_SCAN_INVALID_PARAMETER;
1254 }
1255 if (!ScanSystemData::GetInstance().SaveScannerMap()) {
1256 SCAN_HILOGE("ScanServiceAbility UpdateScannerName SaveScannerMap fail");
1257 return E_SCAN_GENERIC_FAILURE;
1258 }
1259 SCAN_HILOGI("ScanServiceAbility UpdateScannerName end");
1260 return E_SCAN_NONE;
1261 }
1262
OnStartScan(const std::string scannerId,const bool & batchMode)1263 int32_t ScanServiceAbility::OnStartScan(const std::string scannerId, const bool &batchMode)
1264 {
1265 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1266 SCAN_HILOGE("no permission to access scan service");
1267 return E_SCAN_NO_PERMISSION;
1268 }
1269 std::string userCachedImageDir = ObtainUserCacheDirectory(GetCurrentUserId());
1270 if (!std::filesystem::exists(userCachedImageDir)) {
1271 SCAN_HILOGE("The user directory %{public}s does not exist.", userCachedImageDir.c_str());
1272 return E_SCAN_GENERIC_FAILURE;
1273 }
1274 std::queue<int32_t> emptyQueue;
1275 scanQueue.swap(emptyQueue);
1276 int32_t status = StartScan(scannerId, batchMode_);
1277 if (status != E_SCAN_NONE) {
1278 SCAN_HILOGE("Start Scan error");
1279 return status;
1280 }
1281 currentUseScannerUserId_ = GetCurrentUserId();
1282 batchMode_ = batchMode;
1283 g_scannerState = SCANNER_SCANING;
1284 auto exe = [=]() {
1285 StartScanTask(scannerId);
1286 };
1287 serviceHandler_->PostTask(exe, ASYNC_CMD_DELAY);
1288 SCAN_HILOGI("StartScan successfully");
1289 return E_SCAN_NONE;
1290 }
1291
StartScan(const std::string scannerId,const bool & batchMode)1292 int32_t ScanServiceAbility::StartScan(const std::string scannerId, const bool &batchMode)
1293 {
1294 ManualStart();
1295 std::lock_guard<std::mutex> autoLock(lock_);
1296 if (!CheckPermission(PERMISSION_NAME_PRINT)) {
1297 SCAN_HILOGE("no permission to access scan service");
1298 return E_SCAN_NO_PERMISSION;
1299 }
1300 SCAN_HILOGI("ScanServiceAbility StartScan start");
1301
1302 if (g_scannerState == SCANNER_CANCELING) {
1303 SCAN_HILOGE("scan task is canceling");
1304 return E_SCAN_DEVICE_BUSY;
1305 }
1306 SaneStatus saneStatus = SaneManagerClient::GetInstance()->SaneStart(scannerId);
1307 if (saneStatus != SANE_STATUS_GOOD) {
1308 SCAN_HILOGE("SaneStart failed, status is %{public}u", saneStatus);
1309 SaneManagerClient::GetInstance()->SaneCancel(scannerId);
1310 auto it = scanTaskMap.find(nextPicId);
1311 if (it != scanTaskMap.end() && it != scanTaskMap.begin()) {
1312 it--;
1313 (it->second).SetScanProgress(SCAN_PROGRESS_100);
1314 }
1315 return ScanUtil::ConvertErro(saneStatus);
1316 }
1317 ScanProgress prog;
1318 scanTaskMap[nextPicId] = prog;
1319 scanQueue.push(nextPicId);
1320 scanTaskMap[nextPicId].SetPictureId(nextPicId);
1321 auto nowTime = std::chrono::steady_clock::now();
1322 scanTaskMap[nextPicId].SetScanTime(nowTime);
1323 nextPicId++;
1324 SCAN_HILOGI("ScanServiceAbility StartScan end");
1325 return E_SCAN_NONE;
1326 }
1327
StartScanTask(const std::string scannerId)1328 void ScanServiceAbility::StartScanTask(const std::string scannerId)
1329 {
1330 SCAN_HILOGI("ScanServiceAbility StartScanTask start, batchMode_ = [%{public}d]", batchMode_);
1331 if (batchMode_) {
1332 SCAN_HILOGI("start batch mode scan");
1333 GeneratePictureBatch(scannerId);
1334 } else {
1335 SCAN_HILOGI("start single mode scan");
1336 GeneratePictureSingle(scannerId);
1337 }
1338 {
1339 std::lock_guard<std::mutex> autoLock(lock_);
1340 SCAN_HILOGI("StartScanTask finished, doning sane_cancel");
1341 SaneManagerClient::GetInstance()->SaneCancel(scannerId);
1342 }
1343 g_scannerState = SCANNER_READY;
1344 SCAN_HILOGI("ScanServiceAbility StartScanTask end");
1345 }
1346
CreateAndOpenScanFile(std::string & outputFile)1347 bool ScanServiceAbility::CreateAndOpenScanFile(std::string &outputFile)
1348 {
1349 std::string outputDir = ObtainUserCacheDirectory(currentUseScannerUserId_);
1350 char canonicalPath[PATH_MAX] = { 0 };
1351 if (realpath(outputDir.c_str(), canonicalPath) == nullptr) {
1352 SCAN_HILOGE("The real output dir is null, errno:%{public}s", std::to_string(errno).c_str());
1353 return false;
1354 }
1355 outputDir = canonicalPath;
1356 std::ostringstream outputFileStream;
1357 int32_t nowScanId = nextPicId - 1;
1358 outputFileStream << outputDir << "/" << "scan_tmp" << std::to_string(nowScanId) << ".jpg";
1359 outputFile = outputFileStream.str();
1360 if ((ofp = fopen(outputFile.c_str(), "w")) == nullptr) {
1361 SCAN_HILOGE("file [%{private}s] open fail", outputFile.c_str());
1362 return false;
1363 }
1364 std::lock_guard<std::mutex> autoLock(lock_);
1365 auto it = scanTaskMap.find(nowScanId);
1366 if (it == scanTaskMap.end()) {
1367 SCAN_HILOGE("cannot find nowScanId %{private}d", nowScanId);
1368 return false;
1369 }
1370 it->second.SetImageRealPath(outputFile);
1371 return true;
1372 }
1373
GeneratePictureBatch(const std::string & scannerId)1374 void ScanServiceAbility::GeneratePictureBatch(const std::string &scannerId)
1375 {
1376 bool firstScan = true;
1377 std::string outputFile;
1378 int32_t status = E_SCAN_NONE;
1379 do {
1380 if (!firstScan) {
1381 SCAN_HILOGI("not first scan");
1382 status = RestartScan(scannerId);
1383 if (status != E_SCAN_NONE) {
1384 SCAN_HILOGW("RestartScan fail");
1385 break;
1386 }
1387 }
1388 if (!CreateAndOpenScanFile(outputFile)) {
1389 status = E_SCAN_GENERIC_FAILURE;
1390 SCAN_HILOGE("CreateAndOpenScanFile fail");
1391 break;
1392 }
1393 status = DoScanTask(scannerId);
1394 firstScan = false;
1395 } while (status == E_SCAN_EOF);
1396 if (status == E_SCAN_NO_DOCS) {
1397 SCAN_HILOGI("GeneratePictureSingle exit successfully");
1398 } else {
1399 SCAN_HILOGE("GeneratePictureSingle fail, status = %{public}d", status);
1400 }
1401 }
1402
GeneratePictureSingle(const std::string & scannerId)1403 void ScanServiceAbility::GeneratePictureSingle(const std::string &scannerId)
1404 {
1405 int32_t status = E_SCAN_NONE;
1406 std::string outputFile;
1407 if (!CreateAndOpenScanFile(outputFile)) {
1408 status = E_SCAN_GENERIC_FAILURE;
1409 SCAN_HILOGE("CreateAndOpenScanFile fail");
1410 return;
1411 }
1412 status = DoScanTask(scannerId);
1413 if (status == E_SCAN_EOF) {
1414 SCAN_HILOGI("GeneratePictureSingle exit successfully");
1415 } else {
1416 SCAN_HILOGE("GeneratePictureSingle fail, status = %{public}d", status);
1417 }
1418 }
1419
DoScanTask(const std::string & scannerId)1420 int32_t ScanServiceAbility::DoScanTask(const std::string &scannerId)
1421 {
1422 bool isFirstFrame = true;
1423 int32_t scanStatus = E_SCAN_NONE;
1424 ScanParameters parm;
1425 struct jpeg_error_mgr jerr;
1426 do {
1427 SCAN_HILOGI("start DoScanTask");
1428 if (!isFirstFrame) {
1429 scanStatus = StartScan(scannerId, batchMode_);
1430 if (scanStatus != E_SCAN_NONE) {
1431 SCAN_HILOGW("restart scanner fail");
1432 break;
1433 }
1434 }
1435 scanStatus = GetScanParameters(scannerId, parm);
1436 if (scanStatus != E_SCAN_NONE) {
1437 SCAN_HILOGE("DoScanTask error, after GetScanParameters");
1438 break;
1439 }
1440 if (isFirstFrame) {
1441 scanStatus = WriteJpegHeader(parm, &jerr);
1442 if (scanStatus != E_SCAN_NONE) {
1443 SCAN_HILOGE("StartScanTask error exit after WriteJpegHeader");
1444 break;
1445 }
1446 jpegbuf = new (std::nothrow) JSAMPLE[parm.GetBytesPerLine() / sizeof(JSAMPLE)]{};
1447 if (jpegbuf == nullptr) {
1448 SCAN_HILOGE("jpegbuf malloc fail");
1449 break;
1450 }
1451 }
1452 GetPicFrame(scannerId, scanStatus, parm);
1453 if (scanStatus != E_SCAN_EOF) {
1454 SCAN_HILOGE("get scanframe fail");
1455 break;
1456 }
1457 isFirstFrame = false;
1458 } while (!(parm.GetLastFrame()));
1459 CleanUpAfterScan(scanStatus);
1460 return scanStatus;
1461 }
1462
RestartScan(const std::string & scannerId)1463 int32_t ScanServiceAbility::RestartScan(const std::string &scannerId)
1464 {
1465 SCAN_HILOGI("not first scan");
1466 int32_t status = StartScan(scannerId, batchMode_);
1467 if (status == E_SCAN_NONE) {
1468 SCAN_HILOGI("ScanTask restart success");
1469 std::lock_guard<std::mutex> autoLock(lock_);
1470 auto it = scanTaskMap.find(nextPicId - 2);
1471 if (it != scanTaskMap.end()) {
1472 it->second.SetIsFinal(false);
1473 }
1474 } else if (status == E_SCAN_NO_DOCS) {
1475 SCAN_HILOGI("The feeder is out of paper.");
1476 } else {
1477 std::lock_guard<std::mutex> autoLock(lock_);
1478 SCAN_HILOGE("RestartScan fail");
1479 scanQueue.push(nextPicId);
1480 ScanProgress prog;
1481 auto result = scanTaskMap.insert({nextPicId, prog});
1482 if (result.second) {
1483 auto it = result.first;
1484 it->second.SetPictureId(nextPicId);
1485 auto nowTime = std::chrono::steady_clock::now();
1486 it->second.SetScanTime(nowTime);
1487 }
1488 nextPicId++;
1489 }
1490 return status;
1491 }
1492
CleanUpAfterScan(int32_t scanStatus)1493 void ScanServiceAbility::CleanUpAfterScan(int32_t scanStatus)
1494 {
1495 int32_t nowScanId = nextPicId - 1;
1496 if (scanStatus != E_SCAN_EOF && scanStatus != E_SCAN_NO_DOCS) {
1497 std::lock_guard<std::mutex> autoLock(lock_);
1498 auto it = scanTaskMap.find(nowScanId);
1499 if (it != scanTaskMap.end()) {
1500 it->second.SetTaskCode(static_cast<ScanErrorCode>(scanStatus));
1501 }
1502 jpeg_destroy_compress(cinfoPtr);
1503 SCAN_HILOGE("DoScanTask fail, SetTaskCode : %{public}d", scanStatus);
1504 } else {
1505 std::lock_guard<std::mutex> autoLock(lock_);
1506 auto it = scanTaskMap.find(nowScanId);
1507 if (it != scanTaskMap.end()) {
1508 it->second.SetScanProgress(SCAN_PROGRESS_100);
1509 }
1510 jpeg_finish_compress(cinfoPtr);
1511 fflush(ofp);
1512 SCAN_HILOGD("End of normal scan");
1513 }
1514 DELETE_ARRAY_AND_NULLIFY(jpegbuf)
1515 if (ofp != nullptr) {
1516 fclose(ofp);
1517 ofp = nullptr;
1518 }
1519 }
1520
WriteJpegHeader(ScanParameters & parm,struct jpeg_error_mgr * jerr)1521 int32_t ScanServiceAbility::WriteJpegHeader(ScanParameters &parm, struct jpeg_error_mgr* jerr)
1522 {
1523 ScanFrame format = parm.GetFormat();
1524 int32_t width = parm.GetPixelsPerLine();
1525 int32_t height = parm.GetLines();
1526 cinfoPtr->err = jpeg_std_error(jerr);
1527 cinfoPtr->err->error_exit = [](j_common_ptr cinfo) {
1528 g_isJpegWriteSuccess = false;
1529 };
1530 g_isJpegWriteSuccess = true;
1531 jpeg_create_compress(cinfoPtr);
1532 jpeg_stdio_dest(cinfoPtr, ofp);
1533
1534 cinfoPtr->image_width = (JDIMENSION)width;
1535 cinfoPtr->image_height = (JDIMENSION)height;
1536 if (format == SCAN_FRAME_RGB) {
1537 cinfoPtr->in_color_space = JCS_RGB;
1538 cinfoPtr->input_components = CHANNEL_THREE;
1539 SCAN_HILOGI("generate RGB picture");
1540 } else if (format == SCAN_FRAME_GRAY) {
1541 cinfoPtr->in_color_space = JCS_GRAYSCALE;
1542 cinfoPtr->input_components = CHANNEL_ONE;
1543 SCAN_HILOGI("generate gray picture");
1544 } else {
1545 SCAN_HILOGE("not support this color");
1546 return E_SCAN_INVALID_PARAMETER;
1547 }
1548 jpeg_set_defaults(cinfoPtr);
1549 cinfoPtr->density_unit = 1;
1550 cinfoPtr->X_density = dpi;
1551 cinfoPtr->Y_density = dpi;
1552 cinfoPtr->write_JFIF_header = TRUE;
1553 SCAN_HILOGI("width:[%{public}d],height:[%{public}d],dpi:[%{public}d]", width, height, dpi);
1554 jpeg_set_quality(cinfoPtr, JPEG_QUALITY_SEVENTY_FIVE, TRUE);
1555 jpeg_start_compress(cinfoPtr, TRUE);
1556 SCAN_HILOGI("finish write jpegHeader");
1557 return E_SCAN_NONE;
1558 }
1559
CleanScanTask(const std::string & scannerId)1560 void ScanServiceAbility::CleanScanTask(const std::string &scannerId)
1561 {
1562 CancelScan(scannerId);
1563 scanTaskMap.clear();
1564 g_hasIoFaild = true;
1565 }
1566
SetScanProgr(int64_t & totalBytes,const int64_t & hundredPercent,const int32_t & curReadSize)1567 void ScanServiceAbility::SetScanProgr(int64_t &totalBytes, const int64_t& hundredPercent, const int32_t& curReadSize)
1568 {
1569 if (hundredPercent == 0) {
1570 SCAN_HILOGE("hundredPercent equals zero.");
1571 return;
1572 }
1573 std::lock_guard<std::mutex> autoLock(lock_);
1574 int32_t nowScanId = nextPicId - 1;
1575 auto it = scanTaskMap.find(nowScanId);
1576 if (it == scanTaskMap.end()) {
1577 SCAN_HILOGW("cannot find %{public}d", nowScanId);
1578 return;
1579 }
1580 totalBytes += static_cast<int64_t>(curReadSize);
1581 int64_t progr = ((totalBytes * SCAN_PROGRESS_100) / hundredPercent);
1582 if (progr >= SCAN_PROGRESS_100) {
1583 progr = SCAN_PROGRESS_100 - 1;
1584 }
1585 if (progr > (it->second.GetScanProgress())) {
1586 it->second.SetScanProgress(static_cast<int32_t>(progr));
1587 }
1588 }
1589
GetPicFrame(const std::string scannerId,int32_t & scanStatus,ScanParameters & parm)1590 void ScanServiceAbility::GetPicFrame(const std::string scannerId,
1591 int32_t &scanStatus, ScanParameters &parm)
1592 {
1593 int64_t totalBytes = 0;
1594 int jpegrow = 0;
1595 int64_t hundredPercent = ((int64_t)parm.GetBytesPerLine()) * parm.GetLines() * (((SaneFrame)parm.GetFormat()
1596 == SANE_FRAME_RGB || (SaneFrame)parm.GetFormat() == SANE_FRAME_GRAY) ? CHANNEL_ONE : CHANNEL_THREE);
1597 scanStatus = E_SCAN_GOOD;
1598 while (scanStatus == E_SCAN_GOOD) {
1599 SanePictureData pictureData;
1600 SaneStatus saneStatus = SaneManagerClient::GetInstance()->
1601 SaneRead(scannerId, buffer_size, pictureData);
1602 scanStatus = ScanUtil::ConvertErro(saneStatus);
1603 if (pictureData.ret_ == SANE_READ_FAIL) {
1604 SCAN_HILOGE("sane_read failed, scanStatus: [%{public}d]", scanStatus);
1605 break;
1606 }
1607 auto ret = memcpy_s(saneReadBuf, buffer_size, pictureData.dataBuffer_.data(), pictureData.dataBuffer_.size());
1608 if (ret != ERR_OK) {
1609 scanStatus = E_SCAN_GENERIC_FAILURE;
1610 SCAN_HILOGE("memcpy_s failed, errorCode:[%{public}d]", ret);
1611 break;
1612 }
1613 SetScanProgr(totalBytes, hundredPercent, pictureData.dataBuffer_.size());
1614 if (!WritePicData(jpegrow, pictureData.dataBuffer_.size(), parm, scanStatus)) {
1615 SCAN_HILOGE("WritePicData fail");
1616 break;
1617 }
1618 if (scanStatus == SANE_STATUS_EOF) {
1619 SCAN_HILOGI("sane_read finished.");
1620 break;
1621 }
1622 }
1623 }
1624
WritePicData(int & jpegrow,int32_t curReadSize,ScanParameters & parm,int32_t & scanStatus)1625 bool ScanServiceAbility::WritePicData(int &jpegrow, int32_t curReadSize,
1626 ScanParameters &parm, int32_t &scanStatus)
1627 {
1628 constexpr int bit = 1;
1629 int i = 0;
1630 int left = curReadSize;
1631 while (jpegrow + left >= parm.GetBytesPerLine()) {
1632 if (!g_isJpegWriteSuccess) {
1633 scanStatus = E_SCAN_NO_MEM;
1634 return false;
1635 }
1636 int ret = memcpy_s(jpegbuf + jpegrow, parm.GetBytesPerLine(),
1637 saneReadBuf + i, parm.GetBytesPerLine() - jpegrow);
1638 if (ret != ERR_OK) {
1639 scanStatus = E_SCAN_GENERIC_FAILURE;
1640 SCAN_HILOGE("memcpy_s failed");
1641 return false;
1642 }
1643 if (parm.GetDepth() != 1) {
1644 jpeg_write_scanlines(cinfoPtr, &jpegbuf, bit);
1645 i += parm.GetBytesPerLine() - jpegrow;
1646 left -= parm.GetBytesPerLine() - jpegrow;
1647 jpegrow = 0;
1648 continue;
1649 }
1650 constexpr int byteBits = 8;
1651 JSAMPLE *buf8 = (JSAMPLE *)malloc(parm.GetBytesPerLine() * byteBits);
1652 if (buf8 == nullptr) {
1653 scanStatus = E_SCAN_GENERIC_FAILURE;
1654 SCAN_HILOGE("pic buffer malloc fail");
1655 return false;
1656 }
1657 for (int col1 = 0; col1 < parm.GetBytesPerLine(); col1++) {
1658 for (int col8 = 0; col8 < byteBits; col8++) {
1659 buf8[col1 * byteBits + col8] = jpegbuf[col1] & (1 << (byteBits - col8 - bit)) ? 0 : 0xff;
1660 }
1661 }
1662 jpeg_write_scanlines(cinfoPtr, &buf8, bit);
1663 free(buf8);
1664 i += parm.GetBytesPerLine() - jpegrow;
1665 left -= parm.GetBytesPerLine() - jpegrow;
1666 jpegrow = 0;
1667 }
1668 if (memcpy_s(jpegbuf + jpegrow, parm.GetBytesPerLine(), saneReadBuf + i, left) != ERR_OK) {
1669 scanStatus = E_SCAN_GENERIC_FAILURE;
1670 SCAN_HILOGE("memcpy_s failed");
1671 return false;
1672 }
1673 jpegrow += left;
1674 return true;
1675 }
1676
GetCurrentUserId()1677 int32_t ScanServiceAbility::GetCurrentUserId()
1678 {
1679 constexpr int32_t UID_TRANSFORM_DIVISOR = 200000;
1680 int32_t userId = IPCSkeleton::GetCallingUid() / UID_TRANSFORM_DIVISOR;
1681 if (userId < START_USER_ID || userId > MAX_USER_ID) {
1682 SCAN_HILOGE("userId %{public}d is out of range.", userId);
1683 return INVALID_USER_ID;
1684 }
1685 SCAN_HILOGD("Current userId = %{public}d.", userId);
1686 return userId;
1687 }
1688
ObtainUserCacheDirectory(const int32_t & userId)1689 std::string ScanServiceAbility::ObtainUserCacheDirectory(const int32_t& userId)
1690 {
1691 if (userId < START_USER_ID || userId > MAX_USER_ID) {
1692 SCAN_HILOGE("Invalid userId %{public}d.", userId);
1693 return "";
1694 }
1695 std::ostringstream oss;
1696 oss << "/data/service/el2/" << userId << "/print_service";
1697 return oss.str();
1698 }
1699
1700 } // namespace OHOS::Scan