cli-parser-cleanup (#15)

Reviewed-on: moritz/ptouch-prnt#15

src/core/PrinterDriverFactory.cpp

@@ -0,0 +1,69 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "PrinterDriverFactory.hpp"
+
+#include <algorithm>
+#include <spdlog/spdlog.h>
+
+#include <memory>
+
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "printers/FakePrinter.hpp"
+#include "printers/P700Printer.hpp"
+
+namespace ptprnt {
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::create(libusbwrap::usbId id) {
+
+    if (printer::P700Printer::mInfo.usbId == id) {
+        spdlog::info("Found printer P700!");
+        return std::make_shared<printer::P700Printer>();
+    } else {
+        spdlog::trace("{:04x}:{:04x} is not a compatible printer", id.first, id.second);
+    }
+    return nullptr;
+}
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::createFakePrinter() {
+    spdlog::info("Creating FakePrinter (virtual test printer)");
+    return std::make_shared<printer::FakePrinter>();
+}
+
+std::shared_ptr<IPrinterDriver> PrinterDriverFactory::createByName(const std::string& driverName) {
+    // Convert to lowercase for case-insensitive comparison
+    std::string nameLower = driverName;
+    std::ranges::transform(nameLower, nameLower.begin(), [](unsigned char c) { return std::tolower(c); });
+
+    if (nameLower == "p700" || nameLower == "p700printer") {
+        spdlog::info("Creating P700 printer driver by name");
+        return std::make_shared<printer::P700Printer>();
+    } else if (nameLower == "fakeprinter" || nameLower == "fake") {
+        return createFakePrinter();
+    }
+
+    spdlog::warn("Unknown printer driver name: {}", driverName);
+    return nullptr;
+}
+
+std::vector<std::string> PrinterDriverFactory::listAllDrivers() const {
+    return {std::string(printer::P700Printer::mInfo.driverName), std::string(printer::FakePrinter::mInfo.driverName)};
+}
+
+}  // namespace ptprnt

src/core/PrinterDriverFactory.hpp

@@ -0,0 +1,68 @@
+/* 
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "printers/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;
+
+    /**
+     * @brief Create a printer driver based on USB ID
+     * @param id USB vendor and product ID
+     * @return Printer driver instance or nullptr if no match
+     */
+    std::shared_ptr<IPrinterDriver> create(libusbwrap::usbId id);
+
+    /**
+     * @brief Create a virtual FakePrinter for testing without hardware
+     * @return FakePrinter instance
+     */
+    std::shared_ptr<IPrinterDriver> createFakePrinter();
+
+    /**
+     * @brief Create a printer driver by name
+     * @param driverName Name of the driver (from PrinterInfo.driverName)
+     * @return Printer driver instance or nullptr if no match
+     */
+    std::shared_ptr<IPrinterDriver> createByName(const std::string& driverName);
+
+    /**
+     * @brief Get list of all available printer driver names
+     * @return Vector of driver names
+     */
+    std::vector<std::string> listAllDrivers() const;
+
+   private:
+};
+
+}  // namespace ptprnt

src/core/PrinterService.cpp

@@ -0,0 +1,95 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "PrinterService.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include "core/PrinterDriverFactory.hpp"
+
+namespace ptprnt::core {
+
+PrinterService::PrinterService() = default;
+
+bool PrinterService::initialize() {
+    if (!mUsbDeviceFactory.init()) {
+        spdlog::error("Could not initialize libusb");
+        return false;
+    }
+    return true;
+}
+
+std::vector<std::shared_ptr<IPrinterDriver>> PrinterService::detectPrinters() {
+    spdlog::debug("Detecting printers...");
+
+    auto usbDevs       = mUsbDeviceFactory.findAllDevices();
+    auto driverFactory = std::make_unique<PrinterDriverFactory>();
+    mDetectedPrinters.clear();
+
+    for (auto& usbDev : usbDevs) {
+        auto driver = driverFactory->create(usbDev->getUsbId());
+        if (driver != nullptr) {
+            mDetectedPrinters.push_back(driver);
+        }
+    }
+
+    spdlog::debug("Found {} compatible printer(s)", mDetectedPrinters.size());
+    return mDetectedPrinters;
+}
+
+std::shared_ptr<IPrinterDriver> PrinterService::selectPrinter(const std::string& printerName) {
+    // If a specific printer is requested by name (not "auto"), try to create it directly
+    if (printerName != "auto") {
+        auto driverFactory = std::make_unique<PrinterDriverFactory>();
+        auto printer       = driverFactory->createByName(printerName);
+        if (printer) {
+            mCurrentPrinter = printer;
+            spdlog::info("Using explicitly selected printer: {}", printerName);
+            return mCurrentPrinter;
+        }
+        spdlog::error("Printer driver '{}' not found", printerName);
+        return nullptr;
+    }
+
+    // Auto mode: detect USB printers
+    if (mDetectedPrinters.empty()) {
+        detectPrinters();
+    }
+
+    if (mDetectedPrinters.empty()) {
+        spdlog::error("No compatible printers detected");
+        return nullptr;
+    }
+
+    // Auto-select first detected printer
+    mCurrentPrinter = mDetectedPrinters.front();
+    spdlog::info("Auto-selected printer: {}", mCurrentPrinter->getName());
+    return mCurrentPrinter;
+}
+
+bool PrinterService::printLabel(std::unique_ptr<graphics::ILabel> label) {
+    if (!mCurrentPrinter) {
+        spdlog::error("No printer selected");
+        return false;
+    }
+
+    return mCurrentPrinter->printLabel(std::move(label));
+}
+
+}  // namespace ptprnt::core

