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_service_stub.h"
17 #include "ipc_skeleton.h"
18 #include "iscan_service.h"
19 #include "message_parcel.h"
20 #include "scan_constant.h"
21 #include "scan_log.h"
22 #include "scanner_info.h"
23 #include "scan_service_ability.h"
24 
25 namespace OHOS::Scan {
26 using namespace OHOS::HiviewDFX;
27 
ScanServiceStub()28 ScanServiceStub::ScanServiceStub()
29 {
30     cmdMap_[CMD_INIT_SCAN] = &ScanServiceStub::OnInitScan;
31     cmdMap_[CMD_EXIT_SCAN] = &ScanServiceStub::OnExitScan;
32     cmdMap_[CMD_GET_SCANNER_LIST] = &ScanServiceStub::OnGetScannerList;
33     cmdMap_[CMD_STOP_DISCOVER] = &ScanServiceStub::OnStopDiscover;
34     cmdMap_[CMD_OPEN_SCANNER] = &ScanServiceStub::OnOpenScanner;
35     cmdMap_[CMD_CLOSE_SCANNER] = &ScanServiceStub::OnCloseScanner;
36     cmdMap_[CMD_GET_SCAN_OPTION_DESC] = &ScanServiceStub::OnGetScanOptionDesc;
37     cmdMap_[CMD_OP_SCAN_OPTION_VALUE] = &ScanServiceStub::OnOpScanOptionValue;
38     cmdMap_[CMD_GET_SCAN_PARAMETERS] = &ScanServiceStub::OnGetScanParameters;
39     cmdMap_[CMD_START_SCAN] = &ScanServiceStub::OnStartScan;
40     cmdMap_[CMD_GET_SINGLE_FRAME_FD] = &ScanServiceStub::OnGetSingleFrameFD;
41     cmdMap_[CMD_CANCEL_SCAN] = &ScanServiceStub::OnCancelScan;
42     cmdMap_[CMD_SET_SCAN_IO_MODE] = &ScanServiceStub::OnSetScanIOMode;
43     cmdMap_[CMD_GET_SCAN_SELECT_FD] = &ScanServiceStub::OnGetScanSelectFd;
44     cmdMap_[CMD_GET_SCANNER_STATE] = &ScanServiceStub::OnGetScannerState;
45     cmdMap_[CMD_GET_SCAN_PROGRESS] = &ScanServiceStub::OnGetScanProgress;
46     cmdMap_[CMD_CONNECT_SCANNER] = &ScanServiceStub::OnConnectScanner;
47     cmdMap_[CMD_DISCONNECT_SCANNER] = &ScanServiceStub::OnDisConnectScanner;
48     cmdMap_[CMD_GET_CONNECTED_SCANNER] = &ScanServiceStub::OnGetConnectedScanner;
49     cmdMap_[CMD_UPDATE_SCANNER_NAME] = &ScanServiceStub::OnUpdateScannerName;
50     cmdMap_[CMD_ON] = &ScanServiceStub::OnEventOn;
51     cmdMap_[CMD_OFF] = &ScanServiceStub::OnEventOff;
52 }
53 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)54 int32_t ScanServiceStub::OnRemoteRequest(
55     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
56 {
57     SCAN_HILOGD("OnRemoteRequest started, code = %{public}d", code);
58     auto descriptorToken = data.ReadInterfaceToken();
59     if (descriptorToken != GetDescriptor()) {
60         SCAN_HILOGE("Remote descriptor not the same as local descriptor.");
61         return E_SCAN_RPC_FAILURE;
62     }
63 
64     auto itFunc = cmdMap_.find(code);
65     if (itFunc != cmdMap_.end()) {
66         auto requestFunc = itFunc->second;
67         if (requestFunc != nullptr) {
68             bool result = (this->*requestFunc)(data, reply);
69             return result ? E_SCAN_NONE : E_SCAN_SERVER_FAILURE;
70         }
71     }
72     SCAN_HILOGW("default case, need check.");
73     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
74 }
75 
OnInitScan(MessageParcel & data,MessageParcel & reply)76 bool ScanServiceStub::OnInitScan(MessageParcel &data, MessageParcel &reply)
77 {
78     SCAN_HILOGI("ScanServiceStub::OnInitScan start");
79     int32_t ret = E_SCAN_RPC_FAILURE;
80     int32_t scanVersion = 0;
81     {
82         std::lock_guard<std::mutex> autoLock(lock_);
83         ScanServiceAbility::appCount_++;
84         SCAN_HILOGI("ScanServiceAbility::appCount_= %{public}d", ScanServiceAbility::appCount_);
85     }
86     if (isSaneInit_) {
87         SCAN_HILOGW("is isSaneInit_ed");
88         return true;
89     }
90     ret = InitScan(scanVersion);
91     isSaneInit_ = true;
92     reply.WriteInt32(ret);
93     reply.WriteInt32(scanVersion);
94     SCAN_HILOGI("ScanServiceStub::OnInitScan end");
95     return ret == E_SCAN_NONE;
96 }
97 
OnExitScan(MessageParcel & data,MessageParcel & reply)98 bool ScanServiceStub::OnExitScan(MessageParcel &data, MessageParcel &reply)
99 {
100     SCAN_HILOGI("ScanServiceStub::OnExitScan start");
101     auto scanServiceAbilityPtr = ScanServiceAbility::GetInstance();
102     if (scanServiceAbilityPtr == nullptr) {
103         SCAN_HILOGE("scanServiceAbilityPtr is a nullptr");
104         reply.WriteInt32(E_SCAN_GENERIC_FAILURE);
105         return false;
106     }
107     {
108         std::lock_guard<std::mutex> autoLock(lock_);
109         ScanServiceAbility::appCount_ = ScanServiceAbility::appCount_ - 1 >= 0 ? ScanServiceAbility::appCount_ - 1 : 0;
110         SCAN_HILOGI("appCount = %{public}d", ScanServiceAbility::appCount_);
111         if (ScanServiceAbility::appCount_ == 0) {
112             SCAN_HILOGI("connected app number = 0, start unloadSA");
113             scanServiceAbilityPtr->UnloadSystemAbility();
114         }
115     }
116     reply.WriteInt32(E_SCAN_NONE);
117     SCAN_HILOGI("ScanServiceStub::OnExitScan end");
118     return true;
119 }
120 
OnGetScannerList(MessageParcel & data,MessageParcel & reply)121 bool ScanServiceStub::OnGetScannerList(MessageParcel &data, MessageParcel &reply)
122 {
123     SCAN_HILOGI("ScanServiceStub::OnGetScannerList start");
124     int32_t ret = GetScannerList();
125     reply.WriteInt32(ret);
126     SCAN_HILOGI("ScanServiceStub::OnGetScannerList end");
127     return ret == E_SCAN_NONE;
128 }
129 
OnStopDiscover(MessageParcel & data,MessageParcel & reply)130 bool ScanServiceStub::OnStopDiscover(MessageParcel &data, MessageParcel &reply)
131 {
132     SCAN_HILOGD("ScanServiceStub::OnStopDiscover start");
133     int32_t ret = StopDiscover();
134     reply.WriteInt32(ret);
135     SCAN_HILOGD("ScanServiceStub::OnStopDiscover end");
136     return ret == E_SCAN_NONE;
137 }
138 
OnOpenScanner(MessageParcel & data,MessageParcel & reply)139 bool ScanServiceStub::OnOpenScanner(MessageParcel &data, MessageParcel &reply)
140 {
141     SCAN_HILOGI("ScanServiceStub::OnOpenScanner start");
142     std::string scannerId = data.ReadString();
143     int32_t ret = OpenScanner(scannerId);
144     reply.WriteInt32(ret);
145     SCAN_HILOGI("ScanServiceStub::OnOpenScanner end");
146     return ret == E_SCAN_NONE;
147 }
148 
OnCloseScanner(MessageParcel & data,MessageParcel & reply)149 bool ScanServiceStub::OnCloseScanner(MessageParcel &data, MessageParcel &reply)
150 {
151     SCAN_HILOGI("ScanServiceStub::OnCloseScanner start");
152     std::string scannerId = data.ReadString();
153     int32_t ret = CloseScanner(scannerId);
154     reply.WriteInt32(ret);
155     SCAN_HILOGI("ScanServiceStub::OnCloseScanner end");
156     return ret == E_SCAN_NONE;
157 }
158 
OnGetScanOptionDesc(MessageParcel & data,MessageParcel & reply)159 bool ScanServiceStub::OnGetScanOptionDesc(MessageParcel &data, MessageParcel &reply)
160 {
161     SCAN_HILOGI("ScanServiceStub::OnGetScanOptionDesc start");
162     std::string scannerId = data.ReadString();
163     int32_t optionIndex = data.ReadInt32();
164     ScanOptionDescriptor desc;
165     int32_t ret = GetScanOptionDesc(scannerId, optionIndex, desc);
166     reply.WriteInt32(ret);
167     if (ret == E_SCAN_NONE) {
168         desc.Marshalling(reply);
169     }
170     SCAN_HILOGI("ScanServiceStub::OnGetScanOptionDesc end");
171     return ret == E_SCAN_NONE;
172 }
173 
OnOpScanOptionValue(MessageParcel & data,MessageParcel & reply)174 bool ScanServiceStub::OnOpScanOptionValue(MessageParcel &data, MessageParcel &reply)
175 {
176     SCAN_HILOGD("ScanServiceStub::OnOpScanOptionValue start");
177     std::string scannerId = data.ReadString();
178     int32_t optionIndex = data.ReadInt32();
179     ScanOptionOpType op = (ScanOptionOpType) data.ReadUint32();
180     ScanOptionValue value;
181     auto scanOptionValue = ScanOptionValue::Unmarshalling(data);
182     if (scanOptionValue == nullptr) {
183         SCAN_HILOGE("scanOptionValue is a nullptr.");
184         return false;
185     }
186     value = *scanOptionValue;
187     int32_t info;
188     int32_t ret = OpScanOptionValue(scannerId, optionIndex, op, value, info);
189     reply.WriteInt32(ret);
190     if (ret == E_SCAN_NONE) {
191         value.Marshalling(reply);
192         if (op == SCAN_ACTION_GET_VALUE) {
193             reply.WriteInt32(info);
194         }
195     }
196     SCAN_HILOGD("ScanServiceStub::OnOpScanOptionValue end");
197     return ret == E_SCAN_NONE;
198 }
199 
OnGetScanParameters(MessageParcel & data,MessageParcel & reply)200 bool ScanServiceStub::OnGetScanParameters(MessageParcel &data, MessageParcel &reply)
201 {
202     SCAN_HILOGD("ScanServiceStub::OnGetScanParameters start");
203     std::string scannerId = data.ReadString();
204     ScanParameters para;
205     int32_t ret = GetScanParameters(scannerId, para);
206     reply.WriteInt32(ret);
207     if (ret == E_SCAN_NONE) {
208         para.Marshalling(reply);
209     }
210     SCAN_HILOGD("ScanServiceStub::OnGetScanParameters end");
211     return ret == E_SCAN_NONE;
212 }
213 
OnStartScan(MessageParcel & data,MessageParcel & reply)214 bool ScanServiceStub::OnStartScan(MessageParcel &data, MessageParcel &reply)
215 {
216     SCAN_HILOGI("ScanServiceStub::OnStartScan start");
217     std::string scannerId = data.ReadString();
218     bool batchMode = data.ReadBool();
219     int32_t ret = ScanServiceAbility::GetInstance()->OnStartScan(scannerId, batchMode);
220     reply.WriteInt32(ret);
221     SCAN_HILOGI("ScanServiceStub::OnStartScan end");
222     return ret == E_SCAN_NONE;
223 }
224 
OnGetSingleFrameFD(MessageParcel & data,MessageParcel & reply)225 bool ScanServiceStub::OnGetSingleFrameFD(MessageParcel &data, MessageParcel &reply)
226 {
227     SCAN_HILOGD("ScanServiceStub::OnGetSingleFrameFD start");
228     std::string scannerId = data.ReadString();
229     int32_t fd = data.ReadFileDescriptor();
230     uint32_t frameSize = 0;
231     int32_t ret = GetSingleFrameFD(scannerId, frameSize, fd);
232     reply.WriteInt32(ret);
233     if (ret == E_SCAN_NONE) {
234         reply.WriteInt32(frameSize);
235     }
236     SCAN_HILOGD("ScanServiceStub::OnGetSingleFrameFD end");
237     return ret == E_SCAN_NONE;
238 }
239 
OnCancelScan(MessageParcel & data,MessageParcel & reply)240 bool ScanServiceStub::OnCancelScan(MessageParcel &data, MessageParcel &reply)
241 {
242     SCAN_HILOGI("ScanServiceStub::OnCancelScan start");
243     std::string scannerId = data.ReadString();
244     int32_t ret = CancelScan(scannerId);
245     reply.WriteInt32(ret);
246     SCAN_HILOGI("ScanServiceStub::OnCancelScan end");
247     return ret == E_SCAN_NONE;
248 }
249 
OnSetScanIOMode(MessageParcel & data,MessageParcel & reply)250 bool ScanServiceStub::OnSetScanIOMode(MessageParcel &data, MessageParcel &reply)
251 {
252     SCAN_HILOGD("ScanServiceStub::OnSetScanIOMode start");
253     std::string scannerId = data.ReadString();
254     bool isNonBlocking = data.ReadBool();
255     int32_t ret = SetScanIOMode(scannerId, isNonBlocking);
256     reply.WriteInt32(ret);
257     SCAN_HILOGD("ScanServiceStub::OnSetScanIOMode end");
258     return ret == E_SCAN_NONE;
259 }
260 
OnGetScanSelectFd(MessageParcel & data,MessageParcel & reply)261 bool ScanServiceStub::OnGetScanSelectFd(MessageParcel &data, MessageParcel &reply)
262 {
263     SCAN_HILOGD("ScanServiceStub::OnGetScanSelectFd start");
264     std::string scannerId = data.ReadString();
265     int32_t fd = 0;
266     int32_t ret = GetScanSelectFd(scannerId, fd);
267     reply.WriteInt32(ret);
268     reply.WriteInt32(fd);
269     SCAN_HILOGD("ScanServiceStub::OnGetScanSelectFd end");
270     return ret == E_SCAN_NONE;
271 }
272 
OnEventOn(MessageParcel & data,MessageParcel & reply)273 bool ScanServiceStub::OnEventOn(MessageParcel &data, MessageParcel &reply)
274 {
275     std::string taskId = data.ReadString();
276     std::string type = data.ReadString();
277     SCAN_HILOGD("ScanServiceStub::OnEventOn type=%{public}s ", type.c_str());
278     if (type.empty()) {
279         SCAN_HILOGE("ScanServiceStub::OnEventOn type is null.");
280         reply.WriteInt32(E_SCAN_RPC_FAILURE);
281         return false;
282     }
283     sptr<IRemoteObject> remote = data.ReadRemoteObject();
284     if (remote == nullptr) {
285         SCAN_HILOGE("ScanServiceStub::OnEventOn remote is nullptr");
286         reply.WriteInt32(E_SCAN_RPC_FAILURE);
287         return false;
288     }
289     sptr<IScanCallback> listener = iface_cast<IScanCallback>(remote);
290     if (listener.GetRefPtr() == nullptr) {
291         SCAN_HILOGE("ScanServiceStub::OnEventOn listener is null");
292         reply.WriteInt32(E_SCAN_RPC_FAILURE);
293         return false;
294     }
295     int32_t ret = On(taskId, type, listener);
296     reply.WriteInt32(ret);
297     SCAN_HILOGD("ScanServiceStub::OnEventOn out");
298     return ret == E_SCAN_NONE;
299 }
300 
OnEventOff(MessageParcel & data,MessageParcel & reply)301 bool ScanServiceStub::OnEventOff(MessageParcel &data, MessageParcel &reply)
302 {
303     SCAN_HILOGD("ScanServiceStub::OnEventOff in");
304     std::string taskId = data.ReadString();
305     std::string type = data.ReadString();
306     SCAN_HILOGD("ScanServiceStub::OnEventOff type=%{public}s ", type.c_str());
307     int32_t ret = Off(taskId, type);
308     reply.WriteInt32(ret);
309     SCAN_HILOGD("ScanServiceStub::OnEventOff out");
310     return ret == E_SCAN_NONE;
311 }
312 
OnGetScannerState(MessageParcel & data,MessageParcel & reply)313 bool ScanServiceStub::OnGetScannerState(MessageParcel &data, MessageParcel &reply)
314 {
315     SCAN_HILOGD("ScanServiceStub::OnGetScannerState start");
316     int32_t ret = E_SCAN_RPC_FAILURE;
317     int32_t scannerState = 0;
318     ret = GetScannerState(scannerState);
319     reply.WriteInt32(ret);
320     reply.WriteInt32(scannerState);
321     SCAN_HILOGD("ScanServiceStub::OnGetScannerState end");
322     return ret == E_SCAN_NONE;
323 }
324 
OnGetScanProgress(MessageParcel & data,MessageParcel & reply)325 bool ScanServiceStub::OnGetScanProgress(MessageParcel &data, MessageParcel &reply)
326 {
327     SCAN_HILOGD("ScanServiceStub::OnGetScanProgress start");
328     std::string scannerId = data.ReadString();
329     ScanProgress prog;
330     int32_t ret = GetScanProgress(scannerId, prog);
331     reply.WriteInt32(ret);
332     if (ret == E_SCAN_NONE) {
333         prog.Marshalling(reply);
334     }
335     SCAN_HILOGD("ScanServiceStub::OnGetScanProgress end");
336     return ret == E_SCAN_NONE;
337 }
338 
OnConnectScanner(MessageParcel & data,MessageParcel & reply)339 bool ScanServiceStub::OnConnectScanner(MessageParcel &data, MessageParcel &reply)
340 {
341     SCAN_HILOGD("ScanServiceStub::OnConnectScanner start");
342     std::string serialNumber = data.ReadString();
343     std::string discoverMode = data.ReadString();
344     int32_t ret = AddScanner(serialNumber, discoverMode);
345     reply.WriteInt32(ret);
346     SCAN_HILOGD("ScanServiceStub::OnConnectScanner end");
347     return ret == E_SCAN_NONE;
348 }
349 
OnDisConnectScanner(MessageParcel & data,MessageParcel & reply)350 bool ScanServiceStub::OnDisConnectScanner(MessageParcel &data, MessageParcel &reply)
351 {
352     SCAN_HILOGD("ScanServiceStub::OnDisConnectScanner start");
353     std::string serialNumber = data.ReadString();
354     std::string discoverMode = data.ReadString();
355     int32_t ret = DeleteScanner(serialNumber, discoverMode);
356     reply.WriteInt32(ret);
357     SCAN_HILOGD("ScanServiceStub::OnDisConnectScanner end");
358     return ret == E_SCAN_NONE;
359 }
360 
OnGetConnectedScanner(MessageParcel & data,MessageParcel & reply)361 bool ScanServiceStub::OnGetConnectedScanner(MessageParcel &data, MessageParcel &reply)
362 {
363     SCAN_HILOGD("ScanServiceStub::OnGetConnectedScanner start");
364     std::vector<ScanDeviceInfo> allAddedScanner;
365     int32_t ret = GetAddedScanner(allAddedScanner);
366     reply.WriteInt32(ret);
367     if (ret == E_SCAN_NONE) {
368         uint32_t size = static_cast<uint32_t>(allAddedScanner.size());
369         reply.WriteUint32(size);
370         for (uint32_t index = 0; index < size; index++) {
371             allAddedScanner[index].Marshalling(reply);
372         }
373     }
374     SCAN_HILOGD("ScanServiceStub::OnGetConnectedScanner end");
375     return ret == E_SCAN_NONE;
376 }
377 
OnUpdateScannerName(MessageParcel & data,MessageParcel & reply)378 bool ScanServiceStub::OnUpdateScannerName(MessageParcel &data, MessageParcel &reply)
379 {
380     SCAN_HILOGD("ScanServiceStub::OnUpdateScannerName start");
381     std::string serialNumber = data.ReadString();
382     std::string discoverMode = data.ReadString();
383     std::string deviceName = data.ReadString();
384     int32_t ret = UpdateScannerName(serialNumber, discoverMode, deviceName);
385     reply.WriteInt32(ret);
386     SCAN_HILOGD("ScanServiceStub::OnUpdateScannerName end");
387     return ret == E_SCAN_NONE;
388 }
389 
390 } // namespace OHOS::Scan
391