simpleble 0.0.1

data/vendor/simpleble/simpleble/src/backends/macos/PeripheralMac.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "AdapterBaseTypes.h"
+#include "PeripheralBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <memory>
+
+namespace SimpleBLE {
+
+class PeripheralMac : public PeripheralBase {
+  public:
+    PeripheralMac(void* opaque_peripheral, void* opaque_adapter, advertising_data_t advertising_data);
+    ~PeripheralMac();
+
+    virtual void* underlying() const override;
+
+    virtual std::string identifier() override;
+    virtual BluetoothAddress address() override;
+    virtual BluetoothAddressType address_type() override;
+    virtual int16_t tx_power() override;
+    virtual int16_t rssi() override;
+    virtual uint16_t mtu() override;
+
+    virtual void connect() override;
+    virtual void disconnect() override;
+    virtual bool is_connected() override;
+    virtual bool is_connectable() override;
+    virtual bool is_paired() override;
+    virtual void unpair() override;
+
+    virtual std::vector<std::shared_ptr<ServiceBase>> available_services() override;
+    virtual std::vector<std::shared_ptr<ServiceBase>> advertised_services() override;
+    virtual std::map<uint16_t, ByteArray> manufacturer_data() override;
+
+    // clang-format off
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+    virtual void write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) override;
+    virtual void write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data) override;
+    // clang-format on
+
+    virtual void set_callback_on_connected(std::function<void()> on_connected) override;
+    virtual void set_callback_on_disconnected(std::function<void()> on_disconnected) override;
+
+    void delegate_did_connect();
+    void delegate_did_fail_to_connect(void* opaque_error);
+    void delegate_did_disconnect(void* opaque_error);
+
+    void update_advertising_data(advertising_data_t advertising_data);
+
+  protected:
+    /**
+     * Holds a pointer to the Objective-C representation of this object.
+     */
+    void* opaque_internal_;
+
+    int16_t rssi_;
+    int16_t tx_power_;
+
+    bool is_connectable_;
+
+    bool manual_disconnect_triggered_;
+
+    std::map<uint16_t, ByteArray> manufacturer_data_;
+    std::map<BluetoothUUID, ByteArray> service_data_;
+
+    kvn::safe_callback<void()> callback_on_connected_;
+    kvn::safe_callback<void()> callback_on_disconnected_;
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/macos/Utils.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#import <CoreBluetooth/CoreBluetooth.h>
+#import <Foundation/Foundation.h>
+
+#include <simpleble/Types.h>
+
+SimpleBLE::BluetoothUUID uuidToSimpleBLE(CBUUID* uuid);
+NSString* uuidToString(CBUUID* uuid);

data/vendor/simpleble/simpleble/src/backends/plain/AdapterPlain.cpp

@@ -0,0 +1,65 @@
+#include <simpleble/Peripheral.h>
+
+#include "AdapterPlain.h"
+#include "BuilderBase.h"
+#include "CommonUtils.h"
+#include "PeripheralBase.h"
+#include "PeripheralPlain.h"
+
+#include <memory>
+#include <thread>
+
+using namespace SimpleBLE;
+
+bool AdapterPlain::bluetooth_enabled() { return true; }
+
+AdapterPlain::AdapterPlain() {}
+
+AdapterPlain::~AdapterPlain() {}
+
+void* AdapterPlain::underlying() const { return nullptr; }
+
+std::string AdapterPlain::identifier() { return "Plain Adapter"; }
+
+BluetoothAddress AdapterPlain::address() { return "AA:BB:CC:DD:EE:FF"; }
+
+void AdapterPlain::power_on() {}
+
+void AdapterPlain::power_off() {}
+
+bool AdapterPlain::is_powered() { return true; }
+
+void AdapterPlain::scan_start() {
+    is_scanning_ = true;
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_start_);
+
+    Peripheral peripheral = Factory::build(std::make_shared<PeripheralPlain>());
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_found_, peripheral);
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_updated_, peripheral);
+}
+
+void AdapterPlain::scan_stop() {
+    is_scanning_ = false;
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_stop_);
+}
+
+void AdapterPlain::scan_for(int timeout_ms) {
+    scan_start();
+    std::this_thread::sleep_for(std::chrono::milliseconds(timeout_ms));
+    scan_stop();
+}
+
+bool AdapterPlain::scan_is_active() { return is_scanning_; }
+SharedPtrVector<PeripheralBase> AdapterPlain::scan_get_results() {
+    SharedPtrVector<PeripheralBase> peripherals;
+    peripherals.push_back(std::make_shared<PeripheralPlain>());
+
+    return peripherals;
+}
+
+SharedPtrVector<PeripheralBase> AdapterPlain::get_paired_peripherals() {
+    SharedPtrVector<PeripheralBase> peripherals;
+    peripherals.push_back(std::make_shared<PeripheralPlain>());
+
+    return peripherals;
+}

