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_OPEN_SCANNER] = &ScanServiceStub::OnOpenScanner;
34 cmdMap_[CMD_CLOSE_SCANNER] = &ScanServiceStub::OnCloseScanner;
35 cmdMap_[CMD_GET_SCAN_OPTION_DESC] = &ScanServiceStub::OnGetScanOptionDesc;
36 cmdMap_[CMD_OP_SCAN_OPTION_VALUE] = &ScanServiceStub::OnOpScanOptionValue;
37 cmdMap_[CMD_GET_SCAN_PARAMETERS] = &ScanServiceStub::OnGetScanParameters;
38 cmdMap_[CMD_START_SCAN] = &ScanServiceStub::OnStartScan;
39 cmdMap_[CMD_CANCEL_SCAN] = &ScanServiceStub::OnCancelScan;
40 cmdMap_[CMD_GET_SCAN_PROGRESS] = &ScanServiceStub::OnGetScanProgress;
41 cmdMap_[CMD_CONNECT_SCANNER] = &ScanServiceStub::OnConnectScanner;
42 cmdMap_[CMD_DISCONNECT_SCANNER] = &ScanServiceStub::OnDisConnectScanner;
43 cmdMap_[CMD_GET_CONNECTED_SCANNER] = &ScanServiceStub::OnGetConnectedScanner;
44 cmdMap_[CMD_ON] = &ScanServiceStub::OnEventOn;
45 cmdMap_[CMD_OFF] = &ScanServiceStub::OnEventOff;
46 }
47
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)48 int32_t ScanServiceStub::OnRemoteRequest(
49 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
50 {
51 SCAN_HILOGD("OnRemoteRequest started, code = %{public}d", code);
52 auto descriptorToken = data.ReadInterfaceToken();
53 if (descriptorToken != GetDescriptor()) {
54 SCAN_HILOGE("Remote descriptor not the same as local descriptor.");
55 return E_SCAN_RPC_FAILURE;
56 }
57
58 auto itFunc = cmdMap_.find(code);
59 if (itFunc != cmdMap_.end()) {
60 auto requestFunc = itFunc->second;
61 if (requestFunc != nullptr) {
62 bool result = (this->*requestFunc)(data, reply);
63 return result ? E_SCAN_NONE : E_SCAN_SERVER_FAILURE;
64 }
65 }
66 SCAN_HILOGW("default case, need check.");
67 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
68 }
69
OnInitScan(MessageParcel & data,MessageParcel & reply)70 bool ScanServiceStub::OnInitScan(MessageParcel &data, MessageParcel &reply)
71 {
72 SCAN_HILOGI("ScanServiceStub::OnInitScan start");
73 int32_t ret = InitScan();
74 reply.WriteInt32(ret);
75 SCAN_HILOGI("ScanServiceStub::OnInitScan end");
76 return ret == E_SCAN_NONE;
77 }
78
OnExitScan(MessageParcel & data,MessageParcel & reply)79 bool ScanServiceStub::OnExitScan(MessageParcel &data, MessageParcel &reply)
80 {
81 SCAN_HILOGI("ScanServiceStub::OnExitScan start");
82 int32_t ret = ExitScan();
83 reply.WriteInt32(ret);
84 SCAN_HILOGI("ScanServiceStub::OnExitScan end");
85 return ret == E_SCAN_NONE;
86 }
87
OnGetScannerList(MessageParcel & data,MessageParcel & reply)88 bool ScanServiceStub::OnGetScannerList(MessageParcel &data, MessageParcel &reply)
89 {
90 SCAN_HILOGI("ScanServiceStub::OnGetScannerList start");
91 int32_t ret = GetScannerList();
92 reply.WriteInt32(ret);
93 SCAN_HILOGI("ScanServiceStub::OnGetScannerList end");
94 return ret == E_SCAN_NONE;
95 }
96
OnOpenScanner(MessageParcel & data,MessageParcel & reply)97 bool ScanServiceStub::OnOpenScanner(MessageParcel &data, MessageParcel &reply)
98 {
99 SCAN_HILOGI("ScanServiceStub::OnOpenScanner start");
100 std::string scannerId = data.ReadString();
101 int32_t ret = OpenScanner(scannerId);
102 reply.WriteInt32(ret);
103 SCAN_HILOGI("ScanServiceStub::OnOpenScanner end");
104 return ret == E_SCAN_NONE;
105 }
106
OnCloseScanner(MessageParcel & data,MessageParcel & reply)107 bool ScanServiceStub::OnCloseScanner(MessageParcel &data, MessageParcel &reply)
108 {
109 SCAN_HILOGI("ScanServiceStub::OnCloseScanner start");
110 std::string scannerId = data.ReadString();
111 int32_t ret = CloseScanner(scannerId);
112 reply.WriteInt32(ret);
113 SCAN_HILOGI("ScanServiceStub::OnCloseScanner end");
114 return ret == E_SCAN_NONE;
115 }
116
OnGetScanOptionDesc(MessageParcel & data,MessageParcel & reply)117 bool ScanServiceStub::OnGetScanOptionDesc(MessageParcel &data, MessageParcel &reply)
118 {
119 SCAN_HILOGI("ScanServiceStub::OnGetScanOptionDesc start");
120 std::string scannerId = data.ReadString();
121 int32_t optionIndex = data.ReadInt32();
122 ScanOptionDescriptor desc;
123 int32_t ret = GetScanOptionDesc(scannerId, optionIndex, desc);
124 reply.WriteInt32(ret);
125 if (ret == E_SCAN_NONE) {
126 desc.Marshalling(reply);
127 }
128 SCAN_HILOGI("ScanServiceStub::OnGetScanOptionDesc end");
129 return ret == E_SCAN_NONE;
130 }
131
OnOpScanOptionValue(MessageParcel & data,MessageParcel & reply)132 bool ScanServiceStub::OnOpScanOptionValue(MessageParcel &data, MessageParcel &reply)
133 {
134 SCAN_HILOGD("ScanServiceStub::OnOpScanOptionValue start");
135 std::string scannerId = data.ReadString();
136 int32_t optionIndex = data.ReadInt32();
137 ScanOptionOpType op = (ScanOptionOpType) data.ReadUint32();
138 ScanOptionValue value;
139 auto scanOptionValue = ScanOptionValue::Unmarshalling(data);
140 if (scanOptionValue == nullptr) {
141 SCAN_HILOGE("scanOptionValue is a nullptr.");
142 return false;
143 }
144 value = *scanOptionValue;
145 int32_t ret = OpScanOptionValue(scannerId, optionIndex, op, value);
146 reply.WriteInt32(ret);
147 if (ret == E_SCAN_NONE) {
148 value.Marshalling(reply);
149 }
150 SCAN_HILOGD("ScanServiceStub::OnOpScanOptionValue end");
151 return ret == E_SCAN_NONE;
152 }
153
OnGetScanParameters(MessageParcel & data,MessageParcel & reply)154 bool ScanServiceStub::OnGetScanParameters(MessageParcel &data, MessageParcel &reply)
155 {
156 SCAN_HILOGD("ScanServiceStub::OnGetScanParameters start");
157 std::string scannerId = data.ReadString();
158 ScanParameters para;
159 int32_t ret = GetScanParameters(scannerId, para);
160 reply.WriteInt32(ret);
161 if (ret == E_SCAN_NONE) {
162 para.Marshalling(reply);
163 }
164 SCAN_HILOGD("ScanServiceStub::OnGetScanParameters end");
165 return ret == E_SCAN_NONE;
166 }
167
OnStartScan(MessageParcel & data,MessageParcel & reply)168 bool ScanServiceStub::OnStartScan(MessageParcel &data, MessageParcel &reply)
169 {
170 SCAN_HILOGI("ScanServiceStub::OnStartScan start");
171 std::string scannerId = data.ReadString();
172 bool batchMode = data.ReadBool();
173 int32_t ret = ScanServiceAbility::GetInstance()->OnStartScan(scannerId, batchMode);
174 reply.WriteInt32(ret);
175 SCAN_HILOGI("ScanServiceStub::OnStartScan end");
176 return ret == E_SCAN_NONE;
177 }
178
OnCancelScan(MessageParcel & data,MessageParcel & reply)179 bool ScanServiceStub::OnCancelScan(MessageParcel &data, MessageParcel &reply)
180 {
181 SCAN_HILOGI("ScanServiceStub::OnCancelScan start");
182 std::string scannerId = data.ReadString();
183 int32_t ret = CancelScan(scannerId);
184 reply.WriteInt32(ret);
185 SCAN_HILOGI("ScanServiceStub::OnCancelScan end");
186 return ret == E_SCAN_NONE;
187 }
188
OnEventOn(MessageParcel & data,MessageParcel & reply)189 bool ScanServiceStub::OnEventOn(MessageParcel &data, MessageParcel &reply)
190 {
191 std::string taskId = data.ReadString();
192 std::string type = data.ReadString();
193 SCAN_HILOGD("ScanServiceStub::OnEventOn type=%{public}s ", type.c_str());
194 if (type.empty()) {
195 SCAN_HILOGE("ScanServiceStub::OnEventOn type is null.");
196 reply.WriteInt32(E_SCAN_RPC_FAILURE);
197 return false;
198 }
199 sptr<IRemoteObject> remote = data.ReadRemoteObject();
200 if (remote == nullptr) {
201 SCAN_HILOGE("ScanServiceStub::OnEventOn remote is nullptr");
202 reply.WriteInt32(E_SCAN_RPC_FAILURE);
203 return false;
204 }
205 sptr<IScanCallback> listener = iface_cast<IScanCallback>(remote);
206 if (listener.GetRefPtr() == nullptr) {
207 SCAN_HILOGE("ScanServiceStub::OnEventOn listener is null");
208 reply.WriteInt32(E_SCAN_RPC_FAILURE);
209 return false;
210 }
211 int32_t ret = On(taskId, type, listener);
212 reply.WriteInt32(ret);
213 SCAN_HILOGD("ScanServiceStub::OnEventOn out");
214 return ret == E_SCAN_NONE;
215 }
216
OnEventOff(MessageParcel & data,MessageParcel & reply)217 bool ScanServiceStub::OnEventOff(MessageParcel &data, MessageParcel &reply)
218 {
219 SCAN_HILOGD("ScanServiceStub::OnEventOff in");
220 std::string taskId = data.ReadString();
221 std::string type = data.ReadString();
222 SCAN_HILOGD("ScanServiceStub::OnEventOff type=%{public}s ", type.c_str());
223 int32_t ret = Off(taskId, type);
224 reply.WriteInt32(ret);
225 SCAN_HILOGD("ScanServiceStub::OnEventOff out");
226 return ret == E_SCAN_NONE;
227 }
228
OnGetScanProgress(MessageParcel & data,MessageParcel & reply)229 bool ScanServiceStub::OnGetScanProgress(MessageParcel &data, MessageParcel &reply)
230 {
231 SCAN_HILOGD("ScanServiceStub::OnGetScanProgress start");
232 std::string scannerId = data.ReadString();
233 ScanProgress prog;
234 int32_t ret = GetScanProgress(scannerId, prog);
235 reply.WriteInt32(ret);
236 if (ret == E_SCAN_NONE) {
237 prog.Marshalling(reply);
238 }
239 SCAN_HILOGD("ScanServiceStub::OnGetScanProgress end");
240 return ret == E_SCAN_NONE;
241 }
242
OnConnectScanner(MessageParcel & data,MessageParcel & reply)243 bool ScanServiceStub::OnConnectScanner(MessageParcel &data, MessageParcel &reply)
244 {
245 SCAN_HILOGD("ScanServiceStub::OnConnectScanner start");
246 std::string serialNumber = data.ReadString();
247 std::string discoverMode = data.ReadString();
248 int32_t ret = AddScanner(serialNumber, discoverMode);
249 reply.WriteInt32(ret);
250 SCAN_HILOGD("ScanServiceStub::OnConnectScanner end");
251 return ret == E_SCAN_NONE;
252 }
253
OnDisConnectScanner(MessageParcel & data,MessageParcel & reply)254 bool ScanServiceStub::OnDisConnectScanner(MessageParcel &data, MessageParcel &reply)
255 {
256 SCAN_HILOGD("ScanServiceStub::OnDisConnectScanner start");
257 std::string serialNumber = data.ReadString();
258 std::string discoverMode = data.ReadString();
259 int32_t ret = DeleteScanner(serialNumber, discoverMode);
260 reply.WriteInt32(ret);
261 SCAN_HILOGD("ScanServiceStub::OnDisConnectScanner end");
262 return ret == E_SCAN_NONE;
263 }
264
OnGetConnectedScanner(MessageParcel & data,MessageParcel & reply)265 bool ScanServiceStub::OnGetConnectedScanner(MessageParcel &data, MessageParcel &reply)
266 {
267 SCAN_HILOGD("ScanServiceStub::OnGetConnectedScanner start");
268 std::vector<ScanDeviceInfo> allAddedScanner;
269 int32_t ret = GetAddedScanner(allAddedScanner);
270 reply.WriteInt32(ret);
271 if (ret == E_SCAN_NONE) {
272 uint32_t size = static_cast<uint32_t>(allAddedScanner.size());
273 reply.WriteUint32(size);
274 for (uint32_t index = 0; index < size; index++) {
275 allAddedScanner[index].Marshalling(reply);
276 }
277 }
278 SCAN_HILOGD("ScanServiceStub::OnGetConnectedScanner end");
279 return ret == E_SCAN_NONE;
280 }
281
282 } // namespace OHOS::Scan
283