simpleble 0.0.1

data/vendor/simpleble/simpleble/src/external/logfwd.hpp

@@ -0,0 +1,35 @@
+#ifndef LOGFWD_HPP
+#define LOGFWD_HPP
+
+#include <string>
+
+namespace logfwd {
+
+enum level : int {
+    NONE = 0,
+    FATAL,
+    ERROR,
+    WARN,
+    INFO,
+#pragma push_macro("DEBUG")
+#undef DEBUG
+    DEBUG,
+#pragma pop_macro("DEBUG")
+    VERBOSE,
+};
+
+// clang-format off
+
+void receive(
+    level level,
+    const std::string& module,
+    const std::string& file,
+    uint32_t line,
+    const std::string& function,
+    const std::string& message);
+
+// clang-format on
+
+}  // namespace logfwd
+
+#endif  // LOGFWD_HPP

data/vendor/simpleble/simpleble/src/frontends/base/Adapter.cpp

@@ -0,0 +1,111 @@
+#include <simpleble/Adapter.h>
+#include "Backend.h"
+
+#include "BuildVec.h"
+#include "LoggingInternal.h"
+#include "backends/common/AdapterBase.h"
+
+using namespace SimpleBLE;
+
+std::vector<Adapter> Adapter::get_adapters() {
+    std::vector<Adapter> adapter_list;
+    for (auto& backend : Backend::get_backends()) {
+        for (auto& adapter : backend.get_adapters()) {
+            adapter_list.push_back(adapter);
+        }
+    }
+
+    return adapter_list;
+}
+
+// TODO: this should be the implementation of the per-backend bluetooth_enabled() function
+// bool Adapter::bluetooth_enabled() { return (*this)->bluetooth_enabled(); }
+
+bool Adapter::bluetooth_enabled() { return get_enabled_backend().bluetooth_enabled(); }
+
+bool Adapter::initialized() const { return internal_ != nullptr; }
+
+void* Adapter::underlying() const { return (*this)->underlying(); }
+
+/**
+ * Return the adapter implementation if it is initialized.
+ *
+ * @throws SimpleBLE::NotInitialized if the adapter is not initialized.
+ */
+AdapterBase* Adapter::operator->() {
+    if (!internal_) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+const AdapterBase* Adapter::operator->() const {
+    if (!internal_) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+std::string Adapter::identifier() { return (*this)->identifier(); }
+
+BluetoothAddress Adapter::address() { return (*this)->address(); }
+
+void Adapter::power_on() { (*this)->power_on(); }
+
+void Adapter::power_off() { (*this)->power_off(); }
+
+bool Adapter::is_powered() { return (*this)->is_powered(); }
+
+void Adapter::set_callback_on_power_on(std::function<void()> on_power_on) {
+    (*this)->set_callback_on_power_on(std::move(on_power_on));
+}
+
+void Adapter::set_callback_on_power_off(std::function<void()> on_power_off) {
+    (*this)->set_callback_on_power_off(std::move(on_power_off));
+}
+
+void Adapter::scan_start() {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_start();
+}
+
+void Adapter::scan_stop() {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_stop();
+}
+
+void Adapter::scan_for(int timeout_ms) {
+    if (!bluetooth_enabled()) {
+        SIMPLEBLE_LOG_WARN(fmt::format("Bluetooth is not enabled."));
+        return;
+    }
+    (*this)->scan_for(timeout_ms);
+}
+
+bool Adapter::scan_is_active() { return (*this)->scan_is_active(); }
+
+std::vector<Peripheral> Adapter::scan_get_results() { return Factory::vector((*this)->scan_get_results()); }
+
+std::vector<Peripheral> Adapter::get_paired_peripherals() { return Factory::vector((*this)->get_paired_peripherals()); }
+
+void Adapter::set_callback_on_scan_start(std::function<void()> on_scan_start) {
+    (*this)->set_callback_on_scan_start(std::move(on_scan_start));
+}
+
+void Adapter::set_callback_on_scan_stop(std::function<void()> on_scan_stop) {
+    (*this)->set_callback_on_scan_stop(std::move(on_scan_stop));
+}
+
+void Adapter::set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated) {
+    (*this)->set_callback_on_scan_updated(std::move(on_scan_updated));
+}
+
+void Adapter::set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found) {
+    (*this)->set_callback_on_scan_found(std::move(on_scan_found));
+}

data/vendor/simpleble/simpleble/src/frontends/base/Backend.cpp

