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
16 #include "scan_manager_client.h"
17
18 #include "iservice_registry.h"
19 #include "system_ability_definition.h"
20
21 namespace OHOS::Scan {
22 std::mutex ScanManagerClient::instanceLock_;
23 sptr<ScanManagerClient> ScanManagerClient::instance_ = nullptr;
24
ScanManagerClient()25 ScanManagerClient::ScanManagerClient() : scanServiceProxy_(nullptr), deathRecipient_(nullptr)
26 {}
27
~ScanManagerClient()28 ScanManagerClient::~ScanManagerClient()
29 {}
30
GetInstance()31 sptr<ScanManagerClient> ScanManagerClient::GetInstance()
32 {
33 if (instance_ == nullptr) {
34 std::lock_guard<std::mutex> autoLock(instanceLock_);
35 if (instance_ == nullptr) {
36 instance_ = new ScanManagerClient;
37 }
38 }
39 return instance_;
40 }
GetScanServiceProxy()41 sptr<IScanService> ScanManagerClient::GetScanServiceProxy()
42 {
43 sptr<ISystemAbilityManager> systemAbilityManager =
44 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
45 if (systemAbilityManager == nullptr) {
46 SCAN_HILOGE("Getting SystemAbilityManager failed.");
47 return nullptr;
48 }
49 if (scanServiceProxy_ != nullptr) {
50 SCAN_HILOGD("scanServiceProxy_ already get");
51 return scanServiceProxy_;
52 }
53 auto systemAbility = systemAbilityManager->GetSystemAbility(SCAN_SERVICE_ID, "");
54 if (systemAbility == nullptr) {
55 SCAN_HILOGE("Get SystemAbility failed.");
56 return nullptr;
57 }
58 if (deathRecipient_ == nullptr) {
59 deathRecipient_ = new ScanSaDeathRecipient();
60 }
61 systemAbility->AddDeathRecipient(deathRecipient_);
62 sptr<IScanService> serviceProxy = iface_cast<IScanService>(systemAbility);
63 if (serviceProxy == nullptr) {
64 SCAN_HILOGE("Get ScanManagerClientProxy from SA failed.");
65 return nullptr;
66 }
67 SCAN_HILOGD("Getting ScanManagerClientProxy succeeded.");
68 return serviceProxy;
69 }
70
OnRemoteSaDied(const wptr<IRemoteObject> & remote)71 void ScanManagerClient::OnRemoteSaDied(const wptr<IRemoteObject> &remote)
72 {
73 scanServiceProxy_ = nullptr;
74 ready_ = false;
75 }
76
LoadServer()77 bool ScanManagerClient::LoadServer()
78 {
79 if (ready_) {
80 return true;
81 }
82 std::lock_guard<std::mutex> lock(loadMutex_);
83 if (ready_) {
84 return true;
85 }
86
87 auto sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
88 if (sm == nullptr) {
89 SCAN_HILOGE("GetSystemAbilityManager return null");
90 return false;
91 }
92
93 sptr<ScanSyncLoadCallback> loadCallback_ = new (std::nothrow) ScanSyncLoadCallback();
94 if (loadCallback_ == nullptr) {
95 SCAN_HILOGE("new ScanSyncLoadCallback fail");
96 return false;
97 }
98
99 int32_t result = sm->LoadSystemAbility(SCAN_SERVICE_ID, loadCallback_);
100 if (result != ERR_OK) {
101 SCAN_HILOGE("LoadSystemAbility %{public}d failed, result: %{public}d", SCAN_SERVICE_ID, result);
102 return false;
103 }
104
105 {
106 std::unique_lock<std::mutex> conditionLock(conditionMutex_);
107 auto waitStatus = syncCon_.wait_for(
108 conditionLock, std::chrono::milliseconds(LOAD_SA_TIMEOUT_MS), [this]() { return ready_; });
109 if (!waitStatus) {
110 SCAN_HILOGE("scan server load sa timeout");
111 return false;
112 }
113 }
114 return true;
115 }
116
LoadServerSuccess()117 void ScanManagerClient::LoadServerSuccess()
118 {
119 std::unique_lock<std::mutex> lock(conditionMutex_);
120 ready_ = true;
121 syncCon_.notify_one();
122 SCAN_HILOGD("load scan server success");
123 }
124
LoadServerFail()125 void ScanManagerClient::LoadServerFail()
126 {
127 ready_ = false;
128 SCAN_HILOGE("load scan server fail");
129 }
130
InitScan(int32_t & scanVersion)131 int32_t ScanManagerClient::InitScan(int32_t &scanVersion)
132 {
133 std::lock_guard<std::mutex> lock(proxyLock_);
134 SCAN_HILOGD("ScanManagerClient InitScan start.");
135 if (!LoadServer()) {
136 SCAN_HILOGE("load scan server fail");
137 return E_SCAN_RPC_FAILURE;
138 }
139
140 if (scanServiceProxy_ == nullptr) {
141 SCAN_HILOGW("Redo GetScanServiceProxy");
142 scanServiceProxy_ = GetScanServiceProxy();
143 }
144 if (scanServiceProxy_ == nullptr) {
145 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
146 return E_SCAN_RPC_FAILURE;
147 }
148 int32_t ret = scanServiceProxy_->InitScan(scanVersion);
149 SCAN_HILOGD("ScanManagerClient InitScan end ret = [%{public}d].", ret);
150 return ret;
151 }
152
ExitScan()153 int32_t ScanManagerClient::ExitScan()
154 {
155 std::lock_guard<std::mutex> lock(proxyLock_);
156 SCAN_HILOGD("ScanManagerClient ExitScan start.");
157 if (!LoadServer()) {
158 SCAN_HILOGE("load scan server fail");
159 return E_SCAN_RPC_FAILURE;
160 }
161
162 if (scanServiceProxy_ == nullptr) {
163 SCAN_HILOGW("Redo GetScanServiceProxy");
164 scanServiceProxy_ = GetScanServiceProxy();
165 }
166 if (scanServiceProxy_ == nullptr) {
167 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
168 return E_SCAN_RPC_FAILURE;
169 }
170 int32_t ret = scanServiceProxy_->ExitScan();
171 SCAN_HILOGD("ScanManagerClient ExitScan end ret = [%{public}d].", ret);
172 return ret;
173 }
174
GetScannerList()175 int32_t ScanManagerClient::GetScannerList()
176 {
177 std::lock_guard<std::mutex> lock(proxyLock_);
178 SCAN_HILOGD("ScanManagerClient GetScannerList start.");
179 if (!LoadServer()) {
180 SCAN_HILOGE("load scan server fail");
181 return E_SCAN_RPC_FAILURE;
182 }
183
184 if (scanServiceProxy_ == nullptr) {
185 SCAN_HILOGW("Redo GetScanServiceProxy");
186 scanServiceProxy_ = GetScanServiceProxy();
187 }
188 if (scanServiceProxy_ == nullptr) {
189 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
190 return E_SCAN_RPC_FAILURE;
191 }
192 int32_t ret = scanServiceProxy_->GetScannerList();
193 SCAN_HILOGD("ScanManagerClient GetScannerList end ret = [%{public}d].", ret);
194 return ret;
195 }
196
StopDiscover()197 int32_t ScanManagerClient::StopDiscover()
198 {
199 std::lock_guard<std::mutex> lock(proxyLock_);
200 SCAN_HILOGD("ScanManagerClient StopDiscover start.");
201 if (!LoadServer()) {
202 SCAN_HILOGE("load scan server fail");
203 return E_SCAN_RPC_FAILURE;
204 }
205
206 if (scanServiceProxy_ == nullptr) {
207 SCAN_HILOGW("Redo GetScanServiceProxy");
208 scanServiceProxy_ = GetScanServiceProxy();
209 }
210 if (scanServiceProxy_ == nullptr) {
211 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
212 return E_SCAN_RPC_FAILURE;
213 }
214 int32_t ret = scanServiceProxy_->StopDiscover();
215 SCAN_HILOGD("ScanManagerClient StopDiscover end ret = [%{public}d].", ret);
216 return ret;
217 }
218
OpenScanner(const std::string scannerId)219 int32_t ScanManagerClient::OpenScanner(const std::string scannerId)
220 {
221 std::lock_guard<std::mutex> lock(proxyLock_);
222 SCAN_HILOGD("ScanManagerClient OpenScanner start.");
223 if (!LoadServer()) {
224 SCAN_HILOGE("load scan server fail");
225 return E_SCAN_RPC_FAILURE;
226 }
227
228 if (scanServiceProxy_ == nullptr) {
229 SCAN_HILOGW("Redo GetScanServiceProxy");
230 scanServiceProxy_ = GetScanServiceProxy();
231 }
232 if (scanServiceProxy_ == nullptr) {
233 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
234 return E_SCAN_RPC_FAILURE;
235 }
236 int32_t ret = scanServiceProxy_->OpenScanner(scannerId);
237 SCAN_HILOGD("ScanManagerClient OpenScanner end ret = [%{public}d].", ret);
238 return ret;
239 }
240
CloseScanner(const std::string scannerId)241 int32_t ScanManagerClient::CloseScanner(const std::string scannerId)
242 {
243 std::lock_guard<std::mutex> lock(proxyLock_);
244 SCAN_HILOGD("ScanManagerClient CloseScanner start.");
245 if (!LoadServer()) {
246 SCAN_HILOGE("load scan server fail");
247 return E_SCAN_RPC_FAILURE;
248 }
249
250 if (scanServiceProxy_ == nullptr) {
251 SCAN_HILOGW("Redo GetScanServiceProxy");
252 scanServiceProxy_ = GetScanServiceProxy();
253 }
254 if (scanServiceProxy_ == nullptr) {
255 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
256 return E_SCAN_RPC_FAILURE;
257 }
258 int32_t ret = scanServiceProxy_->CloseScanner(scannerId);
259 SCAN_HILOGD("ScanManagerClient CloseScanner end ret = [%{public}d].", ret);
260 return ret;
261 }
262
GetScanOptionDesc(const std::string scannerId,const int32_t optionIndex,ScanOptionDescriptor & desc)263 int32_t ScanManagerClient::GetScanOptionDesc(
264 const std::string scannerId, const int32_t optionIndex, ScanOptionDescriptor &desc)
265 {
266 std::lock_guard<std::mutex> lock(proxyLock_);
267 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc start.");
268 if (!LoadServer()) {
269 SCAN_HILOGE("load scan server fail");
270 return E_SCAN_RPC_FAILURE;
271 }
272
273 if (scanServiceProxy_ == nullptr) {
274 SCAN_HILOGW("Redo GetScanServiceProxy");
275 scanServiceProxy_ = GetScanServiceProxy();
276 }
277 if (scanServiceProxy_ == nullptr) {
278 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
279 return E_SCAN_RPC_FAILURE;
280 }
281 int32_t ret = scanServiceProxy_->GetScanOptionDesc(scannerId, optionIndex, desc);
282 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc end ret = [%{public}d].", ret);
283 return ret;
284 }
285
OpScanOptionValue(const std::string scannerId,const int32_t optionIndex,const ScanOptionOpType op,ScanOptionValue & value,int32_t & info)286 int32_t ScanManagerClient::OpScanOptionValue(const std::string scannerId, const int32_t optionIndex,
287 const ScanOptionOpType op, ScanOptionValue &value, int32_t &info)
288 {
289 std::lock_guard<std::mutex> lock(proxyLock_);
290 SCAN_HILOGD("ScanManagerClient OpScanOptionValue start.");
291 if (!LoadServer()) {
292 SCAN_HILOGE("load scan server fail");
293 return E_SCAN_RPC_FAILURE;
294 }
295
296 if (scanServiceProxy_ == nullptr) {
297 SCAN_HILOGW("Redo GetScanServiceProxy");
298 scanServiceProxy_ = GetScanServiceProxy();
299 }
300 if (scanServiceProxy_ == nullptr) {
301 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
302 return E_SCAN_RPC_FAILURE;
303 }
304 int32_t ret = scanServiceProxy_->OpScanOptionValue(scannerId, optionIndex, op, value, info);
305 SCAN_HILOGD("ScanManagerClient OpScanOptionValue end ret = [%{public}d].", ret);
306 return ret;
307 }
308
GetScanParameters(const std::string scannerId,ScanParameters & para)309 int32_t ScanManagerClient::GetScanParameters(const std::string scannerId, ScanParameters ¶)
310 {
311 std::lock_guard<std::mutex> lock(proxyLock_);
312 SCAN_HILOGD("ScanManagerClient GetScanParameters start.");
313 if (!LoadServer()) {
314 SCAN_HILOGE("load scan server fail");
315 return E_SCAN_RPC_FAILURE;
316 }
317
318 if (scanServiceProxy_ == nullptr) {
319 SCAN_HILOGW("Redo GetScanServiceProxy");
320 scanServiceProxy_ = GetScanServiceProxy();
321 }
322 if (scanServiceProxy_ == nullptr) {
323 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
324 return E_SCAN_RPC_FAILURE;
325 }
326 int32_t ret = scanServiceProxy_->GetScanParameters(scannerId, para);
327 SCAN_HILOGD("ScanManagerClient GetScanParameters end ret = [%{public}d].", ret);
328 return ret;
329 }
330
StartScan(const std::string scannerId,const bool & batchMode)331 int32_t ScanManagerClient::StartScan(const std::string scannerId, const bool &batchMode)
332 {
333 std::lock_guard<std::mutex> lock(proxyLock_);
334 SCAN_HILOGD("ScanManagerClient StartScan start.");
335 if (!LoadServer()) {
336 SCAN_HILOGE("load scan server fail");
337 return E_SCAN_RPC_FAILURE;
338 }
339
340 if (scanServiceProxy_ == nullptr) {
341 SCAN_HILOGW("Redo GetScanServiceProxy");
342 scanServiceProxy_ = GetScanServiceProxy();
343 }
344 if (scanServiceProxy_ == nullptr) {
345 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
346 return E_SCAN_RPC_FAILURE;
347 }
348 int32_t ret = scanServiceProxy_->StartScan(scannerId, batchMode);
349 SCAN_HILOGD("ScanManagerClient StartScan end ret = [%{public}d].", ret);
350 return ret;
351 }
352
GetSingleFrameFD(const std::string scannerId,uint32_t & size,uint32_t fd)353 int32_t ScanManagerClient::GetSingleFrameFD(const std::string scannerId, uint32_t &size, uint32_t fd)
354 {
355 std::lock_guard<std::mutex> lock(proxyLock_);
356 SCAN_HILOGD("ScanManagerClient GetSingleFrameFD start.");
357 if (!LoadServer()) {
358 SCAN_HILOGE("load scan server fail");
359 return E_SCAN_RPC_FAILURE;
360 }
361
362 if (scanServiceProxy_ == nullptr) {
363 SCAN_HILOGW("Redo GetScanServiceProxy");
364 scanServiceProxy_ = GetScanServiceProxy();
365 }
366 if (scanServiceProxy_ == nullptr) {
367 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
368 return E_SCAN_RPC_FAILURE;
369 }
370 int32_t ret = scanServiceProxy_->GetSingleFrameFD(scannerId, size, fd);
371 SCAN_HILOGD("ScanManagerClient GetSingleFrameFD end ret = [%{public}d].", ret);
372 return ret;
373 }
374
CancelScan(const std::string scannerId)375 int32_t ScanManagerClient::CancelScan(const std::string scannerId)
376 {
377 std::lock_guard<std::mutex> lock(proxyLock_);
378 SCAN_HILOGD("ScanManagerClient CancelScan start.");
379 if (!LoadServer()) {
380 SCAN_HILOGE("load scan server fail");
381 return E_SCAN_RPC_FAILURE;
382 }
383
384 if (scanServiceProxy_ == nullptr) {
385 SCAN_HILOGW("Redo GetScanServiceProxy");
386 scanServiceProxy_ = GetScanServiceProxy();
387 }
388 if (scanServiceProxy_ == nullptr) {
389 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
390 return E_SCAN_RPC_FAILURE;
391 }
392 int32_t ret = scanServiceProxy_->CancelScan(scannerId);
393 SCAN_HILOGD("ScanManagerClient CancelScan end ret = [%{public}d].", ret);
394 return ret;
395 }
396
SetScanIOMode(const std::string scannerId,const bool isNonBlocking)397 int32_t ScanManagerClient::SetScanIOMode(const std::string scannerId, const bool isNonBlocking)
398 {
399 std::lock_guard<std::mutex> lock(proxyLock_);
400 SCAN_HILOGD("ScanManagerClient SetScanIOMode start.");
401 if (!LoadServer()) {
402 SCAN_HILOGE("load scan server fail");
403 return E_SCAN_RPC_FAILURE;
404 }
405
406 if (scanServiceProxy_ == nullptr) {
407 SCAN_HILOGW("Redo GetScanServiceProxy");
408 scanServiceProxy_ = GetScanServiceProxy();
409 }
410 if (scanServiceProxy_ == nullptr) {
411 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
412 return E_SCAN_RPC_FAILURE;
413 }
414 int32_t ret = scanServiceProxy_->SetScanIOMode(scannerId, isNonBlocking);
415 SCAN_HILOGD("ScanManagerClient SetScanIOMode end ret = [%{public}d].", ret);
416 return ret;
417 }
418
GetScanSelectFd(const std::string scannerId,int32_t & fd)419 int32_t ScanManagerClient::GetScanSelectFd(const std::string scannerId, int32_t &fd)
420 {
421 std::lock_guard<std::mutex> lock(proxyLock_);
422 SCAN_HILOGD("ScanManagerClient GetScanSelectFd start.");
423 if (!LoadServer()) {
424 SCAN_HILOGE("load scan server fail");
425 return E_SCAN_RPC_FAILURE;
426 }
427
428 if (scanServiceProxy_ == nullptr) {
429 SCAN_HILOGW("Redo GetScanServiceProxy");
430 scanServiceProxy_ = GetScanServiceProxy();
431 }
432 if (scanServiceProxy_ == nullptr) {
433 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
434 return E_SCAN_RPC_FAILURE;
435 }
436 int32_t ret = scanServiceProxy_->GetScanSelectFd(scannerId, fd);
437 SCAN_HILOGD("ScanManagerClient GetScanSelectFd end ret = [%{public}d].", ret);
438 return ret;
439 }
440
On(const std::string & taskId,const std::string & type,const sptr<IScanCallback> & listener)441 int32_t ScanManagerClient::On(const std::string &taskId, const std::string &type, const sptr<IScanCallback> &listener)
442 {
443 std::lock_guard<std::mutex> lock(proxyLock_);
444 SCAN_HILOGD("ScanManagerClient On start.");
445 if (!LoadServer()) {
446 SCAN_HILOGE("load scan server fail");
447 return E_SCAN_RPC_FAILURE;
448 }
449
450 if (scanServiceProxy_ == nullptr) {
451 SCAN_HILOGW("Redo GetScanServiceProxy");
452 scanServiceProxy_ = GetScanServiceProxy();
453 }
454 if (scanServiceProxy_ == nullptr) {
455 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
456 return E_SCAN_RPC_FAILURE;
457 }
458 int32_t ret = scanServiceProxy_->On(taskId, type, listener);
459 SCAN_HILOGD("ScanManagerClient On out ret = [%{public}d].", ret);
460 return ret;
461 }
462
Off(const std::string & taskId,const std::string & type)463 int32_t ScanManagerClient::Off(const std::string &taskId, const std::string &type)
464 {
465 std::lock_guard<std::mutex> lock(proxyLock_);
466 SCAN_HILOGD("ScanManagerClient Off start.");
467 if (!LoadServer()) {
468 SCAN_HILOGE("load scan server fail");
469 return E_SCAN_RPC_FAILURE;
470 }
471
472 if (scanServiceProxy_ == nullptr) {
473 SCAN_HILOGW("Redo GetScanServiceProxy");
474 scanServiceProxy_ = GetScanServiceProxy();
475 }
476 if (scanServiceProxy_ == nullptr) {
477 SCAN_HILOGE("Off quit because redoing GetScanServiceProxy failed.");
478 return E_SCAN_RPC_FAILURE;
479 }
480 int32_t ret = scanServiceProxy_->Off(taskId, type);
481 SCAN_HILOGD("ScanManagerClient Off out ret = [%{public}d].", ret);
482 return ret;
483 }
484
GetScannerState(int32_t & scannerState)485 int32_t ScanManagerClient::GetScannerState(int32_t &scannerState)
486 {
487 std::lock_guard<std::mutex> lock(proxyLock_);
488 SCAN_HILOGD("ScanManagerClient GetScannerState start.");
489 if (!LoadServer()) {
490 SCAN_HILOGE("load scan server fail");
491 return E_SCAN_RPC_FAILURE;
492 }
493
494 if (scanServiceProxy_ == nullptr) {
495 SCAN_HILOGW("Redo GetScanServiceProxy");
496 scanServiceProxy_ = GetScanServiceProxy();
497 }
498 if (scanServiceProxy_ == nullptr) {
499 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
500 return E_SCAN_RPC_FAILURE;
501 }
502 int32_t ret = scanServiceProxy_->GetScannerState(scannerState);
503 SCAN_HILOGD("ScanManagerClient GetScannerState end ret = [%{public}d].", ret);
504 return ret;
505 }
506
GetScanProgress(const std::string scannerId,ScanProgress & prog)507 int32_t ScanManagerClient::GetScanProgress(const std::string scannerId, ScanProgress &prog)
508 {
509 std::lock_guard<std::mutex> lock(proxyLock_);
510 SCAN_HILOGI("ScanManagerClient GetScanProgress start.");
511 if (!LoadServer()) {
512 SCAN_HILOGE("load scan server fail");
513 return E_SCAN_RPC_FAILURE;
514 }
515 if (scanServiceProxy_ == nullptr) {
516 SCAN_HILOGW("Redo GetScanServiceProxy");
517 scanServiceProxy_ = GetScanServiceProxy();
518 if (scanServiceProxy_ == nullptr) {
519 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
520 return E_SCAN_RPC_FAILURE;
521 }
522 }
523 int32_t ret = scanServiceProxy_->GetScanProgress(scannerId, prog);
524 SCAN_HILOGI("ScanManagerClient GetScanProgress end ret = [%{public}d].", ret);
525 return ret;
526 }
527
AddScanner(const std::string & serialNumber,const std::string & discoverMode)528 int32_t ScanManagerClient::AddScanner(const std::string& serialNumber, const std::string& discoverMode)
529 {
530 std::lock_guard<std::mutex> lock(proxyLock_);
531 SCAN_HILOGD("ScanManagerClient AddScanner start.");
532 if (!LoadServer()) {
533 SCAN_HILOGE("load scan server fail");
534 return E_SCAN_RPC_FAILURE;
535 }
536
537 if (scanServiceProxy_ == nullptr) {
538 SCAN_HILOGW("Redo GetScanServiceProxy");
539 scanServiceProxy_ = GetScanServiceProxy();
540 }
541 if (scanServiceProxy_ == nullptr) {
542 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
543 return E_SCAN_RPC_FAILURE;
544 }
545 int32_t ret = scanServiceProxy_->AddScanner(serialNumber, discoverMode);
546 SCAN_HILOGD("ScanManagerClient AddScanner end ret = [%{public}d].", ret);
547 return ret;
548 }
549
DeleteScanner(const std::string & serialNumber,const std::string & discoverMode)550 int32_t ScanManagerClient::DeleteScanner(const std::string& serialNumber, const std::string& discoverMode)
551 {
552 std::lock_guard<std::mutex> lock(proxyLock_);
553 SCAN_HILOGD("ScanManagerClient DeleteScanner start.");
554 if (!LoadServer()) {
555 SCAN_HILOGE("load scan server fail");
556 return E_SCAN_RPC_FAILURE;
557 }
558
559 if (scanServiceProxy_ == nullptr) {
560 SCAN_HILOGW("Redo GetScanServiceProxy");
561 scanServiceProxy_ = GetScanServiceProxy();
562 }
563 if (scanServiceProxy_ == nullptr) {
564 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
565 return E_SCAN_RPC_FAILURE;
566 }
567 int32_t ret = scanServiceProxy_->DeleteScanner(serialNumber, discoverMode);
568 SCAN_HILOGD("ScanManagerClient DeleteScanner end ret = [%{public}d].", ret);
569 return ret;
570 }
571
GetAddedScanner(std::vector<ScanDeviceInfo> & allAddedScanner)572 int32_t ScanManagerClient::GetAddedScanner(std::vector<ScanDeviceInfo>& allAddedScanner)
573 {
574 std::lock_guard<std::mutex> lock(proxyLock_);
575 SCAN_HILOGD("ScanManagerClient GetAddedScanner start.");
576 if (!LoadServer()) {
577 SCAN_HILOGE("load scan server fail");
578 return E_SCAN_RPC_FAILURE;
579 }
580
581 if (scanServiceProxy_ == nullptr) {
582 SCAN_HILOGW("Redo GetScanServiceProxy");
583 scanServiceProxy_ = GetScanServiceProxy();
584 }
585 if (scanServiceProxy_ == nullptr) {
586 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
587 return E_SCAN_RPC_FAILURE;
588 }
589 int32_t ret = scanServiceProxy_->GetAddedScanner(allAddedScanner);
590 SCAN_HILOGD("ScanManagerClient GetAddedScanner end ret = [%{public}d].", ret);
591 return ret;
592 }
593
UpdateScannerName(const std::string & serialNumber,const std::string & discoverMode,const std::string & deviceName)594 int32_t ScanManagerClient::UpdateScannerName(const std::string& serialNumber,
595 const std::string& discoverMode, const std::string& deviceName)
596 {
597 std::lock_guard<std::mutex> lock(proxyLock_);
598 SCAN_HILOGD("ScanManagerClient UpdateScannerName start.");
599 if (!LoadServer()) {
600 SCAN_HILOGE("load scan server fail");
601 return E_SCAN_RPC_FAILURE;
602 }
603
604 if (scanServiceProxy_ == nullptr) {
605 SCAN_HILOGW("Redo GetScanServiceProxy");
606 scanServiceProxy_ = GetScanServiceProxy();
607 }
608 if (scanServiceProxy_ == nullptr) {
609 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
610 return E_SCAN_RPC_FAILURE;
611 }
612 int32_t ret = scanServiceProxy_->UpdateScannerName(serialNumber, discoverMode, deviceName);
613 SCAN_HILOGD("ScanManagerClient UpdateScannerName end ret = [%{public}d].", ret);
614 return ret;
615 }
616
AddPrinter(const std::string & serialNumber,const std::string & discoverMode)617 int32_t ScanManagerClient::AddPrinter(const std::string& serialNumber, const std::string& discoverMode)
618 {
619 std::lock_guard<std::mutex> lock(proxyLock_);
620 SCAN_HILOGD("ScanManagerClient AddPrinter start.");
621 if (!LoadServer()) {
622 SCAN_HILOGE("load scan server fail");
623 return E_SCAN_RPC_FAILURE;
624 }
625
626 if (scanServiceProxy_ == nullptr) {
627 SCAN_HILOGW("Redo GetScanServiceProxy");
628 scanServiceProxy_ = GetScanServiceProxy();
629 }
630 if (scanServiceProxy_ == nullptr) {
631 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
632 return E_SCAN_RPC_FAILURE;
633 }
634 int32_t ret = scanServiceProxy_->AddPrinter(serialNumber, discoverMode);
635 SCAN_HILOGD("ScanManagerClient AddPrinter end ret = [%{public}d].", ret);
636 return ret;
637 }
638 } // namespace OHOS::Scan
639