simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/dongl/usb/UsbHelperApple.cpp

@@ -0,0 +1,266 @@
+#include "UsbHelperApple.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOReturn.h>
+#include <IOKit/serial/IOSerialKeys.h>
+#include <IOKit/usb/IOUSBLib.h>
+#include <IOKit/serial/ioss.h>
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <termios.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstring>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <fmt/core.h>
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+template <typename T, typename Deleter>
+class ScopedResource {
+  public:
+    ScopedResource(T resource = nullptr) : resource_(resource) {}
+    ~ScopedResource() {
+        if (resource_) deleter_(resource_);
+    }
+
+    T get() const { return resource_; }
+    T operator->() const { return resource_; }
+    operator bool() const { return resource_ != nullptr; }
+
+  private:
+    T resource_;
+    Deleter deleter_;
+};
+
+struct CFReleaser {
+    void operator()(CFTypeRef obj) const { CFRelease(obj); }
+};
+
+struct IOReleaser {
+    void operator()(io_object_t obj) const { IOObjectRelease(obj); }
+};
+
+using ScopedCFRef = ScopedResource<CFTypeRef, CFReleaser>;
+using ScopedIOObject = ScopedResource<io_object_t, IOReleaser>;
+
+UsbHelperApple::UsbHelperApple(const std::string& device_path) : UsbHelperImpl(device_path) {
+        // Open and configure the serial port
+        if (!_open_serial_port()) {
+            throw std::runtime_error("Failed to open serial port: " + _device_path);
+        }
+
+        _running = true;
+        _thread = std::thread(&UsbHelperApple::_run, this);
+}
+
+UsbHelperApple::~UsbHelperApple() {
+    _running = false;
+    if (_thread.joinable()) {
+        _thread.join();
+    }
+    _close_serial_port();
+}
+
+void UsbHelperApple::tx(const kvn::bytearray& data) {
+    const ssize_t written = write(_serial_fd, data.data(), data.size());
+    if (written != data.size()) {
+        throw std::runtime_error("Failed to write to serial port: " + std::string(strerror(errno)));
+    }
+}
+
+void UsbHelperApple::set_rx_callback(std::function<void(const kvn::bytearray&)> callback) {
+    _rx_callback.load(callback);
+}
+
+std::vector<std::string> UsbHelperApple::get_dongl_devices() {
+    std::vector<std::string> dongle_devices;
+
+    io_iterator_t raw_iterator = 0;
+    if (IOServiceGetMatchingServices(kIOMainPortDefault, IOServiceMatching(kIOSerialBSDServiceValue), &raw_iterator) !=
+        kIOReturnSuccess) {
+        return {};
+    }
+    ScopedIOObject iterator(raw_iterator);
+
+    io_service_t raw_service;
+    while ((raw_service = IOIteratorNext(iterator.get()))) {
+        ScopedIOObject service_guard(raw_service);
+
+        // Get the callout device raw_path (/dev/cu.*)
+        char raw_path[PATH_MAX];
+        ScopedCFRef pathCF((CFStringRef)IORegistryEntryCreateCFProperty(raw_service, CFSTR(kIOCalloutDeviceKey),
+                                                                        kCFAllocatorDefault, 0));
+        if (!pathCF) {
+            continue;
+        }
+
+        if (!CFStringGetCString((CFStringRef)pathCF.get(), raw_path, sizeof(raw_path), kCFStringEncodingUTF8)) {
+            continue;
+        }
+
+        std::string path(raw_path);
+
+        //fmt::print("Checking device path: {}\n", path);
+
+        // Search up parents for idVendor and idProduct
+        ScopedCFRef vidCF((CFNumberRef)IORegistryEntrySearchCFProperty(
+            raw_service, kIOServicePlane, CFSTR(kUSBVendorID), kCFAllocatorDefault,
+            kIORegistryIterateParents | kIORegistryIterateRecursively));
+        ScopedCFRef pidCF((CFNumberRef)IORegistryEntrySearchCFProperty(
+            raw_service, kIOServicePlane, CFSTR(kUSBProductID), kCFAllocatorDefault,
+            kIORegistryIterateParents | kIORegistryIterateRecursively));
+
+        if (!vidCF || !pidCF) {
+            continue;
+        }
+
+        uint16_t vid, pid;
+        CFNumberGetValue((CFNumberRef)vidCF.get(), kCFNumberSInt16Type, &vid);
+        CFNumberGetValue((CFNumberRef)pidCF.get(), kCFNumberSInt16Type, &pid);
+
+        //fmt::print("VID/PID: 0x{:x}/0x{:x}\n", vid, pid);
+
+        if (vid == UsbHelperImpl::DONGL_VENDOR_ID && pid == UsbHelperImpl::DONGL_PRODUCT_ID) {
+            dongle_devices.push_back(path);
+        }
+    }
+    return dongle_devices;
+}
+
+bool UsbHelperApple::_open_serial_port() {
+    // Open the serial port in non-blocking mode
+    _serial_fd = open(_device_path.c_str(), O_RDWR | O_NOCTTY | O_NONBLOCK);
+    if (_serial_fd < 0) {
+        std::cerr << "Failed to open serial port " << _device_path << ": " << strerror(errno) << std::endl;
+        return false;
+    }
+
+    // Configure the serial port
+    _configure_serial_port();
+
+    //std::cout << "Successfully opened serial port: " << _device_path << std::endl;
+    return true;
+}
+
+void UsbHelperApple::_configure_serial_port() {
+    struct termios tty;
+
+    // Get current serial port settings
+    if (tcgetattr(_serial_fd, &tty) != 0) {
+        throw std::runtime_error("Failed to get serial port attributes: " + std::string(strerror(errno)));
+    }
+
+    // Configure serial port settings
+    tty.c_cflag &= ~PARENB;         // No parity bit
+    tty.c_cflag &= ~CSTOPB;         // One stop bit
+    tty.c_cflag &= ~CSIZE;          // Clear data size bits
+    tty.c_cflag |= CS8;             // 8 data bits
+    tty.c_cflag &= ~CRTSCTS;        // Disable RTS/CTS hardware flow control
+    tty.c_cflag |= CREAD | CLOCAL;  // Enable receiver, ignore modem control lines
+
+    tty.c_lflag &= ~ICANON;  // Disable canonical mode
+    tty.c_lflag &= ~ECHO;    // Disable echo
+    tty.c_lflag &= ~ECHOE;   // Disable erasure echo
+    tty.c_lflag &= ~ECHONL;  // Disable new-line echo
+    tty.c_lflag &= ~ISIG;    // Disable interpretation of INTR, QUIT and SUSP
+
+    tty.c_iflag &= ~(IXON | IXOFF | IXANY);                                       // Disable software flow control
+    tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);  // Disable special handling
+
+    tty.c_oflag &= ~OPOST;  // Disable output processing
+    tty.c_oflag &= ~ONLCR;  // Disable conversion of newline to carriage return/line feed
+
+    // Set minimum characters to read and timeout
+    tty.c_cc[VMIN] = 0;   // Read doesn't block
+    tty.c_cc[VTIME] = 0;  // 0.0 seconds read timeout
+
+    // Apply the settings
+    if (tcsetattr(_serial_fd, TCSANOW, &tty) != 0) {
+        throw std::runtime_error("Failed to set serial port attributes: " + std::string(strerror(errno)));
+    }
+
+    speed_t speed = 1000000;  // Set 1 Mbps
+    if (ioctl(_serial_fd, IOSSIOSPEED, &speed) == -1) {
+        throw std::runtime_error("Failed to set serial port speed: " + std::string(strerror(errno)));
+    }
+
+    // Flush any existing data
+    tcflush(_serial_fd, TCIOFLUSH);
+}
+
+void UsbHelperApple::_close_serial_port() {
+    if (_serial_fd >= 0) {
+        close(_serial_fd);
+        _serial_fd = -1;
+        //std::cout << "Closed serial port: " << _device_path << std::endl;
+    }
+}
+
+void UsbHelperApple::_run() {
+    const size_t BUFFER_SIZE = 256;
+    char buffer[BUFFER_SIZE];
+
+    fd_set read_fds;
+    struct timeval timeout;
+
+    //std::cout << "UsbHelperApple: _run() started with non-blocking reads" << std::endl;
+
+    while (_running) {
+        // Clear the file descriptor set
+        FD_ZERO(&read_fds);
+        FD_SET(_serial_fd, &read_fds);
+
+        // Set timeout for select (100ms)
+        timeout.tv_sec = 0;
+        timeout.tv_usec = 100000;  // 100ms
+
+        // Wait for data to be available (non-blocking)
+        int ready = select(_serial_fd + 1, &read_fds, nullptr, nullptr, &timeout);
+
+        if (ready > 0) {
+            // Data is available to read
+            if (FD_ISSET(_serial_fd, &read_fds)) {
+                ssize_t bytes_read = read(_serial_fd, buffer, BUFFER_SIZE - 1);
+
+                if (bytes_read > 0) {
+                    kvn::bytearray data(buffer, bytes_read);
+                    _rx_callback(data);
+                } else if (bytes_read == 0) {
+                    // End of file (device disconnected)
+                    std::cerr << "Serial port disconnected" << std::endl;
+                    break;
+                } else {
+                    // Error reading from serial port
+                    if (errno != EAGAIN && errno != EWOULDBLOCK) {
+                        std::cerr << "Error reading from serial port: " << strerror(errno) << std::endl;
+                        break;
+                    }
+                }
+            }
+        } else if (ready == 0) {
+            // Timeout - no data available, continue loop
+            continue;
+        } else {
+            // Error in select
+            if (errno != EINTR) {
+                std::cerr << "Error in select: " << strerror(errno) << std::endl;
+                break;
+            }
+        }
+    }
+}
+
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperApple.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "UsbHelperImpl.h"
+#include <thread>
+#include <atomic>
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperApple : public UsbHelperImpl {
+  public:
+    UsbHelperApple(const std::string& device_path);
+    ~UsbHelperApple();
+
+    void tx(const kvn::bytearray& data);
+    void set_rx_callback(std::function<void(const kvn::bytearray&)> callback);
+
+    static std::vector<std::string> get_dongl_devices();
+
+  private:
+    void _run();
+    std::atomic_bool _running;
+    std::thread _thread;
+
+    int _serial_fd;
+    bool _open_serial_port();
+    void _close_serial_port();
+    void _configure_serial_port();
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperImpl.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <kvn/kvn_bytearray.h>
+#include <kvn/kvn_safe_callback.hpp>
+#include <string>
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperImpl {
+  public:
+    UsbHelperImpl(const std::string& device_path) : _device_path(device_path) {}
+    virtual ~UsbHelperImpl() = default;
+
+    virtual void tx(const kvn::bytearray& data) = 0;
+    virtual void set_rx_callback(std::function<void(const kvn::bytearray&)> callback) = 0;
+
+    static const uint16_t DONGL_VENDOR_ID = 0x9999; // 0x0403 for legacy dongles
+    static const uint16_t DONGL_PRODUCT_ID = 0x0001; // 0x6001 for legacy dongles
+
+  protected:
+    std::string _device_path;
+    kvn::safe_callback<void(const kvn::bytearray&)> _rx_callback;
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperLinux.cpp

@@ -0,0 +1,21 @@
+#include "UsbHelperLinux.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+UsbHelperLinux::UsbHelperLinux(const std::string& device_path) : UsbHelperImpl(device_path) {}
+
+UsbHelperLinux::~UsbHelperLinux() = default;
+
+void UsbHelperLinux::tx(const kvn::bytearray& data) {}
+
+void UsbHelperLinux::set_rx_callback(std::function<void(const kvn::bytearray&)> callback) {
+    _rx_callback.load(callback);
+}
+
+std::vector<std::string> UsbHelperLinux::get_dongl_devices() { return {}; }
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperLinux.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "UsbHelperImpl.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperLinux : public UsbHelperImpl {
+  public:
+    UsbHelperLinux(const std::string& device_path);
+    ~UsbHelperLinux();
+
+    void tx(const kvn::bytearray& data);
+    void set_rx_callback(std::function<void(const kvn::bytearray&)> callback);
+
+    static std::vector<std::string> get_dongl_devices();
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperNull.cpp

@@ -0,0 +1,21 @@
+#include "UsbHelperNull.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+UsbHelperNull::UsbHelperNull(const std::string& device_path) : UsbHelperImpl(device_path) {}
+
+UsbHelperNull::~UsbHelperNull() = default;
+
+void UsbHelperNull::tx(const kvn::bytearray& data) {}
+
+void UsbHelperNull::set_rx_callback(std::function<void(const kvn::bytearray&)> callback) {
+    _rx_callback.load(callback);
+}
+
+std::vector<std::string> UsbHelperNull::get_dongl_devices() { return {}; }
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperNull.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "UsbHelperImpl.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperNull : public UsbHelperImpl {
+  public:
+    UsbHelperNull(const std::string& device_path);
+    ~UsbHelperNull();
+
+    void tx(const kvn::bytearray& data);
+    void set_rx_callback(std::function<void(const kvn::bytearray&)> callback);
+
+    static std::vector<std::string> get_dongl_devices();
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperWindows.cpp

@@ -0,0 +1,21 @@
+#include "UsbHelperWindows.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+UsbHelperWindows::UsbHelperWindows(const std::string& device_path) : UsbHelperImpl(device_path) {}
+
+UsbHelperWindows::~UsbHelperWindows() = default;
+
+void UsbHelperWindows::tx(const kvn::bytearray& data) {}
+
+void UsbHelperWindows::set_rx_callback(std::function<void(const kvn::bytearray&)> callback) {
+    _rx_callback.load(callback);
+}
+
+std::vector<std::string> UsbHelperWindows::get_dongl_devices() { return {}; }
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/dongl/usb/UsbHelperWindows.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "UsbHelperImpl.h"
+
+namespace SimpleBLE {
+namespace Dongl {
+namespace USB {
+
+class UsbHelperWindows : public UsbHelperImpl {
+  public:
+    UsbHelperWindows(const std::string& device_path);
+    ~UsbHelperWindows();
+
+    void tx(const kvn::bytearray& data);
+    void set_rx_callback(std::function<void(const kvn::bytearray&)> callback);
+
+    static std::vector<std::string> get_dongl_devices();
+};
+
+}  // namespace USB
+}  // namespace Dongl
+}  // namespace SimpleBLE

package/simpleble/src/backends/linux/AdapterLinux.cpp

@@ -0,0 +1,102 @@
+#include <thread>
+
+#include <simpleble/Peripheral.h>
+
+#include "AdapterLinux.h"
+#include "BuildVec.h"
+#include "BuilderBase.h"
+#include "CommonUtils.h"
+#include "PeripheralLinux.h"
+
+using namespace SimpleBLE;
+
+bool AdapterLinux::bluetooth_enabled() { return adapter_->powered(); }
+
+AdapterLinux::AdapterLinux(std::shared_ptr<SimpleBluez::Adapter> adapter) : adapter_(adapter) {}
+
+AdapterLinux::~AdapterLinux() { adapter_->clear_on_device_updated(); }
+
+void* AdapterLinux::underlying() const { return adapter_.get(); }
+
+std::string AdapterLinux::identifier() { return adapter_->identifier(); }
+
+BluetoothAddress AdapterLinux::address() { return adapter_->address(); }
+
+void AdapterLinux::power_on() {
+    // TODO: This will be implemented after SimpleDBus and SimpleBluez are updated to the new architecture.
+}
+
+void AdapterLinux::power_off() {
+    // TODO: This will be implemented after SimpleDBus and SimpleBluez are updated to the new architecture.
+}
+
+bool AdapterLinux::is_powered() {
+    return adapter_->powered();
+}
+
+void AdapterLinux::scan_start() {
+    seen_peripherals_.clear();
+
+    adapter_->set_on_device_updated([this](std::shared_ptr<SimpleBluez::Device> device) {
+        if (!this->is_scanning_) {
+            return;
+        }
+
+        if (this->peripherals_.count(device->address()) == 0) {
+            // If the incoming peripheral has never been seen before, create and save a reference to it.
+            auto base_peripheral = std::make_shared<PeripheralLinux>(device, this->adapter_);
+            this->peripherals_.insert(std::make_pair(device->address(), base_peripheral));
+        }
+
+        // Update the received advertising data.
+        auto peripheral = this->peripherals_.at(device->address());
+
+        // Check if the device has been seen before, to forward the correct call to the user.
+        if (this->seen_peripherals_.count(device->address()) == 0) {
+            // Store it in our table of seen peripherals
+            this->seen_peripherals_.insert(std::make_pair(device->address(), peripheral));
+            SAFE_CALLBACK_CALL(this->_callback_on_scan_found, Factory::build(peripheral));
+        } else {
+            SAFE_CALLBACK_CALL(this->_callback_on_scan_updated, Factory::build(peripheral));
+        }
+    });
+
+    // Start scanning and notify the user.
+    adapter_->discovery_start();
+
+    // TODO: Does a discovery filter need to be set?
+
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_start);
+    is_scanning_ = true;
+}
+
+void AdapterLinux::scan_stop() {
+    adapter_->discovery_stop();
+    is_scanning_ = false;
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_stop);
+
+    // Important: Bluez might continue scanning if another process is also requesting
+    // scanning from the adapter. The use of the is_scanning_ flag is to prevent
+    // any scan updates to reach the user when not expected.
+}
+
+void AdapterLinux::scan_for(int timeout_ms) {
+    scan_start();
+    std::this_thread::sleep_for(std::chrono::milliseconds(timeout_ms));
+    scan_stop();
+}
+
+bool AdapterLinux::scan_is_active() { return is_scanning_ && adapter_->discovering(); }
+
+SharedPtrVector<PeripheralBase> AdapterLinux::scan_get_results() { return Util::values(seen_peripherals_); }
+
+SharedPtrVector<PeripheralBase> AdapterLinux::get_paired_peripherals() {
+    SharedPtrVector<PeripheralBase> peripherals;
+
+    auto paired_list = adapter_->device_paired_get();
+    for (auto& device : paired_list) {
+        peripherals.push_back(std::make_shared<PeripheralLinux>(device, this->adapter_));
+    }
+
+    return peripherals;
+}