@@ -0,0 +1,83 @@
+#include <vector>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/Exceptions.h>
+
+#include "BackendBase.h"
+#include "BuildVec.h"
+#include "CommonUtils.h"
+
+#include "Backend.h"
+
+using namespace SimpleBLE;
+
+namespace SimpleBLE {
+
+static std::shared_ptr<BackendBase> _get_enabled_backend() {
+    using BackendPtr = std::shared_ptr<BackendBase>(void);
+
+    if constexpr (SIMPLEBLE_BACKEND_LINUX) {
+        extern BackendPtr BACKEND_LINUX;
+        return BACKEND_LINUX();
+    } else if constexpr (SIMPLEBLE_BACKEND_WINDOWS) {
+        extern BackendPtr BACKEND_WINDOWS;
+        return BACKEND_WINDOWS();
+    } else if constexpr (SIMPLEBLE_BACKEND_ANDROID) {
+        extern BackendPtr BACKEND_ANDROID;
+        return BACKEND_ANDROID();
+    } else if constexpr (SIMPLEBLE_BACKEND_MACOS) {
+        extern BackendPtr BACKEND_MACOS;
+        return BACKEND_MACOS();
+    } else if constexpr (SIMPLEBLE_BACKEND_IOS) {
+        extern BackendPtr BACKEND_MACOS;
+        return BACKEND_MACOS();
+    } else if constexpr (SIMPLEBLE_BACKEND_PLAIN) {
+        extern BackendPtr BACKEND_PLAIN;
+        return BACKEND_PLAIN();
+    }
+
+    throw Exception::NotInitialized();
+}
+
+Backend get_enabled_backend() { return Factory::build(_get_enabled_backend()); }
+
+// NOTE: in the future, this can return multiple backends
+static SharedPtrVector<BackendBase> _get_backends() {
+    SharedPtrVector<BackendBase> backends = {_get_enabled_backend()};
+    return backends;
+}
+
+}  // namespace SimpleBLE
+
+std::vector<Backend> Backend::get_backends() { return Factory::vector(_get_backends()); }
+
+bool Backend::initialized() const { return internal_ != nullptr; }
+
+BackendBase* Backend::operator->() {
+    if (!initialized()) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+const BackendBase* Backend::operator->() const {
+    if (!initialized()) {
+        throw Exception::NotInitialized();
+    }
+    return internal_.get();
+}
+
+std::vector<Adapter> Backend::get_adapters() { return Factory::vector((*this)->get_adapters()); }
+
+bool Backend::bluetooth_enabled() { return (*this)->bluetooth_enabled(); }
+
+std::optional<Backend> Backend::first_bluetooth_enabled() {
+    for (auto& backend : get_backends()) {
+        if (backend->bluetooth_enabled()) {
+            return backend;
+        }
+    }
+    return std::nullopt;
+}
+
+std::string Backend::name() const noexcept { return (*this)->name(); }

data/vendor/simpleble/simpleble/src/frontends/base/Backend.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/export.h>
+
+namespace SimpleBLE {
+
+class BackendBase;
+
+/**
+ * Backend.
+ *
+ * NOTE: backends must not implement this class directly, but instead derive
+ * from BackendBase, defined in Backend.h.
+ *
+ * This frontend class is hidden from users for the time being. Once the API
+ * stabilizes, this class will be exposed to users.
+ */
+class SIMPLEBLE_EXPORT Backend {
+  public:
+    Backend() = default;
+    virtual ~Backend() = default;
+
+    bool initialized() const;
+
+    /**
+     * Get a list of all available adapters from this backend.
+     */
+    std::vector<Adapter> get_adapters();
+
+    /**
+     * Check if Bluetooth is enabled for this backend.
+     */
+    bool bluetooth_enabled();
+
+    /**
+     * Get the first backend that has Bluetooth enabled.
+     *
+     * @return The first backend that has Bluetooth enabled, or std::nullopt if
+     *    no backends have Bluetooth enabled.
+     */
+    static std::optional<Backend> first_bluetooth_enabled();
+
+    /**
+     * Get the name of the backend.
+     */
+    std::string name() const noexcept;
+
+    /**
+     * Get all available backends.
+     *
+     * This will cause backends to be instantiated/initialized.
+     */
+    static std::vector<Backend> get_backends();
+
+  protected:
+    BackendBase* operator->();
+    const BackendBase* operator->() const;
+
+    std::shared_ptr<BackendBase> internal_;
+};
+
+/**
+ * Get the enabled backend.
+ *
+ * Note: this function should not be part of the public API and will be deleted
+ * once multiple backends are supported.
+ */
+Backend get_enabled_backend();
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/frontends/base/Characteristic.cpp

@@ -0,0 +1,56 @@
+#include <simpleble/Characteristic.h>
+
+#include "BuildVec.h"
+#include "CharacteristicBase.h"
+
+using namespace SimpleBLE;
+
+BluetoothUUID Characteristic::uuid() { return (*this)->uuid(); }
+
+std::vector<Descriptor> Characteristic::descriptors() { return Factory::vector((*this)->descriptors()); }
+
+std::vector<std::string> Characteristic::capabilities() {
+    std::vector<std::string> capabilities;
+
+    if (can_read()) {
+        capabilities.push_back("read");
+    }
+
+    if (can_write_request()) {
+        capabilities.push_back("write_request");
+    }
+
+    if (can_write_command()) {
+        capabilities.push_back("write_command");
+    }
+
+    if (can_notify()) {
+        capabilities.push_back("notify");
+    }
+
+    if (can_indicate()) {
+        capabilities.push_back("indicate");
+    }
+
+    return capabilities;
+}
+
+bool Characteristic::initialized() const { return internal_ != nullptr; }
+
+CharacteristicBase* Characteristic::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const CharacteristicBase* Characteristic::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+bool Characteristic::can_read() { return (*this)->can_read(); }
+bool Characteristic::can_write_request() { return (*this)->can_write_request(); }
+bool Characteristic::can_write_command() { return (*this)->can_write_command(); }
+bool Characteristic::can_notify() { return (*this)->can_notify(); }
+bool Characteristic::can_indicate() { return (*this)->can_indicate(); }

data/vendor/simpleble/simpleble/src/frontends/base/Descriptor.cpp

@@ -0,0 +1,21 @@
+#include <simpleble/Descriptor.h>
+
+#include "DescriptorBase.h"
+
+using namespace SimpleBLE;
+
+bool Descriptor::initialized() const { return internal_ != nullptr; }
+
+DescriptorBase* Descriptor::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const DescriptorBase* Descriptor::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+BluetoothUUID Descriptor::uuid() { return (*this)->uuid(); }

data/vendor/simpleble/simpleble/src/frontends/base/Peripheral.cpp

@@ -0,0 +1,113 @@
+#include <simpleble/Peripheral.h>
+
+#include <simpleble/Exceptions.h>
+#include "BuildVec.h"
+#include "PeripheralBase.h"
+
+using namespace SimpleBLE;
+
+bool Peripheral::initialized() const { return internal_ != nullptr; }
+
+PeripheralBase* Peripheral::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const PeripheralBase* Peripheral::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+std::string Peripheral::identifier() { return (*this)->identifier(); }
+
+SimpleBLE::BluetoothAddress Peripheral::address() { return (*this)->address(); }
+
+SimpleBLE::BluetoothAddressType Peripheral::address_type() { return (*this)->address_type(); }
+
+int16_t Peripheral::rssi() { return (*this)->rssi(); }
+
+int16_t Peripheral::tx_power() { return (*this)->tx_power(); }
+
+uint16_t Peripheral::mtu() { return (*this)->mtu(); }
+
+void Peripheral::connect() { return (*this)->connect(); }
+
+void Peripheral::disconnect() { return (*this)->disconnect(); }
+
+bool Peripheral::is_connected() { return (*this)->is_connected(); }
+
+bool Peripheral::is_connectable() { return (*this)->is_connectable(); }
+
+bool Peripheral::is_paired() { return (*this)->is_paired(); }
+
+void Peripheral::unpair() { return (*this)->unpair(); }
+
+std::vector<Service> Peripheral::services() {
+    return Factory::vector(is_connected() ? internal_->available_services() : internal_->advertised_services());
+}
+
+std::map<uint16_t, ByteArray> Peripheral::manufacturer_data() { return (*this)->manufacturer_data(); }
+
+ByteArray Peripheral::read(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    return internal_->read(service, characteristic);
+}
+
+void Peripheral::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                               ByteArray const& data) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->write_request(service, characteristic, data);
+}
+
+void Peripheral::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                               ByteArray const& data) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->write_command(service, characteristic, data);
+}
+
+void Peripheral::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                        std::function<void(ByteArray payload)> callback) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->notify(service, characteristic, std::move(callback));
+}
+
+void Peripheral::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                          std::function<void(ByteArray payload)> callback) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->indicate(service, characteristic, std::move(callback));
+}
+
+void Peripheral::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->unsubscribe(service, characteristic);
+}
+
+ByteArray Peripheral::read(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                           BluetoothUUID const& descriptor) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    return internal_->read(service, characteristic, descriptor);
+}
+
+void Peripheral::write(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                       BluetoothUUID const& descriptor, ByteArray const& data) {
+    if (!is_connected()) throw Exception::NotConnected();
+
+    internal_->write(service, characteristic, descriptor, data);
+}
+
+void Peripheral::set_callback_on_connected(std::function<void()> on_connected) {
+    (*this)->set_callback_on_connected(std::move(on_connected));
+}
+
+void Peripheral::set_callback_on_disconnected(std::function<void()> on_disconnected) {
+    (*this)->set_callback_on_disconnected(std::move(on_disconnected));
+}

