simpleble 0.0.1

data/vendor/simpleble/simpleble/src/Exceptions.cpp

@@ -0,0 +1,31 @@
+#include <fmt/core.h>
+#include <simpleble/Exceptions.h>
+
+using namespace SimpleBLE;
+using namespace SimpleBLE::Exception;
+
+NotInitialized::NotInitialized() : BaseException("Object has not been initialized.") {}
+
+NotConnected::NotConnected() : BaseException("Peripheral is not connected.") {}
+
+InvalidReference::InvalidReference() : BaseException("Underlying reference to object is invalid.") {}
+
+ServiceNotFound::ServiceNotFound(BluetoothUUID uuid) : BaseException("Service with UUID " + uuid + " not found.") {}
+
+CharacteristicNotFound::CharacteristicNotFound(BluetoothUUID uuid)
+    : BaseException("Characteristic with UUID " + uuid + " not found") {}
+
+DescriptorNotFound::DescriptorNotFound(BluetoothUUID uuid)
+    : BaseException("Descriptor with UUID " + uuid + " not found") {}
+
+OperationNotSupported::OperationNotSupported() : BaseException("The requested operation is not supported.") {}
+
+OperationFailed::OperationFailed() : BaseException("The requested operation has failed.") {}
+
+OperationFailed::OperationFailed(const std::string& err_msg) : BaseException("Operation Failed: " + err_msg) {}
+
+WinRTException::WinRTException(int32_t err_code, const std::string& err_msg)
+    : BaseException(fmt::format("WinRT Exception. Error code {}: {}", err_code, err_msg)) {}
+
+CoreBluetoothException::CoreBluetoothException(const std::string& err_msg)
+    : BaseException(fmt::format("CoreBluetooth Exception: {}", err_msg)) {}

data/vendor/simpleble/simpleble/src/Logging.cpp

@@ -0,0 +1,136 @@
+#include "simpleble/Logging.h"
+
+#include <fmt/chrono.h>
+#include <fmt/core.h>
+#include <ctime>
+#include <fstream>
+#include <mutex>
+
+using namespace SimpleBLE::Logging;
+
+Logger* Logger::get() {
+    static std::mutex get_mutex;       // Static mutex to ensure thread safety when accessing the logger
+    std::scoped_lock lock(get_mutex);  // Unlock the mutex on function return
+    static Logger instance;            // Static instance of the logger to ensure proper lifecycle management
+    return &instance;
+}
+
+Logger::Logger() { log_default_stdout(); }
+
+Logger::~Logger() {}
+
+void Logger::set_level(Level level) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    level_ = level;
+}
+
+Level Logger::get_level() {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    return level_;
+}
+
+void Logger::set_callback(Callback callback) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    callback_ = callback;
+}
+
+bool Logger::has_callback() {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    return callback_ != nullptr;
+}
+
+void Logger::log(Level level, const std::string& module, const std::string& file, uint32_t line,
+                 const std::string& function, const std::string& message) {
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+
+    if (level <= level_ && callback_ != nullptr) {
+        try {
+            callback_(level, module, file, line, function, message);
+        } catch (...) {
+            // Clearly, if the logging callback throws an exception, we should not crash.
+        }
+    }
+}
+
+std::string Logger::level_to_str(Level level) {
+    std::string level_str;
+    switch (level) {
+        case Level::Verbose:
+            level_str = "VERBOSE";
+            break;
+        case Level::Debug:
+            level_str = "DEBUG";
+            break;
+        case Level::Info:
+            level_str = "INFO";
+            break;
+        case Level::Warn:
+            level_str = "WARNING";
+            break;
+        case Level::Error:
+            level_str = "ERROR";
+            break;
+        case Level::Fatal:
+            level_str = "FATAL";
+            break;
+        case Level::None:
+            level_str = "NONE";
+            break;
+    }
+    return level_str;
+}
+
+void Logger::log_default_stdout() {
+    set_callback([](Level level, const std::string& module, const std::string& file, uint32_t line,
+                    const std::string& function, const std::string& message) {
+        std::string level_str = level_to_str(level);
+        fmt::print("[{}] {}: {}:{} in {}: {}\n", level_str, module, file, line, function, message);
+    });
+}
+
+void Logger::log_default_file() {
+    std::time_t t = std::time(nullptr);
+    std::string date_time_str = fmt::format("{:%Y-%m-%d_%H-%M-%S}", fmt::localtime(t));
+    std::string filename = fmt::format("simpleble_{}", date_time_str);
+    log_default_file(filename);
+}
+
+void Logger::log_default_file(const std::string path) {
+    set_callback([=](Level level, const std::string& module, const std::string& file, uint32_t line,
+                     const std::string& function, const std::string& message) {
+        std::string level_str = level_to_str(level);
+        std::string log_message = fmt::format("[{}] {}: {}:{} in {}: {}\n", level_str, module, file, line, function,
+                                              message);
+
+        std::ofstream outfile;
+        outfile.open(path, std::ios_base::app);  // open the file in append mode
+        outfile << log_message;
+        outfile.close();
+    });
+}
+
+#if defined(__linux__) || defined(__APPLE__)
+// For Linux and MacOS, implement a strong definition of the logfwd receive library.
+#include "kvn/logfwd.hpp"
+
+// clang-format off
+void logfwd::receive(
+    logfwd::level level,
+    const std::string& module,
+    const std::string& file,
+    uint32_t line,
+    const std::string& function,
+    const std::string& message) {
+
+    // Forward logs from internal modules into the SimpleBLE logger.
+    Logger::get()->log(
+        static_cast<Level>(level),
+        fmt::format("SimpleBLE->{}", module),
+        file,
+        line,
+        function,
+        message);
+}
+// clang-format on
+
+#endif

