simpleble 0.0.1

data/vendor/simpleble/simplersble/src/bindings/Bindings.cpp

@@ -0,0 +1,338 @@
+#include "Bindings.hpp"
+#include <exception>
+
+#include "simplersble/simplersble/src/lib.rs.h"
+
+rust::Vec<Bindings::RustyAdapterWrapper> Bindings::RustyAdapter_get_adapters() {
+    rust::Vec<Bindings::RustyAdapterWrapper> result;
+
+    for (auto& adapter : SimpleBLE::Adapter::get_adapters()) {
+        Bindings::RustyAdapterWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyAdapter>(adapter);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+bool Bindings::RustyAdapter_bluetooth_enabled() { return SimpleBLE::Adapter::bluetooth_enabled(); }
+
+// InnerAdapter Bindings
+
+void Bindings::RustyAdapter::link(SimpleRsBLE::InnerAdapter& target) const {
+    // Time to explain the weird shenanigan we're doing here:
+    // The TL;DR is that we're making the InnerAdapter(Rust) and the RustyAdapter(C++)
+    // point to each other in a safe way.
+    // To achieve this, the InnerAdapter(Rust) owns a RustyAdapter(C++) via a UniquePtr,
+    // which ensures that calls will always be made to a valid C++ object.
+    // We now give the RustyAdapter(C++) a pointer back to the InnerAdapter(Rust),
+    // so that callbacks can be forwarded back to the Rust domain.
+    // In order to ensure that the InnerAdapter(Rust) is always valid (given
+    // that Rust is keen on moving stuff around) the object is created as a
+    // Pin<Box<T>>
+
+    // `_adapter` is a pointer to a pointer, allowing us to manipulate the contents within const functions.
+    std::lock_guard<std::mutex> lock(_adapter_mutex);
+    _adapter = &target;  // THIS LINE IS SUPER IMPORTANT
+
+    _internal->set_callback_on_scan_start([this]() {
+        if (this->_adapter == nullptr) return;
+
+        this->_adapter->on_callback_scan_start();
+    });
+
+    _internal->set_callback_on_scan_stop([this]() {
+        if (this->_adapter == nullptr) return;
+
+        this->_adapter->on_callback_scan_stop();
+    });
+
+    _internal->set_callback_on_scan_found([this](SimpleBLE::Peripheral peripheral) {
+        if (this->_adapter == nullptr) return;
+
+        Bindings::RustyPeripheralWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyPeripheral>(peripheral);
+        this->_adapter->on_callback_scan_found(wrapper);
+    });
+
+    _internal->set_callback_on_scan_updated([this](SimpleBLE::Peripheral peripheral) {
+        if (this->_adapter == nullptr) return;
+
+        Bindings::RustyPeripheralWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyPeripheral>(peripheral);
+        this->_adapter->on_callback_scan_updated(wrapper);
+    });
+}
+
+void Bindings::RustyAdapter::unlink() const {
+    // Clear all callbacks
+    _internal->set_callback_on_scan_start(nullptr);
+    _internal->set_callback_on_scan_stop(nullptr);
+    _internal->set_callback_on_scan_found(nullptr);
+    _internal->set_callback_on_scan_updated(nullptr);
+
+    // `_adapter` is a pointer to a pointer.
+    std::lock_guard<std::mutex> lock(_adapter_mutex);
+    _adapter = nullptr;
+}
+
+rust::String Bindings::RustyAdapter::identifier() const { return rust::String(_internal->identifier()); }
+
+rust::String Bindings::RustyAdapter::address() const { return rust::String(_internal->address()); }
+
+void Bindings::RustyAdapter::scan_start() const { _internal->scan_start(); }
+
+void Bindings::RustyAdapter::scan_stop() const { _internal->scan_stop(); }
+
+void Bindings::RustyAdapter::scan_for(int32_t timeout_ms) const { _internal->scan_for(timeout_ms); }
+
+bool Bindings::RustyAdapter::scan_is_active() const { return _internal->scan_is_active(); }
+
+rust::Vec<Bindings::RustyPeripheralWrapper> Bindings::RustyAdapter::scan_get_results() const {
+    rust::Vec<Bindings::RustyPeripheralWrapper> result;
+
+    for (auto& peripheral : _internal->scan_get_results()) {
+        Bindings::RustyPeripheralWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyPeripheral>(peripheral);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+rust::Vec<Bindings::RustyPeripheralWrapper> Bindings::RustyAdapter::get_paired_peripherals() const {
+    rust::Vec<Bindings::RustyPeripheralWrapper> result;
+
+    for (auto& peripheral : _internal->get_paired_peripherals()) {
+        Bindings::RustyPeripheralWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyPeripheral>(peripheral);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+// InnerPeripheral Bindings
+
+void Bindings::RustyPeripheral::link(SimpleRsBLE::InnerPeripheral& target) const {
+    // Time to explain the weird shenanigan we're doing here:
+    // The TL;DR is that we're making the InnerPeripheral(Rust) and the RustyPeripheral(C++)
+    // point to each other in a safe way.
+    // To achieve this, the InnerPeripheral(Rust) owns a RustyPeripheral(C++) via a UniquePtr,
+    // which ensures that calls will always be made to a valid C++ object.
+    // We now give the RustyPeripheral(C++) a pointer back to the InnerPeripheral(Rust),
+    // so that callbacks can be forwarded back to the Rust domain.
+    // In order to ensure that the InnerPeripheral(Rust) is always valid (given
+    // that Rust is keen on moving stuff around) the object is created as a
+    // Pin<Box<T>>
+
+    // `_peripheral` is a pointer to a pointer, allowing us to manipulate the contents within const functions.
+    _peripheral = &target;  // THIS LINE IS SUPER IMPORTANT
+
+    _internal->set_callback_on_connected([this]() {
+        if (this->_peripheral == nullptr) return;
+
+        this->_peripheral->on_callback_connected();
+    });
+
+    _internal->set_callback_on_disconnected([this]() {
+        if (this->_peripheral == nullptr) return;
+
+        this->_peripheral->on_callback_disconnected();
+    });
+}
+
+void Bindings::RustyPeripheral::unlink() const {
+    // Clear all callbacks
+    _internal->set_callback_on_connected(nullptr);
+    _internal->set_callback_on_disconnected(nullptr);
+
+    // `_peripheral` is a pointer to a pointer.
+    _peripheral = nullptr;
+}
+
+rust::String Bindings::RustyPeripheral::identifier() const { return rust::String(_internal->identifier()); }
+
+rust::String Bindings::RustyPeripheral::address() const { return rust::String(_internal->address()); }
+
+SimpleBLE::BluetoothAddressType Bindings::RustyPeripheral::address_type() const { return _internal->address_type(); }
+
+int16_t Bindings::RustyPeripheral::rssi() const { return _internal->rssi(); }
+
+int16_t Bindings::RustyPeripheral::tx_power() const { return _internal->tx_power(); }
+
+uint16_t Bindings::RustyPeripheral::mtu() const { return _internal->mtu(); }
+
+void Bindings::RustyPeripheral::connect() const { _internal->connect(); }
+
+void Bindings::RustyPeripheral::disconnect() const { _internal->disconnect(); }
+
+bool Bindings::RustyPeripheral::is_connected() const { return _internal->is_connected(); }
+
+bool Bindings::RustyPeripheral::is_connectable() const { return _internal->is_connectable(); }
+
+bool Bindings::RustyPeripheral::is_paired() const { return _internal->is_paired(); }
+
+void Bindings::RustyPeripheral::unpair() const { _internal->unpair(); }
+
+rust::Vec<Bindings::RustyServiceWrapper> Bindings::RustyPeripheral::services() const {
+    rust::Vec<Bindings::RustyServiceWrapper> result;
+
+    for (auto& service : _internal->services()) {
+        Bindings::RustyServiceWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyService>(service);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+rust::Vec<Bindings::RustyManufacturerDataWrapper> Bindings::RustyPeripheral::manufacturer_data() const {
+    rust::Vec<Bindings::RustyManufacturerDataWrapper> result;
+
+    for (auto& manufacturer_data : _internal->manufacturer_data()) {
+        Bindings::RustyManufacturerDataWrapper wrapper;
+        wrapper.company_id = manufacturer_data.first;
+
+        for (auto& byte : manufacturer_data.second) {
+            wrapper.data.push_back(byte);
+        }
+
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+rust::Vec<uint8_t> Bindings::RustyPeripheral::read(rust::String const& service,
+                                                   rust::String const& characteristic) const {
+    std::string read_result = _internal->read(std::string(service), std::string(characteristic));
+
+    rust::Vec<uint8_t> result;
+    for (auto& byte : read_result) {
+        result.push_back(byte);
+    }
+
+    return result;
+}
+
+void Bindings::RustyPeripheral::write_request(rust::String const& service_rs, rust::String const& characteristic_rs,
+                                              rust::Vec<uint8_t> const& data) const {
+    std::string service(service_rs);
+    std::string characteristic(characteristic_rs);
+    std::string data_vec((char*)data.data(), data.size());
+
+    _internal->write_request(service, characteristic, data_vec);
+}
+
+void Bindings::RustyPeripheral::write_command(rust::String const& service_rs, rust::String const& characteristic_rs,
+                                              rust::Vec<uint8_t> const& data) const {
+    std::string service(service_rs);
+    std::string characteristic(characteristic_rs);
+    std::string data_vec((char*)data.data(), data.size());
+
+    _internal->write_command(service, characteristic, data_vec);
+}
+
+void Bindings::RustyPeripheral::notify(rust::String const& service_rs, rust::String const& characteristic_rs) const {
+    std::string service(service_rs);
+    std::string characteristic(characteristic_rs);
+
+    _internal->notify(service, characteristic, [this, service_rs, characteristic_rs](std::string data) {
+        // NOTE: In this two cases we need to lock the mutex to ensure thread safety, as
+        // the callback cannot be cleared in the unlink() function.
+        std::lock_guard<std::mutex> lock(_peripheral_mutex);
+        if (this->_peripheral == nullptr) return;
+
+        rust::Vec<uint8_t> data_vec;
+        for (auto& byte : data) {
+            data_vec.push_back(byte);
+        }
+
+        this->_peripheral->on_callback_characteristic_updated(service_rs, characteristic_rs, data_vec);
+    });
+}
+
+void Bindings::RustyPeripheral::indicate(rust::String const& service_rs, rust::String const& characteristic_rs) const {
+    std::string service(service_rs);
+    std::string characteristic(characteristic_rs);
+
+    _internal->indicate(service, characteristic, [this, service_rs, characteristic_rs](std::string data) {
+        // NOTE: In this two cases we need to lock the mutex to ensure thread safety, as
+        // the callback cannot be cleared in the unlink() function.
+        std::lock_guard<std::mutex> lock(_peripheral_mutex);
+        if (this->_peripheral == nullptr) return;
+
+        rust::Vec<uint8_t> data_vec;
+        for (auto& byte : data) {
+            data_vec.push_back(byte);
+        }
+
+        this->_peripheral->on_callback_characteristic_updated(service_rs, characteristic_rs, data_vec);
+    });
+}
+
+void Bindings::RustyPeripheral::unsubscribe(rust::String const& service_rs,
+                                            rust::String const& characteristic_rs) const {
+    std::string service(service_rs);
+    std::string characteristic(characteristic_rs);
+
+    _internal->unsubscribe(service, characteristic);
+}
+
+rust::Vec<uint8_t> Bindings::RustyPeripheral::read_descriptor(rust::String const& service,
+                                                              rust::String const& characteristic,
+                                                              rust::String const& descriptor) const {
+    std::string read_result = _internal->read(std::string(service), std::string(characteristic),
+                                              std::string(descriptor));
+
+    rust::Vec<uint8_t> result;
+    for (auto& byte : read_result) {
+        result.push_back(byte);
+    }
+
+    return result;
+}
+
+void Bindings::RustyPeripheral::write_descriptor(rust::String const& service, rust::String const& characteristic,
+                                                 rust::String const& descriptor, rust::Vec<uint8_t> const& data) const {
+    _internal->write(std::string(service), std::string(characteristic), std::string(descriptor),
+                     std::string((char*)data.data(), data.size()));
+}
+
+// Service Bindings
+
+rust::Vec<uint8_t> Bindings::RustyService::data() const {
+    rust::Vec<uint8_t> result;
+    for (auto& byte : _internal->data()) {
+        result.push_back(byte);
+    }
+
+    return result;
+}
+
+rust::Vec<Bindings::RustyCharacteristicWrapper> Bindings::RustyService::characteristics() const {
+    rust::Vec<Bindings::RustyCharacteristicWrapper> result;
+
+    for (auto& characteristic : _internal->characteristics()) {
+        Bindings::RustyCharacteristicWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyCharacteristic>(characteristic);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}
+
+// Characteristic Bindings
+
+rust::Vec<Bindings::RustyDescriptorWrapper> Bindings::RustyCharacteristic::descriptors() const {
+    rust::Vec<Bindings::RustyDescriptorWrapper> result;
+
+    for (auto& descriptor : _internal->descriptors()) {
+        Bindings::RustyDescriptorWrapper wrapper;
+        wrapper.internal = std::make_unique<Bindings::RustyDescriptor>(descriptor);
+        result.push_back(std::move(wrapper));
+    }
+
+    return result;
+}

data/vendor/simpleble/simplersble/src/bindings/Bindings.hpp

@@ -0,0 +1,178 @@
+#pragma once
+
+#include "rust/cxx.h"
+#include "simpleble/Adapter.h"
+#include "simpleble/Peripheral.h"
+
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <mutex>
+
+namespace SimpleRsBLE {
+
+struct InnerAdapter;
+struct InnerPeripheral;
+
+};  // namespace SimpleRsBLE
+
+namespace Bindings {
+
+struct RustyAdapterWrapper;
+struct RustyPeripheralWrapper;
+struct RustyServiceWrapper;
+struct RustyCharacteristicWrapper;
+struct RustyDescriptorWrapper;
+struct RustyManufacturerDataWrapper;
+
+rust::Vec<Bindings::RustyAdapterWrapper> RustyAdapter_get_adapters();
+bool RustyAdapter_bluetooth_enabled();
+
+class RustyAdapter {
+  public:
+    RustyAdapter() = default;
+    virtual ~RustyAdapter() { _internal.reset(); }
+
+    RustyAdapter(SimpleBLE::Adapter adapter) : _internal(new SimpleBLE::Adapter(std::move(adapter))) {};
+
+    void link(SimpleRsBLE::InnerAdapter& target) const;
+    void unlink() const;
+
+    rust::String identifier() const;
+    rust::String address() const;
+
+    void scan_start() const;
+    void scan_stop() const;
+    void scan_for(int32_t timeout_ms) const;
+    bool scan_is_active() const;
+    rust::Vec<Bindings::RustyPeripheralWrapper> scan_get_results() const;
+
+    rust::Vec<Bindings::RustyPeripheralWrapper> get_paired_peripherals() const;
+
+  private:
+    // NOTE: All internal properties need to be handled as pointers,
+    // allowing the calls to RustyAdapter to always be const.
+    // This might require us to store pointers to pointers, so it's
+    // important to be careful when handling these.
+    std::unique_ptr<SimpleBLE::Adapter> _internal;
+    mutable SimpleRsBLE::InnerAdapter* _adapter = nullptr;
+    mutable std::mutex _adapter_mutex;
+};
+
+class RustyPeripheral {
+  public:
+    RustyPeripheral() = default;
+    virtual ~RustyPeripheral() { _internal.reset(); }
+
+    RustyPeripheral(SimpleBLE::Peripheral peripheral) : _internal(new SimpleBLE::Peripheral(peripheral)) {}
+
+    void link(SimpleRsBLE::InnerPeripheral& target) const;
+    void unlink() const;
+
+    rust::String identifier() const;
+    rust::String address() const;
+    SimpleBLE::BluetoothAddressType address_type() const;
+    int16_t rssi() const;
+
+    int16_t tx_power() const;
+    uint16_t mtu() const;
+
+    void connect() const;
+    void disconnect() const;
+    bool is_connected() const;
+    bool is_connectable() const;
+    bool is_paired() const;
+    void unpair() const;
+
+    rust::Vec<Bindings::RustyServiceWrapper> services() const;
+    rust::Vec<Bindings::RustyManufacturerDataWrapper> manufacturer_data() const;
+
+    rust::Vec<uint8_t> read(rust::String const& service, rust::String const& characteristic) const;
+    void write_request(rust::String const& service, rust::String const& characteristic,
+                       rust::Vec<uint8_t> const& data) const;
+    void write_command(rust::String const& service, rust::String const& characteristic,
+                       rust::Vec<uint8_t> const& data) const;
+    void notify(rust::String const& service, rust::String const& characteristic) const;
+    void indicate(rust::String const& service, rust::String const& characteristic) const;
+    void unsubscribe(rust::String const& service, rust::String const& characteristic) const;
+
+    rust::Vec<uint8_t> read_descriptor(rust::String const& service, rust::String const& characteristic,
+                                       rust::String const& descriptor) const;
+    void write_descriptor(rust::String const& service, rust::String const& characteristic,
+                          rust::String const& descriptor, rust::Vec<uint8_t> const& data) const;
+
+  private:
+    // NOTE: All internal properties need to be handled as pointers,
+    // allowing the calls to RustyPeripheral to always be const.
+    // This might require us to store pointers to pointers, so it's
+    // important to be careful when handling these.
+    std::unique_ptr<SimpleBLE::Peripheral> _internal;
+    mutable SimpleRsBLE::InnerPeripheral* _peripheral = nullptr;
+    mutable std::mutex _peripheral_mutex;
+};
+
+class RustyService {
+  public:
+    RustyService() = default;
+    virtual ~RustyService() = default;
+
+    RustyService(SimpleBLE::Service service) : _internal(new SimpleBLE::Service(std::move(service))) {}
+
+    rust::String uuid() const { return rust::String(_internal->uuid()); }
+
+    rust::Vec<uint8_t> data() const;
+
+    rust::Vec<Bindings::RustyCharacteristicWrapper> characteristics() const;
+
+  private:
+    // NOTE: All internal properties need to be handled as pointers,
+    // allowing the calls to RustyService to always be const.
+    // This might require us to store pointers to pointers, so it's
+    // important to be careful when handling these.
+    std::shared_ptr<SimpleBLE::Service> _internal;
+};
+
+class RustyCharacteristic {
+  public:
+    RustyCharacteristic() = default;
+    virtual ~RustyCharacteristic() = default;
+
+    RustyCharacteristic(SimpleBLE::Characteristic characteristic)
+        : _internal(new SimpleBLE::Characteristic(std::move(characteristic))) {}
+
+    rust::String uuid() const { return rust::String(_internal->uuid()); }
+
+    rust::Vec<Bindings::RustyDescriptorWrapper> descriptors() const;
+
+    bool can_read() const { return _internal->can_read(); }
+    bool can_write_request() const { return _internal->can_write_request(); }
+    bool can_write_command() const { return _internal->can_write_command(); }
+    bool can_notify() const { return _internal->can_notify(); }
+    bool can_indicate() const { return _internal->can_indicate(); }
+
+  private:
+    // NOTE: All internal properties need to be handled as pointers,
+    // allowing the calls to RustyCharacteristic to always be const.
+    // This might require us to store pointers to pointers, so it's
+    // important to be careful when handling these.
+    std::shared_ptr<SimpleBLE::Characteristic> _internal;
+};
+
+class RustyDescriptor {
+  public:
+    RustyDescriptor() = default;
+    virtual ~RustyDescriptor() = default;
+
+    RustyDescriptor(SimpleBLE::Descriptor descriptor) : _internal(new SimpleBLE::Descriptor(std::move(descriptor))) {}
+
+    rust::String uuid() const { return rust::String(_internal->uuid()); }
+
+  private:
+    // NOTE: All internal properties need to be handled as pointers,
+    // allowing the calls to RustyDescriptor to always be const.
+    // This might require us to store pointers to pointers, so it's
+    // important to be careful when handling these.
+    std::shared_ptr<SimpleBLE::Descriptor> _internal;
+};
+
+};  // namespace Bindings