simpleble 0.0.1

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

@@ -0,0 +1,376 @@
+#include "PeripheralLinux.h"
+
+#include "BuildVec.h"
+#include "BuilderBase.h"
+#include "CharacteristicBase.h"
+#include "DescriptorBase.h"
+#include "ServiceBase.h"
+
+#include <simpleble/Config.h>
+#include <simpleble/Characteristic.h>
+#include <simpleble/Descriptor.h>
+#include <simpleble/Exceptions.h>
+#include <simpleble/Service.h>
+#include <simplebluez/Exceptions.h>
+#include <algorithm>
+#include <thread>
+#include "CommonUtils.h"
+#include "LoggingInternal.h"
+
+const SimpleBLE::BluetoothUUID BATTERY_SERVICE_UUID = "0000180f-0000-1000-8000-00805f9b34fb";
+const SimpleBLE::BluetoothUUID BATTERY_CHARACTERISTIC_UUID = "00002a19-0000-1000-8000-00805f9b34fb";
+
+using namespace SimpleBLE;
+using namespace std::chrono_literals;
+
+PeripheralLinux::PeripheralLinux(std::shared_ptr<SimpleBluez::Device> device,
+                                 std::shared_ptr<SimpleBluez::Adapter> adapter)
+    : device_(std::move(device)), adapter_(std::move(adapter)) {}
+
+PeripheralLinux::~PeripheralLinux() {
+    // Clear the callbacks to prevent any further events from being sent to the user.
+    this->callback_on_connected_.unload();
+    this->callback_on_disconnected_.unload();
+
+    device_->clear_on_disconnected();
+    device_->clear_on_services_resolved();
+    _cleanup_characteristics();
+}
+
+void* PeripheralLinux::underlying() const { return device_.get(); }
+
+std::string PeripheralLinux::identifier() { return device_->name(); }
+
+BluetoothAddress PeripheralLinux::address() { return device_->address(); }
+
+BluetoothAddressType PeripheralLinux::address_type() {
+    std::string address_type = device_->address_type();
+
+    if (address_type == "public") {
+        return BluetoothAddressType::PUBLIC;
+    } else if (address_type == "public") {
+        return BluetoothAddressType::RANDOM;
+    } else {
+        return BluetoothAddressType::UNSPECIFIED;
+    }
+}
+
+int16_t PeripheralLinux::rssi() { return device_->rssi(); }
+
+int16_t PeripheralLinux::tx_power() { return device_->tx_power(); }
+
+uint16_t PeripheralLinux::mtu() {
+    if (!is_connected()) return 0;
+
+    for (auto bluez_service : device_->services()) {
+        for (auto bluez_characteristic : bluez_service->characteristics()) {
+            // The value provided by Bluez includes an extra 3 bytes from the GATT header
+            // which needs to be removed.
+            return bluez_characteristic->mtu() - 3;
+        }
+    }
+    return 0;
+}
+
+void PeripheralLinux::connect() {
+    device_->clear_on_disconnected();
+    device_->set_on_services_resolved([this]() { this->connection_cv_.notify_all(); });
+
+    // Attempt to connect to the device.
+    for (size_t i = 0; i < 5; i++) {
+        if (_attempt_connect()) {
+            break;
+        }
+    }
+
+    // Set the on_disconnected callback once the connection attempts are finished, thus
+    // preventing disconnection events that should not be seen by the user.
+    device_->set_on_disconnected([this]() {
+        this->_cleanup_characteristics();
+        this->disconnection_cv_.notify_all();
+
+        SAFE_CALLBACK_CALL(this->callback_on_disconnected_);
+    });
+
+    if (!is_connected()) {
+        throw Exception::OperationFailed();
+    }
+
+    SAFE_CALLBACK_CALL(this->callback_on_connected_);
+}
+
+void PeripheralLinux::disconnect() {
+    // Attempt to connect to the device.
+    for (size_t i = 0; i < 5; i++) {
+        if (_attempt_disconnect()) {
+            break;
+        }
+    }
+
+    if (is_connected()) {
+        throw Exception::OperationFailed();
+    }
+}
+
+bool PeripheralLinux::is_connected() {
+    // NOTE: For Bluez, a device being connected means that it's both
+    // connected and services have been resolved.
+    return device_->connected() && device_->services_resolved();
+}
+
+bool PeripheralLinux::is_connectable() { return device_->name() != ""; }
+
+bool PeripheralLinux::is_paired() { return device_->paired(); }
+
+void PeripheralLinux::unpair() {
+    if (device_->paired()) {
+        adapter_->device_remove(device_->path());
+    }
+}
+
+SharedPtrVector<ServiceBase> PeripheralLinux::available_services() {
+    bool is_battery_service_available = false;
+
+    SharedPtrVector<ServiceBase> service_list;
+    for (auto bluez_service : device_->services()) {
+        // Check if the service is the battery service.
+        if (bluez_service->uuid() == BATTERY_SERVICE_UUID) {
+            is_battery_service_available = true;
+        }
+
+        // Build the list of characteristics for the service.
+        SharedPtrVector<CharacteristicBase> characteristic_list;
+        for (auto bluez_characteristic : bluez_service->characteristics()) {
+            // Build the list of descriptors for the characteristic.
+            SharedPtrVector<DescriptorBase> descriptor_list;
+            for (auto bluez_descriptor : bluez_characteristic->descriptors()) {
+                descriptor_list.push_back(std::make_shared<DescriptorBase>(bluez_descriptor->uuid()));
+            }
+
+            std::vector<std::string> flags = bluez_characteristic->flags();
+
+            bool can_read = std::find(flags.begin(), flags.end(), "read") != flags.end();
+            bool can_write_request = std::find(flags.begin(), flags.end(), "write") != flags.end();
+            bool can_write_command = std::find(flags.begin(), flags.end(), "write-without-response") != flags.end();
+            bool can_notify = std::find(flags.begin(), flags.end(), "notify") != flags.end();
+            bool can_indicate = std::find(flags.begin(), flags.end(), "indicate") != flags.end();
+
+            characteristic_list.push_back(
+                std::make_shared<CharacteristicBase>(bluez_characteristic->uuid(), descriptor_list, can_read,
+                                                     can_write_request, can_write_command, can_notify, can_indicate));
+        }
+
+        service_list.push_back(std::make_shared<ServiceBase>(bluez_service->uuid(), characteristic_list));
+    }
+
+    // If the battery service is not available, and the device has the appropriate interface, add it.
+    if (!is_battery_service_available && device_->has_battery_interface()) {
+        // Emulate the battery service through the Battery1 interface.
+        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> PeripheralLinux::advertised_services() {
+    SharedPtrVector<ServiceBase> service_list;
+    for (auto& service_uuid : device_->uuids()) {
+        service_list.push_back(std::make_shared<ServiceBase>(service_uuid));
+    }
+
+    return service_list;
+}
+
+std::map<uint16_t, ByteArray> PeripheralLinux::manufacturer_data() { return device_->manufacturer_data(); }
+
+ByteArray PeripheralLinux::read(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    // Check if the user is attempting to read the battery service/characteristic and if so,
+    //  emulate the battery service through the Battery1 interface if it's not available.
+    if (service == BATTERY_SERVICE_UUID && characteristic == BATTERY_CHARACTERISTIC_UUID &&
+        device_->has_battery_interface()) {
+        // If this point is reached, the battery service needs to be emulated.
+        uint8_t battery_percentage = device_->battery_percentage();
+        return ByteArray(reinterpret_cast<char*>(&battery_percentage), 1);
+    }
+
+    // Otherwise, attempt to read the characteristic using default mechanisms
+    return _get_characteristic(service, characteristic)->read();
+}
+
+void PeripheralLinux::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                    ByteArray const& data) {
+    // TODO: Check if the characteristic is writable.
+    // TODO: SimpleBluez::Characteristic::write_request() should also take ByteArray by const reference (but that's
+    // another library)
+    _get_characteristic(service, characteristic)->write_request(data);
+}
+
+void PeripheralLinux::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                    ByteArray const& data) {
+    // TODO: Check if the characteristic is writable.
+    // TODO: SimpleBluez::Characteristic::write_command() should also take ByteArray by const reference (but that's
+    // another library)
+    _get_characteristic(service, characteristic)->write_command(data);
+}
+
+void PeripheralLinux::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                             std::function<void(ByteArray payload)> callback) {
+    // Check if the user is attempting to notify the battery service/characteristic and if so,
+    //  emulate the battery service through the Battery1 interface if it's not available.
+    if (service == BATTERY_SERVICE_UUID && characteristic == BATTERY_CHARACTERISTIC_UUID &&
+        device_->has_battery_interface()) {
+        // If this point is reached, the battery service needs to be emulated.
+        device_->set_on_battery_percentage_changed(
+            [callback](uint8_t new_value) { callback(ByteArray(reinterpret_cast<char*>(&new_value), 1)); });
+        return;
+    }
+
+    // Otherwise, attempt to read the characteristic using default mechanisms
+    // TODO: What to do if the characteristic is already being notified?
+    // TODO: Check if the property can be notified.
+    auto characteristic_object = _get_characteristic(service, characteristic);
+    characteristic_object->set_on_value_changed([callback](SimpleBluez::ByteArray new_value) { callback(new_value); });
+    characteristic_object->start_notify();
+}
+
+void PeripheralLinux::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                               std::function<void(ByteArray payload)> callback) {
+    notify(service, characteristic, callback);
+}
+
+void PeripheralLinux::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    // Check if the user is attempting to read the battery service/characteristic and if so,
+    //  emulate the battery service through the Battery1 interface if it's not available.
+    if (service == BATTERY_SERVICE_UUID && characteristic == BATTERY_CHARACTERISTIC_UUID &&
+        device_->has_battery_interface()) {
+        // If this point is reached, the battery service needs to be emulated.
+        device_->clear_on_battery_percentage_changed();
+        return;
+    }
+
+    // TODO: What to do if the characteristic is not being notified?
+    auto characteristic_object = _get_characteristic(service, characteristic);
+    characteristic_object->stop_notify();
+
+    // Wait for the characteristic to stop notifying.
+    // TODO: Upgrade SimpleDBus to provide a way to wait for this signal.
+    auto timeout = std::chrono::steady_clock::now() + 5s;
+    while (characteristic_object->notifying() && std::chrono::steady_clock::now() < timeout) {
+        std::this_thread::sleep_for(50ms);
+    }
+}
+
+ByteArray PeripheralLinux::read(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                BluetoothUUID const& descriptor) {
+    return _get_descriptor(service, characteristic, descriptor)->read();
+}
+
+void PeripheralLinux::write(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                            BluetoothUUID const& descriptor, ByteArray const& data) {
+    _get_descriptor(service, characteristic, descriptor)->write(data);
+}
+
+void PeripheralLinux::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 PeripheralLinux::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();
+    }
+}
+
+// Private methods
+
+void PeripheralLinux::_cleanup_characteristics() noexcept {
+    // As this method can be called in multiple stages of a disconnection or object
+    // destruction, the entire execution of this method is wrapped in a try-catch
+    // block to prevent any exceptions from being thrown, as these will most certainly
+    // crash the user application.
+    try {
+        // Clear all callbacks first to ensure that a failure during `stop_notify`
+        // does not leave any dangling callbacks.
+        if (device_->has_battery_interface()) {
+            device_->clear_on_battery_percentage_changed();
+        }
+
+        for (auto bluez_service : device_->services()) {
+            for (auto bluez_characteristic : bluez_service->characteristics()) {
+                bluez_characteristic->clear_on_value_changed();
+            }
+        }
+
+        // Stop notifying all characteristics.
+        for (auto bluez_service : device_->services()) {
+            for (auto bluez_characteristic : bluez_service->characteristics()) {
+                try {
+                    if (bluez_characteristic->notifying()) {
+                        bluez_characteristic->stop_notify();
+                    }
+                } catch (std::exception const& e) {
+                    SIMPLEBLE_LOG_WARN(fmt::format("Exception during characteristic cleanup: {}", e.what()));
+                }
+            }
+        }
+    } catch (std::exception const& e) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Exception during characteristic cleanup: {}", e.what()));
+    } catch (...) {
+        // It's possible during the cleanup process that the Bluez device has already
+        // been removed, which could cause calls to cleanup methods to throw.
+        SIMPLEBLE_LOG_WARN("Unknown exception during characteristic cleanup");
+    }
+}
+
+bool PeripheralLinux::_attempt_connect() {
+    try {
+        device_->connect();
+    } catch (SimpleDBus::Exception::SendFailed const& e) {
+        return false;
+    }
+
+    // Wait for the connection to be confirmed.
+    // The condition variable will return false if the connection was not established.
+    std::unique_lock<std::mutex> lock(connection_mutex_);
+    return connection_cv_.wait_for(lock, Config::SimpleBluez::connection_timeout, [this]() { return is_connected(); });
+}
+
+bool PeripheralLinux::_attempt_disconnect() {
+    _cleanup_characteristics();
+
+    device_->disconnect();
+
+    // Wait for the disconnection to be confirmed.
+    // The condition variable will return false if the connection is still active.
+    std::unique_lock<std::mutex> lock(disconnection_mutex_);
+    return disconnection_cv_.wait_for(lock, Config::SimpleBluez::disconnection_timeout, [this]() { return !is_connected(); });
+}
+
+std::shared_ptr<SimpleBluez::Characteristic> PeripheralLinux::_get_characteristic(
+    BluetoothUUID const& service_uuid, BluetoothUUID const& characteristic_uuid) {
+    try {
+        return device_->get_characteristic(service_uuid, characteristic_uuid);
+    } catch (SimpleBluez::Exception::ServiceNotFoundException& e) {
+        throw Exception::ServiceNotFound(service_uuid);
+    } catch (SimpleBluez::Exception::CharacteristicNotFoundException& e) {
+        throw Exception::CharacteristicNotFound(characteristic_uuid);
+    }
+}
+
+std::shared_ptr<SimpleBluez::Descriptor> PeripheralLinux::_get_descriptor(BluetoothUUID const& service_uuid,
+                                                                          BluetoothUUID const& characteristic_uuid,
+                                                                          BluetoothUUID const& descriptor_uuid) {
+    try {
+        return device_->get_characteristic(service_uuid, characteristic_uuid)->get_descriptor(descriptor_uuid);
+    } catch (SimpleBluez::Exception::DescriptorNotFoundException& e) {
+        throw Exception::DescriptorNotFound(descriptor_uuid);
+    }
+}