data/vendor/simpleble/simpleble/src/LoggingInternal.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <fmt/core.h>
+#include "simpleble/Logging.h"
+
+#define SIMPLEBLE_LOG_LEVEL_NONE 0
+#define SIMPLEBLE_LOG_LEVEL_FATAL 1
+#define SIMPLEBLE_LOG_LEVEL_ERROR 2
+#define SIMPLEBLE_LOG_LEVEL_WARN 3
+#define SIMPLEBLE_LOG_LEVEL_INFO 4
+#define SIMPLEBLE_LOG_LEVEL_DEBUG 5
+#define SIMPLEBLE_LOG_LEVEL_VERBOSE 6
+
+#ifndef SIMPLEBLE_LOG_LEVEL
+#define SIMPLEBLE_LOG_LEVEL SIMPLEBLE_LOG_LEVEL_VERBOSE
+#endif
+
+// clang-format off
+
+#if SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_VERBOSE
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_WARN(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Warn, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_INFO(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Info, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_DEBUG(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Debug, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_VERBOSE(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::VERBOSE, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+
+#elif SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_DEBUG
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_WARN(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Warn, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_INFO(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Info, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_DEBUG(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Debug, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#elif SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_INFO
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_WARN(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Warn, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_INFO(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Info, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_DEBUG(msg) 
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#elif SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_WARN
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_WARN(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Warn, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_INFO(msg) 
+#define SIMPLEBLE_LOG_DEBUG(msg) 
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#elif SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_ERROR
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Error, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_WARN(msg)
+#define SIMPLEBLE_LOG_INFO(msg) 
+#define SIMPLEBLE_LOG_DEBUG(msg) 
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#elif SIMPLEBLE_LOG_LEVEL == SIMPLEBLE_LOG_LEVEL_FATAL
+
+#define SIMPLEBLE_LOG_FATAL(msg) SimpleBLE::Logging::Logger::get()->log(SimpleBLE::Logging::Level::Fatal, "SimpleBLE", __FILE__, __LINE__, __func__, msg)
+#define SIMPLEBLE_LOG_ERROR(msg)
+#define SIMPLEBLE_LOG_WARN(msg)
+#define SIMPLEBLE_LOG_INFO(msg) 
+#define SIMPLEBLE_LOG_DEBUG(msg) 
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#else
+
+#define SIMPLEBLE_LOG_FATAL(msg)
+#define SIMPLEBLE_LOG_ERROR(msg)
+#define SIMPLEBLE_LOG_WARN(msg)
+#define SIMPLEBLE_LOG_INFO(msg) 
+#define SIMPLEBLE_LOG_DEBUG(msg) 
+#define SIMPLEBLE_LOG_VERBOSE(msg)
+
+#endif
+
+// clang-format on

data/vendor/simpleble/simpleble/src/Utils.cpp

@@ -0,0 +1,24 @@
+#include <simpleble/Utils.h>
+#if SIMPLEBLE_BACKEND_MACOS || SIMPLEBLE_BACKEND_IOS
+#include "TargetConditionals.h"
+#endif
+
+namespace SimpleBLE {
+
+OperatingSystem get_operating_system() {
+#ifdef _WIN32
+    return OperatingSystem::WINDOWS;
+#elif TARGET_OS_OSX
+    return OperatingSystem::MACOS;
+#elif TARGET_OS_IOS
+    return OperatingSystem::IOS;
+#elif __linux__
+    return OperatingSystem::LINUX;
+#elif __ANDROID__
+    return OperatingSystem::ANDROID;
+#endif
+}
+
+std::string get_simpleble_version() { return SIMPLEBLE_VERSION; }
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/AdapterAndroid.cpp

@@ -0,0 +1,101 @@
+#include "AdapterAndroid.h"
+#include "BackendAndroid.h"
+#include "BuilderBase.h"
+#include "CommonUtils.h"
+#include "PeripheralAndroid.h"
+#include "simpleble/Peripheral.h"
+
+#include <types/android/bluetooth/BluetoothDevice.h>
+#include <types/android/bluetooth/le/ScanResult.h>
+#include <android/log.h>
+#include <fmt/core.h>
+#include <jni.h>
+#include <thread>
+
+using namespace SimpleBLE;
+
+bool AdapterAndroid::bluetooth_enabled() { return backend_->bluetooth_enabled(); }
+
+AdapterAndroid::AdapterAndroid(std::shared_ptr<BackendAndroid> backend) : backend_(backend) {
+    _btScanCallback.set_callback_onScanResult([this](Android::ScanResult scan_result) {
+        std::string address = scan_result.getDevice().getAddress();
+
+        if (this->peripherals_.count(address) == 0) {
+            // If the incoming peripheral has never been seen before, create and save a reference to it.
+            auto base_peripheral = std::make_shared<PeripheralAndroid>(scan_result.getDevice());
+            this->peripherals_.insert(std::make_pair(address, base_peripheral));
+        }
+
+        // Update the received advertising data.
+        auto base_peripheral = this->peripherals_.at(address);
+        base_peripheral->update_advertising_data(scan_result);
+
+        // Convert the base object into an external-facing Peripheral object
+        Peripheral peripheral = Factory::build(base_peripheral);
+
+        // Check if the device has been seen before, to forward the correct call to the user.
+        if (this->seen_peripherals_.count(address) == 0) {
+            // Store it in our table of seen peripherals
+            this->seen_peripherals_.insert(std::make_pair(address, base_peripheral));
+            SAFE_CALLBACK_CALL(this->_callback_on_scan_found, peripheral);
+        } else {
+            SAFE_CALLBACK_CALL(this->_callback_on_scan_updated, peripheral);
+        }
+    });
+}
+
+AdapterAndroid::~AdapterAndroid() {}
+
+void* AdapterAndroid::underlying() const { return nullptr; }
+
+std::string AdapterAndroid::identifier() { return _btAdapter.getName(); }
+
+BluetoothAddress AdapterAndroid::address() { return BluetoothAddress(_btAdapter.getAddress()); }
+
+void AdapterAndroid::power_on() {
+    // NOTE: This feature was deprecated in API level 33.
+    // Despite us targeting API level 31, we'll play nicely and not call this method.
+    // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#enable()
+}
+
+void AdapterAndroid::power_off() {
+    // NOTE: This feature was deprecated in API level 33.
+    // Despite us targeting API level 31, we'll play nicely and not call this method.
+    // https://developer.android.com/reference/android/bluetooth/BluetoothAdapter#disable()
+}
+
+bool AdapterAndroid::is_powered() { return _btAdapter.isEnabled(); }
+
+void AdapterAndroid::scan_start() {
+    seen_peripherals_.clear();
+    _btScanner.startScan(_btScanCallback);
+    scanning_ = true;
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_start);
+}
+
+void AdapterAndroid::scan_stop() {
+    _btScanner.stopScan(_btScanCallback);
+    scanning_ = false;
+    SAFE_CALLBACK_CALL(this->_callback_on_scan_stop);
+}
+
+void AdapterAndroid::scan_for(int timeout_ms) {
+    scan_start();
+    std::this_thread::sleep_for(std::chrono::milliseconds(timeout_ms));
+    scan_stop();
+}
+
+bool AdapterAndroid::scan_is_active() { return scanning_; }
+
+SharedPtrVector<PeripheralBase> AdapterAndroid::scan_get_results() { return Util::values(seen_peripherals_); }
+
+SharedPtrVector<PeripheralBase> AdapterAndroid::get_paired_peripherals() {
+    SharedPtrVector<PeripheralBase> peripherals;
+
+    auto paired_list = _btAdapter.getBondedDevices();
+    for (auto& device : paired_list) {
+        peripherals.push_back(std::make_shared<PeripheralAndroid>(device));
+    }
+
+    return peripherals;
+}

data/vendor/simpleble/simpleble/src/backends/android/AdapterAndroid.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+#include "../common/AdapterBase.h"
+
+#include <kvn_safe_callback.hpp>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "types/android/bluetooth/BluetoothAdapter.h"
+#include "types/android/bluetooth/le/BluetoothScanner.h"
+#include "bridge/ScanCallback.h"
+
+namespace SimpleBLE {
+
+class BackendAndroid;
+class PeripheralAndroid;
+class Peripheral;
+
+class AdapterAndroid : public AdapterBase {
+  public:
+    AdapterAndroid(std::shared_ptr<BackendAndroid> backend);
+    virtual ~AdapterAndroid();
+
+    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;
+
+    // NOTE: The following methods have been made public to allow the JNI layer to call them, but
+    // should not be called directly by the user.
+
+    void onScanResultCallback(JNIEnv* env, jobject thiz, jint callback_type, jobject result);
+    void onBatchScanResultsCallback(JNIEnv* env, jobject thiz, jobject results);
+    void onScanFailedCallback(JNIEnv* env, jobject thiz, jint error_code);
+
+  private:
+    std::shared_ptr<BackendAndroid> backend_;
+
+    Android::BluetoothAdapter _btAdapter = Android::BluetoothAdapter::getDefaultAdapter();
+    Android::BluetoothScanner _btScanner = _btAdapter.getBluetoothLeScanner();
+    Android::Bridge::ScanCallback _btScanCallback;
+
+    std::map<BluetoothAddress, std::shared_ptr<PeripheralAndroid>> peripherals_;
+    std::map<BluetoothAddress, std::shared_ptr<PeripheralAndroid>> seen_peripherals_;
+
+    std::atomic<bool> scanning_{false};
+};
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/BackendAndroid.cpp

@@ -0,0 +1,40 @@
+#include "BackendAndroid.h"
+#include "AdapterAndroid.h"
+#include "BuildVec.h"
+#include "CommonUtils.h"
+#include "types/android/bluetooth/BluetoothAdapter.h"
+#include "simplejni/Registry.hpp"
+
+#include <android/log.h>
+#include <fmt/core.h>
+
+#include <string>
+
+namespace SimpleBLE {
+
+std::shared_ptr<BackendAndroid> BACKEND_ANDROID() { return BackendAndroid::get(); }
+
+BackendAndroid::BackendAndroid(buildToken) {
+    SimpleJNI::Registrar::get().preload(SimpleJNI::VM::env());
+}
+
+std::string BackendAndroid::name() const noexcept { return "Android"; }
+
+SharedPtrVector<AdapterBase> BackendAndroid::get_adapters() {
+    SharedPtrVector<AdapterBase> adapters;
+    adapters.push_back(std::make_shared<AdapterAndroid>(shared_from_this()));
+
+    return adapters;
+}
+
+bool BackendAndroid::bluetooth_enabled() {
+    Android::BluetoothAdapter btAdapter = Android::BluetoothAdapter::getDefaultAdapter();
+
+    bool isEnabled = btAdapter.isEnabled();
+    int bluetoothState = btAdapter.getState();
+    __android_log_write(ANDROID_LOG_INFO, "SimpleBLE", fmt::format("Bluetooth state: {}", bluetoothState).c_str());
+
+    return isEnabled;  // bluetoothState == 12;
+}
+
+}  // namespace SimpleBLE

data/vendor/simpleble/simpleble/src/backends/android/BackendAndroid.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../common/BackendBase.h"
+#include "../common/BackendUtils.h"
+
+namespace SimpleBLE {
+
+class BackendAndroid : public BackendSingleton<BackendAndroid> {
+  public:
+    BackendAndroid(buildToken);
+    virtual ~BackendAndroid() = default;
+
+    virtual std::vector<std::shared_ptr<AdapterBase>> get_adapters() override;
+    virtual bool bluetooth_enabled() override;
+    virtual std::string name() const noexcept override;
+
+  private:
+};
+
+}  // namespace SimpleBLE