Implement open() and close() for Usb class, added a lot of TODO's

src/P700Driver.cpp

@@ -26,15 +26,24 @@ P700Driver::~P700Driver() {
 }
 
 driver::info P700Driver::getInfo() {
-    return driver::info{};
+    return mInfo;
 }
 
 bool P700Driver::open() {
-    return false;
+    auto maybeUsbDev = mUsbDriver->open(mUsbDev);
+    if(!maybeUsbDev.has_value()) {
+        spdlog::error("Can't open P700 printer");
+        return false;
+    }
+    mUsbDev = maybeUsbDev.value();
+    return true;
 }
 
 bool P700Driver::close() {
-    return false;
+    if(!mUsbDriver->close(mUsbDev)) {
+        return false;
+    }
+    return true;
 }
 
 bool P700Driver::command() {
@@ -49,6 +58,8 @@ bool P700Driver::init() {
         return false;
     }
 
+    // TODO: There is the possibility, that two printers with the same ID are connected
+    //       We have to take that into account
     auto devIt =
         std::find_if(devs.value().begin(), devs.value().end(), [=](auto dev) {
             return mUsbDev.vendorId == dev.vendorId &&

src/P700Printer.cpp

@@ -5,8 +5,9 @@
 
 namespace ptprnt::printer {
 
-P700Printer::P700Printer(std::unique_ptr<driver::P700Driver> driver) {
-    if (!driver->open()) {
+P700Printer::P700Printer(std::shared_ptr<driver::P700Driver> driver) {
+    mDriver = std::move(driver);
+    if (!mDriver->open()) {
         throw std::invalid_argument("Could not open driver!");
     }
 }

src/Usb.cpp

@@ -17,31 +17,87 @@ Usb::~Usb() {
 }
 
 std::optional<std::vector<UsbDevice>> Usb::getDevices() {
-    libusb_device** devs;
-    libusb_device* dev;
-    struct libusb_device_descriptor desc;
-    int r, i = 0;
+    // TODO: wrap libUsbDevs in a smart pointer with custom destructor
+    //       calling libusb_free_device_list
+    libusb_device** libUsbDevs;
+    libusb_device* libUsbDev;
+    struct libusb_device_descriptor libUsbDesc;
+    int ret, i = 0;
 
     mDevices.clear();
 
-    libusb_get_device_list(NULL, &devs);
+    if (0 == (ret = libusb_get_device_list(NULL, &libUsbDevs))) {
+        spdlog::error("Could not find any USB devices: {}",
+                      libusb_error_name(ret));
+        return std::nullopt;
+    }
 
-    while ((dev = devs[i++]) != NULL) {
+    while ((libUsbDev = libUsbDevs[i++]) != NULL) {
         UsbDevice newDev;
 
-        if ((r = libusb_get_device_descriptor(dev, &desc)) < 0) {
+        if ((ret = libusb_get_device_descriptor(libUsbDev, &libUsbDesc)) < 0) {
             spdlog::error("failed to open device");
-            libusb_free_device_list(devs, 1);
+            libusb_free_device_list(libUsbDevs, 1);
             return std::nullopt;
         }
 
-        newDev.vendorId = desc.idVendor;
-        newDev.productId = desc.idProduct;
-
+        newDev.vendorId = libUsbDesc.idVendor;
+        newDev.productId = libUsbDesc.idProduct;
+        newDev.device = libUsbDev;
+        newDev.hndl =
+            nullptr;  // handle is only available after we opened the dev
         mDevices.push_back(newDev);
     }
 
+    libusb_free_device_list(libUsbDevs, 1);
     return mDevices;
 }
 
+std::optional<UsbDevice> Usb::open(UsbDevice dev) {
+    libusb_device_handle* libUsbHandle = nullptr;
+    int ret = 0;
+
+    if ((ret = libusb_open(dev.device, &libUsbHandle) != 0)) {
+        spdlog::error("Could not open device {0:04X}:{1:04X}: {2}",
+                      dev.vendorId, dev.productId, libusb_error_name(ret));
+        return std::nullopt;
+    }
+
+    // detach the device from the kernel if it is active
+    if ((ret = libusb_kernel_driver_active(libUsbHandle, 0)) == 1) {
+        if ((ret = libusb_detach_kernel_driver(libUsbHandle, 0)) != 0) {
+            spdlog::error(
+                "Could not detach kernel driver for device {0:04X}:{1:04X}: "
+                "{2}",
+                dev.vendorId, dev.productId, libusb_error_name(ret));
+            return std::nullopt;
+        }
+    }
+
+    // claim interface
+    if ((ret = libusb_claim_interface(libUsbHandle, 0)) != 0) {
+        spdlog::error(
+            "Could not claim interface {0:04X}:{1:04X}: "
+            "{2}",
+            dev.vendorId, dev.productId, libusb_error_name(ret));
+    }
+
+    dev.hndl = libUsbHandle;
+
+    return dev;
+}
+
+bool Usb::close(UsbDevice dev) {
+    int ret = 0;
+    if(0 != (ret = libusb_release_interface(dev.hndl, 0))) {
+        spdlog::error(
+            "Could not close USB device {0:04X}:{1:04X}: "
+            "{2}",
+            dev.vendorId, dev.productId, libusb_error_name(ret));
+    }
+
+    libusb_close(dev.hndl);
+    return true;
+}
+
 }  // namespace ptprnt::driver

src/main.cpp

@@ -25,8 +25,8 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    auto driver = std::make_unique<driver::P700Driver>(usb);
-    //auto printer = std::make_unique<printer::P700Printer>(std::move(driver));
+    auto driver = std::make_shared<driver::P700Driver>(usb);
+    auto printer = std::make_unique<printer::P700Printer>(std::move(driver));
     //printer::info info = printer->getInfo();
 
     return 0;