data/vendor/simpleble/simpleble/src/backends/plain/AdapterPlain.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "AdapterBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace SimpleBLE {
+
+/**
+ * Dummy adapter for testing purposes.
+ */
+class AdapterPlain : public AdapterBase {
+  public:
+    AdapterPlain();
+    virtual ~AdapterPlain();
+
+    virtual 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::atomic_bool is_scanning_{false};
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/plain/BackendPlain.cpp

@@ -0,0 +1,30 @@
+#include <string>
+#include "AdapterPlain.h"
+#include "BackendUtils.h"
+#include "CommonUtils.h"
+
+namespace SimpleBLE {
+
+class BackendPlain : public BackendSingleton<BackendPlain> {
+  public:
+    BackendPlain(buildToken) {};
+    virtual ~BackendPlain() = default;
+
+    virtual SharedPtrVector<AdapterBase> get_adapters() override;
+    virtual bool bluetooth_enabled() override;
+    std::string name() const noexcept override;
+};
+
+std::shared_ptr<BackendBase> BACKEND_PLAIN() { return BackendPlain::get(); }
+
+std::string BackendPlain::name() const noexcept { return "Plain"; }
+
+bool BackendPlain::bluetooth_enabled() { return true; }
+
+SharedPtrVector<AdapterBase> BackendPlain::get_adapters() {
+    SharedPtrVector<AdapterBase> adapters;
+    adapters.push_back(std::make_shared<AdapterPlain>());
+    return adapters;
+}
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/plain/PeripheralPlain.cpp

@@ -0,0 +1,159 @@
+#include "PeripheralPlain.h"
+
+#include "CharacteristicBase.h"
+#include "DescriptorBase.h"
+#include "ServiceBase.h"
+
+#include <simpleble/Exceptions.h>
+
+#include <memory>
+
+#include "CommonUtils.h"
+#include "LoggingInternal.h"
+
+using namespace SimpleBLE;
+using namespace std::chrono_literals;
+
+const SimpleBLE::BluetoothUUID BATTERY_SERVICE_UUID = "0000180f-0000-1000-8000-00805f9b34fb";
+const SimpleBLE::BluetoothUUID BATTERY_CHARACTERISTIC_UUID = "00002a19-0000-1000-8000-00805f9b34fb";
+
+PeripheralPlain::PeripheralPlain() {}
+
+PeripheralPlain::~PeripheralPlain() {}
+
+void* PeripheralPlain::underlying() const { return nullptr; }
+
+std::string PeripheralPlain::identifier() { return "Plain Peripheral"; }
+
+BluetoothAddress PeripheralPlain::address() { return "11:22:33:44:55:66"; }
+
+BluetoothAddressType PeripheralPlain::address_type() { return BluetoothAddressType::PUBLIC; };
+
+int16_t PeripheralPlain::rssi() { return -60; }
+
+int16_t PeripheralPlain::tx_power() { return 5; }
+
+uint16_t PeripheralPlain::mtu() {
+    if (is_connected()) {
+        return 247;
+    } else {
+        return 0;
+    }
+}
+
+void PeripheralPlain::connect() {
+    connected_ = true;
+    paired_ = true;
+    SAFE_CALLBACK_CALL(this->callback_on_connected_);
+}
+
+void PeripheralPlain::disconnect() {
+    connected_ = false;
+    SAFE_CALLBACK_CALL(this->callback_on_disconnected_);
+}
+bool PeripheralPlain::is_connected() { return connected_; }
+
+bool PeripheralPlain::is_connectable() { return true; }
+
+bool PeripheralPlain::is_paired() { return paired_; }
+
+void PeripheralPlain::unpair() { paired_ = false; }
+
+SharedPtrVector<ServiceBase> PeripheralPlain::available_services() {
+    if (!connected_) return {};
+
+    SharedPtrVector<ServiceBase> service_list;
+    SharedPtrVector<DescriptorBase> descriptor_list;
+    SharedPtrVector<CharacteristicBase> characteristic_list = {std::make_shared<CharacteristicBase>(
+        BATTERY_CHARACTERISTIC_UUID, descriptor_list, true, false, false, true, false)};
+
+    service_list.push_back(std::make_shared<ServiceBase>(BATTERY_SERVICE_UUID, characteristic_list));
+    return service_list;
+}
+
+SharedPtrVector<ServiceBase> PeripheralPlain::advertised_services() { return {}; }
+
+std::map<uint16_t, ByteArray> PeripheralPlain::manufacturer_data() { return {{0x004C, "test"}}; }
+
+ByteArray PeripheralPlain::read(BluetoothUUID const& service, BluetoothUUID const& characteristic) { return {}; }
+
+void PeripheralPlain::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                    ByteArray const& data) {}
+
+void PeripheralPlain::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                    ByteArray const& data) {}
+
+void PeripheralPlain::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                             std::function<void(ByteArray payload)> callback) {
+    if (callback) {
+        callback_mutex_.lock();
+        callbacks_[{service, characteristic}] = std::move(callback);
+        callback_mutex_.unlock();
+
+        task_runner_.dispatch(
+            [this, service, characteristic]() -> std::optional<std::chrono::seconds> {
+                std::lock_guard<std::mutex> lock(callback_mutex_);
+                auto it = this->callbacks_.find({service, characteristic});
+
+                if (it == this->callbacks_.end()) {
+                    return std::nullopt;
+                }
+
+                it->second("Hello from notify");
+                return 1s;
+            },
+            1s);
+    }
+}
+
+void PeripheralPlain::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                               std::function<void(ByteArray payload)> callback) {
+    if (callback) {
+        callback_mutex_.lock();
+        callbacks_[{service, characteristic}] = std::move(callback);
+        callback_mutex_.unlock();
+
+        task_runner_.dispatch(
+            [this, service, characteristic]() -> std::optional<std::chrono::seconds> {
+                std::lock_guard<std::mutex> lock(callback_mutex_);
+                auto it = this->callbacks_.find({service, characteristic});
+
+                if (it == this->callbacks_.end()) {
+                    return std::nullopt;
+                }
+
+                it->second("Hello from notify");
+                return 1s;
+            },
+            1s);
+    }
+}
+
+void PeripheralPlain::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    std::lock_guard<std::mutex> lock(callback_mutex_);
+    callbacks_.erase({service, characteristic});
+}
+
+ByteArray PeripheralPlain::read(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                BluetoothUUID const& descriptor) {
+    return {};
+}
+
+void PeripheralPlain::write(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                            BluetoothUUID const& descriptor, ByteArray const& data) {}
+
+void PeripheralPlain::set_callback_on_connected(std::function<void()> on_connected) {
+    if (on_connected) {
+        callback_on_connected_.load(std::move(on_connected));
+    } else {
+        callback_on_connected_.unload();
+    }
+}
+
+void PeripheralPlain::set_callback_on_disconnected(std::function<void()> on_disconnected) {
+    if (on_disconnected) {
+        callback_on_disconnected_.load(std::move(on_disconnected));
+    } else {
+        callback_on_disconnected_.unload();
+    }
+}

