1 /* 2 * Copyright (c) 2023 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 #ifndef PRINT_CUPS_CLIENT_H 17 #define PRINT_CUPS_CLIENT_H 18 19 #include <vector> 20 #include <string> 21 #include <functional> 22 #include <json/json.h> 23 24 #include "singleton.h" 25 #include "print_cups_wrapper.h" 26 #include "print_service_ability.h" 27 #include "print_job.h" 28 29 namespace OHOS::Print { 30 typedef std::function<void()> CallbackFunc; 31 32 struct JobParameters { 33 uint32_t cupsJobId; 34 uint32_t borderless; 35 uint32_t numCopies; 36 bool isAutoRotate; 37 bool isLandscape; 38 std::string duplex; 39 std::string printQuality; 40 std::string jobName; 41 std::string jobOriginatingUserName; 42 std::string printerId; 43 std::string printerName; 44 std::string printerUri; 45 std::string documentFormat; 46 std::string mediaSize; 47 std::string mediaType; 48 std::string color; 49 std::string serviceJobId; 50 std::vector<uint32_t> fdList; 51 PrintServiceAbility *serviceAbility; 52 std::string printerAttrsOption_cupsOption; 53 }; 54 55 enum StatePolicy { 56 STATE_POLICY_STANDARD = 0, 57 STATE_POLICY_BLOCK = 1, 58 STATE_POLICY_HINT = 2, 59 STATE_POLICY_DELAY = 3, 60 }; 61 struct JobStatus { 62 char printer_state_reasons[1024]; 63 ipp_jstate_t job_state; 64 char job_state_reasons[1024]; 65 }; 66 struct JobMonitorParam { 67 PrintServiceAbility *serviceAbility = nullptr; 68 std::string serviceJobId; 69 int cupsJobId = 0; 70 std::string printerUri; 71 std::string printerName; 72 std::string printerId; 73 http_t *http = nullptr; 74 75 StatePolicy policyArray[16] = {}; 76 ipp_jstate_t job_state = IPP_JOB_PENDING; 77 char job_state_reasons[1024] = {}; 78 char job_printer_state_reasons[1024] = {}; 79 bool isFirstQueryState = true; 80 int32_t timesOfSameState = -1; 81 bool isBlock = false; 82 uint32_t substate = 0; 83 bool isPrinterStopped = false; 84 bool isCanceled = false; 85 JobMonitorParamJobMonitorParam86 JobMonitorParam() {} JobMonitorParamJobMonitorParam87 JobMonitorParam(PrintServiceAbility *serviceAbility, std::string serviceJobId, int cupsJobId, 88 std::string printerUri, std::string printerName, std::string printerId, http_t *http) 89 : serviceAbility(serviceAbility), serviceJobId(serviceJobId), cupsJobId(cupsJobId), 90 printerUri(printerUri), printerName(printerName), printerId(printerId), http(http) {} 91 ~JobMonitorParamJobMonitorParam92 ~JobMonitorParam() 93 { 94 if (http != nullptr) { httpClose(http); } 95 } 96 }; 97 struct MediaSize { 98 std::string name; 99 const float WidthInInches; 100 const float HeightInInches; 101 }; 102 103 std::string GetUsbPrinterSerial(const std::string &deviceUri); 104 std::vector<PrinterInfo> GetUsbPrinters(); 105 void ClearUsbPrinters(); 106 void DeviceCb(const char *deviceClass, const char *deviceId, const char *deviceInfo, 107 const char *deviceMakeAndModel, const char *deviceUri, const char *deviceLocation, void *userData); 108 109 class PrintCupsClient final : public DelayedSingleton<PrintCupsClient>, 110 public std::enable_shared_from_this<PrintCupsClient> { 111 public: 112 PrintCupsClient(); 113 ~PrintCupsClient(); 114 115 int32_t InitCupsResources(); 116 void StopCupsdService(); 117 bool IsCupsServerAlive(); 118 void QueryPPDInformation(const char *makeModel, std::vector<std::string> &ppds); 119 int32_t AddPrinterToCups(const std::string &printerUri, const std::string &printerName, 120 const std::string &printerMake); 121 int32_t AddPrinterToCupsWithSpecificPpd(const std::string &printerUri, const std::string &printerName, 122 const std::string &ppd); 123 int32_t AddPrinterToCupsWithPpd(const std::string &printerUri, const std::string &printerName, 124 const std::string &ppdName, const std::string &ppdData); 125 int32_t QueryPrinterCapabilityByUri(const std::string &printerUri, const std::string &printerId, 126 PrinterCapability &printerCaps); 127 int32_t QueryPrinterStatusByUri(const std::string &printerUri, PrinterStatus &status); 128 int32_t DeleteCupsPrinter(const char *printerName); 129 void AddCupsPrintJob(const PrintJob &jobInfo); 130 void CancelCupsJob(std::string serviceJobId); 131 132 int32_t QueryAddedPrinterList(std::vector<std::string> &printerName); 133 ppd_file_t* GetPPDFile(const std::string &printerName); 134 int32_t SetDefaultPrinter(const std::string &printerName); 135 136 int32_t QueryPrinterAttrList(const std::string &printerName, const std::vector<std::string> &keyList, 137 std::vector<std::string> &valueList); 138 int32_t QueryPrinterInfoByPrinterId(const std::string& printerId, PrinterInfo &info); 139 int32_t DiscoverUsbPrinters(std::vector<PrinterInfo> &printers); 140 int32_t QueryPrinterCapabilityFromPPD(const std::string &name, PrinterCapability &printerCaps); 141 bool CheckPrinterOnline(std::shared_ptr<JobMonitorParam> monitorParams, const uint32_t timeout = 3000); 142 143 private: 144 bool HandleFiles(JobParameters *jobParams, uint32_t num_files, http_t *http, uint32_t jobId); 145 void StartCupsJob(JobParameters *jobParams, CallbackFunc callback); 146 static void SymlinkFile(std::string &srcFilePath, std::string &destFilePath); 147 static void SymlinkDirectory(const char *srcDir, const char *destDir); 148 static void CopyDirectory(const char *srcDir, const char *destDir); 149 static bool ChangeFilterPermission(const std::string &path, mode_t mode); 150 bool CheckPrinterMakeModel(JobParameters *jobParams); 151 bool CheckPrinterDriverExist(const char *makeModel); 152 bool VerifyPrintJob(JobParameters *jobParams, int &num_options, uint32_t &jobId, 153 cups_option_t *options, http_t *http); 154 static int FillBorderlessOptions(JobParameters *jobParams, int num_options, cups_option_t **options); 155 static int FillLandscapeOptions(JobParameters *jobParams, int num_options, cups_option_t **options); 156 static int FillJobOptions(JobParameters *jobParams, int num_options, cups_option_t **options); 157 static float ConvertInchTo100MM(float num); 158 static void UpdatePrintJobStateInJobParams(JobParameters *jobParams, uint32_t state, uint32_t subState); 159 static std::string GetIpAddress(unsigned int number); 160 static bool IsIpConflict(const std::string &printerId, std::string &nic); 161 void StartMonitor(); 162 bool JobStatusCallback(std::shared_ptr<JobMonitorParam> monitorParams); 163 bool SpecialJobStatusCallback(std::shared_ptr<JobMonitorParam> monitorParams); 164 bool IsPrinterStopped(std::shared_ptr<JobMonitorParam> monitorParams); 165 bool GetBlockedAndUpdateSubstate(std::shared_ptr<JobMonitorParam> monitorParams, StatePolicy policy, 166 std::string substateString, PrintJobSubState jobSubstate); 167 uint32_t GetNewSubstate(uint32_t substate, PrintJobSubState singleSubstate); 168 bool QueryJobState(http_t *http, std::shared_ptr<JobMonitorParam> monitorParams); 169 bool UpdateJobState(std::shared_ptr<JobMonitorParam> monitorParams, ipp_t *response); 170 bool IfContinueToHandleJobState(std::shared_ptr<JobMonitorParam> monitorParams); 171 void BuildMonitorPolicy(std::shared_ptr<JobMonitorParam> monitorParams); 172 void ParseStateReasons(std::shared_ptr<JobMonitorParam> monitorParams); 173 174 int32_t StartCupsdServiceNotAlive(); 175 int32_t StartCupsdService(); 176 JobParameters *GetNextJob(); 177 void StartNextJob(); 178 void JobSentCallback(); 179 180 void UpdateBorderlessJobParameter(Json::Value& optionJson, JobParameters *params); 181 void UpdateJobParameterByOption(Json::Value& optionJson, JobParameters *params); 182 JobParameters* BuildJobParameters(const PrintJob &jobInfo); 183 std::string GetColorString(uint32_t colorCode); 184 std::string GetMedieSize(const PrintJob &jobInfo); 185 std::string GetDulpexString(uint32_t duplexCode); 186 void DumpJobParameters(JobParameters* jobParams); 187 bool IsPrinterExist(const char *printerUri, const char *printerName, const char *ppdName); 188 189 void ParsePPDInfo(ipp_t *response, const char *ppd_make_model, const char *ppd_name, 190 std::vector<std::string> &ppds); 191 ipp_t *QueryPrinterAttributesByUri(const std::string &printerUri, const std::string &nic, int num, 192 const char * const *pattrs); 193 bool ResumePrinter(const std::string &printerName); 194 bool CancelPrinterJob(int cupsJobId); 195 196 private: 197 bool toCups_ = true; 198 IPrintAbilityBase* printAbility_ = nullptr; 199 std::vector<JobParameters*> jobQueue_; 200 JobParameters *currentJob_ = nullptr; 201 std::vector<std::shared_ptr<JobMonitorParam>> jobMonitorList_; 202 std::mutex jobMonitorMutex_; 203 }; 204 } // namespace OHOS::Print 205 #endif // PRINT_CUPS_CLIENT_H