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 "print_service_stub.h"
17 #include "ipc_skeleton.h"
18 #include "iprint_service.h"
19 #include "message_parcel.h"
20 #include "print_constant.h"
21 #include "print_extension_info.h"
22 #include "print_job.h"
23 #include "print_log.h"
24 
25 namespace OHOS::Print {
26 using namespace OHOS::HiviewDFX;
27 
PrintServiceStub()28 PrintServiceStub::PrintServiceStub()
29 {
30     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_START_PRINT] = &PrintServiceStub::OnStartPrint;
31     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STOP_PRINT] = &PrintServiceStub::OnStopPrint;
32     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_CONNECTPRINTER] = &PrintServiceStub::OnConnectPrinter;
33     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_DISCONNECTPRINTER] = &PrintServiceStub::OnDisconnectPrinter;
34     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STARTDISCOVERPRINTER] = &PrintServiceStub::OnStartDiscoverPrinter;
35     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STOPDISCOVERPRINTER] = &PrintServiceStub::OnStopDiscoverPrint;
36     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYALLEXTENSION] = &PrintServiceStub::OnQueryAllExtension;
37     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STARTPRINTJOB] = &PrintServiceStub::OnStartPrintJob;
38     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_CANCELPRINTJOB] = &PrintServiceStub::OnCancelPrintJob;
39     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_ADDPRINTERS] = &PrintServiceStub::OnAddPrinters;
40     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_REMOVEPRINTERS] = &PrintServiceStub::OnRemovePrinters;
41     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTERS] = &PrintServiceStub::OnUpdatePrinters;
42     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTERSTATE] = &PrintServiceStub::OnUpdatePrinterState;
43     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTJOBSTATE_FORNORMALAPP] =
44         &PrintServiceStub::OnUpdatePrintJobStateForNormalApp;
45     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTJOBSTATE_FORSYSTEMAPP] =
46         &PrintServiceStub::OnUpdatePrintJobStateOnlyForSystemApp;
47     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEEXTENSIONINFO] = &PrintServiceStub::OnUpdateExtensionInfo;
48     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_REQUESTPREVIEW] = &PrintServiceStub::OnRequestPreview;
49     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYPRINTERCAPABILITY] =
50         &PrintServiceStub::OnQueryPrinterCapability;
51     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_ON] = &PrintServiceStub::OnEventOn;
52     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_OFF] = &PrintServiceStub::OnEventOff;
53     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_REG_EXT_CB] = &PrintServiceStub::OnRegisterExtCallback;
54     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UNREG_EXT_CB] = &PrintServiceStub::OnUnregisterAllExtCallback;
55     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_LOAD_EXT] = &PrintServiceStub::OnLoadExtSuccess;
56     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYALLPRINTJOB] = &PrintServiceStub::OnQueryAllPrintJob;
57     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYPRINTJOBBYID] = &PrintServiceStub::OnQueryPrintJobById;
58     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_ADDPRINTERTOCUPS] = &PrintServiceStub::OnAddPrinterToCups;
59     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYPRINTERCAPABILITYBYURI] =
60         &PrintServiceStub::OnQueryPrinterCapabilityByUri;
61     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STARTPRINTJOB_BY_ADAPTER] = &PrintServiceStub::OnPrintByAdapter;
62     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_START_GET_FILE] = &PrintServiceStub::OnStartGetPrintFile;
63     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_NOTIFY_PRINT_SERVICE] = &PrintServiceStub::OnNotifyPrintService;
64     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_START_SERVICE] = &PrintServiceStub::OnStartService;
65     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_REG_PRINTER_CB] = &PrintServiceStub::OnRegisterPrinterCallback;
66     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UNREG_PRINTER_CB] = &PrintServiceStub::OnUnregisterPrinterCallback;
67     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYPRINTERINFOBYPRINTERID] =
68         &PrintServiceStub::OnQueryPrinterInfoByPrinterId;
69     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYADDEDPRINTER] = &PrintServiceStub::OnQueryAddedPrinter;
70     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_QUERYPRINTERPROPERTIES] =
71         &PrintServiceStub::OnQueryPrinterProperties;
72     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_STARTNATIVEPRINTJOB] = &PrintServiceStub::OnStartNativePrintJob;
73     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_NOTIFY_PRINT_SERVICE_EVENT] =
74         &PrintServiceStub::OnNotifyPrintServiceEvent;
75     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_GET_PRINTER_PREFERENCE] =
76         &PrintServiceStub::OnGetPrinterPreference;
77     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_SET_PRINTER_PREFERENCE] =
78         &PrintServiceStub::OnSetPrinterPreference;
79     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_SET_DEFAULT_PRINTERID] = &PrintServiceStub::OnSetDefaultPrinter;
80     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_DELETE_PRINTER_FROM_CUPS] =
81         &PrintServiceStub::OnDeletePrinterFromCups;
82     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_DISCOVER_USB_PRINTERS] = &PrintServiceStub::OnDiscoverUsbPrinters;
83     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_ADDPRINTERTODISCOVERY] = &PrintServiceStub::OnAddPrinterToDiscovery;
84     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTERINDISCOVERY] =
85         &PrintServiceStub::OnUpdatePrinterInDiscovery;
86     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_REMOVEPRINTERFROMDISCOVERY] =
87         &PrintServiceStub::OnRemovePrinterFromDiscovery;
88     cmdMap_[OHOS::Print::IPrintInterfaceCode::CMD_UPDATEPRINTERINSYSTEM] =
89         &PrintServiceStub::OnUpdatePrinterInSystem;
90 }
91 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)92 int32_t PrintServiceStub::OnRemoteRequest(
93     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
94 {
95     PRINT_HILOGD("OnRemoteRequest started, code = %{public}d", code);
96     auto descriptorToken = data.ReadInterfaceToken();
97     if (descriptorToken != GetDescriptor()) {
98         PRINT_HILOGE("Remote descriptor not the same as local descriptor.");
99         return E_PRINT_RPC_FAILURE;
100     }
101 
102     auto itFunc = cmdMap_.find(code);
103     if (itFunc != cmdMap_.end()) {
104         auto requestFunc = itFunc->second;
105         if (requestFunc != nullptr) {
106             bool result = (this->*requestFunc)(data, reply);
107             return result ? E_PRINT_NONE : E_PRINT_GENERIC_FAILURE;
108         }
109     }
110     PRINT_HILOGW("default case, need check.");
111     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
112 }
113 
OnStartService(MessageParcel & data,MessageParcel & reply)114 bool PrintServiceStub::OnStartService(MessageParcel &data, MessageParcel &reply)
115 {
116     PRINT_HILOGD("nativePrint PrintServiceStub::OnStartService in");
117     int32_t ret = E_PRINT_INVALID_PARAMETER;
118     if (data.ReadString() == "nativePrint") {
119         ret = StartService();
120         reply.WriteInt32(ret);
121         PRINT_HILOGI("nativePrint PrintServiceStub::OnStartService out:%{public}d", ret);
122     }
123     return ret == E_PRINT_NONE;
124 }
125 
OnStartPrint(MessageParcel & data,MessageParcel & reply)126 bool PrintServiceStub::OnStartPrint(MessageParcel &data, MessageParcel &reply)
127 {
128     PRINT_HILOGI("PrintServiceStub::OnStartPrint in");
129     std::vector<std::string> fileList;
130     std::vector<uint32_t> fdList;
131 
132     if (data.ReadBool()) {
133         data.ReadStringVector(&fileList);
134         PRINT_HILOGD("Current file is %{public}zd", fileList.size());
135         if (fileList.size() > PRINT_MAX_PRINT_COUNT) {
136             PRINT_HILOGE("fileList'size is out of range.");
137             reply.WriteInt32(E_PRINT_INVALID_PARAMETER);
138             return false;
139         }
140     }
141 
142     if (data.ReadBool()) {
143         int32_t len = data.ReadInt32();
144         if (len > PRINT_MAX_PRINT_COUNT) {
145             PRINT_HILOGE("len is out of range.");
146             reply.WriteInt32(E_PRINT_INVALID_PARAMETER);
147             return false;
148         }
149         for (int32_t index = 0; index < len; index++) {
150             uint32_t fd = static_cast<uint32_t>(data.ReadFileDescriptor());
151             PRINT_HILOGD("fdList[%{public}d] = %{public}d", index, fd);
152             fdList.emplace_back(fd);
153         }
154     }
155     std::string taskId = data.ReadString();
156     int32_t ret = StartPrint(fileList, fdList, taskId);
157     reply.WriteInt32(ret);
158     PRINT_HILOGD("PrintServiceStub::OnStartPrint out");
159     return ret == E_PRINT_NONE;
160 }
161 
OnStopPrint(MessageParcel & data,MessageParcel & reply)162 bool PrintServiceStub::OnStopPrint(MessageParcel &data, MessageParcel &reply)
163 {
164     PRINT_HILOGI("PrintServiceStub::OnStopPrint in");
165     std::string taskId = data.ReadString();
166     int32_t ret = StopPrint(taskId);
167     reply.WriteInt32(ret);
168     PRINT_HILOGD("PrintServiceStub::OnStopPrint out");
169     return ret == E_PRINT_NONE;
170 }
171 
OnConnectPrinter(MessageParcel & data,MessageParcel & reply)172 bool PrintServiceStub::OnConnectPrinter(MessageParcel &data, MessageParcel &reply)
173 {
174     PRINT_HILOGI("PrintServiceStub::OnConnectPrinter in");
175     int32_t ret = ConnectPrinter(data.ReadString());
176     reply.WriteInt32(ret);
177     PRINT_HILOGD("PrintServiceStub::OnConnectPrinter out");
178     return ret == E_PRINT_NONE;
179 }
180 
OnDisconnectPrinter(MessageParcel & data,MessageParcel & reply)181 bool PrintServiceStub::OnDisconnectPrinter(MessageParcel &data, MessageParcel &reply)
182 {
183     PRINT_HILOGI("PrintServiceStub::OnDisconnectPrinter in");
184     int32_t ret = DisconnectPrinter(data.ReadString());
185     reply.WriteInt32(ret);
186     PRINT_HILOGD("PrintServiceStub::OnDisconnectPrinter out");
187     return ret == E_PRINT_NONE;
188 }
189 
OnStartDiscoverPrinter(MessageParcel & data,MessageParcel & reply)190 bool PrintServiceStub::OnStartDiscoverPrinter(MessageParcel &data, MessageParcel &reply)
191 {
192     PRINT_HILOGI("PrintServiceStub::OnStartDiscoverPrinter in");
193     std::vector<std::string> extensionList;
194     data.ReadStringVector(&extensionList);
195     int32_t ret = StartDiscoverPrinter(extensionList);
196     reply.WriteInt32(ret);
197     PRINT_HILOGD("PrintServiceStub::OnStartDiscoverPrinter out");
198     return ret == E_PRINT_NONE;
199 }
200 
OnStopDiscoverPrint(MessageParcel & data,MessageParcel & reply)201 bool PrintServiceStub::OnStopDiscoverPrint(MessageParcel &data, MessageParcel &reply)
202 {
203     PRINT_HILOGI("PrintServiceStub::OnStopDiscoverPrint in");
204     int32_t ret = StopDiscoverPrinter();
205     reply.WriteInt32(ret);
206     PRINT_HILOGD("PrintServiceStub::OnStopDiscoverPrint out");
207     return ret == E_PRINT_NONE;
208 }
209 
OnQueryAllExtension(MessageParcel & data,MessageParcel & reply)210 bool PrintServiceStub::OnQueryAllExtension(MessageParcel &data, MessageParcel &reply)
211 {
212     PRINT_HILOGI("PrintServiceStub::OnQueryAllExtension in");
213     std::vector<PrintExtensionInfo> printerInfo;
214     int32_t ret = QueryAllExtension(printerInfo);
215     reply.WriteInt32(ret);
216     if (ret == E_PRINT_NONE) {
217         uint32_t size = static_cast<uint32_t>(printerInfo.size());
218         reply.WriteUint32(size);
219         for (uint32_t index = 0; index < size; index++) {
220             printerInfo[index].Marshalling(reply);
221         }
222     }
223     PRINT_HILOGD("PrintServiceStub::OnQueryAllExtension out");
224     return ret == E_PRINT_NONE;
225 }
226 
OnStartPrintJob(MessageParcel & data,MessageParcel & reply)227 bool PrintServiceStub::OnStartPrintJob(MessageParcel &data, MessageParcel &reply)
228 {
229     PRINT_HILOGI("PrintServiceStub::OnStartPrintJob in");
230     int32_t ret = E_PRINT_RPC_FAILURE;
231     auto jobInfoPtr = PrintJob::Unmarshalling(data);
232     if (jobInfoPtr != nullptr) {
233         jobInfoPtr->Dump();
234         ret = StartPrintJob(*jobInfoPtr);
235     }
236     reply.WriteInt32(ret);
237     PRINT_HILOGD("PrintServiceStub::OnStartPrintJob out");
238     return ret == E_PRINT_NONE;
239 }
240 
OnCancelPrintJob(MessageParcel & data,MessageParcel & reply)241 bool PrintServiceStub::OnCancelPrintJob(MessageParcel &data, MessageParcel &reply)
242 {
243     PRINT_HILOGI("PrintServiceStub::OnCancelPrintJob in");
244     int32_t ret = CancelPrintJob(data.ReadString());
245     reply.WriteInt32(ret);
246     PRINT_HILOGD("PrintServiceStub::OnStartPrintJob out");
247     return ret == E_PRINT_NONE;
248 }
249 
OnAddPrinters(MessageParcel & data,MessageParcel & reply)250 bool PrintServiceStub::OnAddPrinters(MessageParcel &data, MessageParcel &reply)
251 {
252     PRINT_HILOGI("PrintServiceStub::OnAddPrinters in");
253     std::vector<PrinterInfo> printerInfos;
254     uint32_t len = 0;
255     if (!data.ReadUint32(len)) {
256         PRINT_HILOGE("read data len failed.");
257         return false;
258     }
259     PRINT_HILOGD("OnStartDiscoverPrinter len = %{public}d", len);
260 
261     if (len > PRINT_MAX_PRINT_COUNT) {
262         PRINT_HILOGE("len is out of range.");
263         reply.WriteInt32(E_PRINT_INVALID_PARAMETER);
264         return false;
265     }
266     for (uint32_t i = 0; i < len; i++) {
267         auto infoPtr = PrinterInfo::Unmarshalling(data);
268         if (infoPtr == nullptr) {
269             PRINT_HILOGW("invalid printer object");
270             continue;
271         }
272         infoPtr->Dump();
273         printerInfos.emplace_back(*infoPtr);
274     }
275     int32_t ret = E_PRINT_RPC_FAILURE;
276     if (printerInfos.size() > 0) {
277         ret = AddPrinters(printerInfos);
278     }
279     reply.WriteInt32(ret);
280     PRINT_HILOGD("PrintServiceStub::OnAddPrinters out");
281     return ret == E_PRINT_NONE;
282 }
283 
OnQueryPrinterInfoByPrinterId(MessageParcel & data,MessageParcel & reply)284 bool PrintServiceStub::OnQueryPrinterInfoByPrinterId(MessageParcel &data, MessageParcel &reply)
285 {
286     PRINT_HILOGI("PrintServiceStub::OnQueryPrinterInfoByPrinterId in");
287     std::string printerId = data.ReadString();
288     PrinterInfo info;
289     int32_t ret = QueryPrinterInfoByPrinterId(printerId, info);
290     reply.WriteInt32(ret);
291     PRINT_HILOGI("PrintServiceStub::OnQueryPrinterInfoByPrinterId out %{public}s", info.GetPrinterName().c_str());
292     info.Marshalling(reply);
293     PRINT_HILOGI("PrintServiceStub::OnQueryPrinterInfoByPrinterId out");
294     return ret == E_PRINT_NONE;
295 }
296 
OnGetPrinterPreference(MessageParcel & data,MessageParcel & reply)297 bool PrintServiceStub::OnGetPrinterPreference(MessageParcel &data, MessageParcel &reply)
298 {
299     PRINT_HILOGI("PrintServiceStub::OnGetPrinterPreference in");
300     std::string printerId = data.ReadString();
301     std::string printPreference;
302     int32_t ret = GetPrinterPreference(printerId, printPreference);
303     reply.WriteInt32(ret);
304     reply.WriteString(printPreference);
305     return ret == E_PRINT_NONE;
306 }
307 
OnSetPrinterPreference(MessageParcel & data,MessageParcel & reply)308 bool PrintServiceStub::OnSetPrinterPreference(MessageParcel &data, MessageParcel &reply)
309 {
310     PRINT_HILOGI("PrintServiceStub::OnSetPrinterPreference in");
311     std::string printerId = data.ReadString();
312     std::string printPreference = data.ReadString();
313     int32_t ret = SetPrinterPreference(printerId, printPreference);
314     reply.WriteInt32(ret);
315     return ret == E_PRINT_NONE;
316 }
317 
OnQueryAddedPrinter(MessageParcel & data,MessageParcel & reply)318 bool PrintServiceStub::OnQueryAddedPrinter(MessageParcel &data, MessageParcel &reply)
319 {
320     PRINT_HILOGI("PrintServiceStub::OnQueryAddedPrinter in");
321     std::vector<std::string> printerNameList;
322 
323     int32_t ret = QueryAddedPrinter(printerNameList);
324     reply.WriteInt32(ret);
325     reply.WriteStringVector(printerNameList);
326 
327     PRINT_HILOGI("PrintServiceStub::OnQueryAddedPrinter out");
328     return ret == E_PRINT_NONE;
329 }
330 
OnQueryPrinterProperties(MessageParcel & data,MessageParcel & reply)331 bool PrintServiceStub::OnQueryPrinterProperties(MessageParcel &data, MessageParcel &reply)
332 {
333     PRINT_HILOGI("PrintServiceStub::OnQueryAddedPrinter in");
334     std::string printerId = data.ReadString();
335     std::vector<std::string> keyList;
336     data.ReadStringVector(&keyList);
337     std::vector<std::string> valueList;
338     int32_t ret = QueryPrinterProperties(printerId, keyList, valueList);
339     reply.WriteInt32(ret);
340     reply.WriteStringVector(valueList);
341     PRINT_HILOGI("PrintServiceStub::OnQueryAddedPrinter out");
342     return ret == E_PRINT_NONE;
343 }
344 
OnStartNativePrintJob(MessageParcel & data,MessageParcel & reply)345 bool PrintServiceStub::OnStartNativePrintJob(MessageParcel &data, MessageParcel &reply)
346 {
347     PRINT_HILOGI("PrintServiceStub::OnStartNativePrintJob in");
348     int32_t ret = E_PRINT_RPC_FAILURE;
349     auto printJobPtr = PrintJob::Unmarshalling(data);
350     if (printJobPtr != nullptr) {
351         printJobPtr->Dump();
352         ret = StartNativePrintJob(*printJobPtr);
353     }
354     reply.WriteInt32(ret);
355     PRINT_HILOGD("PrintServiceStub::OnStartPrintJob out");
356     return ret == E_PRINT_NONE;
357 }
358 
OnRemovePrinters(MessageParcel & data,MessageParcel & reply)359 bool PrintServiceStub::OnRemovePrinters(MessageParcel &data, MessageParcel &reply)
360 {
361     PRINT_HILOGI("PrintServiceStub::OnRemovePrinters in");
362     std::vector<std::string> printerIds;
363     data.ReadStringVector(&printerIds);
364     PRINT_HILOGD("OnStartDiscoverPrinter len = %{public}zd", printerIds.size());
365 
366     if (printerIds.size() > PRINT_MAX_PRINT_COUNT) {
367         PRINT_HILOGE("printerIds'size is out of range.");
368         reply.WriteInt32(E_PRINT_INVALID_PARAMETER);
369         return false;
370     }
371     int32_t ret = RemovePrinters(printerIds);
372     reply.WriteInt32(ret);
373 
374     PRINT_HILOGD("PrintServiceStub::OnRemovePrinters out");
375     return ret == E_PRINT_NONE;
376 }
377 
OnUpdatePrinters(MessageParcel & data,MessageParcel & reply)378 bool PrintServiceStub::OnUpdatePrinters(MessageParcel &data, MessageParcel &reply)
379 {
380     PRINT_HILOGI("PrintServiceStub::OnUpdatePrinters in");
381     std::vector<PrinterInfo> printerInfos;
382     uint32_t len = 0;
383     if (!data.ReadUint32(len)) {
384         PRINT_HILOGE("read data len failed.");
385         return false;
386     }
387     PRINT_HILOGD("OnUpdatePrinters len = %{public}d", len);
388 
389     if (len > PRINT_MAX_PRINT_COUNT) {
390         PRINT_HILOGE("len is out of range.");
391         reply.WriteInt32(E_PRINT_INVALID_PARAMETER);
392         return false;
393     }
394     for (uint32_t i = 0; i < len; i++) {
395         auto infoPtr = PrinterInfo::Unmarshalling(data);
396         if (infoPtr == nullptr) {
397             PRINT_HILOGW("invalid printer object");
398             continue;
399         }
400         infoPtr->Dump();
401         printerInfos.emplace_back(*infoPtr);
402     }
403     int32_t ret = E_PRINT_RPC_FAILURE;
404     if (printerInfos.size() > 0) {
405         ret = UpdatePrinters(printerInfos);
406     }
407     reply.WriteInt32(ret);
408     PRINT_HILOGD("PrintServiceStub::OnUpdatePrinters out");
409     return ret == E_PRINT_NONE;
410 }
411 
OnUpdatePrinterState(MessageParcel & data,MessageParcel & reply)412 bool PrintServiceStub::OnUpdatePrinterState(MessageParcel &data, MessageParcel &reply)
413 {
414     PRINT_HILOGI("PrintServiceStub::OnUpdatePrinterState in");
415     std::string printerId = data.ReadString();
416     uint32_t state = data.ReadUint32();
417     int32_t ret = UpdatePrinterState(printerId, state);
418     reply.WriteInt32(ret);
419     PRINT_HILOGD("PrintServiceStub::OnUpdatePrinterState out");
420     return ret == E_PRINT_NONE;
421 }
422 
OnUpdatePrintJobStateForNormalApp(MessageParcel & data,MessageParcel & reply)423 bool PrintServiceStub::OnUpdatePrintJobStateForNormalApp(MessageParcel &data, MessageParcel &reply)
424 {
425     PRINT_HILOGI("PrintServiceStub::OnUpdatePrintJobStateForNormalApp in");
426     std::string jobId = data.ReadString();
427     uint32_t state = data.ReadUint32();
428     uint32_t subState = data.ReadUint32();
429     PRINT_HILOGD("jobId = %{public}s; state = %{public}d; subState = %{public}d",
430         jobId.c_str(), state, subState);
431     int32_t ret = UpdatePrintJobStateForNormalApp(jobId, state, subState);
432     reply.WriteInt32(ret);
433     PRINT_HILOGD("PrintServiceStub::OnUpdatePrintJobStateForNormalApp out");
434     return ret == E_PRINT_NONE;
435 }
436 
OnUpdatePrintJobStateOnlyForSystemApp(MessageParcel & data,MessageParcel & reply)437 bool PrintServiceStub::OnUpdatePrintJobStateOnlyForSystemApp(MessageParcel &data, MessageParcel &reply)
438 {
439     PRINT_HILOGI("PrintServiceStub::OnUpdatePrintJobStateOnlyForSystemApp in");
440     std::string jobId = data.ReadString();
441     uint32_t state = data.ReadUint32();
442     uint32_t subState = data.ReadUint32();
443     PRINT_HILOGD("OnUpdatePrintJobStateOnlyForSystemApp jobId = %{public}s", jobId.c_str());
444     PRINT_HILOGD("OnUpdatePrintJobStateOnlyForSystemApp state = %{public}d", state);
445     PRINT_HILOGD("OnUpdatePrintJobStateOnlyForSystemApp subState = %{public}d", subState);
446 
447     int32_t ret = UpdatePrintJobStateOnlyForSystemApp(jobId, state, subState);
448     reply.WriteInt32(ret);
449     PRINT_HILOGD("PrintServiceStub::OnUpdatePrintJobStateOnlyForSystemApp out");
450     return ret == E_PRINT_NONE;
451 }
452 
OnUpdateExtensionInfo(MessageParcel & data,MessageParcel & reply)453 bool PrintServiceStub::OnUpdateExtensionInfo(MessageParcel &data, MessageParcel &reply)
454 {
455     PRINT_HILOGI("PrintServiceStub::OnUpdateExtensionInfo in");
456     std::string extInfo = data.ReadString();
457     PRINT_HILOGD("OnUpdateExtensionInfo extInfo = %{public}s", extInfo.c_str());
458 
459     int32_t ret = UpdateExtensionInfo(extInfo);
460     reply.WriteInt32(ret);
461     PRINT_HILOGD("PrintServiceStub::OnUpdateExtensionInfo out");
462     return ret == E_PRINT_NONE;
463 }
464 
OnRequestPreview(MessageParcel & data,MessageParcel & reply)465 bool PrintServiceStub::OnRequestPreview(MessageParcel &data, MessageParcel &reply)
466 {
467     PRINT_HILOGI("PrintServiceStub::OnRequestPreview in");
468     int32_t ret = E_PRINT_RPC_FAILURE;
469     std::string previewResult = "";
470     auto jobInfoPtr = PrintJob::Unmarshalling(data);
471     if (jobInfoPtr != nullptr) {
472         jobInfoPtr->Dump();
473         ret = RequestPreview(*jobInfoPtr, previewResult);
474     }
475     reply.WriteInt32(ret);
476     reply.WriteString(previewResult);
477     PRINT_HILOGD("PrintServiceStub::OnRequestPreview out");
478     return ret == E_PRINT_NONE;
479 }
480 
OnQueryPrinterCapability(MessageParcel & data,MessageParcel & reply)481 bool PrintServiceStub::OnQueryPrinterCapability(MessageParcel &data, MessageParcel &reply)
482 {
483     PRINT_HILOGI("PrintServiceStub::OnQueryPrinterCapability in");
484     std::string printerId = data.ReadString();
485     PRINT_HILOGD("printerId : %{private}s", printerId.c_str());
486     int32_t ret = QueryPrinterCapability(printerId);
487     reply.WriteInt32(ret);
488     PRINT_HILOGD("PrintServiceStub::OnQueryPrinterCapability out");
489     return ret == E_PRINT_NONE;
490 }
491 
OnQueryAllPrintJob(MessageParcel & data,MessageParcel & reply)492 bool PrintServiceStub::OnQueryAllPrintJob(MessageParcel &data, MessageParcel &reply)
493 {
494     PRINT_HILOGI("PrintServiceStub::OnQueryAllPrintJob in");
495     std::vector<PrintJob> printJob;
496     printJob.clear();
497     int32_t ret = QueryAllPrintJob(printJob);
498     reply.WriteInt32(ret);
499     if (ret == E_PRINT_NONE) {
500         uint32_t size = static_cast<uint32_t>(printJob.size());
501         reply.WriteUint32(size);
502         for (uint32_t index = 0; index < size; index++) {
503             printJob[index].Marshalling(reply);
504         }
505     }
506     PRINT_HILOGD("PrintServiceStub::OnQueryAllPrintJob out");
507     return ret == E_PRINT_NONE;
508 }
509 
OnQueryPrintJobById(MessageParcel & data,MessageParcel & reply)510 bool PrintServiceStub::OnQueryPrintJobById(MessageParcel &data, MessageParcel &reply)
511 {
512     PRINT_HILOGI("PrintServiceStub::OnQueryPrintJobById in");
513     PrintJob printJob;
514     std::string printJobId = data.ReadString();
515     int32_t ret = QueryPrintJobById(printJobId, printJob);
516     reply.WriteInt32(ret);
517     printJob.Marshalling(reply);
518     PRINT_HILOGD("PrintServiceStub::OnQueryPrintJobById out");
519     return ret == E_PRINT_NONE;
520 }
521 
OnAddPrinterToCups(MessageParcel & data,MessageParcel & reply)522 bool PrintServiceStub::OnAddPrinterToCups(MessageParcel &data, MessageParcel &reply)
523 {
524     PRINT_HILOGI("PrintServiceStub::OnAddPrinterToCups in");
525     std::string printerUri = data.ReadString();
526     std::string printerName = data.ReadString();
527     std::string printerMake = data.ReadString();
528     int32_t ret = AddPrinterToCups(printerUri, printerName, printerMake);
529     reply.WriteInt32(ret);
530     PRINT_HILOGD("PrintServiceStub::OnAddPrinterToCups out");
531     return ret == E_PRINT_NONE;
532 }
533 
OnQueryPrinterCapabilityByUri(MessageParcel & data,MessageParcel & reply)534 bool PrintServiceStub::OnQueryPrinterCapabilityByUri(MessageParcel &data, MessageParcel &reply)
535 {
536     PRINT_HILOGI("PrintServiceStub::OnQueryPrinterCapabilityByUri in");
537     PrinterCapability printerCaps;
538     std::string printerUri = data.ReadString();
539     std::string printerId = data.ReadString();
540     int32_t ret = QueryPrinterCapabilityByUri(printerUri, printerId, printerCaps);
541     reply.WriteInt32(ret);
542     printerCaps.Marshalling(reply);
543     PRINT_HILOGD("PrintServiceStub::OnQueryPrinterCapabilityByUri out");
544     return ret == E_PRINT_NONE;
545 }
546 
OnNotifyPrintServiceEvent(MessageParcel & data,MessageParcel & reply)547 bool PrintServiceStub::OnNotifyPrintServiceEvent(MessageParcel &data, MessageParcel &reply)
548 {
549     PRINT_HILOGI("PrintServiceStub::OnNotifyPrintServiceEvent in");
550     std::string jobId = data.ReadString();
551     uint32_t event = data.ReadUint32();
552     PRINT_HILOGD("OnNotifyPrintServiceEvent jobId = %{public}s, event = %{public}d", jobId.c_str(), event);
553     int32_t ret = NotifyPrintServiceEvent(jobId, event);
554     reply.WriteInt32(ret);
555     PRINT_HILOGD("PrintServiceStub::OnNotifyPrintServiceEvent out");
556     return ret == E_PRINT_NONE;
557 }
558 
OnSetDefaultPrinter(MessageParcel & data,MessageParcel & reply)559 bool PrintServiceStub::OnSetDefaultPrinter(MessageParcel &data, MessageParcel &reply)
560 {
561     PRINT_HILOGI("PrintServiceStub::OnSetDefaultPrinter in");
562     std::string printerId = data.ReadString();
563     uint32_t type = data.ReadUint32();
564     int32_t ret = SetDefaultPrinter(printerId, type);
565     reply.WriteInt32(ret);
566     PRINT_HILOGD("PrintServiceStub::OnSetDefaultPrinter out");
567     return ret == E_PRINT_NONE;
568 }
569 
OnDeletePrinterFromCups(MessageParcel & data,MessageParcel & reply)570 bool PrintServiceStub::OnDeletePrinterFromCups(MessageParcel &data, MessageParcel &reply)
571 {
572     PRINT_HILOGI("PrintServiceStub::OnDeletePrinterFromCups in");
573     std::string printerName = data.ReadString();
574     int32_t ret = DeletePrinterFromCups(printerName);
575     reply.WriteInt32(ret);
576     PRINT_HILOGD("PrintServiceStub::OnDeletePrinterFromCups out");
577     return ret == E_PRINT_NONE;
578 }
579 
OnDiscoverUsbPrinters(MessageParcel & data,MessageParcel & reply)580 bool PrintServiceStub::OnDiscoverUsbPrinters(MessageParcel &data, MessageParcel &reply)
581 {
582     PRINT_HILOGI("PrintServiceStub::OnDiscoverUsbPrinters in");
583     std::vector<PrinterInfo> printers;
584     int32_t ret = DiscoverUsbPrinters(printers);
585     reply.WriteInt32(ret);
586     if (ret == E_PRINT_NONE) {
587         uint32_t size = static_cast<uint32_t>(printers.size());
588         reply.WriteUint32(size);
589         for (uint32_t index = 0; index < size; index++) {
590             printers[index].Marshalling(reply);
591         }
592     }
593     PRINT_HILOGD("PrintServiceStub::OnDiscoverUsbPrinters out");
594     return ret == E_PRINT_NONE;
595 }
596 
OnEventOn(MessageParcel & data,MessageParcel & reply)597 bool PrintServiceStub::OnEventOn(MessageParcel &data, MessageParcel &reply)
598 {
599     std::string taskId = data.ReadString();
600     std::string type = data.ReadString();
601     PRINT_HILOGI("PrintServiceStub::OnEventOn type=%{public}s ", type.c_str());
602     if (type.empty()) {
603         PRINT_HILOGE("PrintServiceStub::OnEventOn type is null.");
604         reply.WriteInt32(E_PRINT_RPC_FAILURE);
605         return false;
606     }
607     sptr<IRemoteObject> remote = data.ReadRemoteObject();
608     if (remote == nullptr) {
609         PRINT_HILOGE("PrintServiceStub::OnEventOn remote is nullptr");
610         reply.WriteInt32(E_PRINT_RPC_FAILURE);
611         return false;
612     }
613     sptr<IPrintCallback> listener = iface_cast<IPrintCallback>(remote);
614     if (listener.GetRefPtr() == nullptr) {
615         PRINT_HILOGE("PrintServiceStub::OnEventOn listener is null");
616         reply.WriteInt32(E_PRINT_RPC_FAILURE);
617         return false;
618     }
619     int32_t ret = On(taskId, type, listener);
620     reply.WriteInt32(ret);
621     PRINT_HILOGD("PrintServiceStub::OnEventOn out");
622     return ret == E_PRINT_NONE;
623 }
624 
OnEventOff(MessageParcel & data,MessageParcel & reply)625 bool PrintServiceStub::OnEventOff(MessageParcel &data, MessageParcel &reply)
626 {
627     PRINT_HILOGD("PrintServiceStub::OnEventOff in");
628     std::string taskId = data.ReadString();
629     std::string type = data.ReadString();
630     PRINT_HILOGI("PrintServiceStub::OnEventOff type=%{public}s ", type.c_str());
631     int32_t ret = Off(taskId, type);
632     reply.WriteInt32(ret);
633     PRINT_HILOGD("PrintServiceStub::OnEventOff out");
634     return ret == E_PRINT_NONE;
635 }
636 
OnRegisterPrinterCallback(MessageParcel & data,MessageParcel & reply)637 bool PrintServiceStub::OnRegisterPrinterCallback(MessageParcel &data, MessageParcel &reply)
638 {
639     std::string type = data.ReadString();
640     if (type.empty()) {
641         PRINT_HILOGE("PrintServiceStub::OnEventOn type is null.");
642         reply.WriteInt32(E_PRINT_RPC_FAILURE);
643         return false;
644     }
645     PRINT_HILOGI("PrintServiceStub::OnRegisterPrinterCallback type=%{public}s ", type.c_str());
646     sptr<IRemoteObject> remote = data.ReadRemoteObject();
647     if (remote == nullptr) {
648         PRINT_HILOGE("PrintServiceStub::OnEventOn remote is nullptr");
649         reply.WriteInt32(E_PRINT_RPC_FAILURE);
650         return false;
651     }
652     sptr<IPrintCallback> listener = iface_cast<IPrintCallback>(remote);
653     if (listener.GetRefPtr() == nullptr) {
654         PRINT_HILOGE("PrintServiceStub::OnEventOn listener is null");
655         reply.WriteInt32(E_PRINT_RPC_FAILURE);
656         return false;
657     }
658     int32_t ret = RegisterPrinterCallback(type, listener);
659     reply.WriteInt32(ret);
660     PRINT_HILOGD("PrintServiceStub::OnRegisterPrinterCallback out");
661     return ret == E_PRINT_NONE;
662 }
663 
OnUnregisterPrinterCallback(MessageParcel & data,MessageParcel & reply)664 bool PrintServiceStub::OnUnregisterPrinterCallback(MessageParcel &data, MessageParcel &reply)
665 {
666     std::string type = data.ReadString();
667     if (type.empty()) {
668         reply.WriteInt32(E_PRINT_RPC_FAILURE);
669         return false;
670     }
671     PRINT_HILOGI("PrintServiceStub::OnUnregisterPrinterCallback type=%{public}s ", type.c_str());
672     int32_t ret = UnregisterPrinterCallback(type);
673     reply.WriteInt32(ret);
674     PRINT_HILOGD("PrintServiceStub::OnUnregisterPrinterCallback out");
675     return ret == E_PRINT_NONE;
676 }
677 
OnRegisterExtCallback(MessageParcel & data,MessageParcel & reply)678 bool PrintServiceStub::OnRegisterExtCallback(MessageParcel &data, MessageParcel &reply)
679 {
680     PRINT_HILOGI("PrintServiceStub::OnRegisterExtCallback in");
681     std::string extensionCID = data.ReadString();
682     sptr<IRemoteObject> remote = data.ReadRemoteObject();
683     if (remote == nullptr) {
684         PRINT_HILOGD("PrintServiceStub::OnRegisterExtCallback remote is nullptr");
685         reply.WriteInt32(E_PRINT_RPC_FAILURE);
686         return false;
687     }
688     sptr<IPrintExtensionCallback> listener = iface_cast<IPrintExtensionCallback>(remote);
689     if (listener.GetRefPtr() == nullptr) {
690         PRINT_HILOGD("PrintServiceStub::OnRegisterExtCallback listener is null");
691         reply.WriteInt32(E_PRINT_RPC_FAILURE);
692         return false;
693     }
694 
695     int32_t ret = RegisterExtCallback(extensionCID, listener);
696     reply.WriteInt32(ret);
697     PRINT_HILOGD("PrintServiceStub::OnRegisterExtCallback out");
698     return ret == E_PRINT_NONE;
699 }
700 
OnUnregisterAllExtCallback(MessageParcel & data,MessageParcel & reply)701 bool PrintServiceStub::OnUnregisterAllExtCallback(MessageParcel &data, MessageParcel &reply)
702 {
703     PRINT_HILOGI("PrintServiceStub::OnUnregisterAllExtCallback in");
704     std::string extensionId = data.ReadString();
705     int32_t ret = UnregisterAllExtCallback(extensionId);
706     reply.WriteInt32(ret);
707     PRINT_HILOGD("PrintServiceStub::OnUnregisterAllExtCallback out");
708     return ret == E_PRINT_NONE;
709 }
710 
OnLoadExtSuccess(MessageParcel & data,MessageParcel & reply)711 bool PrintServiceStub::OnLoadExtSuccess(MessageParcel &data, MessageParcel &reply)
712 {
713     PRINT_HILOGI("PrintServiceStub::OnLoadExtSuccess in");
714     std::string extensionId = data.ReadString();
715     int32_t ret = LoadExtSuccess(extensionId);
716     reply.WriteInt32(ret);
717     PRINT_HILOGD("PrintServiceStub::OnLoadExtSuccess out");
718     return ret == E_PRINT_NONE;
719 }
720 
OnPrintByAdapter(MessageParcel & data,MessageParcel & reply)721 bool PrintServiceStub::OnPrintByAdapter(MessageParcel &data, MessageParcel &reply)
722 {
723     PRINT_HILOGI("PrintServiceStub::OnPrintByAdapter in");
724     int32_t ret = E_PRINT_RPC_FAILURE;
725     std::string jobName = data.ReadString();
726     auto attrs = PrintAttributes::Unmarshalling(data);
727     std::string taskId = data.ReadString();
728     if (attrs != nullptr) {
729         attrs->Dump();
730         ret = PrintByAdapter(jobName, *attrs, taskId);
731     }
732     reply.WriteInt32(ret);
733     PRINT_HILOGI("PrintServiceStub::OnPrintByAdapter out");
734     return ret == E_PRINT_NONE;
735 }
736 
OnStartGetPrintFile(MessageParcel & data,MessageParcel & reply)737 bool PrintServiceStub::OnStartGetPrintFile(MessageParcel &data, MessageParcel &reply)
738 {
739     PRINT_HILOGI("PrintServiceStub::OnStartGetPrintFile in");
740     int32_t ret = E_PRINT_RPC_FAILURE;
741     std::string jobId = data.ReadString();
742     auto attrs = PrintAttributes::Unmarshalling(data);
743     uint32_t fd = static_cast<uint32_t>(data.ReadFileDescriptor());
744     if (attrs != nullptr) {
745         ret = StartGetPrintFile(jobId, *attrs, fd);
746     }
747     reply.WriteInt32(ret);
748     PRINT_HILOGI("PrintServiceStub::OnStartGetPrintFile out");
749     return ret == E_PRINT_NONE;
750 }
751 
OnNotifyPrintService(MessageParcel & data,MessageParcel & reply)752 bool PrintServiceStub::OnNotifyPrintService(MessageParcel &data, MessageParcel &reply)
753 {
754     PRINT_HILOGI("PrintServiceStub::OnNotifyPrintService in");
755     std::string jobId = data.ReadString();
756     std::string type = data.ReadString();
757     PRINT_HILOGD(
758         "PrintServiceStub::OnNotifyPrintService jobId=%{public}s type=%{public}s ", jobId.c_str(), type.c_str());
759     int32_t ret = NotifyPrintService(jobId, type);
760     reply.WriteInt32(ret);
761     PRINT_HILOGD("PrintServiceStub::OnNotifyPrintService out");
762     return ret == E_PRINT_NONE;
763 }
764 
765 
OnAddPrinterToDiscovery(MessageParcel & data,MessageParcel & reply)766 bool PrintServiceStub::OnAddPrinterToDiscovery(MessageParcel &data, MessageParcel &reply)
767 {
768     PRINT_HILOGI("PrintServiceStub::OnAddPrinterToDiscovery in");
769     auto infoPtr = PrinterInfo::Unmarshalling(data);
770     if (infoPtr == nullptr) {
771         PRINT_HILOGW("invalid printer object");
772         reply.WriteInt32(E_PRINT_RPC_FAILURE);
773         PRINT_HILOGD("PrintServiceStub::OnAddPrinterToDiscovery out with failure");
774         return false;
775     }
776     infoPtr->Dump();
777     int32_t ret = AddPrinterToDiscovery(*infoPtr);
778     reply.WriteInt32(ret);
779     PRINT_HILOGD("PrintServiceStub::OnAddPrinterToDiscovery out with ret = %{public}d", ret);
780     return ret == E_PRINT_NONE;
781 }
782 
OnUpdatePrinterInDiscovery(MessageParcel & data,MessageParcel & reply)783 bool PrintServiceStub::OnUpdatePrinterInDiscovery(MessageParcel &data, MessageParcel &reply)
784 {
785     PRINT_HILOGI("PrintServiceStub::OnUpdatePrinterInDiscovery in");
786 
787     auto infoPtr = PrinterInfo::Unmarshalling(data);
788     if (infoPtr == nullptr) {
789         PRINT_HILOGE("Failed to unmarshall printer info");
790         reply.WriteInt32(E_PRINT_RPC_FAILURE);
791         return false;
792     }
793 
794     infoPtr->Dump();
795     int32_t ret = UpdatePrinterInDiscovery(*infoPtr);
796     reply.WriteInt32(ret);
797 
798     PRINT_HILOGD("PrintServiceStub::OnUpdatePrinterInDiscovery out");
799     return ret == E_PRINT_NONE;
800 }
801 
OnRemovePrinterFromDiscovery(MessageParcel & data,MessageParcel & reply)802 bool PrintServiceStub::OnRemovePrinterFromDiscovery(MessageParcel &data, MessageParcel &reply)
803 {
804     PRINT_HILOGI("PrintServiceStub::OnRemovePrinterFromDiscovery in");
805 
806     std::string printerId = data.ReadString();
807 
808     int32_t ret = RemovePrinterFromDiscovery(printerId);
809     reply.WriteInt32(ret);
810 
811     PRINT_HILOGD("PrintServiceStub::OnRemovePrinterFromDiscovery out");
812     return ret == E_PRINT_NONE;
813 }
814 
OnUpdatePrinterInSystem(MessageParcel & data,MessageParcel & reply)815 bool PrintServiceStub::OnUpdatePrinterInSystem(MessageParcel &data, MessageParcel &reply)
816 {
817     PRINT_HILOGI("PrintServiceStub::OnUpdatePrinterInSystem in");
818 
819     auto infoPtr = PrinterInfo::Unmarshalling(data);
820     if (infoPtr == nullptr) {
821         PRINT_HILOGE("Failed to unmarshall printer info");
822         reply.WriteInt32(E_PRINT_RPC_FAILURE);
823         return false;
824     }
825 
826     infoPtr->Dump();
827     int32_t ret = UpdatePrinterInSystem(*infoPtr);
828     reply.WriteInt32(ret);
829 
830     PRINT_HILOGD("PrintServiceStub::OnUpdatePrinterInSystem out");
831     return ret == E_PRINT_NONE;
832 }
833 
834 } // namespace OHOS::Print
835