Implemented printer status retrieval

src/libusbwrap/UsbDevice.cpp

@@ -1,8 +1,10 @@
 #include "libusbwrap/UsbDevice.hpp"
 
+#include <cstdint>
 #include <stdexcept>
 
 #include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
@@ -22,14 +24,67 @@ UsbDevice::~UsbDevice() {
     }
 }
 
-Error UsbDevice::open() {
-    return static_cast<Error>(libusb_open(mLibusbDev, &mLibusbDevHandle));
+bool UsbDevice::open() {
+    int openStatus = libusb_open(mLibusbDev, &mLibusbDevHandle);
+    if (openStatus != 0) {
+        mLastError = static_cast<Error>(openStatus);
+        return false;
+    }
+
+    return true;
 }
 
 void UsbDevice::close() {
     libusb_close(mLibusbDevHandle);
 }
 
+bool UsbDevice::detachKernelDriver(int interfaceNo) {
+    // TODO: cover the other status codes that can be returned
+    int kernelDriverStatus = libusb_kernel_driver_active(mLibusbDevHandle, interfaceNo);
+    if (kernelDriverStatus == 1) {  // kernel driver is active, we have to detach to continue...
+        int detachStatus = libusb_detach_kernel_driver(mLibusbDevHandle, interfaceNo);
+        if (detachStatus != 0) {
+            mLastError = static_cast<Error>(detachStatus);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool UsbDevice::claimInterface(int interfaceNo) {
+    // TODO: cover the other status codes that can be returned
+    int claimInterfaceStatus = libusb_claim_interface(mLibusbDevHandle, interfaceNo);
+    if (claimInterfaceStatus != 0) {
+        mLastError = static_cast<Error>(claimInterfaceStatus);
+        return false;
+    }
+    return true;
+}
+
+bool UsbDevice::releaseInterface(int interfaceNo) {
+    int releaseInterfaceStatus = libusb_release_interface(mLibusbDevHandle, interfaceNo);
+    if (releaseInterfaceStatus != 0) {
+        mLastError = static_cast<Error>(releaseInterfaceStatus);
+        return false;
+    }
+    return true;
+}
+
+bool UsbDevice::bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+                             unsigned int timeout) {
+    // TODO: implement error handling for incomplete transactions (tx length != data length)
+    int bulkTransferStatus = 0;
+
+    bulkTransferStatus =
+        libusb_bulk_transfer(mLibusbDevHandle, endpoint, data.data(), data.size(), tx, timeout);
+    if (bulkTransferStatus != 0) {
+        mLastError = static_cast<Error>(bulkTransferStatus);
+        return false;
+    }
+    return true;
+}
+
 const uint16_t UsbDevice::getVid() {
     return mLibusbDevDesc.idVendor;
 }
@@ -49,4 +104,12 @@ const uint8_t UsbDevice::getBusNumber() {
 const uint8_t UsbDevice::getPortNumber() {
     return libusb_get_port_number(mLibusbDev);
 }
+
+const Error UsbDevice::getLastError() {
+    return mLastError;
+}
+
+const std::string UsbDevice::getLastErrorString() {
+    return std::string(libusb_error_name(static_cast<int>(mLastError)));
+}
 }  // namespace libusbwrap

src/libusbwrap/UsbDevice.hpp

@@ -4,6 +4,7 @@
 #include <cstddef>
 
 #include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
 #include "libusbwrap/interface/IUsbDevice.hpp"
 
 namespace libusbwrap {
@@ -16,9 +17,16 @@ class UsbDevice : public IUsbDevice {
     UsbDevice(const UsbDevice&)      = delete;
     UsbDevice& operator=(UsbDevice&) = delete;
 
-    Error open() override;
+    bool open() override;
     void close() override;
 
+    // libusb wrappers
+    bool detachKernelDriver(int interfaceNo) override;
+    bool claimInterface(int interfaceNo) override;
+    bool releaseInterface(int interfaceNo) override;
+    bool bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+                      unsigned int timeout) override;
+
     // getters
     const uint16_t getVid() override;
     const uint16_t getPid() override;
@@ -26,11 +34,16 @@ class UsbDevice : public IUsbDevice {
     const uint8_t getBusNumber() override;
     const uint8_t getPortNumber() override;
 
+    // errors
+    const Error getLastError() override;
+    const std::string getLastErrorString() override;
+
    private:
     libusb_context* mLibusbCtx{nullptr};
     libusb_device* mLibusbDev{nullptr};
     libusb_device_handle* mLibusbDevHandle{nullptr};
     libusb_device_descriptor mLibusbDevDesc;
     std::atomic<bool> mIsOpen = false;
+    Error mLastError          = Error::SUCCESS;
 };
 }  // namespace libusbwrap

src/libusbwrap/UsbDeviceFactory.cpp

@@ -33,8 +33,6 @@ int UsbDeviceFactory::refreshDeviceList() {
         spdlog::error("Error enumarating USB devices");
     } else if (ret == 0) {
         spdlog::warn("No USB devices found");
-    } else {
-        spdlog::debug("Found {} USB devices", ret);
     }
 
     return ret;

src/libusbwrap/interface/IUsbDevice.hpp

@@ -4,6 +4,8 @@
 
 #include <cstdint>
 #include <optional>
+#include <string>
+#include <vector>
 
 #include "libusb.h"
 #include "libusbwrap/LibUsbTypes.hpp"
@@ -22,14 +24,25 @@ enum class Speed {
 
 class IUsbDevice {
    public:
-    virtual Error open() = 0;
+    virtual bool open()  = 0;
     virtual void close() = 0;
 
+    // libusb wrappers
+    virtual bool detachKernelDriver(int interfaceNo) = 0;
+    virtual bool claimInterface(int interfaceNo)     = 0;
+    virtual bool releaseInterface(int interfaceNo)   = 0;
+    virtual bool bulkTransfer(uint8_t endpoint, std::vector<uint8_t>& data, int* tx,
+                              unsigned int timeout)  = 0;
+
     // getters
     virtual const uint16_t getVid()        = 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;
+
+    // errors
+    virtual const Error getLastError()             = 0;
+    virtual const std::string getLastErrorString() = 0;
 };
 }  // namespace libusbwrap