package/simpleble/src/backends/linux/AdapterLinux.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "../common/AdapterBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <simplebluez/Adapter.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace SimpleBLE {
+
+class PeripheralLinux;
+
+class AdapterLinux : public SimpleBLE::AdapterBase {
+  public:
+    AdapterLinux(std::shared_ptr<SimpleBluez::Adapter> adapter);
+    virtual ~AdapterLinux();
+
+    void* underlying() const override;
+
+    virtual std::string identifier() override;
+    virtual BluetoothAddress address() override;
+
+    virtual void power_on() override;
+    virtual void power_off() override;
+    virtual bool is_powered() override;
+
+    virtual void scan_start() override;
+    virtual void scan_stop() override;
+    virtual void scan_for(int timeout_ms) override;
+    virtual bool scan_is_active() override;
+    virtual std::vector<std::shared_ptr<PeripheralBase>> scan_get_results() override;
+
+    virtual std::vector<std::shared_ptr<PeripheralBase>> get_paired_peripherals() override;
+
+    virtual bool bluetooth_enabled() override;
+
+  private:
+    std::shared_ptr<SimpleBluez::Adapter> adapter_;
+
+    std::atomic_bool is_scanning_;
+
+    std::map<BluetoothAddress, std::shared_ptr<PeripheralLinux>> peripherals_;
+    std::map<BluetoothAddress, std::shared_ptr<PeripheralLinux>> seen_peripherals_;
+};
+
+}  // namespace SimpleBLE