data/vendor/simpleble/simpleble/src/backends/plain/PeripheralPlain.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Service.h>
+#include <simpleble/Types.h>
+#include "PeripheralBase.h"
+
+#include <TaskRunner.hpp>
+#include <kvn_safe_callback.hpp>
+
+#include <atomic>
+#include <map>
+#include <memory>
+#include <mutex>
+
+namespace SimpleBLE {
+
+class PeripheralPlain : public PeripheralBase {
+  public:
+    PeripheralPlain();
+    virtual ~PeripheralPlain();
+
+    void* underlying() const override;
+
+    virtual std::string identifier() override;
+    virtual BluetoothAddress address() override;
+    virtual BluetoothAddressType address_type() override;
+    virtual int16_t rssi() override;
+    virtual int16_t tx_power() override;
+    virtual uint16_t mtu() override;
+
+    virtual void connect() override;
+    virtual void disconnect() override;
+    virtual bool is_connected() override;
+    virtual bool is_connectable() override;
+    virtual bool is_paired() override;
+    virtual void unpair() override;
+
+    virtual std::vector<std::shared_ptr<ServiceBase>> available_services() override;
+    virtual std::vector<std::shared_ptr<ServiceBase>> advertised_services() override;
+
+    virtual std::map<uint16_t, ByteArray> manufacturer_data() override;
+
+    // clang-format off
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+    virtual void write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) override;
+    virtual void notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) override;
+    virtual void unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) override;
+
+    virtual ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) override;
+    virtual void write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data) override;
+    // clang-format on
+
+    virtual void set_callback_on_connected(std::function<void()> on_connected) override;
+    virtual void set_callback_on_disconnected(std::function<void()> on_disconnected) override;
+
+  private:
+    std::atomic_bool connected_{false};
+    std::atomic_bool paired_{false};
+
+    kvn::safe_callback<void()> callback_on_connected_;
+    kvn::safe_callback<void()> callback_on_disconnected_;
+
+    std::mutex callback_mutex_;
+    std::map<std::pair<BluetoothUUID, BluetoothUUID>, std::function<void(ByteArray payload)>> callbacks_;
+
+    TaskRunner task_runner_;
+};
+
+}  // namespace SimpleBLE