simpleble 0.0.1

data/vendor/simpleble/simpleble/src/backends/common/PeripheralBase.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class ServiceBase;
+
+/**
+ * Abstract base class for Bluetooth adapter implementations.
+ *
+ * Each backend must implement this class.
+ *
+ * Notes for implementers: ...
+ */
+class PeripheralBase {
+  public:
+    virtual ~PeripheralBase() = default;
+
+    virtual void* underlying() const = 0;
+
+    virtual std::string identifier() = 0;
+    virtual BluetoothAddress address() = 0;
+    virtual BluetoothAddressType address_type() = 0;
+    virtual int16_t rssi() = 0;
+
+    /**
+     * @brief Provides the advertised transmit power in dBm.
+     *
+     * @note If the field has not been advertised by the peripheral,
+     *       the returned value will be -32768.
+     */
+    virtual int16_t tx_power() = 0;
+    virtual uint16_t mtu() = 0;
+
+    virtual void connect() = 0;
+    virtual void disconnect() = 0;
+    virtual bool is_connected() = 0;
+    virtual bool is_connectable() = 0;
+    virtual bool is_paired() = 0;
+    virtual void unpair() = 0;
+
+    /**
+     * Available services (if the peripheral is connected).
+     */
+    virtual std::vector<std::shared_ptr<ServiceBase>> available_services() = 0;
+
+    /**
+     * Advertised services (if the peripheral is not connected).
+     */
+    virtual std::vector<std::shared_ptr<ServiceBase>> advertised_services() = 0;
+
+    virtual std::map<uint16_t, ByteArray> manufacturer_data() = 0;
+
+    // clang-format off
+    /* These methods are called by the frontend ONLY when the device is connected.
+    */
+    // clang-format off
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic) = 0;
+    virtual void write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) = 0;
+    virtual void write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) = 0;
+    virtual void notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) = 0;
+    virtual void indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) = 0;
+    virtual void unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) = 0;
+
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) = 0;
+    virtual void write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data) = 0;
+    // clang-format on
+
+    virtual void set_callback_on_connected(std::function<void()> on_connected) = 0;
+    virtual void set_callback_on_disconnected(std::function<void()> on_disconnected) = 0;
+
+  protected:
+    PeripheralBase() = default;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/common/ServiceBase.cpp

@@ -0,0 +1,18 @@
+
+#include "ServiceBase.h"
+#include "CommonUtils.h"
+
+using namespace SimpleBLE;
+
+ServiceBase::ServiceBase(const BluetoothUUID& uuid) : uuid_(uuid) {}
+
+ServiceBase::ServiceBase(const BluetoothUUID& uuid, const ByteArray& data) : uuid_(uuid), data_(data) {}
+
+ServiceBase::ServiceBase(const BluetoothUUID& uuid, SharedPtrVector<CharacteristicBase>& characteristics)
+    : uuid_(uuid), characteristics_(characteristics) {}
+
+BluetoothUUID ServiceBase::uuid() { return uuid_; }
+
+ByteArray ServiceBase::data() { return data_; }
+
+SharedPtrVector<CharacteristicBase> ServiceBase::characteristics() { return characteristics_; }

data/vendor/simpleble/simpleble/src/backends/common/ServiceBase.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+#include <memory>
+
+namespace SimpleBLE {
+
+class CharacteristicBase;
+
+class ServiceBase {
+  public:
+    ServiceBase(const BluetoothUUID& uuid);
+    ServiceBase(const BluetoothUUID& uuid, const ByteArray& data);
+    ServiceBase(const BluetoothUUID& uuid, std::vector<std::shared_ptr<CharacteristicBase>>& characteristics);
+    virtual ~ServiceBase() = default;
+
+    BluetoothUUID uuid();
+    ByteArray data();
+    std::vector<std::shared_ptr<CharacteristicBase>> characteristics();
+
+  protected:
+    BluetoothUUID uuid_;
+    ByteArray data_;
+    std::vector<std::shared_ptr<CharacteristicBase>> characteristics_;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/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;
+}

data/vendor/simpleble/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

data/vendor/simpleble/simpleble/src/backends/linux/BackendBluez.cpp

@@ -0,0 +1,87 @@
+#include "AdapterLinux.h"
+#include "BackendBase.h"
+#include "BackendUtils.h"
+#include "CommonUtils.h"
+
+#include <simplebluez/Bluez.h>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <thread>
+
+namespace SimpleBLE {
+
+class BackendBluez : public BackendSingleton<BackendBluez> {
+  public:
+    BackendBluez(buildToken);
+    virtual ~BackendBluez();
+
+    SimpleBluez::Bluez bluez;
+
+    virtual SharedPtrVector<AdapterBase> get_adapters() override;
+    virtual bool bluetooth_enabled() override;
+    std::string name() const noexcept override;
+
+  private:
+    std::thread* async_thread;
+    std::atomic_bool async_thread_active;
+    void async_thread_function();
+};
+
+std::shared_ptr<BackendBase> BACKEND_LINUX() { return BackendBluez::get(); }
+
+BackendBluez::BackendBluez(buildToken) {
+    static std::mutex get_mutex;       // Static mutex to ensure thread safety when accessing the logger
+    std::scoped_lock lock(get_mutex);  // Unlock the mutex on function return
+
+    bluez.init();
+    async_thread_active = true;
+    async_thread = new std::thread(&BackendBluez::async_thread_function, this);
+}
+
+BackendBluez::~BackendBluez() {
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+    async_thread->join();
+    delete async_thread;
+}
+
+SharedPtrVector<AdapterBase> BackendBluez::get_adapters() {
+    SharedPtrVector<AdapterBase> adapter_list;
+
+    auto internal_adapters = bluez.get_adapters();
+    for (auto& adapter : internal_adapters) {
+        adapter_list.push_back(std::make_shared<AdapterLinux>(adapter));
+    }
+    return adapter_list;
+}
+
+bool BackendBluez::bluetooth_enabled() {
+    bool enabled = false;
+
+    auto internal_adapters = bluez.get_adapters();
+    for (auto& adapter : internal_adapters) {
+        if (adapter->powered()) {
+            enabled = true;
+            break;
+        }
+    }
+
+    return enabled;
+}
+
+std::string BackendBluez::name() const noexcept { return "SimpleBluez"; }
+
+void BackendBluez::async_thread_function() {
+    SAFE_RUN({ bluez.register_agent(); });
+
+    while (async_thread_active) {
+        SAFE_RUN({ bluez.run_async(); });
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+}  // namespace SimpleBLE