src/core/PrinterService.hpp

@@ -0,0 +1,89 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "interface/IPrinterService.hpp"
+#include "libusbwrap/UsbDeviceFactory.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
+
+namespace ptprnt::core {
+
+/**
+ * @brief Core service for printer operations
+ *
+ * Concrete implementation of IPrinterService.
+ * Provides the core library functionality for:
+ * - Detecting printers
+ * - Selecting printers
+ * - Building and printing labels
+ */
+class PrinterService : public IPrinterService {
+   public:
+    PrinterService();
+    ~PrinterService() override = default;
+
+    PrinterService(const PrinterService&)            = delete;
+    PrinterService& operator=(const PrinterService&) = delete;
+    PrinterService(PrinterService&&)                 = delete;
+    PrinterService& operator=(PrinterService&&)      = delete;
+
+    /**
+     * @brief Initialize USB device factory
+     * @return true on success, false on failure
+     */
+    bool initialize() override;
+
+    /**
+     * @brief Detect all compatible printers
+     * @return Vector of detected printers
+     */
+    std::vector<std::shared_ptr<IPrinterDriver>> detectPrinters() override;
+
+    /**
+     * @brief Select a printer by name or auto-detect
+     * @param printerName Printer driver name, or "auto" for first detected
+     * @return Printer driver, or nullptr if not found
+     */
+    std::shared_ptr<IPrinterDriver> selectPrinter(const std::string& printerName) override;
+
+    /**
+     * @brief Get the currently selected printer
+     * @return Current printer, or nullptr if none selected
+     */
+    [[nodiscard]] std::shared_ptr<IPrinterDriver> getCurrentPrinter() const override { return mCurrentPrinter; }
+
+    /**
+     * @brief Print a label
+     * @param label The label to print
+     * @return true on success, false on failure
+     */
+    bool printLabel(std::unique_ptr<graphics::ILabel> label) override;
+
+   private:
+    libusbwrap::UsbDeviceFactory mUsbDeviceFactory;
+    std::vector<std::shared_ptr<IPrinterDriver>> mDetectedPrinters;
+    std::shared_ptr<IPrinterDriver> mCurrentPrinter;
+};
+
+}  // namespace ptprnt::core

src/core/interface/IPrinterService.hpp

@@ -0,0 +1,74 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "graphics/interface/ILabel.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
+
+namespace ptprnt::core {
+
+/**
+ * @brief Interface for core printer service operations
+ *
+ * This interface allows for mocking printer operations in unit tests
+ * and provides a clear contract for printer service implementations.
+ */
+class IPrinterService {
+   public:
+    virtual ~IPrinterService() = default;
+
+    /**
+     * @brief Initialize the printer service
+     * @return true on success, false on failure
+     */
+    virtual bool initialize() = 0;
+
+    /**
+     * @brief Detect all compatible printers
+     * @return Vector of detected printers
+     */
+    virtual std::vector<std::shared_ptr<IPrinterDriver>> detectPrinters() = 0;
+
+    /**
+     * @brief Select a printer by name or auto-detect
+     * @param printerName Printer driver name, or "auto" for first detected
+     * @return Printer driver, or nullptr if not found
+     */
+    virtual std::shared_ptr<IPrinterDriver> selectPrinter(const std::string& printerName) = 0;
+
+    /**
+     * @brief Get the currently selected printer
+     * @return Current printer, or nullptr if none selected
+     */
+    [[nodiscard]] virtual std::shared_ptr<IPrinterDriver> getCurrentPrinter() const = 0;
+
+    /**
+     * @brief Print a label
+     * @param label The label to print
+     * @return true on success, false on failure
+     */
+    virtual bool printLabel(std::unique_ptr<graphics::ILabel> label) = 0;
+};
+
+}  // namespace ptprnt::core