simplejsble 0.0.4 → 0.0.6

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

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

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

package/simpleble/src/frontends/safe/PeripheralSafe.cpp

@@ -0,0 +1,219 @@
+#include <simpleble/Exceptions.h>
+#include <simpleble/PeripheralSafe.h>
+
+using namespace SimpleBLE::Safe;
+
+using SPeripheral = SimpleBLE::Safe::Peripheral;
+using UPeripheral = SimpleBLE::Peripheral;
+
+SPeripheral::Peripheral(UPeripheral& peripheral) : internal_(peripheral) {}
+SPeripheral::Peripheral(UPeripheral&& peripheral) : internal_(std::move(peripheral)) {}
+
+std::optional<std::string> SPeripheral::identifier() noexcept {
+    try {
+        return internal_.identifier();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::BluetoothAddress> SPeripheral::address() noexcept {
+    try {
+        return internal_.address();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::BluetoothAddressType> SPeripheral::address_type() noexcept {
+    try {
+        return internal_.address_type();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<int16_t> SPeripheral::rssi() noexcept {
+    try {
+        return internal_.rssi();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<int16_t> SPeripheral::tx_power() noexcept {
+    try {
+        return internal_.tx_power();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+std::optional<uint16_t> SPeripheral::mtu() noexcept {
+    try {
+        return internal_.mtu();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::connect() noexcept {
+    try {
+        internal_.connect();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::disconnect() noexcept {
+    try {
+        internal_.disconnect();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<bool> SPeripheral::is_connected() noexcept {
+    try {
+        return internal_.is_connected();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<bool> SPeripheral::is_connectable() noexcept {
+    try {
+        return internal_.is_connectable();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<bool> SPeripheral::is_paired() noexcept {
+    try {
+        return internal_.is_paired();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::unpair() noexcept {
+    try {
+        internal_.unpair();
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<std::map<uint16_t, SimpleBLE::ByteArray>> SPeripheral::manufacturer_data() noexcept {
+    try {
+        return internal_.manufacturer_data();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<std::vector<SimpleBLE::Service>> SPeripheral::services() noexcept {
+    try {
+        return internal_.services();
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+std::optional<SimpleBLE::ByteArray> SPeripheral::read(BluetoothUUID const& service,
+                                                      BluetoothUUID const& characteristic) noexcept {
+    try {
+        return internal_.read(service, characteristic);
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                ByteArray const& data) noexcept {
+    try {
+        internal_.write_request(service, characteristic, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                ByteArray const& data) noexcept {
+    try {
+        internal_.write_command(service, characteristic, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::notify(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                         std::function<void(ByteArray payload)> callback) noexcept {
+    try {
+        internal_.notify(service, characteristic, std::move(callback));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                           std::function<void(ByteArray payload)> callback) noexcept {
+    try {
+        internal_.indicate(service, characteristic, std::move(callback));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) noexcept {
+    try {
+        internal_.unsubscribe(service, characteristic);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+std::optional<SimpleBLE::ByteArray> SPeripheral::read(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                                                      BluetoothUUID const& descriptor) noexcept {
+    try {
+        return internal_.read(service, characteristic, descriptor);
+    } catch (...) {
+        return std::nullopt;
+    }
+}
+
+bool SPeripheral::write(BluetoothUUID const& service, BluetoothUUID const& characteristic,
+                        BluetoothUUID const& descriptor, ByteArray const& data) noexcept {
+    try {
+        internal_.write(service, characteristic, descriptor, data);
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::set_callback_on_connected(std::function<void()> on_connected) noexcept {
+    try {
+        internal_.set_callback_on_connected(std::move(on_connected));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}
+
+bool SPeripheral::set_callback_on_disconnected(std::function<void()> on_disconnected) noexcept {
+    try {
+        internal_.set_callback_on_disconnected(std::move(on_disconnected));
+        return true;
+    } catch (...) {
+        return false;
+    }
+}