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)
26 {
27 deathRecipient_ = new ScanSaDeathRecipient();
28 }
29
~ScanManagerClient()30 ScanManagerClient::~ScanManagerClient()
31 {
32 scanServiceProxy_ = nullptr;
33 deathRecipient_ = nullptr;
34 }
35
GetInstance()36 sptr<ScanManagerClient> ScanManagerClient::GetInstance()
37 {
38 if (instance_ == nullptr) {
39 std::lock_guard<std::mutex> autoLock(instanceLock_);
40 if (instance_ == nullptr) {
41 instance_ = new ScanManagerClient;
42 }
43 }
44 return instance_;
45 }
GetScanServiceProxy()46 sptr<IScanService> ScanManagerClient::GetScanServiceProxy()
47 {
48 {
49 std::unique_lock<std::shared_mutex> lock(proxyLock_);
50 if (scanServiceProxy_ != nullptr) {
51 SCAN_HILOGD("already get scanServiceProxy_");
52 return scanServiceProxy_;
53 }
54 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
55 if (samgrProxy == nullptr) {
56 SCAN_HILOGE("samgrProxy is a nullptr");
57 return nullptr;
58 }
59 auto object = samgrProxy->CheckSystemAbility(SCAN_SERVICE_ID);
60 if (object != nullptr) {
61 object->AddDeathRecipient(deathRecipient_);
62 scanServiceProxy_ = iface_cast<IScanService>(object);
63 return scanServiceProxy_;
64 }
65 }
66 if (LoadScanService()) {
67 std::unique_lock<std::shared_mutex> lock(proxyLock_);
68 return scanServiceProxy_;
69 }
70 return nullptr;
71 }
72
LoadScanService()73 bool ScanManagerClient::LoadScanService()
74 {
75 std::unique_lock<std::shared_mutex> lock(proxyLock_);
76 sptr<ScanSyncLoadCallback> lockCallback = new (std::nothrow) ScanSyncLoadCallback();
77 if (lockCallback == nullptr) {
78 SCAN_HILOGE("lockCallback is a nullptr");
79 return false;
80 }
81 auto samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
82 if (samgrProxy == nullptr) {
83 SCAN_HILOGE("get samgr failed");
84 return false;
85 }
86 int32_t ret = samgrProxy->LoadSystemAbility(SCAN_SERVICE_ID, lockCallback);
87 if (ret != ERR_OK) {
88 SCAN_HILOGE("LoadSystemAbility failed");
89 return false;
90 }
91 auto waitStatus = syncCon_.wait_for(lock, std::chrono::milliseconds(LOAD_SA_TIMEOUT_MS),
92 [this]() { return scanServiceProxy_ != nullptr; });
93 if (!waitStatus) {
94 return false;
95 }
96 return true;
97 }
98
LoadServerSuccess(const sptr<IRemoteObject> & remoteObject)99 void ScanManagerClient::LoadServerSuccess(const sptr<IRemoteObject> &remoteObject)
100 {
101 std::unique_lock<std::shared_mutex> lock(proxyLock_);
102 SCAN_HILOGI("scan_service LoadServerSuccess");
103 if (remoteObject != nullptr) {
104 remoteObject->AddDeathRecipient(deathRecipient_);
105 scanServiceProxy_ = iface_cast<IScanService>(remoteObject);
106 syncCon_.notify_one();
107 }
108 }
109
LoadServerFail()110 void ScanManagerClient::LoadServerFail()
111 {
112 std::unique_lock<std::shared_mutex> lock(proxyLock_);
113 SCAN_HILOGI("scan_service LoadServerFail");
114 scanServiceProxy_ = nullptr;
115 }
116
OnRemoteSaDied(const wptr<IRemoteObject> & object)117 void ScanManagerClient::OnRemoteSaDied(const wptr<IRemoteObject>& object)
118 {
119 std::unique_lock<std::shared_mutex> lock(proxyLock_);
120 scanServiceProxy_ = nullptr;
121 }
122
InitScan(int32_t & scanVersion)123 int32_t ScanManagerClient::InitScan(int32_t &scanVersion)
124 {
125 SCAN_HILOGD("ScanManagerClient InitScan start.");
126 if (scanServiceProxy_ == nullptr) {
127 SCAN_HILOGW("do GetScanServiceProxy");
128 scanServiceProxy_ = GetScanServiceProxy();
129 }
130 std::shared_lock<std::shared_mutex> lock(proxyLock_);
131 if (scanServiceProxy_ == nullptr) {
132 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
133 return E_SCAN_RPC_FAILURE;
134 }
135 int32_t ret = scanServiceProxy_->InitScan(scanVersion);
136 SCAN_HILOGD("ScanManagerClient InitScan end ret = [%{public}d].", ret);
137 return ret;
138 }
139
ExitScan()140 int32_t ScanManagerClient::ExitScan()
141 {
142 SCAN_HILOGD("ScanManagerClient ExitScan start.");
143 if (scanServiceProxy_ == nullptr) {
144 SCAN_HILOGW("do GetScanServiceProxy");
145 scanServiceProxy_ = GetScanServiceProxy();
146 }
147 std::shared_lock<std::shared_mutex> lock(proxyLock_);
148 if (scanServiceProxy_ == nullptr) {
149 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
150 return E_SCAN_RPC_FAILURE;
151 }
152 int32_t ret = scanServiceProxy_->ExitScan();
153 SCAN_HILOGD("ScanManagerClient ExitScan end ret = [%{public}d].", ret);
154 return ret;
155 }
156
GetScannerList()157 int32_t ScanManagerClient::GetScannerList()
158 {
159 SCAN_HILOGD("ScanManagerClient GetScannerList start.");
160 if (scanServiceProxy_ == nullptr) {
161 SCAN_HILOGW("Redo GetScanServiceProxy");
162 scanServiceProxy_ = GetScanServiceProxy();
163 }
164 std::shared_lock<std::shared_mutex> lock(proxyLock_);
165 if (scanServiceProxy_ == nullptr) {
166 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
167 return E_SCAN_RPC_FAILURE;
168 }
169 int32_t ret = scanServiceProxy_->GetScannerList();
170 SCAN_HILOGD("ScanManagerClient GetScannerList end ret = [%{public}d].", ret);
171 return ret;
172 }
173
StopDiscover()174 int32_t ScanManagerClient::StopDiscover()
175 {
176 SCAN_HILOGD("ScanManagerClient StopDiscover start.");
177 if (scanServiceProxy_ == nullptr) {
178 SCAN_HILOGW("Redo GetScanServiceProxy");
179 scanServiceProxy_ = GetScanServiceProxy();
180 }
181 std::shared_lock<std::shared_mutex> lock(proxyLock_);
182 if (scanServiceProxy_ == nullptr) {
183 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
184 return E_SCAN_RPC_FAILURE;
185 }
186 int32_t ret = scanServiceProxy_->StopDiscover();
187 SCAN_HILOGD("ScanManagerClient StopDiscover end ret = [%{public}d].", ret);
188 return ret;
189 }
190
OpenScanner(const std::string scannerId)191 int32_t ScanManagerClient::OpenScanner(const std::string scannerId)
192 {
193 SCAN_HILOGD("ScanManagerClient OpenScanner start.");
194 if (scanServiceProxy_ == nullptr) {
195 SCAN_HILOGW("Redo GetScanServiceProxy");
196 scanServiceProxy_ = GetScanServiceProxy();
197 }
198 std::shared_lock<std::shared_mutex> lock(proxyLock_);
199 if (scanServiceProxy_ == nullptr) {
200 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
201 return E_SCAN_RPC_FAILURE;
202 }
203 int32_t ret = scanServiceProxy_->OpenScanner(scannerId);
204 SCAN_HILOGD("ScanManagerClient OpenScanner end ret = [%{public}d].", ret);
205 return ret;
206 }
207
CloseScanner(const std::string scannerId)208 int32_t ScanManagerClient::CloseScanner(const std::string scannerId)
209 {
210 SCAN_HILOGD("ScanManagerClient CloseScanner start.");
211 if (scanServiceProxy_ == nullptr) {
212 SCAN_HILOGW("Redo GetScanServiceProxy");
213 scanServiceProxy_ = GetScanServiceProxy();
214 }
215 std::shared_lock<std::shared_mutex> lock(proxyLock_);
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_->CloseScanner(scannerId);
221 SCAN_HILOGD("ScanManagerClient CloseScanner end ret = [%{public}d].", ret);
222 return ret;
223 }
224
GetScanOptionDesc(const std::string scannerId,const int32_t optionIndex,ScanOptionDescriptor & desc)225 int32_t ScanManagerClient::GetScanOptionDesc(
226 const std::string scannerId, const int32_t optionIndex, ScanOptionDescriptor &desc)
227 {
228 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc start.");
229 if (scanServiceProxy_ == nullptr) {
230 SCAN_HILOGW("Redo GetScanServiceProxy");
231 scanServiceProxy_ = GetScanServiceProxy();
232 }
233 std::shared_lock<std::shared_mutex> lock(proxyLock_);
234 if (scanServiceProxy_ == nullptr) {
235 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
236 return E_SCAN_RPC_FAILURE;
237 }
238 int32_t ret = scanServiceProxy_->GetScanOptionDesc(scannerId, optionIndex, desc);
239 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc end ret = [%{public}d].", ret);
240 return ret;
241 }
242
OpScanOptionValue(const std::string scannerId,const int32_t optionIndex,const ScanOptionOpType op,ScanOptionValue & value,int32_t & info)243 int32_t ScanManagerClient::OpScanOptionValue(const std::string scannerId, const int32_t optionIndex,
244 const ScanOptionOpType op, ScanOptionValue &value, int32_t &info)
245 {
246 SCAN_HILOGD("ScanManagerClient OpScanOptionValue start.");
247 if (scanServiceProxy_ == nullptr) {
248 SCAN_HILOGW("Redo GetScanServiceProxy");
249 scanServiceProxy_ = GetScanServiceProxy();
250 }
251 std::shared_lock<std::shared_mutex> lock(proxyLock_);
252 if (scanServiceProxy_ == nullptr) {
253 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
254 return E_SCAN_RPC_FAILURE;
255 }
256 int32_t ret = scanServiceProxy_->OpScanOptionValue(scannerId, optionIndex, op, value, info);
257 SCAN_HILOGD("ScanManagerClient OpScanOptionValue end ret = [%{public}d].", ret);
258 return ret;
259 }
260
GetScanParameters(const std::string scannerId,ScanParameters & para)261 int32_t ScanManagerClient::GetScanParameters(const std::string scannerId, ScanParameters ¶)
262 {
263 SCAN_HILOGD("ScanManagerClient GetScanParameters start.");
264 if (scanServiceProxy_ == nullptr) {
265 SCAN_HILOGW("Redo GetScanServiceProxy");
266 scanServiceProxy_ = GetScanServiceProxy();
267 }
268 std::shared_lock<std::shared_mutex> lock(proxyLock_);
269 if (scanServiceProxy_ == nullptr) {
270 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
271 return E_SCAN_RPC_FAILURE;
272 }
273 int32_t ret = scanServiceProxy_->GetScanParameters(scannerId, para);
274 SCAN_HILOGD("ScanManagerClient GetScanParameters end ret = [%{public}d].", ret);
275 return ret;
276 }
277
StartScan(const std::string scannerId,const bool & batchMode)278 int32_t ScanManagerClient::StartScan(const std::string scannerId, const bool &batchMode)
279 {
280 SCAN_HILOGD("ScanManagerClient StartScan start.");
281 if (scanServiceProxy_ == nullptr) {
282 SCAN_HILOGW("Redo GetScanServiceProxy");
283 scanServiceProxy_ = GetScanServiceProxy();
284 }
285 std::shared_lock<std::shared_mutex> lock(proxyLock_);
286 if (scanServiceProxy_ == nullptr) {
287 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
288 return E_SCAN_RPC_FAILURE;
289 }
290 int32_t ret = scanServiceProxy_->StartScan(scannerId, batchMode);
291 SCAN_HILOGD("ScanManagerClient StartScan end ret = [%{public}d].", ret);
292 return ret;
293 }
294
GetSingleFrameFD(const std::string scannerId,uint32_t & size,uint32_t fd)295 int32_t ScanManagerClient::GetSingleFrameFD(const std::string scannerId, uint32_t &size, uint32_t fd)
296 {
297 SCAN_HILOGD("ScanManagerClient GetSingleFrameFD start.");
298 if (scanServiceProxy_ == nullptr) {
299 SCAN_HILOGW("Redo GetScanServiceProxy");
300 scanServiceProxy_ = GetScanServiceProxy();
301 }
302 std::shared_lock<std::shared_mutex> lock(proxyLock_);
303 if (scanServiceProxy_ == nullptr) {
304 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
305 return E_SCAN_RPC_FAILURE;
306 }
307 int32_t ret = scanServiceProxy_->GetSingleFrameFD(scannerId, size, fd);
308 SCAN_HILOGD("ScanManagerClient GetSingleFrameFD end ret = [%{public}d].", ret);
309 return ret;
310 }
311
CancelScan(const std::string scannerId)312 int32_t ScanManagerClient::CancelScan(const std::string scannerId)
313 {
314 SCAN_HILOGD("ScanManagerClient CancelScan start.");
315 if (scanServiceProxy_ == nullptr) {
316 SCAN_HILOGW("Redo GetScanServiceProxy");
317 scanServiceProxy_ = GetScanServiceProxy();
318 }
319 std::shared_lock<std::shared_mutex> lock(proxyLock_);
320 if (scanServiceProxy_ == nullptr) {
321 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
322 return E_SCAN_RPC_FAILURE;
323 }
324 int32_t ret = scanServiceProxy_->CancelScan(scannerId);
325 SCAN_HILOGD("ScanManagerClient CancelScan end ret = [%{public}d].", ret);
326 return ret;
327 }
328
SetScanIOMode(const std::string scannerId,const bool isNonBlocking)329 int32_t ScanManagerClient::SetScanIOMode(const std::string scannerId, const bool isNonBlocking)
330 {
331 SCAN_HILOGD("ScanManagerClient SetScanIOMode start.");
332 if (scanServiceProxy_ == nullptr) {
333 SCAN_HILOGW("Redo GetScanServiceProxy");
334 scanServiceProxy_ = GetScanServiceProxy();
335 }
336 std::shared_lock<std::shared_mutex> lock(proxyLock_);
337 if (scanServiceProxy_ == nullptr) {
338 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
339 return E_SCAN_RPC_FAILURE;
340 }
341 int32_t ret = scanServiceProxy_->SetScanIOMode(scannerId, isNonBlocking);
342 SCAN_HILOGD("ScanManagerClient SetScanIOMode end ret = [%{public}d].", ret);
343 return ret;
344 }
345
GetScanSelectFd(const std::string scannerId,int32_t & fd)346 int32_t ScanManagerClient::GetScanSelectFd(const std::string scannerId, int32_t &fd)
347 {
348 SCAN_HILOGD("ScanManagerClient GetScanSelectFd start.");
349 if (scanServiceProxy_ == nullptr) {
350 SCAN_HILOGW("Redo GetScanServiceProxy");
351 scanServiceProxy_ = GetScanServiceProxy();
352 }
353 std::shared_lock<std::shared_mutex> lock(proxyLock_);
354 if (scanServiceProxy_ == nullptr) {
355 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
356 return E_SCAN_RPC_FAILURE;
357 }
358 int32_t ret = scanServiceProxy_->GetScanSelectFd(scannerId, fd);
359 SCAN_HILOGD("ScanManagerClient GetScanSelectFd end ret = [%{public}d].", ret);
360 return ret;
361 }
362
On(const std::string & taskId,const std::string & type,const sptr<IScanCallback> & listener)363 int32_t ScanManagerClient::On(const std::string &taskId, const std::string &type, const sptr<IScanCallback> &listener)
364 {
365 SCAN_HILOGD("ScanManagerClient On start.");
366 if (scanServiceProxy_ == nullptr) {
367 SCAN_HILOGW("Redo GetScanServiceProxy");
368 scanServiceProxy_ = GetScanServiceProxy();
369 }
370 std::shared_lock<std::shared_mutex> lock(proxyLock_);
371 if (scanServiceProxy_ == nullptr) {
372 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
373 return E_SCAN_RPC_FAILURE;
374 }
375 int32_t ret = scanServiceProxy_->On(taskId, type, listener);
376 SCAN_HILOGD("ScanManagerClient On out ret = [%{public}d].", ret);
377 return ret;
378 }
379
Off(const std::string & taskId,const std::string & type)380 int32_t ScanManagerClient::Off(const std::string &taskId, const std::string &type)
381 {
382 SCAN_HILOGD("ScanManagerClient Off start.");
383 if (scanServiceProxy_ == nullptr) {
384 SCAN_HILOGW("Redo GetScanServiceProxy");
385 scanServiceProxy_ = GetScanServiceProxy();
386 }
387 std::shared_lock<std::shared_mutex> lock(proxyLock_);
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_->Off(taskId, type);
393 SCAN_HILOGD("ScanManagerClient Off out ret = [%{public}d].", ret);
394 return ret;
395 }
396
GetScannerState(int32_t & scannerState)397 int32_t ScanManagerClient::GetScannerState(int32_t &scannerState)
398 {
399 SCAN_HILOGD("ScanManagerClient GetScannerState start.");
400 if (scanServiceProxy_ == nullptr) {
401 SCAN_HILOGW("Redo GetScanServiceProxy");
402 scanServiceProxy_ = GetScanServiceProxy();
403 }
404 std::shared_lock<std::shared_mutex> lock(proxyLock_);
405 if (scanServiceProxy_ == nullptr) {
406 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
407 return E_SCAN_RPC_FAILURE;
408 }
409 int32_t ret = scanServiceProxy_->GetScannerState(scannerState);
410 SCAN_HILOGD("ScanManagerClient GetScannerState end ret = [%{public}d].", ret);
411 return ret;
412 }
413
GetScanProgress(const std::string scannerId,ScanProgress & prog)414 int32_t ScanManagerClient::GetScanProgress(const std::string scannerId, ScanProgress &prog)
415 {
416 SCAN_HILOGI("ScanManagerClient GetScanProgress start.");
417 if (scanServiceProxy_ == nullptr) {
418 SCAN_HILOGW("Redo GetScanServiceProxy");
419 scanServiceProxy_ = GetScanServiceProxy();
420 }
421 std::shared_lock<std::shared_mutex> lock(proxyLock_);
422 if (scanServiceProxy_ == nullptr) {
423 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
424 return E_SCAN_RPC_FAILURE;
425 }
426 int32_t ret = scanServiceProxy_->GetScanProgress(scannerId, prog);
427 SCAN_HILOGI("ScanManagerClient GetScanProgress end ret = [%{public}d].", ret);
428 return ret;
429 }
430
AddScanner(const std::string & serialNumber,const std::string & discoverMode)431 int32_t ScanManagerClient::AddScanner(const std::string& serialNumber, const std::string& discoverMode)
432 {
433 SCAN_HILOGD("ScanManagerClient AddScanner start.");
434 if (scanServiceProxy_ == nullptr) {
435 SCAN_HILOGW("Redo GetScanServiceProxy");
436 scanServiceProxy_ = GetScanServiceProxy();
437 }
438 std::shared_lock<std::shared_mutex> lock(proxyLock_);
439 if (scanServiceProxy_ == nullptr) {
440 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
441 return E_SCAN_RPC_FAILURE;
442 }
443 int32_t ret = scanServiceProxy_->AddScanner(serialNumber, discoverMode);
444 SCAN_HILOGD("ScanManagerClient AddScanner end ret = [%{public}d].", ret);
445 return ret;
446 }
447
DeleteScanner(const std::string & serialNumber,const std::string & discoverMode)448 int32_t ScanManagerClient::DeleteScanner(const std::string& serialNumber, const std::string& discoverMode)
449 {
450 SCAN_HILOGD("ScanManagerClient DeleteScanner start.");
451 if (scanServiceProxy_ == nullptr) {
452 SCAN_HILOGW("Redo GetScanServiceProxy");
453 scanServiceProxy_ = GetScanServiceProxy();
454 }
455 std::shared_lock<std::shared_mutex> lock(proxyLock_);
456 if (scanServiceProxy_ == nullptr) {
457 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
458 return E_SCAN_RPC_FAILURE;
459 }
460 int32_t ret = scanServiceProxy_->DeleteScanner(serialNumber, discoverMode);
461 SCAN_HILOGD("ScanManagerClient DeleteScanner end ret = [%{public}d].", ret);
462 return ret;
463 }
464
GetAddedScanner(std::vector<ScanDeviceInfo> & allAddedScanner)465 int32_t ScanManagerClient::GetAddedScanner(std::vector<ScanDeviceInfo>& allAddedScanner)
466 {
467 SCAN_HILOGD("ScanManagerClient GetAddedScanner start.");
468 if (scanServiceProxy_ == nullptr) {
469 SCAN_HILOGW("Redo GetScanServiceProxy");
470 scanServiceProxy_ = GetScanServiceProxy();
471 }
472 std::shared_lock<std::shared_mutex> lock(proxyLock_);
473 if (scanServiceProxy_ == nullptr) {
474 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
475 return E_SCAN_RPC_FAILURE;
476 }
477 int32_t ret = scanServiceProxy_->GetAddedScanner(allAddedScanner);
478 SCAN_HILOGD("ScanManagerClient GetAddedScanner end ret = [%{public}d].", ret);
479 return ret;
480 }
481
UpdateScannerName(const std::string & serialNumber,const std::string & discoverMode,const std::string & deviceName)482 int32_t ScanManagerClient::UpdateScannerName(const std::string& serialNumber,
483 const std::string& discoverMode, const std::string& deviceName)
484 {
485 SCAN_HILOGD("ScanManagerClient UpdateScannerName start.");
486 if (scanServiceProxy_ == nullptr) {
487 SCAN_HILOGW("Redo GetScanServiceProxy");
488 scanServiceProxy_ = GetScanServiceProxy();
489 }
490 std::shared_lock<std::shared_mutex> lock(proxyLock_);
491 if (scanServiceProxy_ == nullptr) {
492 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
493 return E_SCAN_RPC_FAILURE;
494 }
495 int32_t ret = scanServiceProxy_->UpdateScannerName(serialNumber, discoverMode, deviceName);
496 SCAN_HILOGD("ScanManagerClient UpdateScannerName end ret = [%{public}d].", ret);
497 return ret;
498 }
499
500 } // namespace OHOS::Scan
501