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 #include "scan_log.h"
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()123 int32_t ScanManagerClient::InitScan()
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();
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
OpenScanner(const std::string scannerId)174 int32_t ScanManagerClient::OpenScanner(const std::string scannerId)
175 {
176 SCAN_HILOGD("ScanManagerClient OpenScanner 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_->OpenScanner(scannerId);
187 SCAN_HILOGD("ScanManagerClient OpenScanner end ret = [%{public}d].", ret);
188 return ret;
189 }
190
CloseScanner(const std::string scannerId)191 int32_t ScanManagerClient::CloseScanner(const std::string scannerId)
192 {
193 SCAN_HILOGD("ScanManagerClient CloseScanner 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_->CloseScanner(scannerId);
204 SCAN_HILOGD("ScanManagerClient CloseScanner end ret = [%{public}d].", ret);
205 return ret;
206 }
207
GetScanOptionDesc(const std::string scannerId,const int32_t optionIndex,ScanOptionDescriptor & desc)208 int32_t ScanManagerClient::GetScanOptionDesc(
209 const std::string scannerId, const int32_t optionIndex, ScanOptionDescriptor &desc)
210 {
211 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc start.");
212 if (scanServiceProxy_ == nullptr) {
213 SCAN_HILOGW("Redo GetScanServiceProxy");
214 scanServiceProxy_ = GetScanServiceProxy();
215 }
216 std::shared_lock<std::shared_mutex> lock(proxyLock_);
217 if (scanServiceProxy_ == nullptr) {
218 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
219 return E_SCAN_RPC_FAILURE;
220 }
221 int32_t ret = scanServiceProxy_->GetScanOptionDesc(scannerId, optionIndex, desc);
222 SCAN_HILOGD("ScanManagerClient GetScanOptionDesc end ret = [%{public}d].", ret);
223 return ret;
224 }
225
OpScanOptionValue(const std::string scannerId,const int32_t optionIndex,const ScanOptionOpType op,ScanOptionValue & value)226 int32_t ScanManagerClient::OpScanOptionValue(const std::string scannerId, const int32_t optionIndex,
227 const ScanOptionOpType op, ScanOptionValue &value)
228 {
229 SCAN_HILOGD("ScanManagerClient OpScanOptionValue start.");
230 if (scanServiceProxy_ == nullptr) {
231 SCAN_HILOGW("Redo GetScanServiceProxy");
232 scanServiceProxy_ = GetScanServiceProxy();
233 }
234 std::shared_lock<std::shared_mutex> lock(proxyLock_);
235 if (scanServiceProxy_ == nullptr) {
236 SCAN_HILOGE("On quit because redoing GetScanServiceProxy failed.");
237 return E_SCAN_RPC_FAILURE;
238 }
239 int32_t ret = scanServiceProxy_->OpScanOptionValue(scannerId, optionIndex, op, value);
240 SCAN_HILOGD("ScanManagerClient OpScanOptionValue end ret = [%{public}d].", ret);
241 return ret;
242 }
243
GetScanParameters(const std::string scannerId,ScanParameters & para)244 int32_t ScanManagerClient::GetScanParameters(const std::string scannerId, ScanParameters ¶)
245 {
246 SCAN_HILOGD("ScanManagerClient GetScanParameters 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_->GetScanParameters(scannerId, para);
257 SCAN_HILOGD("ScanManagerClient GetScanParameters end ret = [%{public}d].", ret);
258 return ret;
259 }
260
StartScan(const std::string scannerId,const bool & batchMode)261 int32_t ScanManagerClient::StartScan(const std::string scannerId, const bool &batchMode)
262 {
263 SCAN_HILOGD("ScanManagerClient StartScan 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_->StartScan(scannerId, batchMode);
274 SCAN_HILOGD("ScanManagerClient StartScan end ret = [%{public}d].", ret);
275 return ret;
276 }
277
CancelScan(const std::string scannerId)278 int32_t ScanManagerClient::CancelScan(const std::string scannerId)
279 {
280 SCAN_HILOGD("ScanManagerClient CancelScan 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_->CancelScan(scannerId);
291 SCAN_HILOGD("ScanManagerClient CancelScan end ret = [%{public}d].", ret);
292 return ret;
293 }
294
On(const std::string & taskId,const std::string & type,const sptr<IScanCallback> & listener)295 int32_t ScanManagerClient::On(const std::string &taskId, const std::string &type, const sptr<IScanCallback> &listener)
296 {
297 SCAN_HILOGD("ScanManagerClient On 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_->On(taskId, type, listener);
308 SCAN_HILOGD("ScanManagerClient On out ret = [%{public}d].", ret);
309 return ret;
310 }
311
Off(const std::string & taskId,const std::string & type)312 int32_t ScanManagerClient::Off(const std::string &taskId, const std::string &type)
313 {
314 SCAN_HILOGD("ScanManagerClient Off 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_->Off(taskId, type);
325 SCAN_HILOGD("ScanManagerClient Off out ret = [%{public}d].", ret);
326 return ret;
327 }
328
GetScanProgress(const std::string scannerId,ScanProgress & prog)329 int32_t ScanManagerClient::GetScanProgress(const std::string scannerId, ScanProgress &prog)
330 {
331 SCAN_HILOGI("ScanManagerClient GetScanProgress 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_->GetScanProgress(scannerId, prog);
342 SCAN_HILOGI("ScanManagerClient GetScanProgress end ret = [%{public}d].", ret);
343 return ret;
344 }
345
AddScanner(const std::string & serialNumber,const std::string & discoverMode)346 int32_t ScanManagerClient::AddScanner(const std::string& serialNumber, const std::string& discoverMode)
347 {
348 SCAN_HILOGD("ScanManagerClient AddScanner 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_->AddScanner(serialNumber, discoverMode);
359 SCAN_HILOGD("ScanManagerClient AddScanner end ret = [%{public}d].", ret);
360 return ret;
361 }
362
DeleteScanner(const std::string & serialNumber,const std::string & discoverMode)363 int32_t ScanManagerClient::DeleteScanner(const std::string& serialNumber, const std::string& discoverMode)
364 {
365 SCAN_HILOGD("ScanManagerClient DeleteScanner 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_->DeleteScanner(serialNumber, discoverMode);
376 SCAN_HILOGD("ScanManagerClient DeleteScanner end ret = [%{public}d].", ret);
377 return ret;
378 }
379
GetAddedScanner(std::vector<ScanDeviceInfo> & allAddedScanner)380 int32_t ScanManagerClient::GetAddedScanner(std::vector<ScanDeviceInfo>& allAddedScanner)
381 {
382 SCAN_HILOGD("ScanManagerClient GetAddedScanner 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_->GetAddedScanner(allAddedScanner);
393 SCAN_HILOGD("ScanManagerClient GetAddedScanner end ret = [%{public}d].", ret);
394 return ret;
395 }
396
397 } // namespace OHOS::Scan
398