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