data/vendor/simpleble/simpleble/src/frontends/base/Service.cpp

@@ -0,0 +1,26 @@
+#include <simpleble/Service.h>
+
+#include "BuildVec.h"
+#include "ServiceBase.h"
+
+using namespace SimpleBLE;
+
+bool Service::initialized() const { return internal_ != nullptr; }
+
+ServiceBase* Service::operator->() {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+const ServiceBase* Service::operator->() const {
+    if (!initialized()) throw Exception::NotInitialized();
+
+    return internal_.get();
+}
+
+BluetoothUUID Service::uuid() { return (*this)->uuid(); }
+
+ByteArray Service::data() { return (*this)->data(); }
+
+std::vector<Characteristic> Service::characteristics() { return Factory::vector((*this)->characteristics()); }

data/vendor/simpleble/simpleble/src/frontends/safe/AdapterSafe.cpp

@@ -0,0 +1,158 @@
+#include <simpleble/AdapterSafe.h>
+
+using namespace SimpleBLE;
+
+using SPeripheral = SimpleBLE::Safe::Peripheral;
+using SAdapter = SimpleBLE::Safe::Adapter;
+
+using UAdapter = SimpleBLE::Adapter;
+
+SAdapter::Adapter(UAdapter& adapter) : internal_(adapter) {}
+SAdapter::Adapter(UAdapter&& adapter) : internal_(std::move(adapter)) {}
+
+std::optional<std::string> SAdapter::identifier() noexcept {
+    try {
+        return internal_.identifier();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::BluetoothAddress> SAdapter::address() noexcept {
+    try {
+        return internal_.address();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+SAdapter::operator SimpleBLE::Adapter() const noexcept { return internal_; }
+
+bool SAdapter::scan_start() noexcept {
+    try {
+        internal_.scan_start();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SAdapter::scan_stop() noexcept {
+    try {
+        internal_.scan_stop();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SAdapter::scan_for(int timeout_ms) noexcept {
+    try {
+        internal_.scan_for(timeout_ms);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<bool> SAdapter::scan_is_active() noexcept {
+    try {
+        return internal_.scan_is_active();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::vector<SPeripheral>> SAdapter::scan_get_results() noexcept {
+    try {
+        std::vector<SPeripheral> r;
+        for (auto p : internal_.scan_get_results()) {
+            r.push_back(std::move(p));
+        }
+        return r;
+    } catch (...) {
+        return std::nullopt;
+    }
+    return std::nullopt;
+}
+
+std::optional<std::vector<SPeripheral>> SAdapter::get_paired_peripherals() noexcept {
+    try {
+        std::vector<SPeripheral> r;
+        for (auto p : internal_.get_paired_peripherals()) {
+            r.push_back(std::move(p));
+        }
+        return r;
+    } catch (...) {
+        return std::nullopt;
+    }
+    return std::nullopt;
+}
+
+bool SAdapter::set_callback_on_scan_start(std::function<void()> on_scan_start) noexcept {
+    try {
+        internal_.set_callback_on_scan_start(std::move(on_scan_start));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SAdapter::set_callback_on_scan_stop(std::function<void()> on_scan_stop) noexcept {
+    try {
+        internal_.set_callback_on_scan_stop(std::move(on_scan_stop));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SAdapter::set_callback_on_scan_updated(std::function<void(SPeripheral)> on_scan_updated) noexcept {
+    try {
+        internal_.set_callback_on_scan_updated(
+            [on_scan_updated = std::move(on_scan_updated)](auto p) { on_scan_updated(p); });
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SAdapter::set_callback_on_scan_found(std::function<void(SPeripheral)> on_scan_found) noexcept {
+    try {
+        internal_.set_callback_on_scan_found([on_scan_found = std::move(on_scan_found)](auto p) { on_scan_found(p); });
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+// NOTE: this should be the implementation once per-adapters are supported
+/*
+std::optional<bool> SAdapter::bluetooth_enabled() noexcept {
+    try {
+        return internal_.bluetooth_enabled();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+*/
+std::optional<bool> SAdapter::bluetooth_enabled() noexcept {
+    try {
+        return UAdapter::bluetooth_enabled();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::vector<SAdapter>> SAdapter::get_adapters() noexcept {
+    try {
+        auto adapters = UAdapter::get_adapters();
+        std::vector<SAdapter> safe_adapters;
+        for (auto& adapter : adapters) {
+            safe_adapters.push_back(std::move(adapter));
+        }
+        return safe_adapters;
+    } catch (...) {
+        return std::nullopt;
+    }
+}