simplejsble 0.0.3 → 0.0.5

package/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

package/simpleble/src/backends/macos/PeripheralMac.mm

@@ -0,0 +1,229 @@
+#import "PeripheralMac.h"
+#import "PeripheralBaseMacOS.h"
+#import "ServiceBase.h"
+
+#import "CommonUtils.h"
+
+using namespace SimpleBLE;
+
+PeripheralMac::PeripheralMac(void* opaque_peripheral, void* opaque_adapter, advertising_data_t advertising_data) {
+    CBCentralManager* central_manager = (__bridge CBCentralManager*)opaque_adapter;
+    CBPeripheral* peripheral = (__bridge CBPeripheral*)opaque_peripheral;
+
+    // Cast the Objective-C++ object using __bridge_retained, which will signal ARC to increase
+    // the reference count. This means that AdapterBase will be responsible for releasing the
+    // Objective-C++ object in the destructor.
+    opaque_internal_ = (__bridge_retained void*)[[PeripheralBaseMacOS alloc] init:peripheral centralManager:central_manager];
+
+    is_connectable_ = advertising_data.connectable;
+    manual_disconnect_triggered_ = false;
+    manufacturer_data_ = advertising_data.manufacturer_data;
+    service_data_ = advertising_data.service_data;
+    rssi_ = advertising_data.rssi;
+    tx_power_ = advertising_data.tx_power;
+}
+
+PeripheralMac::~PeripheralMac() {
+    // Cast the opaque pointer back to the Objective-C++ object and release it.
+    // This will signal ARC to decrease the reference count.
+    // NOTE: This is equivalent to calling [opaque_internal_ release] in Objective-C++.
+    PeripheralBaseMacOS* internal = (__bridge_transfer PeripheralBaseMacOS*)opaque_internal_;
+    internal = nil;
+}
+
+void* PeripheralMac::underlying() const {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    return [internal underlying];
+}
+
+std::string PeripheralMac::identifier() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    return std::string([[internal identifier] UTF8String]);
+}
+
+BluetoothAddress PeripheralMac::address() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    return std::string([[internal address] UTF8String]);
+}
+
+BluetoothAddressType PeripheralMac::address_type() { return BluetoothAddressType::UNSPECIFIED; }
+
+int16_t PeripheralMac::rssi() { return rssi_; }
+
+int16_t PeripheralMac::tx_power() { return tx_power_; }
+
+uint16_t PeripheralMac::mtu() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    return [internal mtu];
+}
+
+void PeripheralMac::update_advertising_data(advertising_data_t advertising_data) {
+    is_connectable_ = advertising_data.connectable;
+    manufacturer_data_ = advertising_data.manufacturer_data;
+    rssi_ = advertising_data.rssi;
+    tx_power_ = advertising_data.tx_power;
+
+    advertising_data.service_data.merge(service_data_);
+    service_data_ = advertising_data.service_data;
+}
+
+void PeripheralMac::connect() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    [internal connect];
+
+    SAFE_CALLBACK_CALL(this->callback_on_connected_);
+}
+
+void PeripheralMac::disconnect() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    manual_disconnect_triggered_ = true;
+    [internal disconnect];
+
+    SAFE_CALLBACK_CALL(this->callback_on_disconnected_);
+
+    manual_disconnect_triggered_ = false;
+}
+
+bool PeripheralMac::is_connected() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    return [internal isConnected];
+}
+
+bool PeripheralMac::is_connectable() { return is_connectable_; }
+
+bool PeripheralMac::is_paired() { throw Exception::OperationNotSupported(); }
+
+void PeripheralMac::unpair() { throw Exception::OperationNotSupported(); }
+
+SharedPtrVector<ServiceBase> PeripheralMac::available_services() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    return [internal getServices];
+}
+
+SharedPtrVector<ServiceBase> PeripheralMac::advertised_services() {
+    SharedPtrVector<ServiceBase> service_list;
+    for (auto& [service_uuid, data] : service_data_) {
+        service_list.push_back(std::make_shared<ServiceBase>(service_uuid, data));
+    }
+
+    return service_list;
+}
+
+std::map<uint16_t, ByteArray> PeripheralMac::manufacturer_data() { return manufacturer_data_; }
+
+ByteArray PeripheralMac::read(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+
+    return [internal read:service_uuid characteristic_uuid:characteristic_uuid];
+}
+
+void PeripheralMac::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& byte_array) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    NSData* payload = [NSData dataWithBytes:(void*)byte_array.data() length:byte_array.size()];
+
+    [internal writeRequest:service_uuid characteristic_uuid:characteristic_uuid payload:payload];
+}
+
+void PeripheralMac::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& byte_array) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    NSData* payload = [NSData dataWithBytes:(void*)byte_array.data() length:byte_array.size()];
+
+    [internal writeCommand:service_uuid characteristic_uuid:characteristic_uuid payload:payload];
+}
+
+void PeripheralMac::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                           std::function<void(ByteArray payload)> callback) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    [internal notify:service_uuid characteristic_uuid:characteristic_uuid callback:callback];
+}
+
+void PeripheralMac::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                             std::function<void(ByteArray payload)> callback) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    [internal indicate:service_uuid characteristic_uuid:characteristic_uuid callback:callback];
+}
+
+void PeripheralMac::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    [internal unsubscribe:service_uuid characteristic_uuid:characteristic_uuid];
+}
+
+ByteArray PeripheralMac::read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* descriptor_uuid = [NSString stringWithCString:descriptor.c_str() encoding:NSString.defaultCStringEncoding];
+
+    return [internal read:service_uuid characteristic_uuid:characteristic_uuid descriptor_uuid:descriptor_uuid];
+}
+
+void PeripheralMac::write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor,
+                          ByteArray const& byte_array) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+
+    NSString* service_uuid = [NSString stringWithCString:service.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* characteristic_uuid = [NSString stringWithCString:characteristic.c_str() encoding:NSString.defaultCStringEncoding];
+    NSString* descriptor_uuid = [NSString stringWithCString:descriptor.c_str() encoding:NSString.defaultCStringEncoding];
+    NSData* payload = [NSData dataWithBytes:(void*)byte_array.data() length:byte_array.size()];
+
+    [internal write:service_uuid characteristic_uuid:characteristic_uuid descriptor_uuid:descriptor_uuid payload:payload];
+}
+
+void PeripheralMac::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 PeripheralMac::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();
+    }
+}
+
+void PeripheralMac::delegate_did_connect() {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    [internal delegateDidConnect];
+}
+
+void PeripheralMac::delegate_did_fail_to_connect(void* opaque_error) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    NSError* error = (__bridge NSError*)opaque_error;
+    [internal delegateDidFailToConnect:error];
+}
+
+void PeripheralMac::delegate_did_disconnect(void* opaque_error) {
+    PeripheralBaseMacOS* internal = (__bridge PeripheralBaseMacOS*)opaque_internal_;
+    NSError* error = (__bridge NSError*)opaque_error;
+    [internal delegateDidDisconnect:error];
+
+    // If the user manually disconnects the peripheral, don't call the callback at this point.
+    if (callback_on_disconnected_ && !manual_disconnect_triggered_) {
+        callback_on_disconnected_();
+    }
+}

package/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);

package/simpleble/src/backends/macos/Utils.mm

@@ -0,0 +1,23 @@
+#import "Utils.h"
+
+#import <fmt/core.h>
+
+SimpleBLE::BluetoothUUID uuidToSimpleBLE(CBUUID* uuid) {
+    std::string uuid_raw = [[[uuid UUIDString] lowercaseString] UTF8String];
+
+    if (uuid_raw.length() == 4) {
+        return fmt::format("0000{}-0000-1000-8000-00805f9b34fb", uuid_raw);
+    } else {
+        return uuid_raw;
+    }
+}
+
+NSString* uuidToString(CBUUID* uuid) {
+    NSString* uuidString = [[uuid UUIDString] lowercaseString];
+
+    if ([uuidString length] == 4) {
+        return [NSString stringWithFormat:@"0000%@-0000-1000-8000-00805f9b34fb", uuidString];
+    } else {
+        return uuidString;
+    }
+}

package/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;
+}

package/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

package/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

package/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();
+    }
+}