data/vendor/simpleble/simpleble/src/backends/linux/PeripheralLinux.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Service.h>
+#include <simpleble/Types.h>
+
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Characteristic.h>
+#include <simplebluez/Device.h>
+
+#include "../common/PeripheralBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+
+namespace SimpleBLE {
+
+class PeripheralLinux : public SimpleBLE::PeripheralBase {
+  public:
+    PeripheralLinux(std::shared_ptr<SimpleBluez::Device> device, std::shared_ptr<SimpleBluez::Adapter> adapter);
+    virtual ~PeripheralLinux();
+
+    virtual 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 battery_emulation_required_{false};
+
+    std::shared_ptr<SimpleBluez::Adapter> adapter_;
+    std::shared_ptr<SimpleBluez::Device> device_;
+
+    std::condition_variable connection_cv_;
+    std::mutex connection_mutex_;
+
+    std::condition_variable disconnection_cv_;
+    std::mutex disconnection_mutex_;
+
+    kvn::safe_callback<void()> callback_on_connected_;
+    kvn::safe_callback<void()> callback_on_disconnected_;
+
+    bool _attempt_connect();
+    bool _attempt_disconnect();
+    void _cleanup_characteristics() noexcept;
+
+    std::shared_ptr<SimpleBluez::Characteristic> _get_characteristic(BluetoothUUID const& service_uuid,
+                                                                     BluetoothUUID const& characteristic_uuid);
+
+    std::shared_ptr<SimpleBluez::Descriptor> _get_descriptor(BluetoothUUID const& service_uuid,
+                                                             BluetoothUUID const& characteristic_uuid,
+                                                             BluetoothUUID const& descriptor_uuid);
+};
+
+}  // namespace SimpleBLE

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#import <CoreBluetooth/CoreBluetooth.h>
+#import <Foundation/Foundation.h>
+
+#include <functional>
+#import "AdapterMac.h"
+
+@interface AdapterBaseMacOS : NSObject<CBCentralManagerDelegate>
+
+@property NSString* uuid;
+
+- (bool)isBluetoothEnabled;
+
+- (instancetype)init:(SimpleBLE::AdapterMac*)adapter;
+
+- (void*)underlying;
+
+- (void)powerOn;
+- (void)powerOff;
+- (bool)isPowered;
+
+- (void)scanStart;
+- (void)scanStop;
+- (bool)scanIsActive;
+
+- (NSString*)address;
+
+@end

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

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "AdapterBase.h"
+#include "AdapterBaseTypes.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace SimpleBLE {
+
+class Peripheral;
+class PeripheralBase;
+class PeripheralMac;
+
+/**
+  This class definition acts as an abstraction layer between C++ and Objective-C.
+  If Objective-C headers are included here, everything blows up.
+ */
+class AdapterMac : public AdapterBase {
+  public:
+    AdapterMac();
+    virtual ~AdapterMac();
+
+    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;
+
+    void delegate_did_discover_peripheral(void* opaque_peripheral, void* opaque_adapter,
+                                          advertising_data_t advertising_data);
+    void delegate_did_connect_peripheral(void* opaque_peripheral);
+    void delegate_did_fail_to_connect_peripheral(void* opaque_peripheral, void* opaque_error);
+    void delegate_did_disconnect_peripheral(void* opaque_peripheral, void* opaque_error);
+
+  protected:
+    /**
+     * Holds a pointer to the Objective-C representation of this object.
+     */
+    void* opaque_internal_;
+
+    /**
+     * Holds a map of objective-c peripheral objects to their corresponding C++ objects.
+     *
+     * Whenever some sort of event happens on a peripheral, we need to find
+     * the corresponding PeripheralBase object. The PeripheralBase objects
+     * can be wrapped in disposable Peripheral objects, so there is no need
+     * be careful with them.
+     */
+    std::map<void*, std::shared_ptr<PeripheralMac>> peripherals_;
+    std::map<void*, std::shared_ptr<PeripheralMac>> seen_peripherals_;
+
+  private:
+    BluetoothAddress address() const;
+};
+
+}  // namespace SimpleBLE

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#import <CoreBluetooth/CoreBluetooth.h>
+#import <Foundation/Foundation.h>
+
+#include <cstdint>
+#include <functional>
+#include <vector>
+#import "PeripheralMac.h"
+
+@interface PeripheralBaseMacOS : NSObject<CBPeripheralDelegate>
+
+- (instancetype)init:(CBPeripheral*)peripheral centralManager:(CBCentralManager*)centralManager;
+
+- (void*)underlying;
+
+- (NSString*)identifier;
+- (NSString*)address;
+- (uint16_t)mtu;
+
+- (void)connect;
+- (void)disconnect;
+- (bool)isConnected;
+- (std::vector<std::shared_ptr<SimpleBLE::ServiceBase>>)getServices;
+
+- (SimpleBLE::ByteArray)read:(NSString*)service_uuid characteristic_uuid:(NSString*)characteristic_uuid;
+- (void)writeRequest:(NSString*)service_uuid characteristic_uuid:(NSString*)characteristic_uuid payload:(NSData*)payload;
+- (void)writeCommand:(NSString*)service_uuid characteristic_uuid:(NSString*)characteristic_uuid payload:(NSData*)payload;
+- (void)notify:(NSString*)service_uuid
+    characteristic_uuid:(NSString*)characteristic_uuid
+               callback:(std::function<void(SimpleBLE::ByteArray)>)callback;
+- (void)indicate:(NSString*)service_uuid
+    characteristic_uuid:(NSString*)characteristic_uuid
+               callback:(std::function<void(SimpleBLE::ByteArray)>)callback;
+- (void)unsubscribe:(NSString*)service_uuid characteristic_uuid:(NSString*)characteristic_uuid;
+
+- (SimpleBLE::ByteArray)read:(NSString*)service_uuid
+         characteristic_uuid:(NSString*)characteristic_uuid
+             descriptor_uuid:(NSString*)descriptor_uuid;
+- (void)write:(NSString*)service_uuid
+    characteristic_uuid:(NSString*)characteristic_uuid
+        descriptor_uuid:(NSString*)descriptor_uuid
+                payload:(NSData*)payload;
+
+- (void)delegateDidConnect;
+- (void)delegateDidFailToConnect:(NSError*)error;
+- (void)delegateDidDisconnect:(NSError*)error;
+
+@end