This Commit adds a rudimentary printer factory to greatly simplify the creation of printers

Improve logging output

Reviewed-on: #9

.gitea/workflows/build.yaml

@@ -14,7 +14,7 @@ jobs:
       - name: install meson
         run: apt-get -yq install meson
       - name: Install build dependencies
-        run: apt-get -yq install libusb-1.0-0-dev libspdlog-dev libpango1.0-dev libcairo2-dev gcovr
+        run: apt-get -yq install libusb-1.0-0-dev libspdlog-dev libfmt-dev libpango1.0-dev libcairo2-dev gcovr
       - name: setup builddir
         run: meson setup builddir -Db_coverage=true
       - name: build all targets

README.md

@@ -19,7 +19,7 @@ pacman -S libusb spdlog pango cairo meson gcovr
 
 Install dependencies on Debian/Ubuntu
 ``` bash
-apt-get install libusb-1.0-0-dev libspdlog-dev libpango1.0-dev libcairo2-dev meson gcovr
+apt-get install libusb-1.0-0-dev libspdlog-dev libfmt-dev libpango1.0-dev libcairo2-dev meson gcovr
 ```
 
 ## Build

meson.build

@@ -6,6 +6,7 @@ project('ptprnt', 'cpp',
 
 usb_dep = dependency('libusb-1.0')
 log_dep = dependency('spdlog')
+fmt_dep = dependency('fmt')
 pangocairo_dep = dependency('pangocairo')
 
 # CLI11 
@@ -23,7 +24,7 @@ ptprnt_exe = executable(
     'ptprnt', 
     'src/main.cpp',
     install: true,
-    dependencies : [usb_dep, log_dep, pangocairo_dep, cli11_dep],
+    dependencies : [usb_dep, log_dep, fmt_dep, pangocairo_dep, cli11_dep],
     include_directories: incdir,
     sources: [ptprnt_srcs],
     cpp_args : ['-DPROJ_VERSION="'+meson.project_version()+'"'],

src/P700Printer.cpp

@@ -41,6 +41,11 @@
 
 namespace ptprnt::printer {
 
+const PrinterInfo P700Printer::mInfo = {.driverName = "P700",
+                                        .name       = "Brother P-touch P700",
+                                        .version    = "v1.0",
+                                        .usbId{0x04f9, 0x2061}};
+
 P700Printer::~P700Printer() {
     detachUsbDevice();
     if (mUsbHndl) {
@@ -80,12 +85,8 @@ const PrinterStatus P700Printer::getPrinterStatus() {
     return PrinterStatus{.tapeWidthMm = recvBuf[10]};
 }
 
-const uint16_t P700Printer::getVid() {
+const libusbwrap::usbId P700Printer::getUsbId() {
-    return mInfo.vid;
+    return mInfo.usbId;
-}
-
-const uint16_t P700Printer::getPid() {
-    return mInfo.pid;
 }
 
 bool P700Printer::attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) {

src/P700Printer.hpp

@@ -25,6 +25,7 @@
 
 #include "interface/IPrinterDriver.hpp"
 #include "interface/IPrinterTypes.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 #pragma once
@@ -44,11 +45,13 @@ class P700Printer : public ::ptprnt::IPrinterDriver {
     P700Printer(P700Printer&&)                 = default;
     P700Printer& operator=(P700Printer&&)      = default;
 
+    // Printer info has to be static to be accessed without instantiation
+    static const PrinterInfo mInfo;
+
     // IPrinterDriver
     const std::string_view getDriverName() override;
     const std::string_view getName() override;
-    const uint16_t getPid() override;
+    const libusbwrap::usbId getUsbId() override;
-    const uint16_t getVid() override;
     const std::string_view getVersion() override;
     const PrinterInfo getPrinterInfo() override;
     const PrinterStatus getPrinterStatus() override;
@@ -62,12 +65,6 @@ class P700Printer : public ::ptprnt::IPrinterDriver {
     bool init();
 
     std::shared_ptr<libusbwrap::IUsbDevice> mUsbHndl{nullptr};
-
-    static constexpr PrinterInfo mInfo{.driverName = "P700",
-                                       .name       = "Brother P-touch P700",
-                                       .version    = "v1.0",
-                                       .vid        = 0x04f9,
-                                       .pid        = 0x2061};
     std::map<std::string, std::vector<uint8_t>> commands{
         {"rasterstart",
          {0x1b, 0x69, 0x61,

src/PrinterDriverFactory.cpp

@@ -0,0 +1,22 @@
+#include "PrinterDriverFactory.hpp"
+#include <memory>
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "P700Printer.hpp"
+#include <spdlog/spdlog.h>
+
+namespace ptprnt {
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::create(libusbwrap::usbId id) {
+
+   if(printer::P700Printer::mInfo.usbId == id) {
+      spdlog::debug("Printer is P700!");
+      return std::make_shared<printer::P700Printer>();
+   }
+   else  {
+      spdlog::debug("{:04x}:{:04x} is not a compatible printer", id.first, id.second);
+   }
+   return nullptr;
+}
+
+
+}

src/PrinterDriverFactory.hpp

@@ -0,0 +1,22 @@
+#include <memory>
+#include "interface/IPrinterDriver.hpp"
+#include "libusbwrap/LibUsbTypes.hpp"
+
+namespace ptprnt {
+
+class PrinterDriverFactory {
+   public:
+    PrinterDriverFactory()  = default;
+    ~PrinterDriverFactory() = default;
+
+    PrinterDriverFactory(const PrinterDriverFactory&)            = delete;
+    PrinterDriverFactory& operator=(const PrinterDriverFactory&) = delete;
+    PrinterDriverFactory(PrinterDriverFactory&&)                 = delete;
+    PrinterDriverFactory& operator=(PrinterDriverFactory&&)      = delete;
+
+    std::shared_ptr<IPrinterDriver> create(libusbwrap::usbId id);
+
+   private:
+};
+
+}

src/PtouchPrint.cpp

@@ -16,17 +16,28 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
  */
+#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
+#define SPDLOG_DEBUG_ON
+#define SPDLOG_TRACE_ON
 
 #include "PtouchPrint.hpp"
 
 #include <CLI/App.hpp>
+#include <fmt/core.h>
 #include <spdlog/common.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/logger.h>
+#include <spdlog/sinks/base_sink.h>
+#include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/sinks/stdout_color_sinks.h>
 #include <spdlog/spdlog.h>
 
 #include <functional>
+#include <memory>
+#include <vector>
 
 #include "CLI/Option.hpp"
-#include "P700Printer.hpp"
+#include "PrinterDriverFactory.hpp"
 #include "graphics/Bitmap.hpp"
 #include "libusbwrap/UsbDeviceFactory.hpp"
 
@@ -45,32 +56,35 @@ int PtouchPrint::init(int argc, char** argv) {
     }
 
     if (mVerboseFlag) {
-        setupLogger(spdlog::level::trace);
+        setupLogger(spdlog::level::debug);
     } else {
-        setupLogger(spdlog::level::critical);
+        setupLogger(spdlog::level::err);
     }
 
     if (!mUsbDeviceFactory.init()) {
         spdlog::error("Could not initialize libusb");
         return -1;
     }
-    mCompatiblePrinters = {std::make_shared<ptprnt::printer::P700Printer>()};
     return 0;
 }
 
 int PtouchPrint::run() {
-    auto numFoundPrinters = getCompatiblePrinters();
+    spdlog::debug("ptprnt version {}", mVersionString);
+    SPDLOG_TRACE("testing trace");
+    mDetectedPrinters = getCompatiblePrinters();
+    auto numFoundPrinters = mDetectedPrinters.size();
     if (numFoundPrinters == 0) {
         spdlog::error(
-            "No compatible printers found, please make sure if they are turned on and connected");
+            "No compatible printers found, please make sure that they are turned on and connected");
         return -1;
     } else if (numFoundPrinters > 1) {
         spdlog::warn("Found more than one compatible printer. Currently not supported.");
         return -1;
     }
 
-    auto printer = mCompatiblePrinters[0];
+    auto printer = mDetectedPrinters[0];
-    auto devices = mUsbDeviceFactory.findDevices(printer->getVid(), printer->getPid());
+    const auto printerUsbId = printer->getUsbId();
+    auto devices = mUsbDeviceFactory.findDevices(printerUsbId.first, printerUsbId.second);
     if (devices.size() != 1) {
         spdlog::warn(
             "Found more than one device of the same printer on bus. Currently not supported");
@@ -84,42 +98,44 @@ int PtouchPrint::run() {
     //printer->printText("wurst", 1);
 
     for (auto& cmd : mCommands) {
-        std::cout << cmd.second << std::endl;
+        spdlog::debug("Command: {}", cmd.second);
     }
 
     return 0;
 }
 
-unsigned int PtouchPrint::getCompatiblePrinters() {
+std::vector<std::shared_ptr<IPrinterDriver>> PtouchPrint::getCompatiblePrinters() {
+
     auto usbDevs = mUsbDeviceFactory.findAllDevices();
+    auto driverFactory = std::make_unique<PrinterDriverFactory>();
+    std::vector<std::shared_ptr<IPrinterDriver>> foundPrinterDrivers {};
 
     for (auto usbDev : usbDevs) {
-        auto foundPrinterIt =
+        auto driver = driverFactory->create(usbDev->getUsbId());
-            std::find_if(mCompatiblePrinters.begin(), mCompatiblePrinters.end(),
+        if(driver != nullptr) {
-                         [usbDev](const std::shared_ptr<ptprnt::IPrinterDriver>& printer) {
+            foundPrinterDrivers.push_back(driver);
-                             return printer->getPid() == usbDev->getPid() &&
-                                    printer->getVid() == usbDev->getVid();
-                         });
-        if (foundPrinterIt == mCompatiblePrinters.end()) {
-            continue;
         }
-        auto foundPrinter = *foundPrinterIt;
-        spdlog::info("Found Printer {}", foundPrinter->getName());
-        mDetectedPrinters.push_back(foundPrinter);
     }
-    // we can delete all instantiated printers that are not compatible
+    return foundPrinterDrivers;
-    mCompatiblePrinters.clear();
-    return mDetectedPrinters.size();
 }
 
 void PtouchPrint::setupLogger(spdlog::level::level_enum lvl) {
-    spdlog::set_level(lvl);
+    auto consoleSink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    spdlog::debug("Starting ptprnt {}", mVersionString);
+    consoleSink->set_level(lvl);
+    consoleSink->set_pattern("%^%L:%$ %v");
+
+    auto fileSink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("ptprnt.log", true);
+    fileSink->set_level(spdlog::level::trace);
+    fileSink->set_pattern("%Y-%m-%d %H:%m:%S:%e [pid:%P tid:%t] [%^%l%$] %v (%@)");
+    std::vector<spdlog::sink_ptr> sinks{consoleSink, fileSink};
+    auto logger = std::make_shared<spdlog::logger>("default_logger", sinks.begin(), sinks.end());
+    logger->set_level(spdlog::level::trace);
+    spdlog::set_default_logger(logger);
 }
 
 void PtouchPrint::setupCliParser() {
     auto printVersion = [this](std::size_t) {
-        std::cout << "ptprnt version: " << mVersionString << std::endl;
+        fmt::print("ptprnt version: {}\n", mVersionString);
     };
 
     // General options

src/PtouchPrint.hpp

@@ -49,13 +49,12 @@ class PtouchPrint {
     // methods
     void setupLogger(spdlog::level::level_enum lvl);
     void setupCliParser();
-    unsigned int getCompatiblePrinters();
+    std::vector<std::shared_ptr<IPrinterDriver>> getCompatiblePrinters();
 
     // member variables
     CLI::App mApp{ptprnt::APP_DESC};
     libusbwrap::UsbDeviceFactory mUsbDeviceFactory{};
-    std::vector<std::shared_ptr<ptprnt::IPrinterDriver>> mCompatiblePrinters{};
+    std::vector<std::shared_ptr<IPrinterDriver>> mDetectedPrinters{};
-    std::vector<std::shared_ptr<ptprnt::IPrinterDriver>> mDetectedPrinters{};
     std::vector<CliCmd> mCommands{};
     std::string mVersionString = "";
 

src/interface/IPrinterDriver.hpp

@@ -30,11 +30,11 @@ namespace ptprnt {
 
 class IPrinterDriver {
    public:
+    virtual ~IPrinterDriver()                                                     = default;
     virtual const std::string_view getDriverName()                                = 0;
     virtual const std::string_view getName()                                      = 0;
     virtual const std::string_view getVersion()                                   = 0;
-    virtual const uint16_t getVid()                                               = 0;
+    virtual const libusbwrap::usbId getUsbId()                                    = 0;
-    virtual const uint16_t getPid()                                               = 0;
     virtual const PrinterInfo getPrinterInfo()                                    = 0;
     virtual const PrinterStatus getPrinterStatus()                                = 0;
     virtual bool attachUsbDevice(std::shared_ptr<libusbwrap::IUsbDevice> usbHndl) = 0;

src/interface/IPrinterTypes.hpp

@@ -21,6 +21,7 @@
 
 #include <cstdint>
 #include <string_view>
+#include "libusbwrap/LibUsbTypes.hpp"
 
 namespace ptprnt {
 
@@ -28,8 +29,7 @@ struct PrinterInfo {
     std::string_view driverName = "";
     std::string_view name       = "";
     std::string_view version    = "";
-    uint16_t vid                = 0x00;
+    libusbwrap::usbId usbId {0x00, 0x00};
-    uint16_t pid                = 0x00;
 };
 
 struct PrinterStatus {

src/libusbwrap/LibUsbTypes.hpp

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include <memory>
+#include <utility>
 
 #include "libusb.h"
 
@@ -40,4 +40,7 @@ enum class Error {
     NOT_SUPPORTED = LIBUSB_ERROR_NOT_SUPPORTED,
     OTHER         = LIBUSB_ERROR_OTHER
 };
-}
+
+using usbId = std::pair<uint16_t, uint16_t>;
+
+}  // namespace libusbwrap

src/libusbwrap/UsbDevice.cpp

@@ -104,12 +104,8 @@ bool UsbDevice::bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int*
     return true;
 }
 
-const uint16_t UsbDevice::getVid() {
+const usbId UsbDevice::getUsbId() {
-    return mLibusbDevDesc.idVendor;
+    return {mLibusbDevDesc.idVendor, mLibusbDevDesc.idProduct};
-}
-
-const uint16_t UsbDevice::getPid() {
-    return mLibusbDevDesc.idProduct;
 }
 
 const device::Speed UsbDevice::getSpeed() {

src/libusbwrap/UsbDevice.hpp

@@ -29,8 +29,8 @@
 namespace libusbwrap {
 class UsbDevice : public IUsbDevice {
    public:
-    UsbDevice(libusb_context* ctx, libusb_device* dev);
+    explicit UsbDevice(libusb_context* ctx, libusb_device* dev);
-    ~UsbDevice();
+    ~UsbDevice() override;
 
     // delete copy ctor and assignment
     UsbDevice(const UsbDevice&)      = delete;
@@ -47,8 +47,7 @@ class UsbDevice : public IUsbDevice {
                       unsigned int timeout) override;
 
     // getters
-    const uint16_t getVid() override;
+    const usbId getUsbId() override;
-    const uint16_t getPid() override;
     const device::Speed getSpeed() override;
     const uint8_t getBusNumber() override;
     const uint8_t getPortNumber() override;

src/libusbwrap/interface/IUsbDevice.hpp

@@ -24,6 +24,7 @@ enum class Speed {
 
 class IUsbDevice {
    public:
+    virtual ~IUsbDevice() = default;
     virtual bool open()   = 0;
     virtual void close()  = 0;
 
@@ -35,8 +36,7 @@ class IUsbDevice {
                               unsigned int timeout)  = 0;
 
     // getters
-    virtual const uint16_t getVid()        = 0;
+    virtual const usbId getUsbId()         = 0;
-    virtual const uint16_t getPid()        = 0;
     virtual const device::Speed getSpeed() = 0;
     virtual const uint8_t getBusNumber()   = 0;
     virtual const uint8_t getPortNumber()  = 0;

src/libusbwrap/interface/IUsbDeviceFactory.hpp

@@ -9,6 +9,7 @@
 namespace libusbwrap {
 class IUsbDeviceFactory {
    public:
+    virtual ~IUsbDeviceFactory()                                      = default;
     virtual std::vector<std::shared_ptr<IUsbDevice>> findAllDevices() = 0;
     virtual std::vector<std::shared_ptr<IUsbDevice>> findDevices(uint16_t vid, uint16_t pid) = 0;
 };

src/meson.build

@@ -8,6 +8,7 @@ ptprnt_hpps = files (
     'interface/IPrinterTypes.hpp',
     'P700Printer.hpp',
     'PtouchPrint.hpp',
+    'PrinterDriverFactory.hpp',
     'graphics/Bitmap.hpp',
     'graphics/Image.hpp',
     'graphics/Monochrome.hpp'
@@ -15,6 +16,7 @@ ptprnt_hpps = files (
 
 ptprnt_srcs = files (
     'PtouchPrint.cpp',
+    'PrinterDriverFactory.cpp',
     'P700Printer.cpp',
     'graphics/Image.cpp',
     'graphics/Bitmap.cpp',