diff --git a/BUILD.gn b/BUILD.gn new file mode 100644 index 0000000..4d9425f --- /dev/null +++ b/BUILD.gn @@ -0,0 +1,25 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +################################################################################ +group("print_packages") { + if (is_standard_system) { + deps = [ + "etc/init:printservice.rc", + "profile:print_sa_profiles", + "services:print_service", + ] + } +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..4947287 --- /dev/null +++ b/LICENSE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS \ No newline at end of file diff --git a/OAT.xml b/OAT.xml new file mode 100644 index 0000000..c2bb8cb --- /dev/null +++ b/OAT.xml @@ -0,0 +1,67 @@ + + + + + + LICENSE + + + + + + + + + + \ No newline at end of file diff --git a/bundle.json b/bundle.json new file mode 100644 index 0000000..55ccacb --- /dev/null +++ b/bundle.json @@ -0,0 +1,58 @@ +{ + "name": "@ohos/print", + "description": "Provide printer management and print ability for 3rd party app", + "version": "3.1", + "license": "Apache License 2.0", + "publishAs": "code-segment", + "segment": { + "destPath": "base/print/print" + }, + "dirs": {}, + "scripts": {}, + "component": { + "name": "print", + "subsystem": "print", + "syscap": [ + "SystemCapability.MiscServices.Download" + ], + "features": [ + ], + "adapted_system_type": [ + "standard" + ], + "rom":"2MB", + "ram":"10MB", + "deps": { + "components": [ + "ability_manager", + "aafwk_standard", + "appexecfwk_standard", + "common_event_service", + "distributeddatamgr", + "hisysevent_native", + "hiviewdfx_hilog_native", + "ipc", + "safwk", + "samgr_standard", + "startup_l2", + "utils_base" + ], + "third_party": [ + ] + }, + "build": { + "sub_component": [ + "//base/print/print/interfaces/kits/napi:print", + "//base/print/print/frameworks/innerkitsimpl:printclient", + "//base/print/print/services:print_service", + "//base/print/print/etc/init:printservice.rc", + "//base/print/print/profile:print_sa_profiles" + ], + "test": [ + ] + }, + "hisysevent_config": [ + "//base/print/print/hisysevent.yaml" + ] + } + } diff --git a/etc/init/BUILD.gn b/etc/init/BUILD.gn new file mode 100644 index 0000000..f27e75c --- /dev/null +++ b/etc/init/BUILD.gn @@ -0,0 +1,23 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +################################################################################ + +ohos_prebuilt_etc("printservice.rc") { + source = "printservice.cfg" + relative_install_dir = "init" + part_name = "print" + subsystem_name = "print" +} diff --git a/etc/init/printservice.cfg b/etc/init/printservice.cfg new file mode 100644 index 0000000..cd03afc --- /dev/null +++ b/etc/init/printservice.cfg @@ -0,0 +1,17 @@ +{ + "jobs" : [{ + "name" : "boot", + "cmds" : [ + "start print_service" + ] + } + ], + "services" : [{ + "name" : "print_service", + "path" : ["/system/bin/sa_main", "/system/profile/print_service.xml"], + "uid" : "print", + "gid" : ["print", "shell"], + "secon" : "u:r:print_service:s0" + } + ] +} diff --git a/etc/init/printservice.rc b/etc/init/printservice.rc new file mode 100644 index 0000000..296fee9 --- /dev/null +++ b/etc/init/printservice.rc @@ -0,0 +1,20 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +on boot + start print_service +service print_service /system/bin/sa_main /system/profile/print_service.xml + class z_core + user system + group system shell + seclabel u:r:print_service:s0 diff --git a/frameworks/innerkitsimpl/BUILD.gn b/frameworks/innerkitsimpl/BUILD.gn new file mode 100644 index 0000000..94adbbe --- /dev/null +++ b/frameworks/innerkitsimpl/BUILD.gn @@ -0,0 +1,80 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//base/request/request/request_aafwk.gni") +import("//build/ohos.gni") + +config("print_interfaces_kits_napi_config") { + visibility = [ ":*" ] + include_dirs = [ "include" ] + + cflags_cc = [ "-fexceptions" ] +} +ohos_shared_library("printclient") { + include_dirs = [ + "//foundation/arkui/ace_engine/frameworks/base/utils", + "//foundation/arkui/napi", + "//foundation/arkui/napi/interfaces/kits", + "//foundation/arkui/napi/interfaces/inner_api", + "//third_party/node/src", + "//third_party/curl/include", + "${ability_runtime_services_path}/common/include", + "//utils/system/safwk/native/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/app/", + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_services_path}/abilitymgr/include", + "${ability_runtime_inner_api_path}/ability_manager/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/Isamgr", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//base/print/print/utils/include", + ] + public_configs = [ ":print_interfaces_kits_napi_config" ] + + sources = [ + "src/print_manager.cpp", + "src/print_notify_stub.cpp", + "src/print_service_proxy.cpp", + "src/print_cap_ability.cpp", + "src/print_margin.cpp", + "src/print_page_size.cpp", + "src/print_resolution.cpp", + "src/print_extension_Info.cpp", + "src/print_info.cpp", + "src/print_range.cpp", + "src/preview_attribute.cpp", + "src/print_job.cpp", + ] + deps = [ + "//foundation/arkui/napi:ace_napi", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/curl:curl", + ] + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "ability_runtime:data_ability_helper", + "ability_runtime:napi_base_context", + "c_utils:utils", + "eventhandler:libeventhandler", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "preferences:native_preferences", + "relational_store:native_appdatafwk", + "relational_store:native_dataability", + "relational_store:native_rdb", + ] + relative_install_dir = "module" + subsystem_name = "print" + part_name = "print" +} diff --git a/frameworks/innerkitsimpl/include/preview_attribute.h b/frameworks/innerkitsimpl/include/preview_attribute.h new file mode 100644 index 0000000..36b4c29 --- /dev/null +++ b/frameworks/innerkitsimpl/include/preview_attribute.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PRINT_RESUME_H +#define PRINT_RESUME_H + +#include +#include "print_range.h" +#include +namespace OHOS::Print { +class PreviewAttribute { +public: + PreviewAttribute(); + + void SetResult(const std::string& result_); + + void SetPreviewRange(PrinterRange previewRange); + + [[nodiscard]] const std::string& GetResult() const; + + [[nodiscard]] PrinterRange GetPreviewRange() const; + + void Dump(); + + ~PreviewAttribute(); +private: + std::string result_; + PrinterRange previewRange_; +}; +} // namespace OHOS::Print +#endif // PRINT_RESUME_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/include/print_cap_ability.h b/frameworks/innerkitsimpl/include/print_cap_ability.h new file mode 100644 index 0000000..aab0355 --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_cap_ability.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PRINT_CAP_ABILITY_H +#define PRINT_CAP_ABILITY_H + +#include +#include +#include +#include "print_margin.h" +#include "print_page_size.h" +#include "print_resolution.h" + +namespace OHOS::Print { +class PrinterCapability { +public: + PrinterCapability (); + + void SetMinMargin(PrintMargin &minMargin); + + void SetPageSize(PrinterPageSize pageSize); + + void SetResolution(PrinterResolution resolution); + + void SetColorMode(uint32_t colorMode); + + void SetDuplexMode(uint32_t duplexMode); + + [[nodiscard]] PrintMargin &GetMinMargin(); + + [[nodiscard]] std::vector &GetPageSize(); + + [[nodiscard]] std::vector &GetResolution(); + + [[nodiscard]] uint32_t GetColorMode(); + + [[nodiscard]] uint32_t GetDuplexMode(); + + void Dump(); + + ~PrinterCapability(); + +private: + PrintMargin minMargin_; + std::vector pageSize_; + std::vector resolution_; + uint32_t colorMode_; + uint32_t duplexMode_; +}; +} // namespace OHOS::Print +#endif // PRINT_CAP_ABILITY_H diff --git a/frameworks/innerkitsimpl/include/print_extension_Info.h b/frameworks/innerkitsimpl/include/print_extension_Info.h new file mode 100644 index 0000000..c17a76b --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_extension_Info.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_EXTENSION_INFO_H +#define PRINT_EXTENSION_INFO_H + +#include +#include +#include + +namespace OHOS::Print { +class PrinterExtensionInfo { +public: + PrinterExtensionInfo(); + + void SetExtensionId(uint32_t extensionId); + + void SetVendorId(uint32_t vendorId); + + void SetVendorName(const std::string &vendorName); + + void SetVendorIcon(uint32_t vendorIcon); + + void SetVersion(const std::string &version); + + [[nodiscard]] uint32_t GetExtensionId() const; + + [[nodiscard]] uint32_t GetVendorId() const; + + [[nodiscard]] std::string &GetVendorName(); + + [[nodiscard]] uint32_t GetVendorIcon() const; + + [[nodiscard]] std::string & GetVersion(); + + void Dump(); + + ~PrinterExtensionInfo(); + +private: + uint32_t extensionId_; + uint32_t vendorId_; + std::string vendorName_; + uint32_t vendorIcon_; + std::string version_; +}; +} // namespace OHOS::Print +#endif // PRINT_EXTENSION_INFO_H diff --git a/frameworks/innerkitsimpl/include/print_info.h b/frameworks/innerkitsimpl/include/print_info.h new file mode 100644 index 0000000..5d63c0f --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_info.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_INFO_H +#define PRINT_INFO_H + +#include +#include +#include +#include "constant.h" +#include "print_cap_ability.h" + +namespace OHOS::Print { +class PrintInfo final { +public: + PrintInfo(); + void SetPrinterId(uint32_t printerId); + + void SetPrinterName(std::string printerName); + + void SetPrinterIcon(uint32_t printIcon); + + void SetPrinterState(uint32_t printerState); + + void SetDescription(std::string description); + + void SetCapability(PrinterCapability capability); + + [[nodiscard]] uint32_t GetPrintId() const; + + [[nodiscard]] std::string &GetPrinterName(); + + [[nodiscard]] uint32_t GetPrinterIcon() const; + + [[nodiscard]] uint32_t GetPrinterState() const; + + [[nodiscard]] std::string &GetDescription(); + + [[nodiscard]] PrinterCapability &GetCapability(); + + enum PrinterState + { + PRINTER_ADDED = 1, + PRINTER_REMOVED = 2, + PRINTER_IDLE = 3, + PRINTER_PRINTING = 4, + PRINTER_BLOCKED = 5, + PRINTER_BUSY = 6, + PRINTER_FAILED = 7, + }; + + void Dump(); + +private: + uint32_t printerId_; + + std::string printerName_; + + uint32_t printerIcon_; + + uint32_t printerState_; + + std::string description_; + + PrinterCapability capability_; +}; +} // namespace OHOS::Print +#endif /* PRINT_INFO_H */ diff --git a/frameworks/innerkitsimpl/include/print_job.h b/frameworks/innerkitsimpl/include/print_job.h new file mode 100644 index 0000000..14a580d --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_job.h @@ -0,0 +1,122 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_PRINT_JOB_H +#define PRINT_PRINT_JOB_H +#include +#include +#include +#include "print_range.h" +#include "print_page_size.h" +#include "print_margin.h" +#include "preview_attribute.h" + +namespace OHOS::Print{ +class PrintJob { +public: + PrintJob(); + + void SetFiles(std::string files); + + void SetJobId(uint32_t jobId); + + void SetPrintId(uint32_t printerid); + + void SetJobState(uint32_t jobState); + + void SetCopyNumber(uint32_t copyNumber); + + void SetPageRange(PrinterRange pageRange_); + + void SetIsSequential(bool isSequential_); + + void SetPageSize(PrinterPageSize pageSize_); + + void SetIsLandscape(bool isLandscape_); + + void SetColorMode(uint32_t colorMode_); + + void SetDuplexMode(uint32_t duplexmode); + + void SetMargin(PrintMargin margin_); + + void SetPreview(PreviewAttribute preview_); + + std::vector&GetFiles(); + + uint32_t GetJobId(); + + uint32_t GetPrinterId(); + + uint32_t GetJobState(); + + uint32_t GetCopyNumber(); + + PrinterRange &GetPageRange(); + + bool GetIsSequential(); + + PrinterPageSize &GetPageSize(); + + bool GetIsLandscape(); + + uint32_t GetColorMode(); + + uint32_t GetDuplexMode(); + + PrintMargin &GetMargin(); + + PreviewAttribute &GetPreview(); + + void Dump(); + + ~PrintJob(); +private: + std::vector files_; + uint32_t jobId_; + uint32_t printerId_; + uint32_t jobState_; + uint32_t copyNumber_; + PrinterRange pageRange_; + bool isSequential_; + PrinterPageSize pageSize_; + bool isLandscape_; + int32_t colorMode_; + int32_t duplexMode_; + PrintMargin margin_; + PreviewAttribute preview_; + + enum PrintJobState { + PRINT_JOB_CREATED = 1, + PRINT_JOB_QUEUED = 2, + PRINT_JOB_PRINTING = 3, + PRINT_JOB_BLOCKED = 4, + PRINT_JOB_SUCCESS = 5, + PRINT_JOB_FAILED = 6, + PRINT_JOB_cancelled = 7, + }; + + enum PrintState{ + PRINT_CREATED = 1, + PRINT_QUEUED = 2, + PRINT_PRINTING = 3, + PRINT_BLOCKED = 4, + PRINT_SUCCESS = 5, + PRINT_FAILED = 6, + PRINT_cancelled = 7, + }; +}; +}// namespace OHOS::Request::Print +#endif /* PRINT_PRINT_JOB_H */ diff --git a/frameworks/innerkitsimpl/include/print_manager.h b/frameworks/innerkitsimpl/include/print_manager.h new file mode 100644 index 0000000..e6a2b48 --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_manager.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_MANAGER_H +#define PRINT_MANAGER_H + +#include +#include +#include +#include "iremote_object.h" +#include "refbase.h" +#include "print_extension_Info.h" +#include "print_notify_stub.h" +#include "print_job.h" +#include "print_service_interface.h" +#include "print_info.h" + +namespace OHOS::Print { +class PrintSaDeathRecipient : public IRemoteObject::DeathRecipient { +public: + explicit PrintSaDeathRecipient(); + ~PrintSaDeathRecipient() = default; + void OnRemoteDied(const wptr &object) override; +}; + +class PrintManager : public RefBase { +public: + PrintManager(); + bool LoadPrintServer(); + void LoadServerSuccess(); + void LoadServerFail(); + ~PrintManager(); + static sptr GetInstance(); + bool CheckPermission(); + + void OnRemoteSaDied(const wptr &object); + + //Client Napi + int32_t Dummy(); + bool Print(uint32_t taskId); + bool QueryAllExtension(std::vector &arrayExtensionInfo); + bool StartDiscoverPrinter(std::vector extensionList); + bool StopDiscoverPrinter(); + bool AddPrinters(std::vector arrayPrintInfo); + bool RemovePrinters(std::vector arrayPrintInfo); + bool ConnectPrinter(uint32_t printerId); + bool DisconnectPrinter(uint32_t printerId); + bool StartPrintJob(PrintJob jobinfo); + bool CancelPrintJob(PrintJob jobinfo); + bool UpdatePrinterState(uint32_t printerId, uint32_t state); + bool UpdatePrinterJobState(uint32_t jobId, uint32_t state); + bool RequestPreview(PrintJob jobinfo, std::string &previewResult); + bool QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability); + + bool On(uint32_t taskId, const std::string& type, const sptr& listener); + bool Off(uint32_t taskId, const std::string& type); + +private: + sptr GetPrintServiceProxy(); + +private: + static std::mutex instanceLock_; + static sptr instance_; + sptr printServiceProxy_; + sptr deathRecipient_; +}; +} // namespace OHOS::Print +#endif // PRINT_MANAGER_H diff --git a/frameworks/innerkitsimpl/include/print_margin.h b/frameworks/innerkitsimpl/include/print_margin.h new file mode 100644 index 0000000..a5910ab --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_margin.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_MARGIN_H +#define PRINT_MARGIN_H + +#include +#include +#include + +namespace OHOS::Print { +class PrintMargin { +public: + PrintMargin(); + + void SetTop(uint32_t top); + + void SetBottom(uint32_t bottom); + + void SetLeft(uint32_t left); + + void SetRight(uint32_t right); + + [[nodiscard]] uint32_t GetTop() const; + + [[nodiscard]] uint32_t GetBottom() const; + + [[nodiscard]] uint32_t GetLeft() const; + + [[nodiscard]] uint32_t GetRight() const; + + PrintMargin &operator=(const PrintMargin &printMargin); + + void Dump(); + + ~PrintMargin (); + +private: + uint32_t top_; + uint32_t bottom_; + uint32_t left_; + uint32_t right_; +}; +} // namespace OHOS::Print +#endif // PRINT_MARGIN_H diff --git a/frameworks/innerkitsimpl/include/print_notify_interface.h b/frameworks/innerkitsimpl/include/print_notify_interface.h new file mode 100644 index 0000000..10b0272 --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_notify_interface.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_NOTIFY_INTERFACE_H +#define PRINT_NOTIFY_INTERFACE_H + +#include "iremote_broker.h" +#include "iremote_object.h" + +namespace OHOS::Print { +class PrintNotifyInterface : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.Print.PrintNotifyInterface"); + virtual void OnCallBack(MessageParcel &data) = 0; +}; + +enum { + PRINT_NOTIFY, +}; +} // namespace OHOS::Print +#endif // PRINT_NOTIFY_INTERFACE_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/include/print_notify_stub.h b/frameworks/innerkitsimpl/include/print_notify_stub.h new file mode 100644 index 0000000..92c41f5 --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_notify_stub.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_NOTIFY_STUB_H +#define PRINT_NOTIFY_STUB_H + +#include +#include "iremote_stub.h" +#include "print_notify_interface.h" + +namespace OHOS::Print { +class PrintNotifyStub : public IRemoteStub { +public: + PrintNotifyStub() = default; + virtual ~PrintNotifyStub() + { + } + int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; +}; +} // namespace OHOS::Print +#endif // PRINT_NOTIFY_STUB_H diff --git a/frameworks/innerkitsimpl/include/print_page_size.h b/frameworks/innerkitsimpl/include/print_page_size.h new file mode 100644 index 0000000..345101a --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_page_size.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_PAGESIZE_H +#define PRINT_PAGESIZE_H + +#include +#include +#include + +namespace OHOS::Print { +class PrinterPageSize { +public: + PrinterPageSize(); + + void SetId(uint32_t id); + + void SetName(const std::string &name); + + void SetWidth(uint32_t width); + + void SetHeight(uint32_t height); + + [[nodiscard]] uint32_t GetId() const; + + [[nodiscard]] std::string &GetName(); + + [[nodiscard]] uint32_t GetWidth() const; + + [[nodiscard]] uint32_t GetHeight() const; + + PrinterPageSize &operator=(const PrinterPageSize &printerPageSize); + + void Dump(); + + ~PrinterPageSize (); + +private: + uint32_t id_; + std::string name_; + uint32_t width_; + uint32_t height_; +}; +} // namespace OHOS::Print +#endif // PRINT_PAGESIZE_H diff --git a/frameworks/innerkitsimpl/include/print_range.h b/frameworks/innerkitsimpl/include/print_range.h new file mode 100644 index 0000000..c93ba52 --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_range.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_RANGE_H +#define PRINT_RANGE_H + +#include +#include + +namespace OHOS::Print { +class PrinterRange{ +public: + PrinterRange(); + + void SetStartPage(uint32_t startPage); + + void SetEndPage(uint32_t endPage); + + void SetPages(uint32_t pages); + + [[nodiscard]]uint32_t GetStartPage() const; + + [[nodiscard]]uint32_t GetEndPage() const; + + [[nodiscard]]std::vector &GetPages(); + + void Dump(); + + ~PrinterRange(); +private: + uint32_t startPage_; + uint32_t endPage_; + std::vector pages_; +}; +}// namespace OHOS::Print +#endif // PRINT_RANGE_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/include/print_resolution.h b/frameworks/innerkitsimpl/include/print_resolution.h new file mode 100644 index 0000000..ef167bf --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_resolution.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_RESOLUTION_H +#define PRINT_RESOLUTION_H + +#include +#include +#include + +namespace OHOS::Print { +class PrinterResolution { +public: + PrinterResolution(); + + void SetId(uint32_t id); + + void SetHorizontalDpi(uint32_t horizontalDpi); + + void SetVerticalDpi(uint32_t verticalDpi); + + [[nodiscard]] uint32_t GetId() const; + + [[nodiscard]] uint32_t GetHorizontalDpi() const; + + [[nodiscard]] uint32_t GetVerticalDpi() const; + + PrinterResolution &operator=(const PrinterResolution &printerResolution); + + void Dump(); + + ~PrinterResolution (); + +private: + uint32_t id_; + uint32_t horizontalDpi_; + uint32_t verticalDpi_; +}; +} // namespace OHOS::Print +#endif // PRINT_RESOLUTION_H diff --git a/frameworks/innerkitsimpl/include/print_service_interface.h b/frameworks/innerkitsimpl/include/print_service_interface.h new file mode 100644 index 0000000..3f3f32c --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_service_interface.h @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_SERVICE_INTERFACE_H +#define PRINT_SERVICE_INTERFACE_H + +#include +#include "print_notify_interface.h" +#include "print_extension_Info.h" +#include "print_info.h" +#include "print_job.h" +#include "iremote_broker.h" + +namespace OHOS::Print { +class PrintServiceInterface : public IRemoteBroker { +public: + DECLARE_INTERFACE_DESCRIPTOR(u"OHOS.Print.PrintServiceInterface"); + virtual int32_t Dummy() = 0; + virtual bool ConnectPrinter(uint32_t printerId) = 0; + virtual bool DisconnectPrinter(uint32_t printerId) = 0; + virtual bool StartDiscoverPrinter(std::vector extensionList) = 0; + virtual bool StopDiscoverPrinter() = 0; + virtual bool QueryAllExtension(std::vector &arrayExtensionInfo) = 0; + virtual bool StartPrintJob(PrintJob jobinfo) = 0; + virtual bool CancelPrintJob(PrintJob jobinfo) = 0; + virtual bool AddPrinters(std::vector arrayPrintInfo) = 0; + virtual bool RemovePrinters(std::vector arrayPrintInfo) = 0; + virtual bool UpdatePrinterState(uint32_t printerId, uint32_t state) = 0; + virtual bool UpdatePrinterJobState(uint32_t jobId, uint32_t state) = 0; + virtual bool RequestPreview(PrintJob jobinfo, std::string &previewResult) = 0; + virtual bool QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) = 0; + virtual bool CheckPermission() = 0; + virtual bool On(uint32_t taskId, const std::string &type, const sptr &listener) = 0; + virtual bool Off(uint32_t taskId, const std::string &type) = 0; +}; + +enum { + CMD_DUMMY, + CMD_CONNECTPRINTER, + CMD_DISCONNECTPRINTER, + CMD_STARTDISCOVERPRINTER, + CMD_STOPDISCOVERPRINTER, + CMD_QUERYALLEXTENSION, + CMD_STARTPRINTJOB, + CMD_CANCELPRINTJOB, + CMD_ADDPRINTERS, + CMD_REMOVEPRINTERS, + CMD_UPDATEPRINTERSTATE, + CMD_UPDATEPRINTERJOBSTATE, + CMD_REQUESTPREVIEW, + CMD_QUERYPRINTERCAPABILITY, + CMD_CHECKPERMISSION, + CMD_ON, + CMD_OFF, +}; +} // namespace OHOS::Print +#endif // PRINT_SERVICE_INTERFACE_H \ No newline at end of file diff --git a/frameworks/innerkitsimpl/include/print_service_proxy.h b/frameworks/innerkitsimpl/include/print_service_proxy.h new file mode 100644 index 0000000..fbc186f --- /dev/null +++ b/frameworks/innerkitsimpl/include/print_service_proxy.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_SERVICE_PROXY_H +#define PRINT_SERVICE_PROXY_H + +#include "iremote_proxy.h" +#include "print_notify_interface.h" +#include "print_service_interface.h" + +namespace OHOS::Print { +class PrintServiceProxy : public IRemoteProxy { +public: + explicit PrintServiceProxy(const sptr &object); + ~PrintServiceProxy() = default; + DISALLOW_COPY_AND_MOVE(PrintServiceProxy); + int32_t Dummy() override; + bool ConnectPrinter(uint32_t printerId) override; + bool DisconnectPrinter(uint32_t printerId) override; + bool QueryAllExtension(std::vector &arrayExtensionInfo) override; + bool StartDiscoverPrinter(std::vector extensionList) override; + bool StopDiscoverPrinter() override; + bool StartPrintJob(PrintJob jobinfo) override; + bool CancelPrintJob(PrintJob jobinfo) override; + bool AddPrinters(std::vector arrayPrintInfo) override; + bool RemovePrinters(std::vector arrayPrintInfo) override; + bool UpdatePrinterState(uint32_t printerId, uint32_t state) override; + bool UpdatePrinterJobState(uint32_t jobId, uint32_t state) override; + bool RequestPreview(PrintJob jobinfo, std::string &previewResult) override; + bool QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) override; + bool CheckPermission() override; + bool On(uint32_t taskId, const std::string &type, const sptr &listener) override; + bool Off(uint32_t taskId, const std::string &type) override; + +private: + static inline BrokerDelegator delegator_; +}; +} // namespace OHOS::Print +#endif // PRINT_SERVICE_PROXY_H diff --git a/frameworks/innerkitsimpl/src/preview_attribute.cpp b/frameworks/innerkitsimpl/src/preview_attribute.cpp new file mode 100644 index 0000000..bbd39c0 --- /dev/null +++ b/frameworks/innerkitsimpl/src/preview_attribute.cpp @@ -0,0 +1,41 @@ +#include "preview_attribute.h" +#include "log.h" +#include +#include +namespace OHOS::Print{ +PreviewAttribute::PreviewAttribute() +{ + +} + +PreviewAttribute::~PreviewAttribute() +{ + +} + +void PreviewAttribute::SetResult(const std::string& result) +{ + result_ = result; +} + +void PreviewAttribute::SetPreviewRange(PrinterRange previewRange) +{ + previewRange_ = previewRange; +} + +const std::string& PreviewAttribute::GetResult() const +{ + return result_; +} + +PrinterRange PreviewAttribute::GetPreviewRange() const +{ + return previewRange_; +} + +void PreviewAttribute::Dump() +{ + PRINT_HILOGD("result_: %{public}s", result_.c_str()); +} +} + diff --git a/frameworks/innerkitsimpl/src/print_cap_ability.cpp b/frameworks/innerkitsimpl/src/print_cap_ability.cpp new file mode 100644 index 0000000..01cd7f6 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_cap_ability.cpp @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_cap_ability.h" +#include "log.h" + +namespace OHOS::Print { +PrinterCapability::PrinterCapability () + : colorMode_(1), duplexMode_(1) { + +} + +void PrinterCapability::SetMinMargin(PrintMargin &minMargin) +{ + minMargin_ = minMargin; +} + +void PrinterCapability::SetPageSize(PrinterPageSize pageSize) +{ + pageSize_.push_back(pageSize); +} + +void PrinterCapability::SetResolution(PrinterResolution resolution) +{ + resolution_.push_back(resolution); +} + +void PrinterCapability::SetColorMode(uint32_t colorMode) +{ + colorMode_ = colorMode; +} + +void PrinterCapability::SetDuplexMode(uint32_t duplexMode) +{ + duplexMode_ = duplexMode; +} + +PrintMargin &PrinterCapability::GetMinMargin() +{ + return minMargin_; +} + +std::vector &PrinterCapability::GetPageSize() +{ + return pageSize_; +} + +std::vector &PrinterCapability::GetResolution() +{ + return resolution_; +} + +uint32_t PrinterCapability::GetColorMode() +{ + return colorMode_; +} + +uint32_t PrinterCapability::GetDuplexMode() +{ + return duplexMode_; +} + +void PrinterCapability::Dump() +{ + PRINT_HILOGD("colorMode_ = %{public}d", colorMode_); + PRINT_HILOGD("duplexMode_ = %{public}d", duplexMode_); +} + +PrinterCapability ::~PrinterCapability () +{ + +} + +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_extension_Info.cpp b/frameworks/innerkitsimpl/src/print_extension_Info.cpp new file mode 100644 index 0000000..aa25c33 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_extension_Info.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_extension_Info.h" +#include "log.h" + +namespace OHOS::Print { +PrinterExtensionInfo::PrinterExtensionInfo () + : extensionId_(0), vendorId_(0), vendorName_("PrinterExtensionInfo"), + vendorIcon_(0), version_("PrinterExtensionInfo") { + +} + +void PrinterExtensionInfo::SetExtensionId(uint32_t extensionId) +{ + extensionId_ = extensionId; +} + +void PrinterExtensionInfo::SetVendorId(uint32_t vendorId) +{ + vendorId_ = vendorId; +} + +void PrinterExtensionInfo::SetVendorName(const std::string &vendorName) +{ + vendorName_ = vendorName; +} + +void PrinterExtensionInfo::SetVendorIcon(uint32_t vendorIcon) +{ + vendorIcon_ = vendorIcon; +} + +void PrinterExtensionInfo::SetVersion(const std::string &version) +{ + version_ = version; +} + +uint32_t PrinterExtensionInfo::GetExtensionId() const +{ + return extensionId_; +} + +uint32_t PrinterExtensionInfo::GetVendorId() const +{ + return vendorId_; +} + +std::string &PrinterExtensionInfo::GetVendorName() +{ + return vendorName_; +} + +uint32_t PrinterExtensionInfo::GetVendorIcon() const +{ + return vendorIcon_; +} + +std::string &PrinterExtensionInfo::GetVersion() +{ + return version_; +} + +void PrinterExtensionInfo::Dump() +{ + PRINT_HILOGD("extensionId = %{public}d", extensionId_); + PRINT_HILOGD("vendorId_ = %{public}d", vendorId_); + PRINT_HILOGD("vendorName_ = %{public}s", vendorName_.c_str()); + PRINT_HILOGD("vendorIcon_ = %{public}d", vendorIcon_); + PRINT_HILOGD("version_ = %{public}s", version_.c_str()); +} + +PrinterExtensionInfo::~PrinterExtensionInfo() +{ + +} +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_info.cpp b/frameworks/innerkitsimpl/src/print_info.cpp new file mode 100644 index 0000000..2f6f937 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_info.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_info.h" +#include "log.h" +#include "constant.h" + +namespace OHOS::Print { +PrintInfo::PrintInfo() + : printerId_(0), printerName_(""), printerIcon_(0), printerState_(ERROR_UNKNOWN), description_("") { +} + +void PrintInfo::SetPrinterId(uint32_t printerId) +{ + printerId_ = printerId; +} +void PrintInfo::SetPrinterName(std::string printerName) +{ + printerName_ = printerName; +} +void PrintInfo::SetPrinterIcon(uint32_t printIcon) +{ + printerIcon_ = printIcon; +} +void PrintInfo::SetPrinterState(uint32_t printerState) +{ + printerState_ = printerState; +} +void PrintInfo::SetDescription(std::string description) +{ + description_ = description; +} +void PrintInfo::SetCapability(PrinterCapability capability) +{ + capability_ = capability; +} + +uint32_t PrintInfo::GetPrintId() const +{ + return printerId_; +} +std::string &PrintInfo::GetPrinterName() +{ + return printerName_; +} + +uint32_t PrintInfo::GetPrinterIcon() const +{ + return printerIcon_; +} +uint32_t PrintInfo::GetPrinterState() const +{ + return printerState_; +} +std::string &PrintInfo::GetDescription() +{ + return description_; +} +PrinterCapability &PrintInfo::GetCapability() +{ + return capability_; +} + +void PrintInfo::Dump() +{ + PRINT_HILOGD("printerId: %{public}d", printerId_); + PRINT_HILOGD("printerName: %{public}s", printerName_.c_str()); + PRINT_HILOGD("printerIcon: %{public}d", printerIcon_); + PRINT_HILOGD("printerState: %{public}d", printerState_); + PRINT_HILOGD("description: %{public}s", description_.c_str()); +} +} // namespace OHOS::Print \ No newline at end of file diff --git a/frameworks/innerkitsimpl/src/print_job.cpp b/frameworks/innerkitsimpl/src/print_job.cpp new file mode 100644 index 0000000..80a6c0b --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_job.cpp @@ -0,0 +1,160 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_job.h" +#include "log.h" + +namespace OHOS::Print{ +PrintJob::PrintJob() +: jobId_(0), jobState_(1), copyNumber_(1), isSequential_(true), +isLandscape_(1), colorMode_(1), duplexMode_(1) { + +} + +PrintJob::~PrintJob() +{ + +} + +void PrintJob::SetFiles(std::string files) +{ + files_.push_back(files); +} + +void PrintJob::SetJobId(uint32_t jobId) +{ + jobId_ = jobId; +} + +void PrintJob::SetPrintId(uint32_t printerid) +{ + printerId_ = printerid; +} + +void PrintJob::SetJobState(uint32_t jobState) +{ + jobState_ = jobState; +} +void PrintJob::SetCopyNumber(uint32_t copyNumber) +{ + copyNumber_ = copyNumber; +} +void PrintJob::SetPageRange(PrinterRange pageRange) +{ + pageRange_ = pageRange; +} +void PrintJob::SetIsSequential(bool isSequential) +{ + isSequential_ = isSequential; +} +void PrintJob::SetPageSize(PrinterPageSize pageSize) +{ + pageSize_ = pageSize; +} +void PrintJob::SetIsLandscape(bool isLandscape) +{ + isLandscape_ = isLandscape; +} +void PrintJob::SetColorMode(uint32_t colorMode) +{ + colorMode_ = colorMode; +} +void PrintJob::SetDuplexMode(uint32_t duplexmode) +{ + duplexMode_ = duplexmode; +} +void PrintJob::SetMargin(PrintMargin margin) +{ + margin_ = margin; +} +void PrintJob::SetPreview(PreviewAttribute preview) +{ + preview_ = preview; +} + +std::vector &PrintJob::GetFiles() +{ + return files_; +} +uint32_t PrintJob::GetJobId() +{ + return jobId_; +} + +uint32_t PrintJob::GetPrinterId() +{ + return printerId_; +} + +uint32_t PrintJob::GetJobState() +{ + return jobState_; +} + +uint32_t PrintJob::GetCopyNumber() +{ + return copyNumber_; +} +PrinterRange &PrintJob::GetPageRange() +{ + return pageRange_; +} +bool PrintJob::GetIsSequential() +{ + return isSequential_; +} +PrinterPageSize &PrintJob::GetPageSize() +{ + return pageSize_; +} +bool PrintJob::GetIsLandscape() +{ + return isLandscape_; +} +uint32_t PrintJob::GetColorMode() +{ + return colorMode_; +} +uint32_t PrintJob::GetDuplexMode() +{ + return duplexMode_; +} +PrintMargin &PrintJob::GetMargin() +{ + return margin_; +} +PreviewAttribute &PrintJob::GetPreview() +{ + return preview_; +} + +void PrintJob::Dump() +{ + uint32_t fileLength = files_.size(); + for(uint32_t i = 0; i < fileLength; i++) + { + PRINT_HILOGD("files_ = %{public}s", files_[i].c_str()); + } + + PRINT_HILOGD("jobId_ = %{public}d", jobId_); + PRINT_HILOGD("printerId_ = %{public}d", printerId_); + PRINT_HILOGD("jobState_ = %{public}d", jobState_); + PRINT_HILOGD("copyNumber_ = %{public}d", copyNumber_); + PRINT_HILOGD("isSequential_ = %{public}d", isSequential_); + PRINT_HILOGD("isLandscape_ = %{public}d", isLandscape_); + PRINT_HILOGD("colorMode_ = %{public}d", colorMode_); + PRINT_HILOGD("duplexMode_ = %{public}d", duplexMode_); +} +} diff --git a/frameworks/innerkitsimpl/src/print_manager.cpp b/frameworks/innerkitsimpl/src/print_manager.cpp new file mode 100644 index 0000000..5c346c0 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_manager.cpp @@ -0,0 +1,325 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_manager.h" +#include "system_ability_definition.h" +#include "iservice_registry.h" +#include "log.h" + +namespace OHOS::Print { +std::mutex PrintManager::instanceLock_; +sptr PrintManager::instance_ = nullptr; + +PrintManager::PrintManager() : printServiceProxy_(nullptr), deathRecipient_(nullptr) { +} + +PrintManager::~PrintManager() +{ +} + +sptr PrintManager::GetInstance() +{ + if (instance_ == nullptr) { + std::lock_guard autoLock(instanceLock_); + if (instance_ == nullptr) { + instance_ = new PrintManager; + } + } + return instance_; +} + +bool PrintManager::On(uint32_t taskId, const std::string &type, const sptr &listener) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("Resume quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager On succeeded."); + return printServiceProxy_->On(taskId, type, listener); +} + +bool PrintManager::Off(uint32_t taskId, const std::string &type) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("Resume quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager Off succeeded."); + return printServiceProxy_->Off(taskId, type); +} + +sptr PrintManager::GetPrintServiceProxy() +{ + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (systemAbilityManager == nullptr) { + PRINT_HILOGE("Getting SystemAbilityManager failed."); + return nullptr; + } + auto systemAbility = systemAbilityManager->GetSystemAbility(PRINT_SERVICE_ID, ""); + if (systemAbility == nullptr) { + PRINT_HILOGE("Get SystemAbility failed."); + return nullptr; + } + deathRecipient_ = new PrintSaDeathRecipient(); + systemAbility->AddDeathRecipient(deathRecipient_); + sptr serviceProxy = iface_cast(systemAbility); + if (serviceProxy == nullptr) { + PRINT_HILOGE("Get PrintManagerProxy from SA failed."); + return nullptr; + } + PRINT_HILOGD("Getting PrintManagerProxy succeeded."); + return serviceProxy; +} + +void PrintManager::OnRemoteSaDied(const wptr &remote) +{ + printServiceProxy_ = GetPrintServiceProxy(); +} + +PrintSaDeathRecipient::PrintSaDeathRecipient() +{ +} + +void PrintSaDeathRecipient::OnRemoteDied(const wptr &object) +{ + PRINT_HILOGE("PrintSaDeathRecipient on remote systemAbility died."); + PrintManager::GetInstance()->OnRemoteSaDied(object); +} + +int32_t PrintManager::Dummy() +{ + return 1; +} + +bool PrintManager::ConnectPrinter(uint32_t printerId) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("AddPrinters quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager AddPrinters succeeded."); + return printServiceProxy_->ConnectPrinter(printerId); +} + +bool PrintManager::DisconnectPrinter(uint32_t printerId) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("DisconnectPrinter quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager DisconnectPrinter succeeded."); + return printServiceProxy_->DisconnectPrinter(printerId); +} + +bool PrintManager::QueryAllExtension(std::vector &arrayExtensionInfo) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("QueryAllExtension quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager QueryAllExtension succeeded."); + return printServiceProxy_->QueryAllExtension(arrayExtensionInfo); +} + +bool PrintManager::StartDiscoverPrinter(std::vector extensionList) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("StartDiscoverPrinter quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager StartDiscoverPrinter succeeded."); + return printServiceProxy_->StartDiscoverPrinter(extensionList); +} + +bool PrintManager::StopDiscoverPrinter() +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("StopDiscoverPrinter quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager StopDiscoverPrint succeeded."); + return printServiceProxy_->StopDiscoverPrinter(); +} + +bool PrintManager::StartPrintJob(PrintJob jobinfo) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("StartPrintJob quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager StartPrintJob succeeded."); + return printServiceProxy_->StartPrintJob(jobinfo); +} + +bool PrintManager::CancelPrintJob(PrintJob jobinfo) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("CancelPrintJob quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager CancelPrintJob succeeded."); + return printServiceProxy_->CancelPrintJob(jobinfo); +}//// + +bool PrintManager::AddPrinters(std::vector arrayPrintInfo) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("AddPrinters quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager AddPrinters succeeded."); + return printServiceProxy_->AddPrinters(arrayPrintInfo); +} + +bool PrintManager::RemovePrinters(std::vector arrayPrintInfo) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("RemovePrinters quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager RemovePrinters succeeded."); + return printServiceProxy_->RemovePrinters(arrayPrintInfo); +} + +bool PrintManager::UpdatePrinterState(uint32_t printerId, uint32_t state) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("UpdatePrinterState quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager UpdatePrinterState succeeded."); + return printServiceProxy_->UpdatePrinterState(printerId, state); +} + +bool PrintManager::UpdatePrinterJobState(uint32_t jobId, uint32_t state) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("UpdatePrinterJobState quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager UpdatePrinterJobState succeeded."); + return printServiceProxy_->UpdatePrinterJobState(jobId, state); +} + +bool PrintManager::RequestPreview(PrintJob jobinfo, std::string &previewResult) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("RequestPreview quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager RequestPreview succeeded."); + return printServiceProxy_->RequestPreview(jobinfo, previewResult); +} + +bool PrintManager::QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("QueryPrinterCapability quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager QueryPrinterCapability succeeded."); + return printServiceProxy_->QueryPrinterCapability(printerId, printerCapability); +} + +bool PrintManager::CheckPermission() +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("Resume quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager CheckPermission succeeded."); + PRINT_HILOGD("Check Permission enable"); + return printServiceProxy_->CheckPermission(); +} + +bool PrintManager::Print(uint32_t taskId) +{ + if (printServiceProxy_ == nullptr) { + PRINT_HILOGW("Redo GetPrintServiceProxy"); + printServiceProxy_ = GetPrintServiceProxy(); + } + if (printServiceProxy_ == nullptr) { + PRINT_HILOGE("Print quit because redoing GetPrintServiceProxy failed."); + return false; + } + PRINT_HILOGD("PrintManager Print succeeded."); + return true; +} +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_margin.cpp b/frameworks/innerkitsimpl/src/print_margin.cpp new file mode 100644 index 0000000..dc895f7 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_margin.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_margin.h" +#include "log.h" + +namespace OHOS::Print { + PrintMargin::PrintMargin () + : top_(0), bottom_(0), left_(0), right_(0) { + + } + + void PrintMargin::SetTop(uint32_t top) + { + top_ = top; + } + + void PrintMargin::SetBottom(uint32_t bottom) + { + bottom_ = bottom; + } + + void PrintMargin::SetLeft(uint32_t left) + { + left_ = left; + } + + void PrintMargin::SetRight(uint32_t right) + { + right_ = right; + } + + uint32_t PrintMargin::GetTop() const + { + return top_; + } + + uint32_t PrintMargin::GetBottom() const + { + return bottom_; + } + + uint32_t PrintMargin::GetLeft() const + { + return left_; + } + + uint32_t PrintMargin::GetRight() const + { + return right_; + } + + PrintMargin &PrintMargin::operator=(const PrintMargin &printMargin) + { + if(this != &printMargin){ + this->top_ = printMargin.top_; + this->bottom_ = printMargin.bottom_; + this->left_ = printMargin.left_; + this->right_ = printMargin.right_; + } + return *this; + } + + void PrintMargin::Dump() + { + PRINT_HILOGD("top_ = %{public}d", top_); + PRINT_HILOGD("bottom_ = %{public}d", bottom_); + PRINT_HILOGD("left_ = %{public}d", left_); + PRINT_HILOGD("right_ = %{public}d", right_); + } + +PrintMargin ::~PrintMargin () +{ + +} + +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_notify_stub.cpp b/frameworks/innerkitsimpl/src/print_notify_stub.cpp new file mode 100644 index 0000000..f5d6236 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_notify_stub.cpp @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_notify_stub.h" +#include "print_common.h" +#include "log.h" + +namespace OHOS::Print { +int32_t PrintNotifyStub::OnRemoteRequest( + uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) +{ + auto descriptorToken = data.ReadInterfaceToken(); + if (descriptorToken != GetDescriptor()) { + PRINT_HILOGE("Remote descriptor not the same as local descriptor."); + return E_PRINT_TRANSACT_ERROR; + } + PRINT_HILOGD("PrintNotifyStub code----> %{public}u", code); + switch (code) { + case PRINT_NOTIFY: { + OnCallBack(data); + break; + } + default: { + return OHOS::UNKNOWN_TRANSACTION; + } + } + return E_PRINT_OK; +} +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_page_size.cpp b/frameworks/innerkitsimpl/src/print_page_size.cpp new file mode 100644 index 0000000..66b34d2 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_page_size.cpp @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_page_size.h" +#include "log.h" + +namespace OHOS::Print { +PrinterPageSize::PrinterPageSize () +: id_(0), name_("PrinterPageSize"), width_(0), height_(0) { + +} + +void PrinterPageSize::SetId(uint32_t id) +{ + id_ = id; +} + +void PrinterPageSize::SetName(const std::string &name) +{ + name_ = name; +} + +void PrinterPageSize::SetWidth(uint32_t width) +{ + width_ = width; +} + +void PrinterPageSize::SetHeight(uint32_t height) +{ + height_ = height; +} + +uint32_t PrinterPageSize::GetId() const +{ + return id_; +} + +std::string &PrinterPageSize::GetName() +{ + return name_; +} + +uint32_t PrinterPageSize::GetWidth() const +{ + return width_; +} + +uint32_t PrinterPageSize::GetHeight() const +{ + return height_; +} + +PrinterPageSize &PrinterPageSize::operator=(const PrinterPageSize &printerPageSize) +{ + if(this != &printerPageSize){ + this->id_ = printerPageSize.id_; + this->name_ = printerPageSize.name_; + this->width_ = printerPageSize.width_; + this->height_ = printerPageSize.height_; + } + return *this; +} + +void PrinterPageSize::Dump() +{ + PRINT_HILOGD("top_ = %{public}d", id_); + PRINT_HILOGD("name_ = %{public}s", name_.c_str()); + PRINT_HILOGD("width_ = %{public}d", width_); + PRINT_HILOGD("height_ = %{public}d", height_); +} + +PrinterPageSize ::~PrinterPageSize () +{ + +} + +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_range.cpp b/frameworks/innerkitsimpl/src/print_range.cpp new file mode 100644 index 0000000..825e77a --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_range.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_range.h" +#include "log.h" + +namespace OHOS::Print { +PrinterRange::PrinterRange() +{ + +} + +PrinterRange::~PrinterRange() +{ + +} + +void PrinterRange::SetStartPage(uint32_t startpage) +{ + startPage_ = startpage; +} + +void PrinterRange::SetEndPage(uint32_t endpage) +{ + endPage_ = endpage; +} + +void PrinterRange::SetPages(uint32_t pages) +{ + pages_.push_back(pages); +} + +uint32_t PrinterRange::GetStartPage() const +{ + return startPage_; +} + +uint32_t PrinterRange::GetEndPage() const +{ + return endPage_; +} + +std::vector &PrinterRange::GetPages() +{ + return pages_; +} + +void PrinterRange::Dump() +{ + PRINT_HILOGD("startPage_ = %{public}d", startPage_); + PRINT_HILOGD("endPage_ = %{public}d", endPage_); + uint32_t pageLength = pages_.size(); + for(uint32_t i = 0; i < pageLength; i++) + { + PRINT_HILOGD("pages_ = %{public}d", pages_[i]); + } +} +} + diff --git a/frameworks/innerkitsimpl/src/print_resolution.cpp b/frameworks/innerkitsimpl/src/print_resolution.cpp new file mode 100644 index 0000000..cefaaa1 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_resolution.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_resolution.h" +#include "log.h" + +namespace OHOS::Print { +PrinterResolution::PrinterResolution() +: id_(0), horizontalDpi_(0), verticalDpi_(0) { + +} + +void PrinterResolution::SetId(uint32_t id) +{ + id_ = id; +} + +void PrinterResolution::SetHorizontalDpi(uint32_t horizontalDpi) +{ + horizontalDpi_ = horizontalDpi; +} + +void PrinterResolution::SetVerticalDpi(uint32_t verticalDpi) +{ + verticalDpi_ = verticalDpi; +} + +uint32_t PrinterResolution::GetId() const +{ + return id_; +} + +uint32_t PrinterResolution::GetHorizontalDpi() const +{ + return horizontalDpi_; +} + +uint32_t PrinterResolution::GetVerticalDpi() const +{ + return verticalDpi_; +} + +PrinterResolution &PrinterResolution::operator=(const PrinterResolution &printerResolution) +{ + if(this != &printerResolution){ + this->id_ = printerResolution.id_; + this->horizontalDpi_ = printerResolution.horizontalDpi_; + this->verticalDpi_ = printerResolution.verticalDpi_; + } + return *this; +} + +void PrinterResolution::Dump() +{ + PRINT_HILOGD("id_ = %{public}d", id_); + PRINT_HILOGD("horizontalDpi_ = %{public}d", horizontalDpi_); + PRINT_HILOGD("verticalDpi_ = %{public}d", verticalDpi_); +} + +PrinterResolution ::~PrinterResolution () +{ + +} +} // namespace OHOS::Print diff --git a/frameworks/innerkitsimpl/src/print_service_proxy.cpp b/frameworks/innerkitsimpl/src/print_service_proxy.cpp new file mode 100644 index 0000000..4616934 --- /dev/null +++ b/frameworks/innerkitsimpl/src/print_service_proxy.cpp @@ -0,0 +1,614 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "print_service_proxy.h" +#include +#include +#include +#include +#include "print_info.h" +#include "iremote_broker.h" +#include "log.h" +#include "print_job.h" +#include "print_common.h" + +namespace OHOS::Print { +using namespace OHOS::HiviewDFX; + +PrintServiceProxy::PrintServiceProxy(const sptr &object) + : IRemoteProxy(object) +{ +} + +int32_t PrintServiceProxy::Dummy() +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(GetDescriptor()); + PRINT_HILOGD("PrintServiceProxy Dummy started."); + bool ret = Remote()->SendRequest(CMD_DUMMY, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGE("Dummy, ret = %{public}d", ret); + return -1; + } + int32_t taskId = reply.ReadInt32(); + PRINT_HILOGD("PrintServiceProxy Dummy succeeded. TaskId = %{public}d", taskId); + return taskId; +} + +bool PrintServiceProxy::ConnectPrinter(uint32_t printerId) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(printerId); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_CONNECTPRINTER, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy ConnectPrinter succeeded."); + return true; +} + +bool PrintServiceProxy::DisconnectPrinter(uint32_t printerId) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(printerId); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_DISCONNECTPRINTER, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy DisconnectPrinter succeeded."); + return true; +} + +bool PrintServiceProxy::QueryAllExtension(std::vector &arrayExtensionInfo) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(5); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_QUERYALLEXTENSION, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + uint32_t replyArrayLength = reply.ReadUint32(); + for(uint32_t i = 0; i < replyArrayLength; i++) + { + PrinterExtensionInfo printerExtensionInfo; + printerExtensionInfo.SetExtensionId(reply.ReadUint32()); + printerExtensionInfo.SetVendorId(reply.ReadUint32()); + printerExtensionInfo.SetVendorName(reply.ReadString()); + printerExtensionInfo.SetVendorIcon(reply.ReadUint32()); + printerExtensionInfo.SetVersion(reply.ReadString()); + arrayExtensionInfo.push_back(printerExtensionInfo); + arrayExtensionInfo[i].Dump(); + } + return true; +} + +bool PrintServiceProxy::StartDiscoverPrinter(std::vector extensionList) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(extensionList.size()); + PRINT_HILOGD("OnStartDiscoverPrinter extensionList.size() = %{public}lu", extensionList.size()); + for(uint32_t i = 0; i < extensionList.size(); i++) + { + data.WriteUint32(extensionList[i]); + } + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_STARTDISCOVERPRINTER, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy StartDiscoverPrinter succeeded."); + return true; +} + +bool PrintServiceProxy::StopDiscoverPrinter() +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_STOPDISCOVERPRINTER, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy StopDiscoverPrinter succeeded."); + return true; +} + +bool PrintServiceProxy::StartPrintJob(PrintJob jobinfo) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + + uint32_t fileLength = jobinfo.GetFiles().size(); + data.WriteUint32(fileLength); + for(uint32_t i = 0; i < fileLength; i++) + { + data.WriteString(jobinfo.GetFiles()[i]); + + } + data.WriteUint32(jobinfo.GetJobId()); + data.WriteUint32(jobinfo.GetPrinterId()); + data.WriteUint32(jobinfo.GetJobState()); + data.WriteUint32(jobinfo.GetCopyNumber()); + + data.WriteUint32(jobinfo.GetPageRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPageRange().GetEndPage()); + uint32_t pageLength = jobinfo.GetPageRange().GetPages().size(); + data.WriteUint32(pageLength); + for(uint32_t i = 0; i < pageLength; i++) + { + data.WriteUint32(jobinfo.GetPageRange().GetPages()[i]); + } + + data.WriteUint32(jobinfo.GetIsSequential()); + + data.WriteUint32(jobinfo.GetPageSize().GetId()); + data.WriteString(jobinfo.GetPageSize().GetName()); + data.WriteUint32(jobinfo.GetPageSize().GetWidth()); + data.WriteUint32(jobinfo.GetPageSize().GetHeight()); + + data.WriteUint32(jobinfo.GetIsLandscape()); + data.WriteUint32(jobinfo.GetColorMode()); + data.WriteUint32(jobinfo.GetDuplexMode()); + + data.WriteUint32(jobinfo.GetMargin().GetTop()); + data.WriteUint32(jobinfo.GetMargin().GetBottom()); + data.WriteUint32(jobinfo.GetMargin().GetLeft()); + data.WriteUint32(jobinfo.GetMargin().GetRight()); + + data.WriteString(jobinfo.GetPreview().GetResult()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetEndPage()); + uint32_t previewPageLength = jobinfo.GetPreview().GetPreviewRange().GetPages().size(); + data.WriteUint32(previewPageLength); + for(uint32_t i = 0; i < previewPageLength; i++) + { + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetPages()[i]); + } + + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_STARTPRINTJOB, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy StartPrintJob succeeded."); + return true; +} + +bool PrintServiceProxy::CancelPrintJob(PrintJob jobinfo) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + + uint32_t fileLength = jobinfo.GetFiles().size(); + data.WriteUint32(fileLength); + for(uint32_t i = 0; i < fileLength; i++) + { + data.WriteString(jobinfo.GetFiles()[i]); + + } + data.WriteUint32(jobinfo.GetJobId()); + data.WriteUint32(jobinfo.GetPrinterId()); + data.WriteUint32(jobinfo.GetJobState()); + data.WriteUint32(jobinfo.GetCopyNumber()); + + data.WriteUint32(jobinfo.GetPageRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPageRange().GetEndPage()); + uint32_t pageLength = jobinfo.GetPageRange().GetPages().size(); + data.WriteUint32(pageLength); + for(uint32_t i = 0; i < pageLength; i++) + { + data.WriteUint32(jobinfo.GetPageRange().GetPages()[i]); + } + + data.WriteUint32(jobinfo.GetIsSequential()); + + data.WriteUint32(jobinfo.GetPageSize().GetId()); + data.WriteString(jobinfo.GetPageSize().GetName()); + data.WriteUint32(jobinfo.GetPageSize().GetWidth()); + data.WriteUint32(jobinfo.GetPageSize().GetHeight()); + + data.WriteUint32(jobinfo.GetIsLandscape()); + data.WriteUint32(jobinfo.GetColorMode()); + data.WriteUint32(jobinfo.GetDuplexMode()); + + data.WriteUint32(jobinfo.GetMargin().GetTop()); + data.WriteUint32(jobinfo.GetMargin().GetBottom()); + data.WriteUint32(jobinfo.GetMargin().GetLeft()); + data.WriteUint32(jobinfo.GetMargin().GetRight()); + + data.WriteString(jobinfo.GetPreview().GetResult()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetEndPage()); + uint32_t previewPageLength = jobinfo.GetPreview().GetPreviewRange().GetPages().size(); + data.WriteUint32(previewPageLength); + for(uint32_t i = 0; i < previewPageLength; i++) + { + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetPages()[i]); + } + + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_CANCELPRINTJOB, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy CancelPrintJob succeeded."); + return true; +} + +bool PrintServiceProxy::AddPrinters(std::vector arrayPrintInfo) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(arrayPrintInfo.size()); + PRINT_HILOGD("OnStartDiscoverPrinter arrayPrintInfo.size() = %{public}lu", arrayPrintInfo.size()); + for(uint32_t i = 0; i < arrayPrintInfo.size(); i++) + { + data.WriteUint32(arrayPrintInfo[i].GetPrintId()); + data.WriteString(arrayPrintInfo[i].GetPrinterName()); + data.WriteUint32(arrayPrintInfo[i].GetPrinterIcon()); + data.WriteUint32(arrayPrintInfo[i].GetPrinterState()); + data.WriteString(arrayPrintInfo[i].GetDescription()); + arrayPrintInfo[i].Dump(); + uint32_t pageSizeLength = arrayPrintInfo[i].GetCapability().GetPageSize().size(); + uint32_t resolutionLength = arrayPrintInfo[i].GetCapability().GetResolution().size(); + data.WriteUint32(pageSizeLength); + data.WriteUint32(resolutionLength); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetTop()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetBottom()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetLeft()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetRight()); + arrayPrintInfo[i].GetCapability().GetMinMargin().Dump(); + for(uint32_t i = 0; i < pageSizeLength; i++) + { + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetId()); + data.WriteString(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetName()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetWidth()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetHeight()); + arrayPrintInfo[i].GetCapability().GetPageSize()[i].Dump(); + } + for(uint32_t i = 0; i < resolutionLength; i++) + { + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetId()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetHorizontalDpi()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetVerticalDpi()); + arrayPrintInfo[i].GetCapability().GetResolution()[i].Dump(); + } + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetColorMode()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetDuplexMode()); + arrayPrintInfo[i].GetCapability().Dump(); + } + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_ADDPRINTERS, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy AddPrinters succeeded."); + return true; +} + +bool PrintServiceProxy::RemovePrinters(std::vector arrayPrintInfo) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(arrayPrintInfo.size()); + PRINT_HILOGD("OnStartDiscoverPrinter arrayPrintInfo.size() = %{public}lu", arrayPrintInfo.size()); + for(uint32_t i = 0; i < arrayPrintInfo.size(); i++) + { + data.WriteUint32(arrayPrintInfo[i].GetPrintId()); + data.WriteString(arrayPrintInfo[i].GetPrinterName()); + data.WriteUint32(arrayPrintInfo[i].GetPrinterIcon()); + data.WriteUint32(arrayPrintInfo[i].GetPrinterState()); + data.WriteString(arrayPrintInfo[i].GetDescription()); + arrayPrintInfo[i].Dump(); + uint32_t pageSizeLength = arrayPrintInfo[i].GetCapability().GetPageSize().size(); + uint32_t resolutionLength = arrayPrintInfo[i].GetCapability().GetResolution().size(); + data.WriteUint32(pageSizeLength); + data.WriteUint32(resolutionLength); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetTop()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetBottom()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetLeft()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetMinMargin().GetRight()); + arrayPrintInfo[i].GetCapability().GetMinMargin().Dump(); + for(uint32_t i = 0; i < pageSizeLength; i++) + { + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetId()); + data.WriteString(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetName()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetWidth()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetPageSize()[i].GetHeight()); + arrayPrintInfo[i].GetCapability().GetPageSize()[i].Dump(); + } + for(uint32_t i = 0; i < resolutionLength; i++) + { + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetId()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetHorizontalDpi()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetResolution()[i].GetVerticalDpi()); + arrayPrintInfo[i].GetCapability().GetResolution()[i].Dump(); + } + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetColorMode()); + data.WriteUint32(arrayPrintInfo[i].GetCapability().GetDuplexMode()); + arrayPrintInfo[i].GetCapability().Dump(); + } + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_REMOVEPRINTERS, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy RemovePrinters succeeded."); + return true; +} + +bool PrintServiceProxy::UpdatePrinterState(uint32_t printerId, uint32_t state) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(printerId); + data.WriteUint32(state); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_UPDATEPRINTERSTATE, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy UpdatePrinterState succeeded."); + return true; +} + +bool PrintServiceProxy::UpdatePrinterJobState(uint32_t jobId, uint32_t state) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteInt32(jobId); + data.WriteUint32(state); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_UPDATEPRINTERJOBSTATE, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + PRINT_HILOGD("PrintServiceProxy UpdatePrinterJobState succeeded."); + return true; +} + +bool PrintServiceProxy::RequestPreview(PrintJob jobinfo, std::string &previewResult) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + uint32_t fileLength = jobinfo.GetFiles().size(); + data.WriteUint32(fileLength); + for(uint32_t i = 0; i < fileLength; i++) + { + data.WriteString(jobinfo.GetFiles()[i]); + + } + data.WriteUint32(jobinfo.GetJobId()); + data.WriteUint32(jobinfo.GetPrinterId()); + data.WriteUint32(jobinfo.GetJobState()); + data.WriteUint32(jobinfo.GetCopyNumber()); + + data.WriteUint32(jobinfo.GetPageRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPageRange().GetEndPage()); + uint32_t pageLength = jobinfo.GetPageRange().GetPages().size(); + data.WriteUint32(pageLength); + for(uint32_t i = 0; i < pageLength; i++) + { + data.WriteUint32(jobinfo.GetPageRange().GetPages()[i]); + } + + data.WriteUint32(jobinfo.GetIsSequential()); + + data.WriteUint32(jobinfo.GetPageSize().GetId()); + data.WriteString(jobinfo.GetPageSize().GetName()); + data.WriteUint32(jobinfo.GetPageSize().GetWidth()); + data.WriteUint32(jobinfo.GetPageSize().GetHeight()); + + data.WriteUint32(jobinfo.GetIsLandscape()); + data.WriteUint32(jobinfo.GetColorMode()); + data.WriteUint32(jobinfo.GetDuplexMode()); + + data.WriteUint32(jobinfo.GetMargin().GetTop()); + data.WriteUint32(jobinfo.GetMargin().GetBottom()); + data.WriteUint32(jobinfo.GetMargin().GetLeft()); + data.WriteUint32(jobinfo.GetMargin().GetRight()); + + data.WriteString(jobinfo.GetPreview().GetResult()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetStartPage()); + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetEndPage()); + uint32_t previewPageLength = jobinfo.GetPreview().GetPreviewRange().GetPages().size(); + data.WriteUint32(previewPageLength); + for(uint32_t i = 0; i < previewPageLength; i++) + { + data.WriteUint32(jobinfo.GetPreview().GetPreviewRange().GetPages()[i]); + } + + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_REQUESTPREVIEW, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + previewResult = reply.ReadString(); + PRINT_HILOGD("PrintServiceProxy RequestPreview succeeded."); + return true; +} + +bool PrintServiceProxy::QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) +{ + MessageParcel data, reply; + MessageOption option; + data.WriteInterfaceToken(PrintServiceProxy::GetDescriptor()); + data.WriteUint32(printerId); + PRINT_HILOGD("PrintServiceProxy ChangeTaskPriority started."); + bool ret = Remote()->SendRequest(CMD_QUERYPRINTERCAPABILITY, data, reply, option); + if (ret != ERR_NONE) { + PRINT_HILOGD("PrintServiceProxy, ret = %{public}d", ret); + return false; + } + uint32_t arraypageSizeLength = reply.ReadUint32(); + uint32_t resolutionLength = reply.ReadUint32(); + PRINT_HILOGD("PrintServiceProxy, arraypageSizeLength = %{public}d", arraypageSizeLength); + PRINT_HILOGD("PrintServiceProxy, resolutionLength = %{public}d", resolutionLength); + printerCapability.GetMinMargin().SetTop(reply.ReadUint32()); + printerCapability.GetMinMargin().SetBottom(reply.ReadUint32()); + printerCapability.GetMinMargin().SetLeft(reply.ReadUint32()); + printerCapability.GetMinMargin().SetRight(reply.ReadUint32()); + printerCapability.GetMinMargin().Dump(); + for(uint32_t i = 0; i < arraypageSizeLength; i++) + { + PrinterPageSize printerPageSize; + printerPageSize.SetId(reply.ReadUint32()); + printerPageSize.SetName(reply.ReadString()); + printerPageSize.SetWidth(reply.ReadUint32()); + printerPageSize.SetHeight(reply.ReadUint32()); + printerCapability.SetPageSize(printerPageSize); + printerCapability.GetPageSize()[i].Dump(); + } + + for(uint32_t i = 0; i < resolutionLength; i++) + { + PrinterResolution printerResolution; + printerResolution.SetId(reply.ReadUint32()); + printerResolution.SetHorizontalDpi(reply.ReadUint32()); + printerResolution.SetVerticalDpi(reply.ReadUint32()); + printerCapability.SetResolution(printerResolution); + printerCapability.GetResolution()[i].Dump(); + } + + printerCapability.SetColorMode(reply.ReadUint32()); + printerCapability.SetDuplexMode(reply.ReadUint32()); + printerCapability.Dump(); + + PRINT_HILOGD("PrintServiceProxy QueryPrinterCapability succeeded."); + return true; +} + +bool PrintServiceProxy::CheckPermission() +{ + PRINT_HILOGD("PrintServiceProxy::CheckPermission in"); + MessageParcel data, reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + PRINT_HILOGE(" Failed to write parcelable "); + return false; + } + + int32_t result = Remote()->SendRequest(CMD_CHECKPERMISSION, data, reply, option); + if (result != ERR_NONE) { + PRINT_HILOGE(" PrintServiceProxy::CheckPermission fail, ret = %{public}d ", result); + return false; + } + bool ret = reply.ReadBool(); + PRINT_HILOGD("PrintServiceProxy::CheckPermission out [ret: %{public}d]", ret); + return ret; +} + +bool PrintServiceProxy::On(uint32_t taskId, const std::string &type, const sptr &listener) +{ + PRINT_HILOGD("PrintServiceProxy::On listener=%{public}p", listener.GetRefPtr()); + MessageParcel data, reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + PRINT_HILOGE(" Failed to write parcelable "); + return false; + } + if (listener == nullptr) { + PRINT_HILOGE("listener is nullptr"); + return false; + } + + if (!data.WriteUint32(taskId)) { + PRINT_HILOGE("write taskId=%{public}d fail", taskId); + return false; + } + + PRINT_HILOGD("PrintServiceProxy::On type=%{public}s", type.c_str()); + if (type.empty()) { + PRINT_HILOGE("PrintServiceProxy::On type is null."); + return false; + } + if (!data.WriteString(type)) { + PRINT_HILOGE("write type failed."); + return false; + } + if (!data.WriteRemoteObject(listener->AsObject().GetRefPtr())) { + PRINT_HILOGE("write parcel failed."); + return false; + } + int32_t result = Remote()->SendRequest(CMD_ON, data, reply, option); + if (result != ERR_NONE) { + PRINT_HILOGE(" PrintServiceProxy::On fail, result = %{public}d ", result); + return false; + } + bool ret = reply.ReadBool(); + PRINT_HILOGD("PrintServiceProxy::On out [result: %{public}d]", ret); + return ret; +} + +bool PrintServiceProxy::Off(uint32_t taskId, const std::string &type) +{ + PRINT_HILOGD("PrintServiceProxy::Off in"); + MessageParcel data, reply; + MessageOption option; + if (!data.WriteInterfaceToken(GetDescriptor())) { + PRINT_HILOGE(" Failed to write parcelable "); + return false; + } + + if (!data.WriteUint32(taskId)) { + PRINT_HILOGE("write taskId=%{public}d fail", taskId); + return false; + } + + if (!data.WriteString(type)) { + PRINT_HILOGE("write type=%{public}s fail", type.c_str()); + return false; + } + int32_t result = Remote()->SendRequest(CMD_OFF, data, reply, option); + if (result != ERR_NONE) { + PRINT_HILOGE(" PrintServiceProxy::Off fail, ret = %{public}d ", result); + return false; + } + bool ret = reply.ReadBool(); + PRINT_HILOGD("PrintServiceProxy::Off out [ret: %{public}d]", ret); + return ret; +} +} // namespace OHOS::Print diff --git a/hisysevent.yaml b/hisysevent.yaml new file mode 100644 index 0000000..f7fd1d5 --- /dev/null +++ b/hisysevent.yaml @@ -0,0 +1,55 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +##################################################### +# below is the format of defining event # +##################################################### +#domain: domain name. [Only one domain name can be defined at the top] +# +#author: the author name who defined this event. +#date: the date when this event was defined, format is YYYY-MM-DD. +#logged: source file which refer to this event. +#usage: the usage of this event. +#//Define event name and event properties. +#@EVENT_NAME: the event definition part begin. +# // __BASE is used for defining the basic info of the event. +# // "type" optional values are: FAULT, STATISTICS, SECURITY, BEHAVIOR. +# // "level" optional values are: CRITICAL, MINOR. +# // "tag" set tags with may used by subscriber of this event, multiple tags devided by space. +# // "desc" full description of this event. +# @PARAMETER: {type: parameter type, arrsize: array length(optional), desc: parameter description}. +# // follow the __BASE block, each line defines a parameter of this event. +# // "type" optional values are: INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64, FLOAT, DOUBLE, STRING. +# // "arrsize" of the parameter is an array, set a non-zero value. +# // "desc" full description of this parameter. + +##################################################### +# Example of some hiviewdfx events definition # +##################################################### + +domain: PRINT + +SERVICE_FAULT: + __BASE: {type: FAULT, level: CRITICAL, desc: The event is service fault } + FAULT_TYPE: {type: INT32, desc: fault id } + MODULE_NAME: {type: STRING, desc: module name } + ERROR_TYPE: {type: INT32, desc: error type } + +RUNTIME_FAULT: + __BASE: {type: FAULT, level: CRITICAL, desc: The event is runtime fault } + FAULT_TYPE: {type: INT32, desc: fault id } + ERROR_TYPE: {type: INT32, desc: error type } + +USAGETIME_STATISTIC: + __BASE: {type: STATISTIC, level: MINOR, desc: The event is usagetime statistic } + PRINT_INFO: {type: STRING, desc: print infomation } diff --git a/interfaces/kits/jskits/@ohos.PrintExtensionAbility.d.ts b/interfaces/kits/jskits/@ohos.PrintExtensionAbility.d.ts new file mode 100644 index 0000000..cd91fd2 --- /dev/null +++ b/interfaces/kits/jskits/@ohos.PrintExtensionAbility.d.ts @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** +* class of print extension. +* +* @systemapi Hide this for inner system use. +* @since 9 +* @sysCap SystemCapability.Print.print +* @StageModelOnly +*/ +declare class PrintExtensionAbility { + + /** + * Called once to initialize the extension. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onCreated(want: Want): void; + + /** + * Called once to start to discover the printers connected with the device. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onStartDiscoverPrinter(): void; + + /** + * Called once to stop discovering the printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onStopDiscoverPrinter(): void; + + /** + * Called once to connect to the specific printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onConnectPrinter(printerId: number): void; + + /** + * Called once to disconnect the specific printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onDisconnectPrinter(printerId: number): void; + + /** + * Called once to start print job. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onStartPrintJob(jobInfo: PrintJob): void; + + /** + * Called once to remove the print job has been started. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onCancelPrintJob(jobInfo: PrintJob): void; + + /** + * Called once to request the capability of the printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onRequestPrinterCapability(printerId: number): PrinterCapability; + + /** + * Called once to request preview and send result to Print SA. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onRequestPreview(jobInfo: PrintJob): Uri; + + /** + * Called once to finalize the extension. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Print.print + * @return - + * @StageModelOnly + */ + onDestroy(): void; +} + +export default PrintExtensionAbility; diff --git a/interfaces/kits/jskits/@ohos.print.d.ts b/interfaces/kits/jskits/@ohos.print.d.ts new file mode 100644 index 0000000..672ed78 --- /dev/null +++ b/interfaces/kits/jskits/@ohos.print.d.ts @@ -0,0 +1,329 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import {AsyncCallback} from './basic'; + +/** + * System print + * @sysCap SystemCapability.Print.print + * @import import print from '@ohos.app.print'; + * @since 9 + */ +declare namespace print { + + interface PrintTask { + /** + * Register event callback when the current print task is in process. + * @since 9 + * @param type block Indicates the print task has been blocked. + * type success Indicates the print task succeed. . + * type fail Indicates the print task has completed with failure. + * type cancel Indicates the print task has been cancelled. + * @param callback The callback function for print task change event + * @permission {@code ohos.permission.PRINT} + * @return - + */ + on(type:'block'| 'success'| 'fail' | 'cancel', callback:() => void): void; + + /** + * Unregister event callback when the current print task is in process. + * @since 9 + * @param type block Indicates the print task has been blocked. + * type success Indicates the print task succeed. . + * type fail Indicates the print task has completed with failure. + * type cancel Indicates the print task has been cancelled. + * @param callback The callback function for print task change event + * @permission {@code ohos.permission.PRINT} + * @return - + */ + off(type:'block'| 'success'| 'fail' | 'cancel', callback?:() => void): void; + } + + /** + * Start new print task for App. + * @since 9 + * @param files Indicates the document list to be printed. + * @param callback The callback function for print task + * @permission {@code ohos.permission.PRINT} + * @return - + */ + function print(files: Array, callback: AsyncCallback): void; + function print(files: Array): Promise; + + interface PrintMargin { + top: number; // top margin + bottom: number; // bottom margin + left: number; // left side margin + right: number; // right side margin + } + + interface PrinterRange { + startPage: number; // start page of sequence + endPage: number; // end page of sequence + pages: Array; // discrete page of sequence + } + interface PreviewAttribute { + previewRange: PrinterRange; // preview page range + result: string; // preview file + } + + interface PrinterResolution { + id: number; // resolution id + horizontalDpi: number // horizontal DPI + verticalDpi: number; // vertical DPI + } + + interface PrinterPageSize { + id: number; // page size id + name: string; // page size name + width: number; // unit: milimeter + height: number; // unit: milimeter + } + + interface PrinterCapability { + /* Printer Capability */ + minMargin: PrintMargin; // min margin of printer + pageSize: Array; // the page size list supported by the printer + resolution: Array; // the resolution list supported by the printer + colorMode: number; // color mode + duplexMode: number; // duplex mode + } + + interface PrinterInfo { + printerId: number; // printer id + printerName: string; // printer name + printerIcon: number; // resource id of printer icon + printerState: PrinterState; // current printer state + description: string; // printer description + capability: PrinterCapability; // printer capability + } + + interface PrintJob { + files: Array; // document list to be printed + /* job attributes */ + printerId: number; // printer id to take charge of printing + jobState: PrintJobState; // current print job state + copyNumber: number; // copies of document list + pageRange: PrinterRange; // range size to be printed + isSequential?: boolean; // sequential print + pageSize?: PrinterPageSize; // the selected page size + isLandscape?: boolean; // vertical printing + colorMode?: number; // color mode + duplexMode?: number; // duplex mode + margin?: PrintMargin; // current margin setting + preview?: PreviewAttribute; // preview setting + } + + enum PrinterState { + PRINTER_ADD = 1, // new printers arrival + PRINTER_REMOVED = 2, // printers lost + PRINTER_IDLE = 3, // printer idle + PRINTER_PRINTING = 4, // printer is working + PRINTER_BLOCK = 5, // printer has been blocked + PRINTER_BUSY = 6, // printer is busy + PRINTER_FAULT = 7 // printer failure + } + + enum PrintJobState { + PRINT_JOB_INIT = 1, // initial state of print job + PRINT_JOB_START = 2, // start print job + PRINT_JOB_PRINTING = 3, // printing + PRINT_JOB_BLOCK = 4, // print job has been blocked + PRINT_JOB_COMPLETE = 5, // print completed + PRINT_JOB_CANCEL = 6 // print job has been cancelled + } + + interface PrinterExtensionInfo extends ExtensionAbilityInfo{ + extensionId: number; // extesion id of printer extension + vendorId: number; // vendor id of extension + vendorName: string; // vendor name + vendorIcon: number; // resource id of vendor + version: string; // version of current printer extension + } + + /** + * Get all printer extensin installed. + * + * @since 9 + * @param callback The callback function for handling the extension list found + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function queryExtensionAbilityInfos(callback: AsyncCallback>): void; + function queryExtensionAbilityInfos(): Promise>; + + /** + * Load the specific printer extension and start to discover printer. + * + * @since 9 + * @param extensionList Indicates the list of printer extension + * empty list of extensionList Indicates to find printer with all installed extension + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function startDiscoverPrinter(extensionList:Array, callback: AsyncCallback): void; + function startDiscoverPrinter(extensionList:Array): Promise; + + /** + * Stop discovering the printer with specific printer extension. + * + * @since 9 + * @param extensionList Indicates the list of printer extension + * empty list of extensionList Indicates to find printer with all installed extension + * @param callback The callback function for indcating the result of API execution + * @permission {@ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function stopDiscoverPrinter(callback: AsyncCallback): void; + function stopDiscoverPrinter(): Promise; + + /** + * Start print job. + * + * @since 9 + * @param jobInfo Indicates the information of print job. + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function startPrintJob(jobinfo:PrintJob, callback:AsyncCallback):void; + function startPrintJob(jobinfo:PrintJob): Promise; + + /** + * Cancel the print job has been sent to printer. + * + * @since 9 + * @param jobInfo Indicates the information of print job. + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function cancelPrintJob(jobinfo:PrintJob, callback:AsyncCallback):void; + function cancelPrintJob(jobinfo:PrintJob): Promise; + + /** + * Request preview of the print job. + * + * @since 9 + * @param jobInfo Indicates the information of print job. + * @param callback The callback function for preview result from printer + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function requestPrintPreview(jobinfo:PrintJob, callback:(result:string) => void): void; + function requestPrintPreview(jobinfo:PrintJob): Promise; + + /** + * Query capability for the specific printer. + * + * @since 9 + * @param printerId Indicates id of the printer + * @param callback The callback function for capability from printer + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function queryPrinterCapability(printerId:number, callback:AsyncCallback):void; + function queryPrinterCapability(printerId:number): Promise + + /** + * Register event callback for the state change of printer. + * + * @since 9 + * @param printerStateChange Indicates state change of printer + * @param callback The callback function for state change of printer. + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + on(type: 'printerStateChange', callback:(state: PrinterState, info: PrinterInfo) => void): void; + off(type: 'printerStateChange', callback:(boolean) => void): void; + + /** + * Register event callback for the specific print job. + * + * @since 9 + * @param jobStateChange Indicates state change of print job + * @param callback The callback function for state change of print job. + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + on(type: 'jobStateChange', callback:(state: PrintJobState, job: PrintJob) => void): void; + off(type: 'jobStateChange', callback:(boolean) => void): void; + + /** + * New printers have been found and notify Print SA. + * + * @since 9 + * @param printers Indicates new arrived printer lists. + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function addPrinters(printers: Array, callback: AsyncCallback): void; + function addPrinters(printers: Array): Promise; + + /** + * Printers have been lost and notify Print SA. + * + * @since 9 + * + * @param printerId Indicates id of the printer + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function removePrinters(printers: Array, callback: AsyncCallback): void; + function removePrinters(printers: Array): Promise; + + /** + * Notify Print SA the state of printer has been changed. + * + * @since 9 + * @param state Indicates new printer state + * @param printerId Indicates id of the printer + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function updatePrinterState(state: PrinterState, printerId: number, callback: AsyncCallback): void; + function updatePrinterState(state: PrinterState, printerId: number): Promise; + + /** + * Notify Print SA the state of print job has been changed. + * + * @since 9 + * @param state Indicates new printer state + * @param jobId Indicates id of the print job + * @param callback The callback function for indcating the result of API execution + * @permission {@code ohos.permission.MANAGE_PRINT_JOB} + * @systemapi Hide this for inner system use. + * @return - + */ + function updatePrintJobState(state: PrintJobState, jobId: number, callback: AsyncCallback): void; + function updatePrintJobState(state: PrintJobState, jobId: number): Promise; +} + +export default print; diff --git a/interfaces/kits/jskits/@ohos.printextension.d.ts b/interfaces/kits/jskits/@ohos.printextension.d.ts new file mode 100644 index 0000000..aaae971 --- /dev/null +++ b/interfaces/kits/jskits/@ohos.printextension.d.ts @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** +* class of print extension. +* +* @systemapi Hide this for inner system use. +* @since 9 +* @sysCap SystemCapability.Miscservices.print +* @StageModelOnly +*/ +declare class printExtension { + + /** + * Called once to initialize the extension. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onCreated(want: object): void; + + /** + * Called once to start to discover the printers connected with the device. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onStartDiscoverPrinter(): void; + + /** + * Called once to stop discovering the printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onStopDiscoverPrinter(): void; + + /** + * Called once to connect to the specific printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onConnectPrinter(printerId: number): void; + + /** + * Called once to disconnect the specific printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onDisconnectPrinter(printerId: number): void; + + /** + * Called once to start print job. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onStartJob(jobInfo: PrintJob): void; + + /** + * Called once to remove the print job has been started. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onCancelJob(jobInfo: PrintJob): void; + + /** + * Called once to request the capability of the printer. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onRequestCapability(printerId: number): PrinterCapability; + + /** + * Called once to request preview and send result to Print SA. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onRequestPreview(jobInfo: PrintJob): Uri; + + /** + * Called once to finalize the extension. + * + * @systemapi Hide this for inner system use. + * @since 9 + * @sysCap SystemCapability.Miscservices.print + * @return - + * @StageModelOnly + */ + onDestroy(): void; +} + +export default printExtension; diff --git a/interfaces/kits/jskits/printextsample.js b/interfaces/kits/jskits/printextsample.js new file mode 100644 index 0000000..b7e80ef --- /dev/null +++ b/interfaces/kits/jskits/printextsample.js @@ -0,0 +1,69 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import Extension from '@ohos.PrintExtensionAbility' +import print from '@ohos.print' + +let MODULE_TAG = "hwprintext" +export default class PrintExtAbility extends Extension { + Array printerListï¼› + onCreated(want) { + console.info(MODULE_TAG + 'ability on created start'); + } + + onStartDiscoverPrinter() { + console.info(MODULE_TAG + "ability start to discover printer"; + if (hasFoundDevice) { + print.addPrinters(printerList); + } + } + + onStopDiscoverPrinter() { + console.info(MODULE_TAG + 'ability stop discovering printer'); + } + + onDestroy() { + console.info(MODULE_TAG + 'ability on destroy'); + } + + onConnectPrinter(printerId) { + console.info(MODULE_TAG + 'ability connect the speci1 printer'); + } + + onDisconnectPrinter(printerId) { + console.info(MODULE_TAG + 'ability disconnect the speci1 printer'); + } + + onStartPrintJob(jobInfo) { + console.info(MODULE_TAG + 'ability start Print Job'); + } + + onCancelPrintJob(jobInfo) { + console.info(MODULE_TAG + 'ability cancel Print Job'); + } + + onRequestPrinterCapability(printerId) { + console.info(MODULE_TAG + 'ability request printer capability'); + var capability = GetDeviceCapability(printerId); + return capability; + } + + onRequestPreview(jobInfo) { + console.info(MODULE_TAG + 'ability request printer preview'); + FileDescriptor fd = print.OpenFile(jobInfo.preview.result); + SavePreviewToFile(fd); + return jobInfo.preview.result; + } +}; \ No newline at end of file diff --git a/interfaces/kits/jskits/printsample.js b/interfaces/kits/jskits/printsample.js new file mode 100644 index 0000000..5e2139c --- /dev/null +++ b/interfaces/kits/jskits/printsample.js @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import printmanager from '@ohos.app.print'; +// start print +export async function startPrint() { + Array fileList = ['./data/printsample.pdf', './data/photo.jpg']; + await printmanager.print(fileList).then(async (task) => { + task.on('block', () => { + console.info('[block] event is called'); + }); + task.on('success', () => { + console.info('[success] event is called'); + }); + task.on('fail', () => { + console.info('[fail] event is called'); + }); + task.on('cancel', () => { + console.info('[cancel] event is called'); + }); + }); +} diff --git a/interfaces/kits/napi/BUILD.gn b/interfaces/kits/napi/BUILD.gn new file mode 100644 index 0000000..033426d --- /dev/null +++ b/interfaces/kits/napi/BUILD.gn @@ -0,0 +1,76 @@ +# Copyright (c) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import("//base/request/request/request_aafwk.gni") +import("//build/ohos.gni") + +config("print_interfaces_kits_napi_config") { + visibility = [ ":*" ] + include_dirs = [ "include" ] + + cflags_cc = [ "-fexceptions" ] +} +ohos_shared_library("print") { + include_dirs = [ + "//foundation/arkui/ace_engine/frameworks/base/utils", + "//foundation/arkui/napi", + "//foundation/arkui/napi/interfaces/kits", + "//foundation/arkui/napi/interfaces/inner_api", + "//third_party/node/src", + "//third_party/curl/include", + "${ability_runtime_services_path}/common/include", + "//utils/system/safwk/native/include", + "${ability_runtime_path}/interfaces/kits/native/appkit/app/", + "${ability_runtime_path}/interfaces/kits/native/ability/native", + "${ability_runtime_services_path}/abilitymgr/include", + "${ability_runtime_inner_api_path}/ability_manager/include", + "//foundation/distributedschedule/samgr/interfaces/innerkits/Isamgr", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy/include", + "//base/print/print/utils/include", + "//base/print/print/frameworks/innerkitsimpl/include", + ] + public_configs = [ ":print_interfaces_kits_napi_config" ] + + sources = [ + "src/print_module.cpp", + "src/napi_print_task.cpp", + "src/napi_inner_print.cpp", + "src/napi_print_ext.cpp", + "src/async_call.cpp", + "src/print_task.cpp", + "src/napi_utils.cpp" + ] + deps = [ + "//foundation/arkui/napi:ace_napi", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//base/print/print/frameworks/innerkitsimpl:printclient", + ] + external_deps = [ + "ability_base:want", + "ability_base:zuri", + "ability_runtime:ability_manager", + "ability_runtime:abilitykit_native", + "ability_runtime:data_ability_helper", + "ability_runtime:napi_base_context", + "c_utils:utils", + "eventhandler:libeventhandler", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "preferences:native_preferences", + "relational_store:native_appdatafwk", + "relational_store:native_dataability", + "relational_store:native_rdb", + ] + relative_install_dir = "module" + subsystem_name = "print" + part_name = "print" +} diff --git a/interfaces/kits/napi/include/async_call.h b/interfaces/kits/napi/include/async_call.h new file mode 100644 index 0000000..e411803 --- /dev/null +++ b/interfaces/kits/napi/include/async_call.h @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef PRINT_ASYNC_CALL_H +#define PRINT_ASYNC_CALL_H + +#include +#include +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "napi/native_node_api.h" + +namespace OHOS::Print { +class AsyncCall final { +public: + class Context { + public: + using InputAction = std::function; + using OutputAction = std::function; + using ExecAction = std::function; + Context(InputAction input, OutputAction output) : input_(std::move(input)), output_(std::move(output)) {}; + virtual ~Context() {}; + void SetAction(InputAction input, OutputAction output = nullptr) + { + input_ = input; + output_ = output; + } + + void SetAction(OutputAction output) + { + SetAction(nullptr, std::move(output)); + } + + virtual napi_status operator()(napi_env env, size_t argc, napi_value *argv, napi_value self) + { + if (input_ == nullptr) { + return napi_ok; + } + return input_(env, argc, argv, self); + } + + virtual napi_status operator()(napi_env env, napi_value *result) + { + if (output_ == nullptr) { + *result = nullptr; + return napi_ok; + } + return output_(env, result); + } + + virtual void Exec() + { + if (exec_ == nullptr) { + return; + } + exec_(this); + }; + + protected: + friend class AsyncCall; + InputAction input_ = nullptr; + OutputAction output_ = nullptr; + ExecAction exec_ = nullptr; + }; + + // The default AsyncCallback in the parameters is at the end position. + static constexpr size_t ASYNC_DEFAULT_POS = -1; + AsyncCall(napi_env env, napi_callback_info info, std::shared_ptr context, size_t pos = ASYNC_DEFAULT_POS); + ~AsyncCall(); + napi_value Call(napi_env env, Context::ExecAction exec = nullptr); + napi_value SyncCall(napi_env env, Context::ExecAction exec = nullptr); + +private: + enum { ARG_ERROR, ARG_DATA, ARG_BUTT }; + static void OnExecute(napi_env env, void *data); + static void OnComplete(napi_env env, napi_status status, void *data); + struct AsyncContext { + std::shared_ptr ctx = nullptr; + napi_ref callback = nullptr; + napi_ref self = nullptr; + napi_deferred defer = nullptr; + napi_async_work work = nullptr; + }; + static void DeleteContext(napi_env env, AsyncContext *context); + + AsyncContext *context_ = nullptr; + napi_env env_ = nullptr; +}; +} // namespace OHOS::Print +#endif // REQUEST_ASYNC_CALL_H diff --git a/interfaces/kits/napi/include/base_context.h b/interfaces/kits/napi/include/base_context.h new file mode 100644 index 0000000..a576f44 --- /dev/null +++ b/interfaces/kits/napi/include/base_context.h @@ -0,0 +1,102 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_BASE_CONTEXT_H +#define PRINT_BASE_CONTEXT_H + +#include + +#include "event_manager.h" +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "noncopyable.h" + +namespace OHOS::Request::Print { +typedef void (*AsyncWorkExecutor)(napi_env env, void *data); + +typedef void (*AsyncWorkCallback)(napi_env env, napi_status status, void *data); + +// support no argument +class BaseContext { +public: + ACE_DISALLOW_COPY_AND_MOVE(BaseContext); + + BaseContext() = delete; + + explicit BaseContext(napi_env env, napi_callback_info info, EventManager *manager); + + virtual ~BaseContext(); + + virtual void ParseParams(napi_value *params, size_t paramsCount); + + void SetParseOK(bool parseOK); + + void SetExecOK(bool execOK); + + void SetErrorCode(int32_t errorCode); + + napi_status SetCallback(napi_value callback); + + void DeleteCallback(); + + void CreateAsyncWork(const std::string &name, AsyncWorkExecutor executor, AsyncWorkCallback callback); + + void DeleteAsyncWork(); + + napi_value CreatePromise(); + + [[nodiscard]] bool IsParseOK() const; + + [[nodiscard]] bool IsExecOK() const; + + [[nodiscard]] napi_env GetEnv() const; + + [[nodiscard]] napi_callback_info GetInfo() const; + + [[nodiscard]] int32_t GetErrorCode() const; + + [[nodiscard]] napi_value GetCallback() const; + + [[nodiscard]] napi_deferred GetDeferred() const; + + [[nodiscard]] const std::string &GetAsyncWorkName() const; + + void Emit(const std::string &type, const std::pair &argv); + +protected: + EventManager *manager_; + +private: + napi_env env_; + + napi_callback_info info_; + + bool parseOK_; + + bool execOK_; + + int32_t errorCode_; + + napi_ref callback_; + + napi_async_work asyncWork_; + + napi_deferred deferred_; + + std::string asyncWorkName_; +}; +} // namespace OHOS::Request::Print + +#endif /* PRINT_BASE_CONTEXT_H */ diff --git a/interfaces/kits/napi/include/napi_inner_print.h b/interfaces/kits/napi/include/napi_inner_print.h new file mode 100644 index 0000000..81a99c4 --- /dev/null +++ b/interfaces/kits/napi/include/napi_inner_print.h @@ -0,0 +1,78 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef NAPI_INNER_PRINT_H +#define NAPI_INNER_PRINT_H + +#include "async_call.h" +#include "napi/native_api.h" +#include "print_cap_ability.h" +#include "print_extension_Info.h" +#include "print_page_size.h" +#include "print_resolution.h" +#include "print_job.h" +#include "print_task.h" +#include "noncopyable.h" +#include +#include + +namespace OHOS::Print { +class NapiInnerPrint { +public: + explicit NapiInnerPrint(uint32_t taskId); + ~NapiInnerPrint(); + + static napi_value QueryExtensionInfo(napi_env env, napi_callback_info info); + static napi_value StartDiscovery(napi_env env, napi_callback_info info); + static napi_value StopDiscovery(napi_env env, napi_callback_info info); + static napi_value ConnectPrint(napi_env env, napi_callback_info info); + static napi_value DisconnectPrint(napi_env env, napi_callback_info info); + static napi_value StartPrint(napi_env env, napi_callback_info info); + static napi_value CancelPrint(napi_env env, napi_callback_info info); + static napi_value RequestPreview(napi_env env, napi_callback_info info); + static napi_value QueryCapability(napi_env env, napi_callback_info info); + static napi_value On(napi_env env, napi_callback_info info); + static napi_value Off(napi_env env, napi_callback_info info); +private: + struct OperationContext : public AsyncCall::Context { + std::string info; + std::vector arrayPrinterExtensionInfo; + std::vector extensionList; + std::string previewResult = ""; + PrintJob jobinfo; + PrintTask *task_ = nullptr; + std::string title_ = ""; + std::string description_ = ""; + std::string filePath_ = ""; + uint32_t speedLimit_ = 0; + uint32_t priority_ = 0; + PrinterCapability printerCapability; + bool result = false; + std::string stateType_ = ""; + uint32_t printStartJobNumber = 0; + uint32_t printCancelJobNumber = 0; + uint32_t printReqPreviewJobNumber = 0; + uint32_t printCapacityId = 0; + uint32_t printConnId = 0; + uint32_t printDisConnId = 0; + std::vector extensionVector; + napi_status status = napi_generic_failure; + OperationContext() : Context(nullptr, nullptr) {}; + OperationContext(InputAction input, OutputAction output) : Context(std::move(input), std::move(output)) {}; + virtual ~OperationContext() {}; + }; +}; +} // namespace OHOS::Print +#endif // NAPI_INNER_PRINT_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/napi_print_ext.h b/interfaces/kits/napi/include/napi_print_ext.h new file mode 100644 index 0000000..02fce9a --- /dev/null +++ b/interfaces/kits/napi/include/napi_print_ext.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef NAPI_PRINT_EXT_H +#define NAPI_PRINT_EXT_H + +#include "async_call.h" +#include "napi/native_api.h" +#include "print_task.h" +#include "print_info.h" +#include "noncopyable.h" + +namespace OHOS::Print { +class NapiPrintExt { +public: + static napi_value AddPrinters(napi_env env, napi_callback_info info); + static napi_value RemovePrinters(napi_env env, napi_callback_info info); + static napi_value UpdatePrinterState(napi_env env, napi_callback_info info); + static napi_value UpdatePrintJobState(napi_env env, napi_callback_info info); + static bool ParseInfo(napi_env env, napi_value InfoValue, PrintInfo &Info); + static bool ParseInfoParam(napi_env env, napi_value InfoValue, PrintInfo &info); + static bool ParseCapability(napi_env env, napi_value InfoValue, PrinterCapability &capability); +private: + struct NapiPrintExtContext : public AsyncCall::Context { + PrintTask *task_ = nullptr; + PrintInfo info_; + std::vector arrayPrintInfo; + bool result = false; + uint32_t printerId = 0; + uint32_t printerJobId = 0; + uint32_t printerState = 0; + uint32_t printerJobState = 0; + napi_status status = napi_generic_failure; + std::vector printInfoVector; + NapiPrintExtContext() : Context(nullptr, nullptr) {}; + NapiPrintExtContext(InputAction input, OutputAction output) : Context(std::move(input), std::move(output)) {}; + virtual ~NapiPrintExtContext() {}; + }; +}; +} // namespace OHOS::Print +#endif // NAPI_PRINT_EXT_H \ No newline at end of file diff --git a/interfaces/kits/napi/include/napi_print_task.h b/interfaces/kits/napi/include/napi_print_task.h new file mode 100644 index 0000000..50ed31a --- /dev/null +++ b/interfaces/kits/napi/include/napi_print_task.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef NAPI_PRINT_TASK_H +#define NAPI_PRINT_TASK_H + +#include "async_call.h" + +namespace OHOS::Print { +class NapiPrintTask { +public: + static napi_value Print(napi_env env, napi_callback_info info); + +private: + static napi_value GetCtor(napi_env env); + static napi_value Initialize(napi_env env, napi_callback_info info); + +private: + static __thread napi_ref globalCtor; +}; +} // namespace OHOS::Print +#endif // NAPI_PRINT_TASK_H diff --git a/interfaces/kits/napi/include/napi_utils.h b/interfaces/kits/napi/include/napi_utils.h new file mode 100644 index 0000000..e005b3b --- /dev/null +++ b/interfaces/kits/napi/include/napi_utils.h @@ -0,0 +1,119 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_NAPI_UTILS_H +#define PRINT_NAPI_UTILS_H + +#include +#include + +#include "napi/native_api.h" +#include "napi/native_common.h" +#include "print_info.h" +#include "print_cap_ability.h" +#include "print_resolution.h" + +namespace OHOS::Print::NapiUtils { +static constexpr int32_t MAX_ARGC = 6; +static constexpr int32_t NO_ARG = 0; +static constexpr int32_t ONE_ARG = 1; +static constexpr int32_t TWO_ARG = 2; +static constexpr int32_t THE_ARG = 3; + +static constexpr int32_t FIRST_ARGV = 0; +static constexpr int32_t SECOND_ARGV = 1; +static constexpr int32_t THIRD_ARGV = 2; + +static constexpr int32_t MAX_NUMBER_BYTES = 8; +static constexpr int32_t MAX_LEN = 4096; + +napi_valuetype GetValueType(napi_env env, napi_value value); + +/* named property */ +bool HasNamedProperty(napi_env env, napi_value object, const std::string &propertyName); + +napi_value GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName); + +void SetNamedProperty(napi_env env, napi_value object, const std::string &name, napi_value value); + +std::vector GetPropertyNames(napi_env env, napi_value object); + +/* UINT32 */ +napi_value CreateUint32(napi_env env, uint32_t code); + +uint32_t GetUint32FromValue(napi_env env, napi_value value); + +uint32_t GetUint32Property(napi_env env, napi_value object, const std::string &propertyName); + +void SetUint32Property(napi_env env, napi_value object, const std::string &name, uint32_t value); + +/* INT32 */ +napi_value CreateInt32(napi_env env, int32_t code); + +int32_t GetInt32FromValue(napi_env env, napi_value value); + +int32_t GetInt32Property(napi_env env, napi_value object, const std::string &propertyName); + +void SetInt32Property(napi_env env, napi_value object, const std::string &name, int32_t value); + +/* String UTF8 */ +napi_value CreateStringUtf8(napi_env env, const std::string &str); + +std::string GetStringFromValueUtf8(napi_env env, napi_value value); + +std::string GetStringPropertyUtf8(napi_env env, napi_value object, const std::string &propertyName); + +void SetStringPropertyUtf8(napi_env env, napi_value object, const std::string &name, const std::string &value); + +std::string GetValueString(napi_env env, napi_value value); + +/* array buffer */ +bool ValueIsArrayBuffer(napi_env env, napi_value value); + +void *GetInfoFromArrayBufferValue(napi_env env, napi_value value, size_t *length); + +napi_value CreateArrayBuffer(napi_env env, size_t length, void **data); + +/* object */ +napi_value CreateObject(napi_env env); + +/* undefined */ +napi_value GetUndefined(napi_env env); + +/* function */ +napi_value CallFunction(napi_env env, napi_value recv, napi_value func, size_t argc, const napi_value *argv); + +napi_value CreateFunction(napi_env env, const std::string &name, napi_callback func, void *arg); + +/* reference */ +napi_ref CreateReference(napi_env env, napi_value callback); + +napi_value GetReference(napi_env env, napi_ref callbackRef); + +void DeleteReference(napi_env env, napi_ref callbackRef); + +/* boolean */ +bool GetBooleanProperty(napi_env env, napi_value object, const std::string &propertyName); + +void SetBooleanProperty(napi_env env, napi_value object, const std::string &name, bool value); + +/* define properties */ +void DefineProperties( + napi_env env, napi_value object, const std::initializer_list &properties); + +std::string ToLower(const std::string &s); + +} // namespace OHOS::Print::NapiUtils +#endif /* PRINT_NAPI_UTILS_H */ diff --git a/interfaces/kits/napi/include/print_task.h b/interfaces/kits/napi/include/print_task.h new file mode 100644 index 0000000..d0d4f1b --- /dev/null +++ b/interfaces/kits/napi/include/print_task.h @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_TASK_H +#define PRINT_TASK_H + +#include +#include +#include + +#include "napi/native_api.h" + +static constexpr const char *EVENT_BLOCK = "blocked"; +static constexpr const char *EVENT_SUCCESS = "success"; +static constexpr const char *EVENT_FAIL = "failed"; +static constexpr const char *EVENT_CANCEL = "cancelled"; + +static constexpr const char *PRINTER_STATE_ADD = "PRINTER_ADDED"; +static constexpr const char *PRINTER_STATE_REMOVED = "PRINTER_REMOVED"; +static constexpr const char *PRINTER_STATE_IDLE = "PRINTER_IDLE"; +static constexpr const char *PRINTER_STATE_PRINTING = "PRINTER_PRINTING"; +static constexpr const char *PRINTER_STATE_BLOCKED = "PRINTER_BLOCKED"; +static constexpr const char *PRINTER_STATE_BUSY = "PRINTER_BUSY"; +static constexpr const char *PRINTER_STATE_FAILED = "PRINTER_FAILED"; + +static constexpr const char *PRINTJOB_STATE_CREATED = "PRINT_JOB_CREATED"; +static constexpr const char *PRINTJOB_STATE_QUEUED = "PRINT_JOB_QUEUED"; +static constexpr const char *PRINTJOB_STATE_PRINTING = "PRINT_JOB_PRINTING"; +static constexpr const char *PRINTJOB_STATE_BLOCKED = "PRINT_JOB_BLOCKED"; +static constexpr const char *PRINTJOB_STATE_SUCCESS = "PRINT_JOB_SUCCESS"; +static constexpr const char *PRINTJOB_STATE_FAILED = "PRINT_JOB_FAILED"; +static constexpr const char *PRINTJOB_STATE_cancelled = "PRINT_JOB_cancelled"; + +namespace OHOS::Print { +class PrintTask { +public: + explicit PrintTask(uint32_t taskId); + ~PrintTask(); + + uint32_t GetId() const; + static napi_value On(napi_env env, napi_callback_info info); + static napi_value Off(napi_env env, napi_callback_info info); + + //bool AddListener(const std::string &type, sptr listener); + //void RemoveListener(const std::string &type, sptr listener); + //void RemoveListener(const std::string &type); + + bool IsSupportType(const std::string &type); + bool IsSupportPrinterStateType(const std::string &type); + bool IsSupportJobStateType(const std::string &type); +private: + int taskId_; + std::mutex mutex_; + //std::map> listenerMap_; + std::map supportEvents_; + std::map supportPrinterState_; + std::map supportJobState_; +}; +} // namespace OHOS::Print +#endif // PRINT_TASK_H diff --git a/interfaces/kits/napi/src/async_call.cpp b/interfaces/kits/napi/src/async_call.cpp new file mode 100644 index 0000000..7a740bb --- /dev/null +++ b/interfaces/kits/napi/src/async_call.cpp @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "async_call.h" + +#include "log.h" +#include "napi_utils.h" + +namespace OHOS::Print { +AsyncCall::AsyncCall(napi_env env, napi_callback_info info, std::shared_ptr context, size_t pos) : env_(env) +{ + context_ = new AsyncContext(); + size_t argc = NapiUtils::MAX_ARGC; + napi_value self = nullptr; + napi_value argv[NapiUtils::MAX_ARGC] = {nullptr}; + NAPI_CALL_RETURN_VOID(env, napi_get_cb_info(env, info, &argc, argv, &self, nullptr)); + pos = ((pos == ASYNC_DEFAULT_POS) ? (argc - 1) : pos); + if (pos >= 0 && pos < argc) { + napi_valuetype valueType = napi_undefined; + napi_typeof(env, argv[pos], &valueType); + if (valueType == napi_function) { + napi_create_reference(env, argv[pos], 1, &context_->callback); + argc = pos; + } + } + NAPI_CALL_RETURN_VOID(env, (*context)(env, argc, argv, self)); + context_->ctx = std::move(context); + napi_create_reference(env, self, 1, &context_->self); +} + +AsyncCall::~AsyncCall() +{ + if (context_ == nullptr) { + return; + } + + DeleteContext(env_, context_); +} + +napi_value AsyncCall::Call(napi_env env, Context::ExecAction exec) +{ + if ((context_ == nullptr) || (context_->ctx == nullptr)) { + PRINT_HILOGD("context_ or context_->ctx is null"); + return nullptr; + } + PRINT_HILOGD("async call exec"); + context_->ctx->exec_ = std::move(exec); + napi_value promise = nullptr; + if (context_->callback == nullptr) { + napi_create_promise(env, &context_->defer, &promise); + } else { + napi_get_undefined(env, &promise); + } + napi_async_work work = context_->work; + napi_value resource = nullptr; + napi_create_string_utf8(env, "AsyncCall", NAPI_AUTO_LENGTH, &resource); + napi_create_async_work(env, nullptr, resource, AsyncCall::OnExecute, AsyncCall::OnComplete, context_, &work); + context_->work = work; + context_ = nullptr; + napi_queue_async_work(env, work); + PRINT_HILOGD("async call exec"); + return promise; +} + +napi_value AsyncCall::SyncCall(napi_env env, AsyncCall::Context::ExecAction exec) +{ + if ((context_ == nullptr) || (context_->ctx == nullptr)) { + PRINT_HILOGD("context_ or context_->ctx is null"); + return nullptr; + } + context_->ctx->exec_ = std::move(exec); + napi_value promise = nullptr; + if (context_->callback == nullptr) { + napi_create_promise(env, &context_->defer, &promise); + } else { + napi_get_undefined(env, &promise); + } + AsyncCall::OnExecute(env, context_); + AsyncCall::OnComplete(env, napi_ok, context_); + return promise; +} + +void AsyncCall::OnExecute(napi_env env, void *data) +{ + PRINT_HILOGD("run the async runnable"); + AsyncContext *context = reinterpret_cast(data); + context->ctx->Exec(); +} + +void AsyncCall::OnComplete(napi_env env, napi_status status, void *data) +{ + PRINT_HILOGD("run the js callback function"); + AsyncContext *context = reinterpret_cast(data); + napi_value output = nullptr; + napi_status runStatus = (*context->ctx)(env, &output); + napi_value result[ARG_BUTT] = {0}; + if (status == napi_ok && runStatus == napi_ok) { + napi_get_undefined(env, &result[ARG_ERROR]); + if (output != nullptr) { + result[ARG_DATA] = output; + } else { + napi_get_undefined(env, &result[ARG_DATA]); + } + } else { + napi_value message = nullptr; + napi_create_string_utf8(env, "async call failed", NAPI_AUTO_LENGTH, &message); + napi_create_error(env, nullptr, message, &result[ARG_ERROR]); + napi_get_undefined(env, &result[ARG_DATA]); + } + if (context->defer != nullptr) { + // promise + if (status == napi_ok && runStatus == napi_ok) { + napi_resolve_deferred(env, context->defer, result[ARG_DATA]); + } else { + napi_reject_deferred(env, context->defer, result[ARG_ERROR]); + } + } else { + // callback + napi_value callback = nullptr; + napi_get_reference_value(env, context->callback, &callback); + napi_value returnValue; + napi_call_function(env, nullptr, callback, ARG_BUTT, result, &returnValue); + } + DeleteContext(env, context); +} +void AsyncCall::DeleteContext(napi_env env, AsyncContext *context) +{ + if (env != nullptr) { + napi_delete_reference(env, context->callback); + napi_delete_reference(env, context->self); + napi_delete_async_work(env, context->work); + } + delete context; +} +} // namespace OHOS::Print \ No newline at end of file diff --git a/interfaces/kits/napi/src/napi_inner_print.cpp b/interfaces/kits/napi/src/napi_inner_print.cpp new file mode 100644 index 0000000..8a613d9 --- /dev/null +++ b/interfaces/kits/napi/src/napi_inner_print.cpp @@ -0,0 +1,517 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "napi_inner_print.h" +#include "print_manager.h" +#include "async_call.h" +#include "log.h" +#include "napi_utils.h" +#include "print_task.h" + +namespace OHOS::Print { +napi_value NapiInnerPrint::QueryExtensionInfo(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == NapiUtils::NO_ARG, " should 0 parameter!", napi_invalid_arg); + PRINT_HILOGD("input over---->"); + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + PRINT_HILOGD("ouput enter---->"); + napi_status status = napi_create_array(env, result); + uint32_t PrinterExtensionInfoLength = context->arrayPrinterExtensionInfo.size(); + for(uint32_t i = 0; i < PrinterExtensionInfoLength; i++) + { + PRINT_HILOGD("PrintServiceProxy, ExtensionId = %{public}d", context->arrayPrinterExtensionInfo[i].GetExtensionId()); + PRINT_HILOGD("PrintServiceProxy, VendorId = %{public}d", context->arrayPrinterExtensionInfo[i].GetVendorId()); + PRINT_HILOGD("PrintServiceProxy, VendorName = %{public}s", context->arrayPrinterExtensionInfo[i].GetVendorName().c_str()); + PRINT_HILOGD("PrintServiceProxy, VendorIcon = %{public}d", context->arrayPrinterExtensionInfo[i].GetVendorIcon()); + PRINT_HILOGD("PrintServiceProxy, Version = %{public}s", context->arrayPrinterExtensionInfo[i].GetVersion().c_str()); + napi_value PrinterInfo; + napi_create_object(env, &PrinterInfo); + NapiUtils::SetUint32Property(env, PrinterInfo, "extensionId", context->arrayPrinterExtensionInfo[i].GetExtensionId()); + NapiUtils::SetUint32Property(env, PrinterInfo, "vendorId", context->arrayPrinterExtensionInfo[i].GetVendorId()); + NapiUtils::SetStringPropertyUtf8(env, PrinterInfo, "vendorName", context->arrayPrinterExtensionInfo[i].GetVendorName().c_str()); + NapiUtils::SetUint32Property(env, PrinterInfo, "vendorIcon", context->arrayPrinterExtensionInfo[i].GetVendorIcon()); + NapiUtils::SetStringPropertyUtf8(env, PrinterInfo, "version", context->arrayPrinterExtensionInfo[i].GetVersion().c_str()); + status = napi_set_element(env, *result, i, PrinterInfo); + } + PRINT_HILOGD("output ---- status[%{public}d]", status); + PRINT_HILOGD("ouput over---->"); + return napi_ok; + }; + auto exec = [context](AsyncCall::Context *ctx) { + PRINT_HILOGD("exec enter---->"); + context->result = PrintManager::GetInstance()->QueryAllExtension(context->arrayPrinterExtensionInfo); + if (context->result == true) { + PRINT_HILOGD("exec over---->"); + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::StartDiscovery(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter StartDiscovery---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + uint32_t result_size = 0; + napi_get_array_length(env, argv[NapiUtils::FIRST_ARGV], &result_size); + napi_value array = argv[NapiUtils::FIRST_ARGV]; + bool isArray = false; + napi_is_array(env, array, &isArray); + NAPI_ASSERT_BASE(env, isArray, " is not array!", napi_invalid_arg); + for (uint32_t i = 0; i < result_size; i++) + { + napi_value value; + napi_get_element(env, array, i, &value); + uint32_t valueNumber; + napi_get_value_uint32(env, value, &valueNumber); + PRINT_HILOGD("output for :---- extensionVector value is :[%{public}d]", valueNumber); + context->extensionVector.push_back((int32_t)valueNumber); + } + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->extensionList.push_back(5); + context->extensionList.push_back(55); + context->extensionList.push_back(555); + context->extensionList.push_back(5555); + context->result = PrintManager::GetInstance()->StartDiscoverPrinter(context->extensionList); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::StopDiscovery(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter StopDiscovery---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 0, " should 0 parameter!", napi_invalid_arg); + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->StopDiscoverPrinter(); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); + return nullptr; +} + +napi_value NapiInnerPrint::ConnectPrint(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ConnectPrint---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, "should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_number, "printerId number is not a number", napi_invalid_arg); + uint32_t printId; + napi_get_value_uint32(env, argv[NapiUtils::FIRST_ARGV], &printId); + PRINT_HILOGD("printId : %{public}d",printId); + context->printConnId = printId; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->ConnectPrinter(context->printConnId); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::DisconnectPrint(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter DisconnectPrint---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_number, "printerId number is not a number", napi_invalid_arg); + uint32_t printId; + napi_get_value_uint32(env,argv[NapiUtils::FIRST_ARGV],&printId); + PRINT_HILOGD("printId : %{public}d",printId); + context->printDisConnId = printId; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->DisconnectPrinter(context->printDisConnId); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); + return nullptr; +} + +napi_value NapiInnerPrint::StartPrint(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter StartPrint---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_object, "printjob number is not a number", napi_invalid_arg); + uint32_t printjobObject; + napi_get_value_uint32(env,argv[NapiUtils::FIRST_ARGV],&printjobObject); + PRINT_HILOGD("printjob : %{public}d",printjobObject); + context->printStartJobNumber = printjobObject; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + uint32_t fileLength = 3; + for(uint32_t i = 0; i < fileLength; i++) + { + context->jobinfo.GetFiles().push_back("JobInfo"); + } + context->jobinfo.SetJobId(9); + context->jobinfo.SetPrintId(99); + context->jobinfo.SetJobState(5); + context->jobinfo.SetCopyNumber(9); + context->jobinfo.GetPageRange().SetStartPage(6); + context->jobinfo.GetPageRange().SetEndPage(7); + context->jobinfo.GetPageRange().SetPages(6); + context->jobinfo.GetPageRange().SetPages(66); + context->jobinfo.SetIsSequential(6); + context->jobinfo.GetPageSize().SetId(6); + context->jobinfo.GetPageSize().SetName("jobinfo.GetPageSize"); + context->jobinfo.GetPageSize().SetWidth(6); + context->jobinfo.GetPageSize().SetHeight(6); + context->jobinfo.SetIsLandscape(6); + context->jobinfo.SetColorMode(6); + context->jobinfo.SetDuplexMode(6); + context->jobinfo.GetMargin().SetTop(6); + context->jobinfo.GetMargin().SetBottom(6); + context->jobinfo.GetMargin().SetLeft(6); + context->jobinfo.GetMargin().SetRight(6); + context->jobinfo.GetPreview().SetResult("data.ReadString()"); + context->jobinfo.GetPreview().GetPreviewRange().SetStartPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetEndPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(66); + context->result = PrintManager::GetInstance()->StartPrintJob(context->jobinfo); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::CancelPrint(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_object, "printjob number is not a object", napi_invalid_arg); + uint32_t printjobObject; + napi_get_value_uint32(env,argv[NapiUtils::FIRST_ARGV],&printjobObject); + PRINT_HILOGD("printjob : %{public}d",printjobObject); + context->printCancelJobNumber = printjobObject; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + uint32_t fileLength = 3; + for(uint32_t i = 0; i < fileLength; i++) + { + context->jobinfo.GetFiles().push_back("JobInfo"); + } + context->jobinfo.SetJobId(9); + context->jobinfo.SetPrintId(99); + context->jobinfo.SetJobState(5); + context->jobinfo.SetCopyNumber(9); + context->jobinfo.GetPageRange().SetStartPage(6); + context->jobinfo.GetPageRange().SetEndPage(7); + context->jobinfo.GetPageRange().SetPages(6); + context->jobinfo.GetPageRange().SetPages(66); + context->jobinfo.SetIsSequential(6); + context->jobinfo.GetPageSize().SetId(6); + context->jobinfo.GetPageSize().SetName("jobinfo.GetPageSize"); + context->jobinfo.GetPageSize().SetWidth(6); + context->jobinfo.GetPageSize().SetHeight(6); + context->jobinfo.SetIsLandscape(6); + context->jobinfo.SetColorMode(6); + context->jobinfo.SetDuplexMode(6); + context->jobinfo.GetMargin().SetTop(6); + context->jobinfo.GetMargin().SetBottom(6); + context->jobinfo.GetMargin().SetLeft(6); + context->jobinfo.GetMargin().SetRight(6); + context->jobinfo.GetPreview().SetResult("data.ReadString()"); + context->jobinfo.GetPreview().GetPreviewRange().SetStartPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetEndPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(66); + context->result = PrintManager::GetInstance()->CancelPrintJob(context->jobinfo); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context), 0); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::RequestPreview(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_object, "printjob number is not a object", napi_invalid_arg); + uint32_t printjobObject; + napi_get_value_uint32(env,argv[NapiUtils::FIRST_ARGV],&printjobObject); + PRINT_HILOGD("printjob : %{public}d",printjobObject); + context->printReqPreviewJobNumber = printjobObject; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_create_string_utf8(env, context->previewResult.c_str(), NAPI_AUTO_LENGTH, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + uint32_t fileLength = 3; + for(uint32_t i = 0; i < fileLength; i++) + { + context->jobinfo.GetFiles().push_back("JobInfo"); + } + context->jobinfo.SetJobId(9); + context->jobinfo.SetPrintId(99); + context->jobinfo.SetJobState(5); + context->jobinfo.SetCopyNumber(9); + context->jobinfo.GetPageRange().SetStartPage(6); + context->jobinfo.GetPageRange().SetEndPage(7); + context->jobinfo.GetPageRange().SetPages(6); + context->jobinfo.GetPageRange().SetPages(66); + context->jobinfo.SetIsSequential(6); + context->jobinfo.GetPageSize().SetId(6); + context->jobinfo.GetPageSize().SetName("jobinfo.GetPageSize"); + context->jobinfo.GetPageSize().SetWidth(6); + context->jobinfo.GetPageSize().SetHeight(6); + context->jobinfo.SetIsLandscape(6); + context->jobinfo.SetColorMode(6); + context->jobinfo.SetDuplexMode(6); + context->jobinfo.GetMargin().SetTop(6); + context->jobinfo.GetMargin().SetBottom(6); + context->jobinfo.GetMargin().SetLeft(6); + context->jobinfo.GetMargin().SetRight(6); + context->jobinfo.GetPreview().SetResult("data.ReadString()"); + context->jobinfo.GetPreview().GetPreviewRange().SetStartPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetEndPage(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(6); + context->jobinfo.GetPreview().GetPreviewRange().SetPages(66); + context->result = PrintManager::GetInstance()->RequestPreview(context->jobinfo, context->previewResult); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::QueryCapability(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter QueryCapability---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_number, "number is not a number", napi_invalid_arg); + uint32_t number; + napi_get_value_uint32(env,argv[NapiUtils::FIRST_ARGV],&number); + PRINT_HILOGD("printjob : %{public}d",number); + context->printCapacityId = number; + PRINT_HILOGD("input over---->"); + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + PRINT_HILOGD("ouput enter---->"); + napi_value resultPrintMargin; + napi_create_object(env, result); + napi_create_object(env, &resultPrintMargin); + napi_value arrPageSize,arrResolution; + napi_status status = napi_create_array(env, &arrPageSize); + status = napi_create_array(env, &arrResolution); + + NapiUtils::SetUint32Property(env, *result, "colorMode", context->printerCapability.GetColorMode()); + NapiUtils::SetUint32Property(env, *result, "duplexMode", context->printerCapability.GetDuplexMode()); + + NapiUtils::SetUint32Property(env, resultPrintMargin, "top", context->printerCapability.GetMinMargin().GetTop()); + NapiUtils::SetUint32Property(env, resultPrintMargin, "bottom", context->printerCapability.GetMinMargin().GetBottom()); + NapiUtils::SetUint32Property(env, resultPrintMargin, "left", context->printerCapability.GetMinMargin().GetLeft()); + NapiUtils::SetUint32Property(env, resultPrintMargin, "right", context->printerCapability.GetMinMargin().GetRight()); + uint32_t printerCapabilityLength = context->printerCapability.GetPageSize().size(); + + for(uint32_t i = 0; i < printerCapabilityLength; i++) + { + napi_value resultPrinterPageSize; + napi_create_object(env, &resultPrinterPageSize); + NapiUtils::SetUint32Property(env, resultPrinterPageSize, "id", context->printerCapability.GetPageSize()[i].GetId()); + NapiUtils::SetStringPropertyUtf8(env, resultPrinterPageSize, "name", context->printerCapability.GetPageSize()[i].GetName().c_str()); + NapiUtils::SetUint32Property(env, resultPrinterPageSize, "width", context->printerCapability.GetPageSize()[i].GetWidth()); + NapiUtils::SetUint32Property(env, resultPrinterPageSize, "height", context->printerCapability.GetPageSize()[i].GetHeight()); + status = napi_set_element(env, arrPageSize, i, resultPrinterPageSize); + } + + uint32_t printerCapabilityresolutionLength = context->printerCapability.GetResolution().size(); + + for(uint32_t i = 0; i < printerCapabilityresolutionLength; i++) + { + napi_value resultPrinterResolution; + napi_create_object(env, &resultPrinterResolution); + NapiUtils::SetUint32Property(env, resultPrinterResolution, "id", context->printerCapability.GetResolution()[i].GetId()); + NapiUtils::SetUint32Property(env, resultPrinterResolution, "horizontalDpi", context->printerCapability.GetResolution()[i].GetHorizontalDpi()); + NapiUtils::SetUint32Property(env, resultPrinterResolution, "verticalDpi", context->printerCapability.GetResolution()[i].GetVerticalDpi()); + status = napi_set_element(env, arrResolution, i, resultPrinterResolution); + } + + status = napi_set_named_property(env, *result, "minMargin", resultPrintMargin); + PRINT_HILOGD("output ---- status[%{public}d]", status); + napi_set_named_property(env, *result, "pageSize", arrPageSize); + napi_set_named_property(env, *result, "resolution", arrResolution); + PRINT_HILOGD("ouput over---->"); + return napi_ok; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->QueryPrinterCapability(5, context->printerCapability); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiInnerPrint::On(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter On---->"); + return nullptr; +} + +napi_value NapiInnerPrint::Off(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter Off---->"); + return nullptr; +} +} // namespace OHOS::Print + + diff --git a/interfaces/kits/napi/src/napi_print_ext.cpp b/interfaces/kits/napi/src/napi_print_ext.cpp new file mode 100644 index 0000000..8cda0df --- /dev/null +++ b/interfaces/kits/napi/src/napi_print_ext.cpp @@ -0,0 +1,339 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "napi_print_ext.h" +#include "async_call.h" +#include "log.h" +#include "napi_utils.h" +#include "print_manager.h" + +static constexpr const char *PARAM_INFO_PRINTID = "printerId"; +static constexpr const char *PARAM_INFO_PRINTERNAME = "printerName"; +static constexpr const char *PARAM_INFO_PRINTERICON = "printerIcon"; +static constexpr const char *PARAM_INFO_PRINTERSTATE = "printerState"; +static constexpr const char *PARAM_INFO_DESCRIPTION = "description"; +static constexpr const char *PARAM_INFO_CAPABILITY = "capability"; + +namespace OHOS::Print { +napi_value NapiPrintExt::AddPrinters(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == NapiUtils::ONE_ARG, " should 1 parameter!", napi_invalid_arg); + napi_value array = argv[NapiUtils::FIRST_ARGV]; + bool isArray = false; + napi_is_array(env, array, &isArray); + NAPI_ASSERT_BASE(env, isArray, " is not array!", napi_invalid_arg); + + uint32_t result_size; + napi_get_array_length(env, argv[NapiUtils::FIRST_ARGV], &result_size); + + PrintInfo info_; + for(uint32_t i = 0; i < result_size; i++) + { + napi_value value; + napi_get_element(env, array, i, &value); + if(!ParseInfo(env, value, info_)) + { + PRINT_HILOGD("PrintInfo is format error!"); + } + context->printInfoVector.push_back(info_); + } + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + for(uint32_t i = 0; i < 3; i++) + { + PrintInfo printInfo; + printInfo.SetPrinterId(1); + printInfo.SetPrinterName("data.ReadString()"); + printInfo.SetPrinterIcon(1); + printInfo.SetPrinterState(1); + printInfo.SetDescription("data.ReadString()"); + printInfo.GetCapability().GetMinMargin().SetTop(1); + printInfo.GetCapability().GetMinMargin().SetBottom(1); + printInfo.GetCapability().GetMinMargin().SetLeft(1); + printInfo.GetCapability().GetMinMargin().SetRight(1); + for(uint32_t i = 0; i < 3; i++) + { + PrinterPageSize printerPageSize; + printerPageSize.SetId(1); + printerPageSize.SetName("data.ReadString()"); + printerPageSize.SetWidth(1); + printerPageSize.SetHeight(1); + printInfo.GetCapability().GetPageSize().push_back(printerPageSize); + } + for(uint32_t i = 0; i < 3; i++) + { + PrinterResolution printerResolution; + printerResolution.SetId(1); + printerResolution.SetHorizontalDpi(1); + printerResolution.SetVerticalDpi(1); + printInfo.GetCapability().GetResolution().push_back(printerResolution); + } + printInfo.GetCapability().SetColorMode(1); + printInfo.GetCapability().SetDuplexMode(1); + context->arrayPrintInfo.push_back(printInfo); + + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrintId()); + PRINT_HILOGD("AddPrinters = %{public}s", context->arrayPrintInfo[i].GetPrinterName().c_str()); + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrinterIcon()); + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrinterState()); + PRINT_HILOGD("AddPrinters = %{public}s", context->arrayPrintInfo[i].GetDescription().c_str()); + } + context->result = PrintManager::GetInstance()->AddPrinters(context->arrayPrintInfo); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +napi_value NapiPrintExt::RemovePrinters(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == 1, " should 1 parameter!", napi_invalid_arg); + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + for(uint32_t i = 0; i < 3; i++) + { + PrintInfo printInfo; + printInfo.SetPrinterId(1); + printInfo.SetPrinterName("data.ReadString()"); + printInfo.SetPrinterIcon(1); + printInfo.SetPrinterState(1); + printInfo.SetDescription("data.ReadString()"); + printInfo.GetCapability().GetMinMargin().SetTop(1); + printInfo.GetCapability().GetMinMargin().SetBottom(1); + printInfo.GetCapability().GetMinMargin().SetLeft(1); + printInfo.GetCapability().GetMinMargin().SetRight(1); + + for(uint32_t i = 0; i < 3; i++) + { + PrinterPageSize printerPageSize; + printerPageSize.SetId(1); + printerPageSize.SetName("data.ReadString()"); + printerPageSize.SetWidth(1); + printerPageSize.SetHeight(1); + printInfo.GetCapability().GetPageSize().push_back(printerPageSize); + } + + for(uint32_t i = 0; i < 3; i++) + { + PrinterResolution printerResolution; + printerResolution.SetId(1); + printerResolution.SetHorizontalDpi(1); + printerResolution.SetVerticalDpi(1); + printInfo.GetCapability().GetResolution().push_back(printerResolution); + } + + printInfo.GetCapability().SetColorMode(1); + printInfo.GetCapability().SetDuplexMode(1); + context->arrayPrintInfo.push_back(printInfo); + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrintId()); + PRINT_HILOGD("AddPrinters = %{public}s", context->arrayPrintInfo[i].GetPrinterName().c_str()); + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrinterIcon()); + PRINT_HILOGD("AddPrinters = %{public}d", context->arrayPrintInfo[i].GetPrinterState()); + PRINT_HILOGD("AddPrinters = %{public}s", context->arrayPrintInfo[i].GetDescription().c_str()); + } + context->result = PrintManager::GetInstance()->RemovePrinters(context->arrayPrintInfo); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} +napi_value NapiPrintExt::UpdatePrinterState(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == NapiUtils::TWO_ARG, " should 2 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_number, "valuetype is not a number", napi_invalid_arg); + uint32_t printerId = 0; + napi_get_value_uint32(env, argv[NapiUtils::FIRST_ARGV], &printerId); + PRINT_HILOGD("printerId : %{public}d", printerId); + context->printerId = printerId; + napi_valuetype valueSecondtype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::SECOND_ARGV], &valueSecondtype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valueSecondtype == napi_number, "valueSecondtype is not a string", napi_invalid_arg); + uint32_t printerState = 0; + napi_get_value_uint32(env, argv[NapiUtils::SECOND_ARGV], &printerState); + PRINT_HILOGD("printerState : %{public}d", printerState); + context->printerState = printerState; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->UpdatePrinterState(context->printerId,context->printerState); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} +napi_value NapiPrintExt::UpdatePrintJobState(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + if (!PrintManager::GetInstance()->CheckPermission()) { + PRINT_HILOGD("no permission to access print service"); + return nullptr; + } + + auto context = std::make_shared(); + auto input = [context](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + NAPI_ASSERT_BASE(env, argc == NapiUtils::TWO_ARG, " should 2 parameter!", napi_invalid_arg); + napi_valuetype valuetype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::FIRST_ARGV], &valuetype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valuetype == napi_number, "printerJobState is not a number", napi_invalid_arg); + uint32_t printerJobId = 0; + napi_get_value_uint32(env, argv[NapiUtils::FIRST_ARGV], &printerJobId); + PRINT_HILOGD("printerJobId : %{public}d", printerJobId); + context->printerJobId = printerJobId; + napi_valuetype valueSecondtype; + NAPI_CALL_BASE(env, napi_typeof(env, argv[NapiUtils::SECOND_ARGV], &valueSecondtype), napi_invalid_arg); + NAPI_ASSERT_BASE(env, valueSecondtype == napi_number, "valueSecondtype is not a string", napi_invalid_arg); + uint32_t printerJobState = 0; + napi_get_value_uint32(env, argv[NapiUtils::SECOND_ARGV], &printerJobState); + PRINT_HILOGD("printerJobState : %{public}d", printerJobState); + context->printerJobState = printerJobState; + return napi_ok; + }; + auto output = [context](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_boolean(env, context->result, result); + PRINT_HILOGD("output ---- [%{public}s], status[%{public}d]", context->result ? "true" : "false", status); + return status; + }; + auto exec = [context](AsyncCall::Context *ctx) { + context->result = PrintManager::GetInstance()->UpdatePrinterJobState(context->printerJobId,context->printerJobState); + if (context->result == true) { + context->status = napi_ok; + } + }; + context->SetAction(std::move(input), std::move(output)); + AsyncCall asyncCall(env, info, std::dynamic_pointer_cast(context)); + return asyncCall.Call(env, exec); +} + +bool NapiPrintExt::ParseInfo(napi_env env, napi_value InfoValue, PrintInfo &info) +{ + if (!ParseInfoParam(env, InfoValue, info)) { + PRINT_HILOGD("ParseInfoParam is error!"); + return false; + } + info.SetPrinterName(NapiUtils::GetStringPropertyUtf8(env, InfoValue, PARAM_INFO_PRINTERNAME)); + info.SetPrinterIcon(NapiUtils::GetUint32Property(env, InfoValue, PARAM_INFO_PRINTERICON)); + info.SetPrinterState(NapiUtils::GetUint32Property(env, InfoValue, PARAM_INFO_PRINTERSTATE)); + info.SetDescription(NapiUtils::GetStringPropertyUtf8(env, InfoValue, PARAM_INFO_DESCRIPTION)); + + PRINT_HILOGD("info_value printId value is: %{public}d", info.GetPrintId()); + PRINT_HILOGD("info_value printerName value is %{public}s", info.GetPrinterName().c_str()); + PRINT_HILOGD("info_value printerIcon value is %{public}d", info.GetPrinterIcon()); + PRINT_HILOGD("info_value printerState value is %{public}d", info.GetPrinterState()); + PRINT_HILOGD("info_value description value is %{public}s", info.GetDescription().c_str()); + return true; +} + +bool NapiPrintExt::ParseInfoParam(napi_env env, napi_value InfoValue, PrintInfo &info) +{ + napi_value param_one = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_PRINTID); + if (NapiUtils::GetValueType(env, param_one) != napi_number) { + PRINT_HILOGD("error param_one"); + return false; + } + napi_value param_two = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_PRINTERNAME); + if (NapiUtils::GetValueType(env, param_two) != napi_string) { + PRINT_HILOGD("error param_two"); + return false; + } + napi_value param_three = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_PRINTERICON); + if (NapiUtils::GetValueType(env, param_three) != napi_number) { + PRINT_HILOGD("error param_three"); + return false; + } + napi_value param_four = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_PRINTERSTATE); + if (NapiUtils::GetValueType(env, param_four) != napi_number) { + PRINT_HILOGD("error param_four"); + return false; + } + napi_value param_five = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_DESCRIPTION); + if (NapiUtils::GetValueType(env, param_five) != napi_number) { + PRINT_HILOGD("error param_five"); + return false; + } + napi_value param_six = NapiUtils::GetNamedProperty(env, InfoValue, PARAM_INFO_CAPABILITY); + if (NapiUtils::GetValueType(env, param_six) != napi_object) { + PRINT_HILOGD("error param_six"); + return false; + } + auto names = NapiUtils::GetPropertyNames(env, InfoValue); + + std::vector::iterator iter; + PRINT_HILOGD("current name list size = %{public}zu", names.size()); + for (iter = names.begin(); iter != names.end(); ++iter) { + uint32_t value = NapiUtils::GetUint32Property(env, param_one, *iter); + if (value) { + info.SetPrinterId(value); + } + } + return true; +} + +bool NapiPrintExt::ParseCapability(napi_env env, napi_value CapValue, PrinterCapability &capability) +{ + return true; +} +} // namespace OHOS::Print diff --git a/interfaces/kits/napi/src/napi_print_task.cpp b/interfaces/kits/napi/src/napi_print_task.cpp new file mode 100644 index 0000000..0a6521a --- /dev/null +++ b/interfaces/kits/napi/src/napi_print_task.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "napi_print_task.h" +#include +#include "async_call.h" +#include "log.h" +#include "napi_utils.h" +#include "print_task.h" +#include "print_manager.h" + +static constexpr const char *FUNCTION_ON = "on"; +static constexpr const char *FUNCTION_OFF = "off"; + +namespace OHOS::Print { +__thread napi_ref NapiPrintTask::globalCtor = nullptr; +std::mutex mutex_; +napi_value NapiPrintTask::Print(napi_env env, napi_callback_info info)//PrintTask +{ + PRINT_HILOGD("Enter print JsMain."); + struct ContextInfo { + napi_ref ref = nullptr; + }; + auto ctxInfo = std::make_shared(); + auto input = [ctxInfo](napi_env env, size_t argc, napi_value *argv, napi_value self) -> napi_status { + PRINT_HILOGD("print parser to native params %{public}d!", static_cast(argc)); + NAPI_ASSERT_BASE(env, (argc > 0) && (argc <= 3), " need 2 or 3 parameters!", napi_invalid_arg); + napi_value proxy = nullptr; + napi_status status = napi_new_instance(env, GetCtor(env), argc, argv, &proxy); + if ((proxy == nullptr) || (status != napi_ok)) { + PRINT_HILOGE("Failed to create print task"); + return napi_generic_failure; + } + napi_create_reference(env, proxy, 1, &(ctxInfo->ref)); + return napi_ok; + }; + auto output = [ctxInfo](napi_env env, napi_value *result) -> napi_status { + napi_status status = napi_get_reference_value(env, ctxInfo->ref, result); + napi_delete_reference(env, ctxInfo->ref); + return status; + }; + auto context = std::make_shared(input, output); + AsyncCall asyncCall(env, info, context); + return asyncCall.Call(env); +} + +napi_value NapiPrintTask::GetCtor(napi_env env) +{ + std::lock_guard lock(mutex_); + napi_value cons; + if (globalCtor != nullptr) { + NAPI_CALL(env, napi_get_reference_value(env, globalCtor, &cons)); + return cons; + } + + napi_property_descriptor clzDes[] = { + {FUNCTION_ON, 0, PrintTask::On, 0, 0, 0, napi_default, 0}, + {FUNCTION_OFF, 0, PrintTask::Off, 0, 0, 0, napi_default, 0}, + }; + NAPI_CALL(env, napi_define_class(env, "NapiPrintTask", NAPI_AUTO_LENGTH, Initialize, nullptr, + sizeof(clzDes) / sizeof(napi_property_descriptor), clzDes, &cons)); + NAPI_CALL(env, napi_create_reference(env, cons, 1, &globalCtor)); + return cons; +} + +napi_value NapiPrintTask::Initialize(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("constructor print task!"); + napi_value self = nullptr; + size_t argc = NapiUtils::MAX_ARGC; + napi_value argv[NapiUtils::MAX_ARGC] = {nullptr}; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &self, nullptr)); + + auto task = new PrintTask(PrintManager::GetInstance()->Dummy()); + if (task == nullptr) { + PRINT_HILOGE("print task fail"); + return nullptr; + } + auto finalize = [](napi_env env, void *data, void *hint) { + PRINT_HILOGD("destructed print task"); + PrintTask *task = reinterpret_cast(data); + delete task; + }; + if (napi_wrap(env, self, task, finalize, nullptr, nullptr) != napi_ok) { + finalize(env, task, nullptr); + return nullptr; + } + PRINT_HILOGD("Succeed to allocate print task"); + return self; +} +} // namespace OHOS::Print diff --git a/interfaces/kits/napi/src/napi_utils.cpp b/interfaces/kits/napi/src/napi_utils.cpp new file mode 100644 index 0000000..15dbf29 --- /dev/null +++ b/interfaces/kits/napi/src/napi_utils.cpp @@ -0,0 +1,308 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "napi_utils.h" + +#include +#include +#include +#include "log.h" +#include "securec.h" + +namespace OHOS::Print::NapiUtils { +static constexpr const int MAX_STRING_LENGTH = 65536; + +napi_valuetype GetValueType(napi_env env, napi_value value) +{ + if (value == nullptr) { + return napi_undefined; + } + + napi_valuetype valueType = napi_undefined; + NAPI_CALL_BASE(env, napi_typeof(env, value, &valueType), napi_undefined); + return valueType; +} + +/* named property */ +bool HasNamedProperty(napi_env env, napi_value object, const std::string &propertyName) +{ + bool hasProperty = false; + NAPI_CALL_BASE(env, napi_has_named_property(env, object, propertyName.c_str(), &hasProperty), false); + return hasProperty; +} + +napi_value GetNamedProperty(napi_env env, napi_value object, const std::string &propertyName) +{ + napi_value value = nullptr; + bool hasProperty = false; + NAPI_CALL(env, napi_has_named_property(env, object, propertyName.c_str(), &hasProperty)); + if (!hasProperty) { + return value; + } + NAPI_CALL(env, napi_get_named_property(env, object, propertyName.c_str(), &value)); + return value; +} + +void SetNamedProperty(napi_env env, napi_value object, const std::string &name, napi_value value) +{ + (void)napi_set_named_property(env, object, name.c_str(), value); +} + +std::vector GetPropertyNames(napi_env env, napi_value object) +{ + std::vector ret; + napi_value names = nullptr; + NAPI_CALL_BASE(env, napi_get_property_names(env, object, &names), ret); + uint32_t length = 0; + NAPI_CALL_BASE(env, napi_get_array_length(env, names, &length), ret); + for (uint32_t index = 0; index < length; ++index) { + napi_value name = nullptr; + if (napi_get_element(env, names, index, &name) != napi_ok) { + continue; + } + if (GetValueType(env, name) != napi_string) { + continue; + } + ret.emplace_back(GetStringFromValueUtf8(env, name)); + } + return ret; +} + +/* UINT32 */ +napi_value CreateUint32(napi_env env, uint32_t code) +{ + napi_value value = nullptr; + if (napi_create_uint32(env, code, &value) != napi_ok) { + return nullptr; + } + return value; +} + +uint32_t GetUint32FromValue(napi_env env, napi_value value) +{ + uint32_t ret = 0; + NAPI_CALL_BASE(env, napi_get_value_uint32(env, value, &ret), 0); + return ret; +} + +uint32_t GetUint32Property(napi_env env, napi_value object, const std::string &propertyName) +{ + if (!HasNamedProperty(env, object, propertyName)) { + return 0; + } + napi_value value = GetNamedProperty(env, object, propertyName); + return GetUint32FromValue(env, value); +} + +void SetUint32Property(napi_env env, napi_value object, const std::string &name, uint32_t value) +{ + napi_value jsValue = CreateUint32(env, value); + if (GetValueType(env, jsValue) != napi_number) { + return; + } + + napi_set_named_property(env, object, name.c_str(), jsValue); +} + +/* INT32 */ +napi_value CreateInt32(napi_env env, int32_t code) +{ + napi_value value = nullptr; + if (napi_create_int32(env, code, &value) != napi_ok) { + return nullptr; + } + return value; +} + +int32_t GetInt32FromValue(napi_env env, napi_value value) +{ + int32_t ret = 0; + NAPI_CALL_BASE(env, napi_get_value_int32(env, value, &ret), 0); + return ret; +} + +int32_t GetInt32Property(napi_env env, napi_value object, const std::string &propertyName) +{ + if (!HasNamedProperty(env, object, propertyName)) { + return 0; + } + napi_value value = GetNamedProperty(env, object, propertyName); + return GetInt32FromValue(env, value); +} + +void SetInt32Property(napi_env env, napi_value object, const std::string &name, int32_t value) +{ + napi_value jsValue = CreateInt32(env, value); + if (GetValueType(env, jsValue) != napi_number) { + return; + } + + napi_set_named_property(env, object, name.c_str(), jsValue); +} + +/* String UTF8 */ +napi_value CreateStringUtf8(napi_env env, const std::string &str) +{ + napi_value value = nullptr; + if (napi_create_string_utf8(env, str.c_str(), strlen(str.c_str()), &value) != napi_ok) { + return nullptr; + } + return value; +} + +std::string GetStringFromValueUtf8(napi_env env, napi_value value) +{ + std::string result; + std::vector str(MAX_STRING_LENGTH + 1, '\0'); + size_t length = 0; + NAPI_CALL_BASE(env, napi_get_value_string_utf8(env, value, &str[0], MAX_STRING_LENGTH, &length), result); + if (length > 0) { + return result.append(&str[0], length); + } + return result; +} + +std::string GetStringPropertyUtf8(napi_env env, napi_value object, const std::string &propertyName) +{ + if (!HasNamedProperty(env, object, propertyName)) { + return ""; + } + napi_value value = GetNamedProperty(env, object, propertyName); + return GetStringFromValueUtf8(env, value); +} + +void SetStringPropertyUtf8(napi_env env, napi_value object, const std::string &name, const std::string &value) +{ + napi_value jsValue = CreateStringUtf8(env, value); + if (GetValueType(env, jsValue) != napi_string) { + return; + } + napi_set_named_property(env, object, name.c_str(), jsValue); +} + +/* array buffer */ +bool ValueIsArrayBuffer(napi_env env, napi_value value) +{ + bool isArrayBuffer = false; + NAPI_CALL_BASE(env, napi_is_arraybuffer(env, value, &isArrayBuffer), false); + return isArrayBuffer; +} + +void *GetInfoFromArrayBufferValue(napi_env env, napi_value value, size_t *length) +{ + if (length == nullptr) { + return nullptr; + } + + void *data = nullptr; + NAPI_CALL(env, napi_get_arraybuffer_info(env, value, &data, length)); + return data; +} + +/* object */ +napi_value CreateObject(napi_env env) +{ + napi_value object = nullptr; + NAPI_CALL(env, napi_create_object(env, &object)); + return object; +} + +/* undefined */ +napi_value GetUndefined(napi_env env) +{ + napi_value undefined = nullptr; + NAPI_CALL(env, napi_get_undefined(env, &undefined)); + return undefined; +} + +/* function */ +napi_value CallFunction(napi_env env, napi_value recv, napi_value func, size_t argc, const napi_value *argv) +{ + napi_value res = nullptr; + NAPI_CALL(env, napi_call_function(env, recv, func, argc, argv, &res)); + return res; +} + +/* reference */ +napi_ref CreateReference(napi_env env, napi_value callback) +{ + napi_ref callbackRef = nullptr; + NAPI_CALL(env, napi_create_reference(env, callback, 1, &callbackRef)); + return callbackRef; +} + +napi_value GetReference(napi_env env, napi_ref callbackRef) +{ + napi_value callback = nullptr; + NAPI_CALL(env, napi_get_reference_value(env, callbackRef, &callback)); + return callback; +} + +void DeleteReference(napi_env env, napi_ref callbackRef) +{ + (void)napi_delete_reference(env, callbackRef); +} + +/* boolean */ +bool GetBooleanProperty(napi_env env, napi_value object, const std::string &propertyName) +{ + if (!HasNamedProperty(env, object, propertyName)) { + return false; + } + napi_value value = GetNamedProperty(env, object, propertyName); + bool ret = false; + NAPI_CALL_BASE(env, napi_get_value_bool(env, value, &ret), false); + return ret; +} + +void SetBooleanProperty(napi_env env, napi_value object, const std::string &name, bool value) +{ + napi_value jsValue = nullptr; + NAPI_CALL_RETURN_VOID(env, napi_get_boolean(env, value, &jsValue)); + if (GetValueType(env, jsValue) != napi_boolean) { + return; + } + + napi_set_named_property(env, object, name.c_str(), jsValue); +} + +/* define properties */ +void DefineProperties( + napi_env env, napi_value object, const std::initializer_list &properties) +{ + napi_property_descriptor descriptors[properties.size()]; + std::copy(properties.begin(), properties.end(), descriptors); + + (void)napi_define_properties(env, object, properties.size(), descriptors); +} + +std::string ToLower(const std::string &s) +{ + std::string res = s; + std::transform(res.begin(), res.end(), res.begin(), tolower); + return res; +} + +std::string GetValueString(napi_env env, napi_value value) +{ + std::string resultValue = ""; + char value_string[256]; + size_t value_size = 256; + size_t result; + napi_get_value_string_utf8(env, value, value_string, value_size, &result); + resultValue = value_string; + return resultValue; +} +} // namespace OHOS::Print::NapiUtils \ No newline at end of file diff --git a/interfaces/kits/napi/src/print_module.cpp b/interfaces/kits/napi/src/print_module.cpp new file mode 100644 index 0000000..0468f67 --- /dev/null +++ b/interfaces/kits/napi/src/print_module.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +//#include "napi/native_api.h" +//#include "napi/native_node_api.h" +#include "napi_print_task.h" +#include "napi_inner_print.h" +#include "napi_print_ext.h" +#include "log.h" +#include "constant.h" + +using namespace OHOS::Print; + +static constexpr const char *FUNCTION_PRINT = "print"; +static constexpr const char *FUNCTION_QUERY_EXT = "queryExtensionAbilityInfos"; +static constexpr const char *FUNCTION_START_DISCOVERY = "startDiscoverPrinter"; +static constexpr const char *FUNCTION_STOP_DISCOVERY = "stopDiscoverPrinter"; +static constexpr const char *FUNCTION_CONNECT_PRINT = "connectPrinter"; +static constexpr const char *FUNCTION_DISCONNECT_PRINT = "disconnectPrinter"; +static constexpr const char *FUNCTION_START_PRINT = "startPrintJob"; +static constexpr const char *FUNCTION_CANCEL_PRINT = "cancelPrintJob"; +static constexpr const char *FUNCTION_REQUEST_PREVIEW = "requestPrintPreview"; +static constexpr const char *FUNCTION_QUERY_CAPABILITY = "queryPrinterCapability"; +static constexpr const char *FUNCTION_REGISTER_EVENT = "on"; +static constexpr const char *FUNCTION_UNREGISTER_EVENT = "off"; +static constexpr const char *FUNCTION_ADD_PRINTER = "addPrinters"; +static constexpr const char *FUNCTION_REMOVE_PRINTER = "removePrinters"; +static constexpr const char *FUNCTION_UPDATE_PRINTER_STATE = "updatePrinterState"; +static constexpr const char *FUNCTION_UPDATE_JOB_STATE = "updatePrintJobState"; + +#define DECLARE_NAPI_METHOD(name, func) { name, 0, func, 0, 0, 0, napi_default, 0 } + +static napi_value Init(napi_env env, napi_value exports) +{ + napi_property_descriptor desc[] = { + DECLARE_NAPI_METHOD(FUNCTION_PRINT, NapiPrintTask::Print), + DECLARE_NAPI_METHOD(FUNCTION_QUERY_EXT, NapiInnerPrint::QueryExtensionInfo), + DECLARE_NAPI_METHOD(FUNCTION_START_DISCOVERY, NapiInnerPrint::StartDiscovery), + DECLARE_NAPI_METHOD(FUNCTION_STOP_DISCOVERY, NapiInnerPrint::StopDiscovery), + DECLARE_NAPI_METHOD(FUNCTION_CONNECT_PRINT, NapiInnerPrint::ConnectPrint), + DECLARE_NAPI_METHOD(FUNCTION_DISCONNECT_PRINT, NapiInnerPrint::DisconnectPrint), + DECLARE_NAPI_METHOD(FUNCTION_START_PRINT, NapiInnerPrint::StartPrint), + DECLARE_NAPI_METHOD(FUNCTION_CANCEL_PRINT, NapiInnerPrint::CancelPrint), + DECLARE_NAPI_METHOD(FUNCTION_REQUEST_PREVIEW, NapiInnerPrint::RequestPreview), + DECLARE_NAPI_METHOD(FUNCTION_QUERY_CAPABILITY, NapiInnerPrint::QueryCapability), + DECLARE_NAPI_METHOD(FUNCTION_REGISTER_EVENT, NapiInnerPrint::On), + DECLARE_NAPI_METHOD(FUNCTION_UNREGISTER_EVENT, NapiInnerPrint::Off), + DECLARE_NAPI_METHOD(FUNCTION_ADD_PRINTER, NapiPrintExt::AddPrinters), + DECLARE_NAPI_METHOD(FUNCTION_REMOVE_PRINTER, NapiPrintExt::RemovePrinters), + DECLARE_NAPI_METHOD(FUNCTION_UPDATE_PRINTER_STATE, NapiPrintExt::UpdatePrinterState), + DECLARE_NAPI_METHOD(FUNCTION_UPDATE_JOB_STATE, NapiPrintExt::UpdatePrintJobState), + }; + + napi_status status = napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc); + PRINT_HILOGD("init upload %{public}d", status); + return exports; +} + +static __attribute__((constructor)) void RegisterModule() +{ + static napi_module module = { + .nm_version = 1, + .nm_flags = 0, + .nm_filename = nullptr, + .nm_register_func = Init, + .nm_modname = "print", + .nm_priv = ((void *)0), + .reserved = { 0 } + }; + napi_module_register(&module); + PRINT_HILOGD("module register print"); +} diff --git a/interfaces/kits/napi/src/print_task.cpp b/interfaces/kits/napi/src/print_task.cpp new file mode 100644 index 0000000..c45c14c --- /dev/null +++ b/interfaces/kits/napi/src/print_task.cpp @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_task.h" +#include "async_call.h" +#include "log.h" + +namespace OHOS::Print { +PrintTask::PrintTask(uint32_t taskId) : taskId_(taskId) +{ + supportEvents_[EVENT_BLOCK] = true; + supportEvents_[EVENT_SUCCESS] = true; + supportEvents_[EVENT_FAIL] = true; + supportEvents_[EVENT_CANCEL] = true; + + supportPrinterState_[PRINTER_STATE_ADD] = true; + supportPrinterState_[PRINTER_STATE_REMOVED] = true; + supportPrinterState_[PRINTER_STATE_IDLE] = true; + supportPrinterState_[PRINTER_STATE_PRINTING] = true; + supportPrinterState_[PRINTER_STATE_BLOCKED] = true; + supportPrinterState_[PRINTER_STATE_BUSY] = true; + supportPrinterState_[PRINTER_STATE_FAILED] = true; + + supportJobState_[PRINTJOB_STATE_CREATED] = true; + supportJobState_[PRINTJOB_STATE_QUEUED] = true; + supportJobState_[PRINTJOB_STATE_PRINTING] = true; + supportJobState_[PRINTJOB_STATE_BLOCKED] = true; + supportJobState_[PRINTJOB_STATE_SUCCESS] = true; + supportJobState_[PRINTJOB_STATE_FAILED] = true; + supportJobState_[PRINTJOB_STATE_cancelled] = true; +} + +PrintTask::~PrintTask() +{ + supportEvents_.clear(); +} + +uint32_t PrintTask::GetId() const +{ + return taskId_; +} + +napi_value PrintTask::On(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + return nullptr; +} + +napi_value PrintTask::Off(napi_env env, napi_callback_info info) +{ + PRINT_HILOGD("Enter ---->"); + return nullptr; +} + +bool PrintTask::IsSupportType(const std::string &type) +{ + return supportEvents_.find(type) != supportEvents_.end(); +} + +bool PrintTask::IsSupportPrinterStateType(const std::string &type) +{ + return supportPrinterState_.find(type) != supportPrinterState_.end(); +} + +bool PrintTask::IsSupportJobStateType(const std::string &type) +{ + PRINT_HILOGD("Enter IsSupportJobStateType."); + return supportJobState_.find(type) != supportJobState_.end(); +} +} // namespace OHOS::Print diff --git a/profile/3707.xml b/profile/3707.xml new file mode 100644 index 0000000..024df5e --- /dev/null +++ b/profile/3707.xml @@ -0,0 +1,24 @@ + + + + print_service + + 3707 + libprint_service.z.so + true + false + 1 + + \ No newline at end of file diff --git a/profile/BUILD.gn b/profile/BUILD.gn new file mode 100644 index 0000000..d219f7c --- /dev/null +++ b/profile/BUILD.gn @@ -0,0 +1,19 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos/sa_profile/sa_profile.gni") + +ohos_sa_profile("print_sa_profiles") { + sources = [ "3707.xml" ] + part_name = "print" +} diff --git a/services/BUILD.gn b/services/BUILD.gn new file mode 100644 index 0000000..0eb7b28 --- /dev/null +++ b/services/BUILD.gn @@ -0,0 +1,84 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +config("print_service_config") { + visibility = [ ":*" ] + include_dirs = [ + "include", + "//third_party/curl/include", + "//third_party/openssl/include", + ] + + ldflags = [ "-Wl,--exclude-libs,libcrypto_static.a" ] + ldflags += [ "-Wl,--exclude-libs,libcurl.a" ] + + cflags_cc = [ "-fexceptions" ] + cflags = [ "-DOPENSSL_ARM64_PLATFORM" ] +} + +ohos_shared_library("print_service") { + sources = [ + "src/print_service_ability.cpp", + "src/print_service_stub.cpp", + "src/print_notify_proxy.cpp", + "src/print_service_manager.cpp", + ] + + public_configs = [ + "//commonlibrary/c_utils/base:utils_config", + ":print_service_config", + ] + include_dirs = [ + "//commonlibrary/c_utils/base/include", + "//utils/system/safwk/native/include", + "//foundation/communication/netmanager_base/interfaces/innerkits/netconnclient/include", + "//base/notification/distributed_notification_service/interfaces/inner_api", + "//base/hiviewdfx/hisysevent/interfaces/native/innerkits/hisysevent/include", + "//base/hiviewdfx/hitrace/interfaces/native/innerkits/include/hitrace_meter", + "//base/print/print/frameworks/innerkitsimpl/include", + "//base/print/print/utils/include", + ] + deps = [ + "//base/notification/distributed_notification_service/frameworks/ans:ans_innerkits", + "//base/telephony/core_service/interfaces/innerkits:tel_core_service_api", + "//foundation/communication/netmanager_base/interfaces/innerkits/netconnclient:net_conn_manager_if", + "//foundation/systemabilitymgr/safwk/interfaces/innerkits/safwk:system_ability_fwk", + "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//base/print/print/frameworks/innerkitsimpl:printclient", + ] + + defines = [ "NO_SSL_CERTIFICATION=1" ] + + external_deps = [ + "ability_base:base", + "ability_base:want", + "ability_base:zuri", + "access_token:libaccesstoken_sdk", + "bundle_framework:appexecfwk_core", + "c_utils:utils", + "drivers_interface_ril:hril_innerkits", + "eventhandler:libeventhandler", + "hisysevent_native:libhisysevent", + "hitrace_native:hitrace_meter", + "hiviewdfx_hilog_native:libhilog", + "init:libbegetutil", + "ipc:ipc_core", + "multimedia_image_standard:image_native", + "os_account:os_account_innerkits", + "relational_store:native_rdb", + ] + subsystem_name = "print" + part_name = "print" +} diff --git a/services/include/print_notify_proxy.h b/services/include/print_notify_proxy.h new file mode 100644 index 0000000..4b43f78 --- /dev/null +++ b/services/include/print_notify_proxy.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_NOTIFY_PROXY_H +#define PRINT_NOTIFY_PROXY_H + +#include "iremote_proxy.h" +#include "print_notify_interface.h" + +namespace OHOS::Print { +class PrintNotifyProxy : public IRemoteProxy { +public: + explicit PrintNotifyProxy(const sptr &impl); + ~PrintNotifyProxy() = default; + void OnCallBack(MessageParcel &data) override; + +private: + static inline BrokerDelegator delegator_; +}; +} // namespace OHOS::Print + +#endif // PRINT_NOTIFY_PROXY_H \ No newline at end of file diff --git a/services/include/print_service_ability.h b/services/include/print_service_ability.h new file mode 100644 index 0000000..ad716a2 --- /dev/null +++ b/services/include/print_service_ability.h @@ -0,0 +1,83 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_SERVICE_ABILITY_H +#define PRINT_SERVICE_ABILITY_H + +#include +#include +#include +#include "event_handler.h" +#include "iremote_object.h" +#include "system_ability.h" +#include "print_notify_interface.h" +#include "print_service_stub.h" + + +namespace OHOS::Print { +enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING }; +class IKeyguardStateCallback; + +class PrintServiceAbility : public SystemAbility, public PrintServiceStub { + DECLARE_SYSTEM_ABILITY(PrintServiceAbility); + +public: + DISALLOW_COPY_AND_MOVE(PrintServiceAbility); + PrintServiceAbility(int32_t systemAbilityId, bool runOnCreate); + PrintServiceAbility(); + ~PrintServiceAbility(); + static sptr GetInstance(); + int32_t Dummy() override; + bool On(uint32_t taskId, const std::string &type, const sptr &listener) override; + bool Off(uint32_t taskId, const std::string &type) override; + bool AddPrinters(std::vector arrayPrintInfo) override; + bool RemovePrinters(std::vector arrayPrintInfo) override; + bool ConnectPrinter(uint32_t printerId) override; + bool DisconnectPrinter(uint32_t printerId) override; + bool QueryAllExtension(std::vector &arrayExtensionInfo) override; + bool StartDiscoverPrinter(std::vector extensionList) override; + bool StopDiscoverPrinter() override; + bool StartPrintJob(PrintJob jobinfo) override; + bool CancelPrintJob(PrintJob jobinfo) override; + bool UpdatePrinterState(uint32_t printerId, uint32_t state) override; + bool UpdatePrinterJobState(uint32_t jobId, uint32_t state) override; + bool RequestPreview(PrintJob jobinfo, std::string &previewResult) override; + bool QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) override; + bool CheckPermission() override; + static void NotifyHandler(const std::string& type, uint32_t taskId, uint32_t argv1, uint32_t argv2); + +protected: + void OnStart() override; + void OnStop() override; + +private: + int32_t Init(); + void InitServiceHandler(); + void ManualStart(); + +private: + ServiceRunningState state_; + static std::mutex instanceLock_; + static sptr instance_; + static std::shared_ptr serviceHandler_; + std::map> registeredListeners_; + std::vector> unlockVecListeners_; + std::mutex listenerMapMutex_; + std::mutex lock_; + const int32_t startTime_ = 1900; + const int32_t extraMonth_ = 1; +}; +} // namespace OHOS::Print +#endif // PRINT_SYSTEM_ABILITY_H diff --git a/services/include/print_service_manager.h b/services/include/print_service_manager.h new file mode 100644 index 0000000..72c2d6d --- /dev/null +++ b/services/include/print_service_manager.h @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_SERVICE_MANAGER_H +#define PRINT_SERVICE_MANAGER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "print_extension_Info.h" +#include "print_cap_ability.h" +#include "print_job.h" +#include "print_info.h" + +#include "constant.h" + +namespace OHOS::Print { +class PrintServiceManager final { +public: + static PrintServiceManager *GetInstance(); + int32_t Dummy(); + bool ConnectPrinter(uint32_t printerId); + bool DisconnectPrinter(uint32_t printerId); + bool QueryExtensionAbilityInfos(std::vector &arrayExtensionInfo); + bool StartDiscoverPrinter(std::vector extensionList); + bool StopDiscoverPrinter(); + bool StartPrintJob(PrintJob jobinfo); + bool CancelPrintJob(PrintJob jobinfo); + bool AddPrinters(std::vector arrayPrintInfo); + bool RemovePrinters(std::vector arrayPrintInfo); + bool UpdatePrinterState(uint32_t printerId, uint32_t state); + bool UpdatePrinterJobState(uint32_t jobId, uint32_t state); + bool RequestPreview(PrintJob jobinfo, std::string &previewResult); + bool QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability); + +private: + explicit PrintServiceManager(); + ~PrintServiceManager(); + +private: + static std::mutex instanceLock_; + static PrintServiceManager* instance_; + +}; +} // namespace OHOS::Request::Print +#endif // PRINT_SERVICE_MANAGER_H diff --git a/services/include/print_service_stub.h b/services/include/print_service_stub.h new file mode 100644 index 0000000..097d452 --- /dev/null +++ b/services/include/print_service_stub.h @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_SERVICE_STUB_H +#define PRINT_SERVICE_STUB_H + +#include "iremote_stub.h" +#include "print_service_interface.h" + +namespace OHOS::Print { +class PrintServiceStub : public IRemoteStub { +public: + int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + +private: + bool OnDummy(MessageParcel &data, MessageParcel &reply); + bool OnEventOn(MessageParcel &data, MessageParcel &reply); + bool OnEventOff(MessageParcel &data, MessageParcel &reply); + bool OnCheckPermission(MessageParcel &data, MessageParcel &reply); + bool OnFindPrinterExtension(MessageParcel &data, MessageParcel &reply); + bool OnRegisterEvent(MessageParcel &data, MessageParcel &reply); + bool OnQueryAllExtension(MessageParcel &data, MessageParcel &reply); + bool OnLoadExtension (MessageParcel &data, MessageParcel &reply); + bool OnStartDiscoverPrinter(MessageParcel &data, MessageParcel &reply); + bool OnStopDiscoverPrint(MessageParcel &data, MessageParcel &reply); + bool OnAddPrinters(MessageParcel &data, MessageParcel &reply); + bool OnRemovePrinters(MessageParcel &data, MessageParcel &reply); + bool OnConnectPrinter(MessageParcel &data, MessageParcel &reply); + bool OnDisconnectPrinter(MessageParcel &data, MessageParcel &reply); + bool OnRequestCapability(MessageParcel &data, MessageParcel &reply); + bool OnStartPrintJob(MessageParcel &data, MessageParcel &reply); + bool OnCancelPrintJob(MessageParcel &data, MessageParcel &reply); + bool OnUpdatePrinterState(MessageParcel &data, MessageParcel &reply); + bool OnUpdatePrinterJobState(MessageParcel &data, MessageParcel &reply); + bool OnRequestPreview(MessageParcel &data, MessageParcel &reply); + bool OnQueryPrinterCapability(MessageParcel &data, MessageParcel &reply); +}; +} // namespace OHOS::Print +#endif // PRINT_SERVICE_STUB_H diff --git a/services/src/print_notify_proxy.cpp b/services/src/print_notify_proxy.cpp new file mode 100644 index 0000000..f8a27c4 --- /dev/null +++ b/services/src/print_notify_proxy.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "print_notify_proxy.h" +#include "log.h" +#include "message_parcel.h" + +namespace OHOS::Print { +PrintNotifyProxy::PrintNotifyProxy(const sptr &impl) : IRemoteProxy(impl) +{ +} + +void PrintNotifyProxy::OnCallBack(MessageParcel &data) +{ + PRINT_HILOGD("PrintNotifyProxy::OnCallBack Start"); + PRINT_HILOGD("data should be filled within service module"); + MessageParcel realData; + MessageParcel reply; + MessageOption option; + + if (!realData.WriteInterfaceToken(PrintNotifyProxy::GetDescriptor())) { + PRINT_HILOGE("write descriptor failed"); + return; + } + uint32_t argv1 = data.ReadUint32(); + uint32_t argv2 = data.ReadUint32(); + PRINT_HILOGD("notification's argument:[%{public}d, %{public}d]", argv1, argv2); + realData.WriteUint32(argv1); + realData.WriteUint32(argv2); + + int error = Remote()->SendRequest(PRINT_NOTIFY, realData, reply, option); + if (error != 0) { + PRINT_HILOGE("SendRequest failed, error %{public}d", error); + } + PRINT_HILOGD("PrintNotifyProxy::OnCallBack End"); +} +} // namespace OHOS::Print diff --git a/services/src/print_service_ability.cpp b/services/src/print_service_ability.cpp new file mode 100644 index 0000000..462fb90 --- /dev/null +++ b/services/src/print_service_ability.cpp @@ -0,0 +1,357 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "print_service_ability.h" + +#include +#include +#include +#include +#include + +#include "core_service_client.h" +#include "ipc_skeleton.h" +#include "accesstoken_kit.h" +#include "iservice_registry.h" +#include "system_ability.h" +#include "system_ability_definition.h" +#include "print_service_manager.h" +#include "print_common.h" +#include "log.h" + +namespace OHOS::Print { +using namespace std; +using namespace OHOS::HiviewDFX; +using namespace Security::AccessToken; + +static const std::string PRINT_PERMISSION_NAME_INTERNET = "ohos.permission.PRINT"; +static const std::string PRINT_PERMISSION_NAME_SESSION = "ohos.permission.PRINT_SESSION_MANAGER"; + + +REGISTER_SYSTEM_ABILITY_BY_ID(PrintServiceAbility, PRINT_SERVICE_ID, true); +const std::int64_t INIT_INTERVAL = 5000L; +std::mutex PrintServiceAbility::instanceLock_; +sptr PrintServiceAbility::instance_; +std::shared_ptr PrintServiceAbility::serviceHandler_; + +PrintServiceAbility::PrintServiceAbility(int32_t systemAbilityId, bool runOnCreate) + : SystemAbility(systemAbilityId, runOnCreate), state_(ServiceRunningState::STATE_NOT_START) +{ +} + +PrintServiceAbility::~PrintServiceAbility() +{ + PRINT_HILOGE("~PrintServiceAbility state_ is %{public}d.", static_cast(state_)); +} + +sptr PrintServiceAbility::GetInstance() +{ + if (instance_ == nullptr) { + std::lock_guard autoLock(instanceLock_); + if (instance_ == nullptr) { + instance_ = new PrintServiceAbility(PRINT_SERVICE_ID, true); + PRINT_HILOGE("PrintServiceAbility instance_ create,addr=%{public}p", instance_.GetRefPtr()); + } + } + return instance_; +} + +int32_t PrintServiceAbility::Init() +{ + bool ret = Publish(PrintServiceAbility::GetInstance()); + if (!ret) { + PRINT_HILOGE("PrintServiceAbility Publish failed."); + return E_PRINT_PUBLISH_FAIL; + } + state_ = ServiceRunningState::STATE_RUNNING; + uint32_t threadNum = 4; + PRINT_HILOGI("Start Print Service Manager with %{public}d threas", threadNum); + PRINT_HILOGE("state_ is %{public}d.", static_cast(state_)); + PRINT_HILOGI("Init PrintServiceAbility success."); + return ERR_OK; +} + +void PrintServiceAbility::OnStart() +{ + PRINT_HILOGI("PrintServiceAbility::Enter OnStart."); + if (instance_ == nullptr) { + instance_ = this; + } + if (state_ == ServiceRunningState::STATE_RUNNING) { + PRINT_HILOGI("PrintServiceAbility is already running."); + return; + } + InitServiceHandler(); + + int32_t ret = Init(); + if (ret != ERR_OK) { + auto callback = [=]() { Init(); }; + serviceHandler_->PostTask(callback, INIT_INTERVAL); + PRINT_HILOGE("PrintServiceAbility Init failed. Try again 5s la00ter"); + return; + } + state_ = ServiceRunningState::STATE_RUNNING; + return; +} + +void PrintServiceAbility::InitServiceHandler() +{ + PRINT_HILOGI("InitServiceHandler started."); + if (serviceHandler_ != nullptr) { + PRINT_HILOGI("InitServiceHandler already init."); + return; + } + std::shared_ptr runner = AppExecFwk::EventRunner::Create("PrintServiceAbility"); + serviceHandler_ = std::make_shared(runner); + PRINT_HILOGI("InitServiceHandler succeeded."); +} + +void PrintServiceAbility::ManualStart() +{ + if (state_ != ServiceRunningState::STATE_RUNNING) { + PRINT_HILOGI("PrintServiceAbility restart."); + OnStart(); + } +} + +void PrintServiceAbility::OnStop() +{ + PRINT_HILOGI("OnStop started."); + if (state_ != ServiceRunningState::STATE_RUNNING) { + return; + } + serviceHandler_ = nullptr; + state_ = ServiceRunningState::STATE_NOT_START; + PRINT_HILOGI("OnStop end."); +} + +int32_t PrintServiceAbility::Dummy() +{ + ManualStart(); + int32_t taskId = -1; + return taskId; +} + +bool PrintServiceAbility::ConnectPrinter(uint32_t printerId) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("PrintServiceAbility ConnectPrinter started."); + return instance->ConnectPrinter(printerId); +} + +bool PrintServiceAbility::DisconnectPrinter(uint32_t printerId) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("DisconnectPrinter ConnectPrinter started."); + return instance->DisconnectPrinter(printerId); +} + +bool PrintServiceAbility::StartDiscoverPrinter(std::vector extensionList) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("StartDiscoverPrinter ConnectPrinter started."); + return instance->StartDiscoverPrinter(extensionList); +} + +bool PrintServiceAbility::StopDiscoverPrinter() +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("StopDiscoverPrinter ConnectPrinter started."); + return instance->StopDiscoverPrinter(); +} + +bool PrintServiceAbility::QueryAllExtension(std::vector &arrayExtensionInfo) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("QueryAllExtension ConnectPrinter started."); + return instance->QueryExtensionAbilityInfos(arrayExtensionInfo); +} + +bool PrintServiceAbility::StartPrintJob(PrintJob jobinfo) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("StartPrintJob ConnectPrinter started."); + return instance->StartPrintJob(jobinfo); +} + +bool PrintServiceAbility::CancelPrintJob(PrintJob jobinfo) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob ConnectPrinter started."); + return instance->CancelPrintJob(jobinfo); +} + +bool PrintServiceAbility::AddPrinters(std::vector arrayPrintInfo) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob ConnectPrinter started."); + return instance->AddPrinters(arrayPrintInfo); +} + +bool PrintServiceAbility::RemovePrinters(std::vector arrayPrintInfo) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob ConnectPrinter started."); + return instance->RemovePrinters(arrayPrintInfo); +} + +bool PrintServiceAbility::UpdatePrinterState(uint32_t printerId, uint32_t state) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob ConnectPrinter started."); + return instance->UpdatePrinterState(printerId, state); +} + +bool PrintServiceAbility::UpdatePrinterJobState(uint32_t jobId, uint32_t state) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob ConnectPrinter started."); + return instance->UpdatePrinterJobState(jobId, state); +} + +bool PrintServiceAbility::RequestPreview(PrintJob jobinfo, std::string &previewResult) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob RequestPreview started."); + return instance->RequestPreview(jobinfo, previewResult); +} + +bool PrintServiceAbility::QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) +{ + ManualStart(); + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + PRINT_HILOGE("CancelPrintJob RequestPreview started."); + return instance->QueryPrinterCapability(printerId, printerCapability); +} + +bool PrintServiceAbility::CheckPermission() +{ + return true; +} + +bool PrintServiceAbility::On(uint32_t taskId, const std::string &type, const sptr &listener) +{ + std::string combineType = type + "-" + std::to_string(taskId); + PRINT_HILOGI("PrintServiceAbility::On started. type=%{public}s", combineType.c_str()); + auto iter = registeredListeners_.find(combineType); + if (iter == registeredListeners_.end()) { + std::lock_guard lck(listenerMapMutex_); + std::pair> newObj(combineType, listener); + const auto temp = registeredListeners_.insert(newObj); + if (!temp.second) { + PRINT_HILOGE("PrintServiceAbility::On insert type=%{public}s object fail.", combineType.c_str()); + return false; + } + } else { + std::lock_guard lck(listenerMapMutex_); + PRINT_HILOGI("PrintServiceAbility::On Replace listener."); + registeredListeners_[combineType] = listener; + } + PRINT_HILOGI("PrintServiceAbility::On end."); + return true; +} + +bool PrintServiceAbility::Off(uint32_t taskId, const std::string &type) +{ + std::string combineType = type + "-" + std::to_string(taskId); + PRINT_HILOGI("PrintServiceAbility::Off started."); + auto iter = registeredListeners_.find(combineType); + if (iter != registeredListeners_.end()) { + PRINT_HILOGE("PrintServiceAbility::Off delete type=%{public}s object message.", combineType.c_str()); + std::lock_guard lck(listenerMapMutex_); + registeredListeners_.erase(iter); + return true; + } + return false; +} + +void PrintServiceAbility::NotifyHandler(const std::string& type, uint32_t taskId, uint32_t argv1, uint32_t argv2) +{ + std::string combineType = type + "-" + std::to_string(taskId); + PRINT_HILOGI("PrintServiceAbility::NotifyHandler started %{public}s [%{public}d, %{public}d].", + combineType.c_str(), argv1, argv2); + auto iter = PrintServiceAbility::GetInstance()->registeredListeners_.find(combineType); + if (iter != PrintServiceAbility::GetInstance()->registeredListeners_.end()) { + PRINT_HILOGE("PrintServiceAbility::NotifyHandler type=%{public}s object message.", combineType.c_str()); + MessageParcel data; + data.WriteUint32(argv1); + data.WriteUint32(argv2); + iter->second->OnCallBack(data); + } +} +} // namespace OHOS::Request::Print diff --git a/services/src/print_service_manager.cpp b/services/src/print_service_manager.cpp new file mode 100644 index 0000000..4b91cbd --- /dev/null +++ b/services/src/print_service_manager.cpp @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_service_manager.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "unistd.h" +#include "log.h" +#include +#include +#include +#include +#include +#include +#include +#include + +namespace OHOS::Print { +std::mutex PrintServiceManager::instanceLock_; +PrintServiceManager *PrintServiceManager::instance_ = nullptr; +PrintServiceManager::PrintServiceManager() +{ +} + +PrintServiceManager::~PrintServiceManager() +{ +} + +PrintServiceManager *PrintServiceManager::GetInstance() +{ + if (instance_ == nullptr) { + std::lock_guard lock(instanceLock_); + if (instance_ == nullptr) { + instance_ = new (std::nothrow) PrintServiceManager; + } + } + return instance_; +} + +int32_t PrintServiceManager::Dummy() +{ + int32_t taskId = -1; + return taskId; +} + +bool PrintServiceManager::ConnectPrinter(uint32_t printerId) +{ + PRINT_HILOGE("PrintServiceManager ConnectPrinter started."); + return true; +} + +bool PrintServiceManager::DisconnectPrinter(uint32_t printerId) +{ + PRINT_HILOGE("PrintServiceManager DisconnectPrinter started."); + return true; +} + +bool PrintServiceManager::StartDiscoverPrinter(std::vector extensionList) +{ + PRINT_HILOGE("PrintServiceManager StartDiscoverPrinter started."); + return true; +} + +bool PrintServiceManager::StopDiscoverPrinter() +{ + PRINT_HILOGE("PrintServiceManager StopDiscoverPrinter started."); + return true; +} + +bool PrintServiceManager::QueryExtensionAbilityInfos(std::vector &arrayExtensionInfo) +{ + PRINT_HILOGE("PrintServiceManager QueryAllExtension enter."); + PrinterExtensionInfo printerExtensionInfo; + arrayExtensionInfo.push_back(printerExtensionInfo); + arrayExtensionInfo[0].SetExtensionId(5); + arrayExtensionInfo[0].SetVendorId(55); + std::string vendorName = "vendorName = print 1.0"; + std::string version = "version = 1.0.0"; + arrayExtensionInfo[0].SetVendorName(vendorName); + arrayExtensionInfo[0].SetVendorIcon(555); + arrayExtensionInfo[0].SetVersion(version); + PRINT_HILOGE("PrintServiceManager QueryAllExtension started."); + return true; +} + +bool PrintServiceManager::StartPrintJob(PrintJob jobinfo) +{ + PRINT_HILOGE("PrintServiceManager StartPrintJob started."); + return true; +} + +bool PrintServiceManager::CancelPrintJob(PrintJob jobinfo) +{ + PRINT_HILOGE("PrintServiceManager CancelPrintJob started."); + return true; +} + +bool PrintServiceManager::AddPrinters(std::vector arrayPrintInfo) +{ + PRINT_HILOGE("PrintServiceManager AddPrinters started."); + return true; +} + +bool PrintServiceManager::RemovePrinters(std::vector arrayPrintInfo) +{ + PRINT_HILOGE("PrintServiceManager RemovePrinters started."); + return true; +} + +bool PrintServiceManager::UpdatePrinterState(uint32_t printerId, uint32_t state) +{ + PRINT_HILOGE("PrintServiceManager UpdatePrinterState started."); + return true; +} + +bool PrintServiceManager::UpdatePrinterJobState(uint32_t jobId, uint32_t state) +{ + PRINT_HILOGE("PrintServiceManager UpdatePrinterJobState started."); + return true; +} + +bool PrintServiceManager::RequestPreview(PrintJob jobinfo, std::string &previewResult) +{ + previewResult = "Preview OK!"; + PRINT_HILOGE("PrintServiceManager RequestPreview started."); + return true; +} + +bool PrintServiceManager::QueryPrinterCapability(uint32_t printerId, PrinterCapability &printerCapability) +{ + auto instance = PrintServiceManager::GetInstance(); + if (instance == nullptr) { + PRINT_HILOGE("PrintServiceManager is null"); + return false; + } + + printerCapability.SetColorMode(10); + printerCapability.SetDuplexMode(11); + + PrintMargin printMargin; + printMargin.SetTop(5); + printMargin.SetBottom(5); + printMargin.SetLeft(5); + printMargin.SetRight(5); + printerCapability.SetMinMargin(printMargin); + + PrinterPageSize printerPageSize; + printerPageSize.SetId(6); + printerPageSize.SetName("name"); + printerPageSize.SetWidth(6); + printerPageSize.SetHeight(6); + printerCapability.SetPageSize(printerPageSize); + + PrinterResolution printerResolution; + printerResolution.SetId(6); + printerResolution.SetHorizontalDpi(6); + printerResolution.SetVerticalDpi(6); + printerCapability.SetResolution(printerResolution); + + printerCapability.Dump(); + printerCapability.GetMinMargin().Dump(); + printerCapability.GetPageSize()[0].Dump(); + printerCapability.GetResolution()[0].Dump(); + PRINT_HILOGE("PrintServiceManager RequestPreview started."); + return true; +} +} // namespace OHOS::Request::Print diff --git a/services/src/print_service_stub.cpp b/services/src/print_service_stub.cpp new file mode 100644 index 0000000..f0cafc2 --- /dev/null +++ b/services/src/print_service_stub.cpp @@ -0,0 +1,614 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "print_service_stub.h" +#include "ipc_skeleton.h" +#include "message_parcel.h" +#include "print_extension_Info.h" +#include "print_common.h" +#include "print_job.h" +#include "print_service_interface.h" +#include "log.h" +#include + +namespace OHOS::Print { +using namespace OHOS::HiviewDFX; + +int32_t PrintServiceStub::OnRemoteRequest( + uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) +{ + PRINT_HILOGD("OnRemoteRequest started, code = %{public}d", code); + auto descriptorToken = data.ReadInterfaceToken(); + if (descriptorToken != GetDescriptor()) { + PRINT_HILOGE("Remote descriptor not the same as local descriptor."); + return E_PRINT_TRANSACT_ERROR; + } + switch (code) { + case CMD_DUMMY: + return OnDummy(data, reply); + case CMD_CONNECTPRINTER: + return OnConnectPrinter(data, reply); + case CMD_DISCONNECTPRINTER: + return OnDisconnectPrinter(data, reply); + case CMD_STARTDISCOVERPRINTER: + return OnStartDiscoverPrinter(data, reply); + case CMD_STOPDISCOVERPRINTER: + return OnStopDiscoverPrint(data, reply); + case CMD_QUERYALLEXTENSION: + return OnQueryAllExtension(data, reply); + case CMD_STARTPRINTJOB: + return OnStartPrintJob(data, reply); + case CMD_CANCELPRINTJOB: + return OnCancelPrintJob(data, reply); + case CMD_ADDPRINTERS: + return OnAddPrinters(data, reply); + case CMD_REMOVEPRINTERS: + return OnRemovePrinters(data, reply); + case CMD_UPDATEPRINTERSTATE: + return OnUpdatePrinterState(data, reply); + case CMD_UPDATEPRINTERJOBSTATE: + return OnUpdatePrinterJobState(data, reply); + case CMD_REQUESTPREVIEW: + return OnRequestPreview(data, reply); + case CMD_QUERYPRINTERCAPABILITY: + return OnQueryPrinterCapability(data, reply); + case CMD_CHECKPERMISSION: + return OnCheckPermission(data, reply); + case CMD_ON: + return OnEventOn(data, reply); + case CMD_OFF: + return OnEventOff(data, reply); + default: + PRINT_HILOGE("Default value received, check needed."); + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); + } + return E_PRINT_OK; +} + +bool PrintServiceStub::OnDummy(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + int32_t fd = data.ReadFileDescriptor(); + PRINT_HILOGI("Get FD from client, fd [%{public}d]", fd); + int32_t result = Dummy(); + if (!reply.WriteInt32(result)) { + PRINT_HILOGE("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnConnectPrinter(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + bool result = ConnectPrinter(data.ReadInt32()); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnDisconnectPrinter(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + bool result = DisconnectPrinter(data.ReadInt32()); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnStartDiscoverPrinter(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + std::vector extensionList; + uint32_t extensionListLength = data.ReadUint32(); + + for(uint32_t i = 0; i < extensionListLength; i++) + { + extensionList.push_back(data.ReadUint32()); + PRINT_HILOGD("OnStartDiscoverPrinter = %{public}d", extensionList[i]); + } + + bool result = StartDiscoverPrinter(extensionList); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnStopDiscoverPrint(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + bool result = StopDiscoverPrinter(); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnQueryAllExtension(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + std::vector printerInfo; + bool result = QueryAllExtension(printerInfo); + if (result) { + uint32_t printerInfoLegth = printerInfo.size(); + reply.WriteUint32(printerInfoLegth); + + for(uint32_t i = 0; i < printerInfoLegth; i++) + { + PRINT_HILOGI("PrintServiceProxy, ExtensionId = %{public}d", printerInfo[i].GetExtensionId()); + PRINT_HILOGI("PrintServiceProxy, VendorId = %{public}d", printerInfo[i].GetVendorId()); + PRINT_HILOGI("PrintServiceProxy, VendorName = %{public}s", printerInfo[i].GetVendorName().c_str()); + PRINT_HILOGI("PrintServiceProxy, VendorIcon = %{public}d", printerInfo[i].GetVendorIcon()); + PRINT_HILOGI("PrintServiceProxy, Version = %{public}s", printerInfo[i].GetVersion().c_str()); + + reply.WriteUint32(printerInfo[i].GetExtensionId()); + reply.WriteUint32(printerInfo[i].GetVendorId()); + reply.WriteString(printerInfo[i].GetVendorName()); + reply.WriteUint32(printerInfo[i].GetVendorIcon()); + reply.WriteString(printerInfo[i].GetVersion()); + } + } + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnStartPrintJob(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + PrintJob jobinfo; + uint32_t fileLength = data.ReadUint32(); + for(uint32_t i = 0; i < fileLength; i++) + { + jobinfo.GetFiles().push_back(data.ReadString()); + + } + jobinfo.SetJobId(data.ReadUint32()); + jobinfo.SetPrintId(data.ReadUint32()); + jobinfo.SetJobState(data.ReadUint32()); + jobinfo.SetCopyNumber(data.ReadUint32()); + + jobinfo.GetPageRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPageRange().SetEndPage(data.ReadUint32()); + uint32_t pageLength = data.ReadUint32(); + for(uint32_t i = 0; i < pageLength; i++) + { + jobinfo.GetPageRange().SetPages(data.ReadUint32()); + } + + jobinfo.SetIsSequential(data.ReadUint32()); + + jobinfo.GetPageSize().SetId(data.ReadUint32()); + jobinfo.GetPageSize().SetName(data.ReadString()); + jobinfo.GetPageSize().SetWidth(data.ReadUint32()); + jobinfo.GetPageSize().SetHeight(data.ReadUint32()); + + jobinfo.SetIsLandscape(data.ReadUint32()); + jobinfo.SetColorMode(data.ReadUint32()); + jobinfo.SetDuplexMode(data.ReadUint32()); + + jobinfo.GetMargin().SetTop(data.ReadUint32()); + jobinfo.GetMargin().SetBottom(data.ReadUint32()); + jobinfo.GetMargin().SetLeft(data.ReadUint32()); + jobinfo.GetMargin().SetRight(data.ReadUint32()); + + jobinfo.GetPreview().SetResult(data.ReadString()); + jobinfo.GetPreview().GetPreviewRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPreview().GetPreviewRange().SetEndPage(data.ReadUint32()); + uint32_t previewPageLength = data.ReadUint32(); + + for(uint32_t i = 0; i < previewPageLength; i++) + { + jobinfo.GetPreview().GetPreviewRange().SetPages(data.ReadUint32()); + } + + jobinfo.Dump(); + jobinfo.GetPageRange().Dump(); + jobinfo.GetPageSize().Dump(); + jobinfo.GetMargin().Dump(); + jobinfo.GetPreview().Dump(); + jobinfo.GetPreview().GetPreviewRange().Dump(); + + bool result = StartPrintJob(jobinfo); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnCancelPrintJob(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + PrintJob jobinfo; + uint32_t fileLength = data.ReadUint32(); + + for(uint32_t i = 0; i < fileLength; i++) + { + jobinfo.GetFiles().push_back(data.ReadString()); + } + + jobinfo.SetJobId(data.ReadUint32()); + jobinfo.SetPrintId(data.ReadUint32()); + jobinfo.SetJobState(data.ReadUint32()); + jobinfo.SetCopyNumber(data.ReadUint32()); + jobinfo.GetPageRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPageRange().SetEndPage(data.ReadUint32()); + uint32_t pageLength = data.ReadUint32(); + + for(uint32_t i = 0; i < pageLength; i++) + { + jobinfo.GetPageRange().SetPages(data.ReadUint32()); + } + + jobinfo.SetIsSequential(data.ReadUint32()); + jobinfo.GetPageSize().SetId(data.ReadUint32()); + jobinfo.GetPageSize().SetName(data.ReadString()); + jobinfo.GetPageSize().SetWidth(data.ReadUint32()); + jobinfo.GetPageSize().SetHeight(data.ReadUint32()); + jobinfo.SetIsLandscape(data.ReadUint32()); + jobinfo.SetColorMode(data.ReadUint32()); + jobinfo.SetDuplexMode(data.ReadUint32()); + jobinfo.GetMargin().SetTop(data.ReadUint32()); + jobinfo.GetMargin().SetBottom(data.ReadUint32()); + jobinfo.GetMargin().SetLeft(data.ReadUint32()); + jobinfo.GetMargin().SetRight(data.ReadUint32()); + jobinfo.GetPreview().SetResult(data.ReadString()); + jobinfo.GetPreview().GetPreviewRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPreview().GetPreviewRange().SetEndPage(data.ReadUint32()); + uint32_t previewPageLength = data.ReadUint32(); + + for(uint32_t i = 0; i < previewPageLength; i++) + { + jobinfo.GetPreview().GetPreviewRange().SetPages(data.ReadUint32()); + } + + jobinfo.Dump(); + jobinfo.GetPageRange().Dump(); + jobinfo.GetPageSize().Dump(); + jobinfo.GetMargin().Dump(); + jobinfo.GetPreview().Dump(); + jobinfo.GetPreview().GetPreviewRange().Dump(); + bool result = CancelPrintJob(jobinfo); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnAddPrinters(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + std::vector arrayPrintInfo; + uint32_t arrayPrintInfoLength = data.ReadUint32(); + PRINT_HILOGD("OnStartDiscoverPrinter arrayPrintInfoLength = %{public}d", arrayPrintInfoLength); + + for(uint32_t i = 0; i < arrayPrintInfoLength; i++) + { + PrintInfo printInfo; + printInfo.SetPrinterId(data.ReadUint32()); + printInfo.SetPrinterName(data.ReadString()); + printInfo.SetPrinterIcon(data.ReadUint32()); + printInfo.SetPrinterState(data.ReadUint32()); + printInfo.SetDescription(data.ReadString()); + uint32_t pageSizeLength = data.ReadUint32(); + uint32_t resolutionLength = data.ReadUint32(); + PRINT_HILOGI("OnStartDiscoverPrinter pageSizeLength = %{public}d", pageSizeLength); + PRINT_HILOGI("OnStartDiscoverPrinter resolutionLength = %{public}d", resolutionLength); + printInfo.GetCapability().GetMinMargin().SetTop(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetBottom(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetLeft(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetRight(data.ReadUint32()); + + for(uint32_t i = 0; i < pageSizeLength; i++) + { + PrinterPageSize printerPageSize; + printerPageSize.SetId(data.ReadUint32()); + printerPageSize.SetName(data.ReadString()); + printerPageSize.SetWidth(data.ReadUint32()); + printerPageSize.SetHeight(data.ReadUint32()); + printInfo.GetCapability().GetPageSize().push_back(printerPageSize); + printerPageSize.Dump(); + } + + for(uint32_t i = 0; i < resolutionLength; i++) + { + PrinterResolution printerResolution; + printerResolution.SetId(data.ReadUint32()); + printerResolution.SetHorizontalDpi(data.ReadUint32()); + printerResolution.SetVerticalDpi(data.ReadUint32()); + printInfo.GetCapability().GetResolution().push_back(printerResolution); + printerResolution.Dump(); + } + + printInfo.GetCapability().SetColorMode(data.ReadUint32()); + printInfo.GetCapability().SetDuplexMode(data.ReadUint32()); + arrayPrintInfo.push_back(printInfo); + arrayPrintInfo[i].Dump(); + arrayPrintInfo[i].GetCapability().GetMinMargin().Dump(); + } + + bool result = AddPrinters(arrayPrintInfo); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnRemovePrinters(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + std::vector arrayPrintInfo; + uint32_t arrayPrintInfoLength = data.ReadUint32(); + PRINT_HILOGD("OnStartDiscoverPrinter arrayPrintInfoLength = %{public}d", arrayPrintInfoLength); + + for(uint32_t i = 0; i < arrayPrintInfoLength; i++) + { + PrintInfo printInfo; + printInfo.SetPrinterId(data.ReadUint32()); + printInfo.SetPrinterName(data.ReadString()); + printInfo.SetPrinterIcon(data.ReadUint32()); + printInfo.SetPrinterState(data.ReadUint32()); + printInfo.SetDescription(data.ReadString()); + uint32_t pageSizeLength = data.ReadUint32(); + uint32_t resolutionLength = data.ReadUint32(); + PRINT_HILOGI("OnStartDiscoverPrinter pageSizeLength = %{public}d", pageSizeLength); + PRINT_HILOGI("OnStartDiscoverPrinter resolutionLength = %{public}d", resolutionLength); + printInfo.GetCapability().GetMinMargin().SetTop(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetBottom(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetLeft(data.ReadUint32()); + printInfo.GetCapability().GetMinMargin().SetRight(data.ReadUint32()); + + for(uint32_t i = 0; i < pageSizeLength; i++) + { + PrinterPageSize printerPageSize; + printerPageSize.SetId(data.ReadUint32()); + printerPageSize.SetName(data.ReadString()); + printerPageSize.SetWidth(data.ReadUint32()); + printerPageSize.SetHeight(data.ReadUint32()); + printInfo.GetCapability().GetPageSize().push_back(printerPageSize); + + printerPageSize.Dump(); + + } + + for(uint32_t i = 0; i < resolutionLength; i++) + { + PrinterResolution printerResolution; + printerResolution.SetId(data.ReadUint32()); + printerResolution.SetHorizontalDpi(data.ReadUint32()); + printerResolution.SetVerticalDpi(data.ReadUint32()); + printInfo.GetCapability().GetResolution().push_back(printerResolution); + printerResolution.Dump(); + } + + printInfo.GetCapability().SetColorMode(data.ReadUint32()); + printInfo.GetCapability().SetDuplexMode(data.ReadUint32()); + arrayPrintInfo.push_back(printInfo); + arrayPrintInfo[i].Dump(); + arrayPrintInfo[i].GetCapability().GetMinMargin().Dump(); + } + + bool result = RemovePrinters(arrayPrintInfo); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnUpdatePrinterState(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + uint32_t printerId = data.ReadUint32(); + uint32_t state = data.ReadUint32(); + PRINT_HILOGD("OnStartDiscoverPrinter printerId = %{public}d", printerId); + PRINT_HILOGD("OnStartDiscoverPrinter state = %{public}d", state); + bool result = UpdatePrinterState(printerId, state); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnUpdatePrinterJobState(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + uint32_t jobId = data.ReadUint32(); + uint32_t state = data.ReadUint32(); + PRINT_HILOGD("OnStartDiscoverPrinter printerId = %{public}d", jobId); + PRINT_HILOGD("OnStartDiscoverPrinter state = %{public}d", state); + bool result = UpdatePrinterJobState(jobId, state); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnRequestPreview(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + PrintJob jobinfo; + uint32_t fileLength = data.ReadUint32(); + + for(uint32_t i = 0; i < fileLength; i++) + { + jobinfo.GetFiles().push_back(data.ReadString()); + + } + + jobinfo.SetJobId(data.ReadUint32()); + jobinfo.SetPrintId(data.ReadUint32()); + jobinfo.SetJobState(data.ReadUint32()); + jobinfo.SetCopyNumber(data.ReadUint32()); + jobinfo.GetPageRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPageRange().SetEndPage(data.ReadUint32()); + uint32_t pageLength = data.ReadUint32(); + + for(uint32_t i = 0; i < pageLength; i++) + { + jobinfo.GetPageRange().SetPages(data.ReadUint32()); + } + + jobinfo.SetIsSequential(data.ReadUint32()); + jobinfo.GetPageSize().SetId(data.ReadUint32()); + jobinfo.GetPageSize().SetName(data.ReadString()); + jobinfo.GetPageSize().SetWidth(data.ReadUint32()); + jobinfo.GetPageSize().SetHeight(data.ReadUint32()); + jobinfo.SetIsLandscape(data.ReadUint32()); + jobinfo.SetColorMode(data.ReadUint32()); + jobinfo.SetDuplexMode(data.ReadUint32()); + jobinfo.GetMargin().SetTop(data.ReadUint32()); + jobinfo.GetMargin().SetBottom(data.ReadUint32()); + jobinfo.GetMargin().SetLeft(data.ReadUint32()); + jobinfo.GetMargin().SetRight(data.ReadUint32()); + jobinfo.GetPreview().SetResult(data.ReadString()); + jobinfo.GetPreview().GetPreviewRange().SetStartPage(data.ReadUint32()); + jobinfo.GetPreview().GetPreviewRange().SetEndPage(data.ReadUint32()); + uint32_t previewPageLength = data.ReadUint32(); + + for(uint32_t i = 0; i < previewPageLength; i++) + { + jobinfo.GetPreview().GetPreviewRange().SetPages(data.ReadUint32()); + } + + jobinfo.Dump(); + jobinfo.GetPageRange().Dump(); + jobinfo.GetPageSize().Dump(); + jobinfo.GetMargin().Dump(); + jobinfo.GetPreview().Dump(); + jobinfo.GetPreview().GetPreviewRange().Dump(); + std::string previewResult = ""; + bool result = RequestPreview(jobinfo, previewResult); + reply.WriteString(previewResult); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnQueryPrinterCapability(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("Receive request"); + PrinterCapability printerCapability; + bool result = QueryPrinterCapability(data.ReadUint32(), printerCapability); + printerCapability.Dump(); + printerCapability.GetMinMargin().Dump(); + printerCapability.GetPageSize()[0].Dump(); + printerCapability.GetResolution()[0].Dump(); + uint32_t arraypageSizeLength = printerCapability.GetPageSize().size(); + reply.WriteUint32(arraypageSizeLength); + uint32_t resolutionLength = printerCapability.GetResolution().size(); + reply.WriteUint32(resolutionLength); + reply.WriteUint32(printerCapability.GetMinMargin().GetTop()); + reply.WriteUint32(printerCapability.GetMinMargin().GetBottom()); + reply.WriteUint32(printerCapability.GetMinMargin().GetLeft()); + reply.WriteUint32(printerCapability.GetMinMargin().GetRight()); + + for(uint32_t i = 0; i < arraypageSizeLength; i++) + { + reply.WriteUint32(printerCapability.GetPageSize()[i].GetId()); + reply.WriteString(printerCapability.GetPageSize()[i].GetName()); + reply.WriteUint32(printerCapability.GetPageSize()[i].GetWidth()); + reply.WriteUint32(printerCapability.GetPageSize()[i].GetHeight()); + } + + for(uint32_t i = 0; i < resolutionLength; i++) + { + reply.WriteUint32(printerCapability.GetResolution()[i].GetId()); + reply.WriteUint32(printerCapability.GetResolution()[i].GetHorizontalDpi()); + reply.WriteUint32(printerCapability.GetResolution()[i].GetVerticalDpi()); + } + + reply.WriteUint32(printerCapability.GetColorMode()); + reply.WriteUint32(printerCapability.GetDuplexMode()); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("WriteBool failed"); + return false; + } + return true; +} + +bool PrintServiceStub::OnCheckPermission(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("PrintServiceStub::OnCheckPermission in"); + + bool result = CheckPermission(); + if (!reply.WriteBool(result)) { + return false; + } + PRINT_HILOGD("PrintServiceStub::OnCheckPermission out"); + return true; +} + +bool PrintServiceStub::OnEventOn(MessageParcel &data, MessageParcel &reply) +{ + uint32_t taskId = data.ReadUint32(); + std::string type = data.ReadString(); + PRINT_HILOGD("PrintServiceStub::OnEventOn taskId = %{public}d type=%{public}s ", taskId, type.c_str()); + if (type.empty()) { + PRINT_HILOGE("PrintServiceStub::OnEventOn type is null."); + return false; + } + sptr remote = data.ReadRemoteObject(); + if (remote == nullptr) { + PRINT_HILOGD("PrintServiceStub::OnEventOn remote is nullptr"); + if (!reply.WriteInt32(ERR_NONE)) { + return false; + } + return true; + } + sptr listener = iface_cast(remote); + if (listener.GetRefPtr() == nullptr) { + PRINT_HILOGD("PrintServiceStub::OnEventOn listener is null"); + return false; + } + bool result = On(taskId, type, listener); + if (!reply.WriteBool(result)) { + PRINT_HILOGD("PrintServiceStub::OnEventOn 4444"); + return false; + } + PRINT_HILOGD("PrintServiceStub::OnEventOn out"); + return true; +} + +bool PrintServiceStub::OnEventOff(MessageParcel &data, MessageParcel &reply) +{ + PRINT_HILOGD("PrintServiceStub::OnEventOff in"); + uint32_t taskId = data.ReadUint32(); + std::string type = data.ReadString(); + PRINT_HILOGD("PrintServiceStub::OnEventOff taskId = %{public}d type=%{public}s ", taskId, type.c_str()); + bool result = Off(taskId, type); + if (!reply.WriteBool(result)) { + return false; + } + PRINT_HILOGD("PrintServiceStub::OnEventOff out"); + return true; +} +} // namespace OHOS::Print diff --git a/utils/BUILD.gn b/utils/BUILD.gn new file mode 100644 index 0000000..8d417a2 --- /dev/null +++ b/utils/BUILD.gn @@ -0,0 +1,31 @@ +# Copyright (C) 2022 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") +ohos_shared_library("wallpaper_utils") { + sources = [ "src/file_deal.cpp" ] + include_dirs = [ "include" ] + deps = [ + "//base/hiviewdfx/hiview/adapter/utility:hiview_adapter_utility", + "//utils/native/base:utils", + ] + external_deps = [ + "ability_base:want", + "common_event_service:cesfwk_innerkits", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "samgr_standard:samgr_proxy", + ] + subsystem_name = "miscservices" + part_name = "wallpaper_native" +} diff --git a/utils/include/constant.h b/utils/include/constant.h new file mode 100644 index 0000000..6f1e8ad --- /dev/null +++ b/utils/include/constant.h @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CONSTANT_H +#define CONSTANT_H + +namespace OHOS::Print { +enum NetworkType { + NETWORK_INVALID = 0x00000000, + NETWORK_MOBILE = 0x00000001, + NETWORK_WIFI = 0x00010000, + NETWORK_MASK = 0x00010001, +}; + +enum ErrorCode { + ERROR_CANNOT_RESUME, + ERROR_DEVICE_NOT_FOUND, + ERROR_FILE_ALREADY_EXISTS, + ERROR_FILE_ERROR, + ERROR_HTTP_DATA_ERROR, + ERROR_INSUFFICIENT_SPACE, + ERROR_TOO_MANY_REDIRECTS, + ERROR_UNHANDLED_HTTP_CODE, + ERROR_UNKNOWN, + ERROR_NETWORK_FAIL, +}; + +enum PausedReason { + PAUSED_QUEUED_FOR_WIFI, + PAUSED_WAITING_FOR_NETWORK, + PAUSED_WAITING_TO_RETRY, + PAUSED_BY_USER, + PAUSED_UNKNOWN, +}; + +enum PRINTStatus { + SESSION_SUCCESS, + SESSION_RUNNING, + SESSION_PENDING, + SESSION_PAUSED, + SESSION_FAILED, + SESSION_UNKNOWN, +}; + +enum HttpErrorCode { + HTTP_OK = 200, + HTTP_PARIAL_FILE = 206, +}; + +const uint32_t DEFAULT_READ_TIMEOUT = 60; +const uint32_t DEFAULT_CONNECT_TIMEOUT = 60; +const uint32_t HTTP_FORCE_STOP = 1; +const uint32_t DEFAULT_LOW_SPEED_LIMIT = 30; + +static constexpr const char *HTTP_METHOD_GET = "GET"; +static constexpr const char *HTTP_URL_PARAM_START = "?"; +static constexpr const char *HTTP_URL_PARAM_SEPARATOR = "&"; +static constexpr const char *HTTP_URL_NAME_VALUE_SEPARATOR = "="; +static constexpr const char *HTTP_HEADER_SEPARATOR = ":"; +static constexpr const char *HTTP_LINE_SEPARATOR = "\r\n"; + +static constexpr const char *HTTP_DEFAULT_USER_AGENT = "libcurl-agent/1.0"; +static constexpr const char *HTTP_DEFAULT_CA_PATH = "/etc/ssl/certs/cacert.pem"; + +static constexpr const char *HTTP_CONTENT_TYPE = "content-type"; +static constexpr const char *HTTP_CONTENT_TYPE_TEXT = "text/plain"; +static constexpr const char *HTTP_CONTENT_TYPE_URL_ENCODE = "application/x-www-form-urlencoded"; +static constexpr const char *HTTP_CONTENT_TYPE_JSON = "application/json"; + +static constexpr int RDB_EXECUTE_OK = 0; +static constexpr int RDB_EXECUTE_FAIL = -1; +static constexpr int OPERATION_OK = 0; +static constexpr int OPERATION_ERROR = -1; + +static constexpr int RDB_OBJECT_EMPTY = -1; +static constexpr int PARAMETER_EMPTY = -1; + +static constexpr int TRANSACTION_COUNT = 100; + + +constexpr int PRINT_INFO = 10000; + +constexpr int REQUEST_PARAMS_NUM = 2; +} // namespace OHOS::Print + +#endif // CONSTANT_H diff --git a/utils/include/log.h b/utils/include/log.h new file mode 100644 index 0000000..fdc660c --- /dev/null +++ b/utils/include/log.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_LOG +#define PRINT_LOG + +#define CONFIG_PRINT_LOG +#ifdef CONFIG_PRINT_LOG +#include "hilog/log.h" + +#ifdef PRINT_HILOGF +#undef PRINT_HILOGF +#endif + +#ifdef PRINT_HILOGE +#undef PRINT_HILOGE +#endif + +#ifdef PRINT_HILOGW +#undef PRINT_HILOGW +#endif + +#ifdef PRINT_HILOGD +#undef PRINT_HILOGD +#endif + +#ifdef PRINT_HILOGI +#undef PRINT_HILOGI +#endif + +#define PRINT_LOG_TAG "printkit" +#define PRINT_LOG_DOMAIN 0xD001C00 +static constexpr OHOS::HiviewDFX::HiLogLabel PRINT_LOG_LABEL = {LOG_CORE, PRINT_LOG_DOMAIN, PRINT_LOG_TAG}; + +#define MAKE_FILE_NAME (__builtin_strrchr(__FILE__, '/') ? __builtin_strrchr(__FILE__, '/') + 1 : __FILE__) + +#define PRINT_HILOGF(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Fatal(PRINT_LOG_LABEL, "[%{public}s %{public}s %{public}d] " fmt, \ + MAKE_FILE_NAME, __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#define PRINT_HILOGE(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Error(PRINT_LOG_LABEL, "[%{public}s %{public}s %{public}d] " fmt, \ + MAKE_FILE_NAME, __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#define PRINT_HILOGW(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Warn(PRINT_LOG_LABEL, "[%{public}s %{public}s %{public}d] " fmt, \ + MAKE_FILE_NAME, __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#define PRINT_HILOGD(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Debug(PRINT_LOG_LABEL, "[%{public}s %{public}s %{public}d] " fmt, \ + MAKE_FILE_NAME, __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#define PRINT_HILOGI(fmt, ...) \ + (void)OHOS::HiviewDFX::HiLog::Info(PRINT_LOG_LABEL, "[%{public}s %{public}s %{public}d] " fmt, \ + MAKE_FILE_NAME, __FUNCTION__, __LINE__, ##__VA_ARGS__) + +#else + +#define PRINT_HILOGF(fmt, ...) +#define PRINT_HILOGE(fmt, ...) +#define PRINT_HILOGW(fmt, ...) +#define PRINT_HILOGD(fmt, ...) +#define PRINT_HILOGI(fmt, ...) +#endif // CONFIG_PRINT_LOG + +#endif /* PRINT_LOG */ \ No newline at end of file diff --git a/utils/include/print_common.h b/utils/include/print_common.h new file mode 100644 index 0000000..249b8cb --- /dev/null +++ b/utils/include/print_common.h @@ -0,0 +1,35 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PRINT_COMMON_H +#define PRINT_COMMON_H + +namespace OHOS::Print { +enum PrintError { + E_PRINT_OK, + E_PRINT_SA_DIED, + E_PRINT_READ_PARCEL_ERROR, + E_PRINT_WRITE_PARCEL_ERROR, + E_PRINT_PUBLISH_FAIL, + E_PRINT_TRANSACT_ERROR, + E_PRINT_DEAL_FAILED, + E_PRINT_PARAMETERS_INVALID, + E_PRINT_SET_RTC_FAILED, + E_PRINT_NOT_FOUND, + E_PRINT_NO_PERMISSION, +}; +} // namespace OHOS::Print + +#endif // PRINT_COMMON_H \ No newline at end of file