simpleble 0.0.1

data/vendor/simpleble/simplebluez/src/interfaces/Agent1.cpp

@@ -0,0 +1,143 @@
+#include "simplebluez/interfaces/Agent1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<Agent1> Agent1::registry{
+    "org.bluez.Agent1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<Agent1>(conn, path));
+    }
+    // clang-format on
+};
+
+Agent1::Agent1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.Agent1") {}
+
+void Agent1::message_handle(SimpleDBus::Message& msg) {
+    if (msg.get_type() == SimpleDBus::Message::Type::METHOD_CALL) {
+        // To minimize the amount of repeated code, create a method return object that will be
+        // used to send the reply.
+        SimpleDBus::Message reply = SimpleDBus::Message::create_method_return(msg);
+
+        if (msg.get_member() == "Release") {
+            // Nothing to do
+
+        } else if (msg.get_member() == "RequestPinCode") {
+            // std::cout << "Agent1::message_handle() RequestPinCode" << std::endl;
+
+            std::string pin_code = "abc123";
+            if (OnRequestPinCode) {
+                pin_code = OnRequestPinCode();
+            }
+
+            if (!pin_code.empty()) {
+                reply.append_argument(SimpleDBus::Holder::create_string(pin_code), DBUS_TYPE_STRING_AS_STRING);
+            } else {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "RequestPasskey") {
+            // std::cout << "Agent1::message_handle() RequestPasskey" << std::endl;
+
+            int32_t passkey = 123456;
+            if (OnRequestPasskey) {
+                passkey = OnRequestPasskey();
+            }
+
+            if (passkey >= 0 && passkey <= 999999) {
+                reply.append_argument(SimpleDBus::Holder::create_uint32(static_cast<uint32_t>(passkey)),
+                                      DBUS_TYPE_UINT32_AS_STRING);
+            } else {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "DisplayPinCode") {
+            // std::cout << "Agent1::message_handle() DisplayPinCode" << std::endl;
+            SimpleDBus::Holder arg_device = msg.extract();
+            SimpleDBus::Holder arg_pin_code = msg.extract();
+
+            bool success = true;
+            if (OnDisplayPinCode) {
+                success = OnDisplayPinCode(arg_pin_code.get_string());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "DisplayPasskey") {
+            // std::cout << "Agent1::message_handle() DisplayPasskey" << std::endl;
+            SimpleDBus::Holder arg_device = msg.extract();
+            SimpleDBus::Holder arg_passkey = msg.extract();
+            SimpleDBus::Holder arg_entered = msg.extract();
+
+            if (OnDisplayPasskey) {
+                OnDisplayPasskey(arg_passkey.get_uint32(), arg_entered.get_uint16());
+            }
+
+        } else if (msg.get_member() == "RequestConfirmation") {
+            // std::cout << "Agent1::message_handle() RequestConfirmation" << std::endl;
+            SimpleDBus::Holder arg_device = msg.extract();
+            SimpleDBus::Holder arg_passkey = msg.extract();
+
+            bool success = true;
+            if (OnRequestConfirmation) {
+                success = OnRequestConfirmation(arg_passkey.get_uint32());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "RequestAuthorization") {
+            // std::cout << "Agent1::message_handle() RequestAuthorization" << std::endl;
+            SimpleDBus::Holder arg_device = msg.extract();
+
+            bool success = true;
+            if (OnRequestAuthorization) {
+                success = OnRequestAuthorization();
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "AuthorizeService") {
+            // std::cout << "Agent1::message_handle() AuthorizeService" << std::endl;
+
+            SimpleDBus::Holder arg_device = msg.extract();
+            SimpleDBus::Holder arg_uuid = msg.extract();
+
+            bool success = true;
+            if (OnAuthorizeService) {
+                success = OnAuthorizeService(arg_uuid.get_string());
+            }
+
+            if (!success) {
+                reply_error(msg, "org.bluez.Error.Rejected", "User rejected the request");
+                return;
+            }
+
+        } else if (msg.get_member() == "Cancel") {
+            // std::cout << "Agent1::message_handle() Cancel" << std::endl;
+            // NOTE: Due to the blocking nature of this interface, the Cancel method won't
+            //       have any real impact on any of the callbacks, and thus will be ignored.
+
+        } else {
+            // std::cout << "Agent1::message_handle() Unknown method: " << msg.get_member() << std::endl;
+        }
+
+        _conn->send(reply);
+    }
+}
+
+void Agent1::reply_error(SimpleDBus::Message& msg, const std::string& error_name, const std::string& error_message) {
+    SimpleDBus::Message reply = SimpleDBus::Message::create_error(msg, error_name, error_message);
+    _conn->send(reply);
+}

data/vendor/simpleble/simplebluez/src/interfaces/AgentManager1.cpp

@@ -0,0 +1,34 @@
+#include <simplebluez/interfaces/AgentManager1.h>
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<AgentManager1> AgentManager1::registry{
+    "org.bluez.AgentManager1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<AgentManager1>(conn, path));
+    }
+    // clang-format on
+};
+
+AgentManager1::AgentManager1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.AgentManager1") {}
+
+void AgentManager1::RegisterAgent(std::string agent, std::string capability) {
+    auto msg = create_method_call("RegisterAgent");
+    msg.append_argument(SimpleDBus::Holder::create_object_path(agent), "o");
+    msg.append_argument(SimpleDBus::Holder::create_string(capability), "s");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void AgentManager1::RequestDefaultAgent(std::string agent) {
+    auto msg = create_method_call("RequestDefaultAgent");
+    msg.append_argument(SimpleDBus::Holder::create_object_path(agent), "o");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void AgentManager1::UnregisterAgent(std::string agent) {
+    auto msg = create_method_call("UnregisterAgent");
+    msg.append_argument(SimpleDBus::Holder::create_object_path(agent), "o");
+    _conn->send_with_reply_and_block(msg);
+}

data/vendor/simpleble/simplebluez/src/interfaces/Battery1.cpp

@@ -0,0 +1,30 @@
+#include "simplebluez/interfaces/Battery1.h"
+
+#include <iostream>
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<Battery1> Battery1::registry{
+    "org.bluez.Battery1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<Battery1>(conn, path));
+    }
+    // clang-format on
+};
+
+Battery1::Battery1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.Battery1") {}
+
+Battery1::~Battery1() { OnPercentageChanged.unload(); }
+
+uint8_t Battery1::Percentage() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Percentage"].get_byte();
+}
+
+void Battery1::property_changed(std::string option_name) {
+    if (option_name == "Percentage") {
+        OnPercentageChanged();
+    }
+}

data/vendor/simpleble/simplebluez/src/interfaces/Device1.cpp

@@ -0,0 +1,170 @@
+#include "simplebluez/interfaces/Device1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<Device1> Device1::registry{
+    "org.bluez.Device1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<Device1>(conn, path));
+    }
+    // clang-format on
+};
+
+Device1::Device1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.Device1") {}
+
+Device1::~Device1() {
+    OnDisconnected.unload();
+    OnServicesResolved.unload();
+}
+
+void Device1::Connect() {
+    auto msg = create_method_call("Connect");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::Disconnect() {
+    auto msg = create_method_call("Disconnect");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::Pair() {
+    auto msg = create_method_call("Pair");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void Device1::CancelPairing() {
+    auto msg = create_method_call("CancelPairing");
+    _conn->send_with_reply_and_block(msg);
+}
+
+int16_t Device1::RSSI() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["RSSI"].get_int16();
+}
+
+int16_t Device1::TxPower() { return _tx_power; }
+
+uint16_t Device1::Appearance() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Appearance"].get_uint16();
+}
+
+std::string Device1::Address() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Address"].get_string();
+}
+
+std::string Device1::AddressType() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["AddressType"].get_string();
+}
+
+std::string Device1::Alias() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Alias"].get_string();
+}
+
+std::string Device1::Name() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Name"].get_string();
+}
+
+std::vector<std::string> Device1::UUIDs() {
+    std::scoped_lock lock(_property_update_mutex);
+
+    std::vector<std::string> uuids;
+    for (SimpleDBus::Holder& uuid : _properties["UUIDs"].get_array()) {
+        uuids.push_back(uuid.get_string());
+    }
+
+    return uuids;
+}
+
+std::map<uint16_t, ByteArray> Device1::ManufacturerData(bool refresh) {
+    if (refresh) {
+        property_refresh("ManufacturerData");
+    }
+
+    // Use the locally cached version to avoid parsing the map multiple times.
+    std::scoped_lock lock(_property_update_mutex);
+    return _manufacturer_data;
+}
+
+std::map<std::string, ByteArray> Device1::ServiceData(bool refresh) {
+    if (refresh) {
+        property_refresh("ServiceData");
+    }
+
+    // Use the locally cached version to avoid parsing the map multiple times.
+    std::scoped_lock lock(_property_update_mutex);
+    return _service_data;
+}
+
+bool Device1::Paired(bool refresh) {
+    if (refresh) {
+        property_refresh("Paired");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Paired"].get_boolean();
+}
+
+bool Device1::Connected(bool refresh) {
+    if (refresh) {
+        property_refresh("Connected");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Connected"].get_boolean();
+}
+
+bool Device1::ServicesResolved(bool refresh) {
+    if (refresh) {
+        property_refresh("ServicesResolved");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["ServicesResolved"].get_boolean();
+}
+
+void Device1::property_changed(std::string option_name) {
+    if (option_name == "Connected") {
+        if (!Connected(false)) {
+            OnDisconnected();
+        }
+    } else if (option_name == "ServicesResolved") {
+        if (ServicesResolved(false)) {
+            OnServicesResolved();
+        }
+    } else if (option_name == "ManufacturerData") {
+        std::scoped_lock lock(_property_update_mutex);
+
+        _manufacturer_data.clear();
+        std::map<uint16_t, SimpleDBus::Holder> manuf_data = _properties["ManufacturerData"].get_dict_uint16();
+        // Loop through all received keys and store them.
+        for (auto& [key, value_array] : manuf_data) {
+            ByteArray raw_manuf_data;
+            for (auto& elem : value_array.get_array()) {
+                raw_manuf_data.push_back(elem.get_byte());
+            }
+            _manufacturer_data[key] = raw_manuf_data;
+        }
+    } else if (option_name == "ServiceData") {
+        std::scoped_lock lock(_property_update_mutex);
+
+        _service_data.clear();
+        std::map<std::string, SimpleDBus::Holder> service_data = _properties["ServiceData"].get_dict_string();
+        // Loop through all received keys and store them.
+        for (auto& [key, value_array] : service_data) {
+            ByteArray raw_service_data;
+            for (auto& elem : value_array.get_array()) {
+                raw_service_data.push_back(elem.get_byte());
+            }
+            _service_data[key] = raw_service_data;
+        }
+    } else if (option_name == "TxPower") {
+        _tx_power = _properties["TxPower"].get_int16();
+    }
+}

data/vendor/simpleble/simplebluez/src/interfaces/GattCharacteristic1.cpp

@@ -0,0 +1,118 @@
+#include "simplebluez/interfaces/GattCharacteristic1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<GattCharacteristic1> GattCharacteristic1::registry{
+    "org.bluez.GattCharacteristic1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<GattCharacteristic1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattCharacteristic1::GattCharacteristic1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.GattCharacteristic1") {}
+
+GattCharacteristic1::~GattCharacteristic1() { OnValueChanged.unload(); }
+
+void GattCharacteristic1::StartNotify() {
+    auto msg = create_method_call("StartNotify");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void GattCharacteristic1::StopNotify() {
+    auto msg = create_method_call("StopNotify");
+    _conn->send_with_reply_and_block(msg);
+}
+
+void GattCharacteristic1::WriteValue(const ByteArray& value, WriteType type) {
+    SimpleDBus::Holder value_data = SimpleDBus::Holder::create_array();
+    for (size_t i = 0; i < value.size(); i++) {
+        value_data.array_append(SimpleDBus::Holder::create_byte(value[i]));
+    }
+
+    SimpleDBus::Holder options = SimpleDBus::Holder::create_dict();
+    if (type == WriteType::REQUEST) {
+        options.dict_append(SimpleDBus::Holder::Type::STRING, "type", SimpleDBus::Holder::create_string("request"));
+    } else if (type == WriteType::COMMAND) {
+        options.dict_append(SimpleDBus::Holder::Type::STRING, "type", SimpleDBus::Holder::create_string("command"));
+    }
+
+    auto msg = create_method_call("WriteValue");
+    msg.append_argument(value_data, "ay");
+    msg.append_argument(options, "a{sv}");
+    _conn->send_with_reply_and_block(msg);
+}
+
+ByteArray GattCharacteristic1::ReadValue() {
+    auto msg = create_method_call("ReadValue");
+
+    // NOTE: ReadValue requires an additional argument, which currently is not supported
+    SimpleDBus::Holder options = SimpleDBus::Holder::create_dict();
+    msg.append_argument(options, "a{sv}");
+
+    SimpleDBus::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBus::Holder value = reply_msg.extract();
+    update_value(value);
+
+    return Value();
+}
+
+std::string GattCharacteristic1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+ByteArray GattCharacteristic1::Value() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _value;
+}
+
+std::vector<std::string> GattCharacteristic1::Flags() {
+    std::scoped_lock lock(_property_update_mutex);
+
+    std::vector<std::string> flags;
+    for (SimpleDBus::Holder& flag : _properties["Flags"].get_array()) {
+        flags.push_back(flag.get_string());
+    }
+
+    return flags;
+}
+
+uint16_t GattCharacteristic1::MTU() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["MTU"].get_uint16();
+}
+
+bool GattCharacteristic1::Notifying(bool refresh) {
+    if (refresh) {
+        property_refresh("Notifying");
+    }
+
+    std::scoped_lock lock(_property_update_mutex);
+    return _properties["Notifying"].get_boolean();
+}
+
+void GattCharacteristic1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    } else if (option_name == "Value") {
+        update_value(_properties["Value"]);
+        OnValueChanged();
+    }
+}
+
+void GattCharacteristic1::update_value(SimpleDBus::Holder& new_value) {
+    std::scoped_lock lock(_property_update_mutex);
+    auto value_array = new_value.get_array();
+
+    char* value_data = new char[value_array.size()];
+    for (std::size_t i = 0; i < value_array.size(); i++) {
+        value_data[i] = value_array[i].get_byte();
+    }
+    _value = ByteArray(value_data, value_array.size());
+    delete[] value_data;
+}

data/vendor/simpleble/simplebluez/src/interfaces/GattDescriptor1.cpp

@@ -0,0 +1,78 @@
+#include "simplebluez/interfaces/GattDescriptor1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<GattDescriptor1> GattDescriptor1::registry{
+    "org.bluez.GattDescriptor1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<GattDescriptor1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattDescriptor1::GattDescriptor1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.GattDescriptor1") {}
+
+GattDescriptor1::~GattDescriptor1() { OnValueChanged.unload(); }
+
+void GattDescriptor1::WriteValue(const ByteArray& value) {
+    SimpleDBus::Holder value_data = SimpleDBus::Holder::create_array();
+    for (size_t i = 0; i < value.size(); i++) {
+        value_data.array_append(SimpleDBus::Holder::create_byte(value[i]));
+    }
+
+    SimpleDBus::Holder options = SimpleDBus::Holder::create_dict();
+
+    auto msg = create_method_call("WriteValue");
+    msg.append_argument(value_data, "ay");
+    msg.append_argument(options, "a{sv}");
+    _conn->send_with_reply_and_block(msg);
+}
+
+ByteArray GattDescriptor1::ReadValue() {
+    auto msg = create_method_call("ReadValue");
+
+    // NOTE: ReadValue requires an additional argument, which currently is not supported
+    SimpleDBus::Holder options = SimpleDBus::Holder::create_dict();
+    msg.append_argument(options, "a{sv}");
+
+    SimpleDBus::Message reply_msg = _conn->send_with_reply_and_block(msg);
+    SimpleDBus::Holder value = reply_msg.extract();
+    update_value(value);
+
+    return Value();
+}
+
+std::string GattDescriptor1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+ByteArray GattDescriptor1::Value() {
+    std::scoped_lock lock(_property_update_mutex);
+    return _value;
+}
+
+void GattDescriptor1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    } else if (option_name == "Value") {
+        update_value(_properties["Value"]);
+        OnValueChanged();
+    }
+}
+
+void GattDescriptor1::update_value(SimpleDBus::Holder& new_value) {
+    std::scoped_lock lock(_property_update_mutex);
+    auto value_array = new_value.get_array();
+
+    char* value_data = new char[value_array.size()];
+    for (std::size_t i = 0; i < value_array.size(); i++) {
+        value_data[i] = value_array[i].get_byte();
+    }
+    _value = ByteArray(value_data, value_array.size());
+    delete[] value_data;
+}

data/vendor/simpleble/simplebluez/src/interfaces/GattService1.cpp

@@ -0,0 +1,28 @@
+#include "simplebluez/interfaces/GattService1.h"
+
+using namespace SimpleBluez;
+
+const SimpleDBus::AutoRegisterInterface<GattService1> GattService1::registry{
+    "org.bluez.GattService1",
+    // clang-format off
+    [](std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path, const SimpleDBus::Holder& options) -> std::shared_ptr<SimpleDBus::Interface> {
+        return std::static_pointer_cast<SimpleDBus::Interface>(std::make_shared<GattService1>(conn, path));
+    }
+    // clang-format on
+};
+
+GattService1::GattService1(std::shared_ptr<SimpleDBus::Connection> conn, std::string path)
+    : SimpleDBus::Interface(conn, "org.bluez", path, "org.bluez.GattService1") {}
+
+std::string GattService1::UUID() {
+    // As the UUID property doesn't change, we can cache it
+    std::scoped_lock lock(_property_update_mutex);
+    return _uuid;
+}
+
+void GattService1::property_changed(std::string option_name) {
+    if (option_name == "UUID") {
+        std::scoped_lock lock(_property_update_mutex);
+        _uuid = _properties["UUID"].get_string();
+    }
+}

data/vendor/simpleble/simplebluez/test/src/helpers/PythonRunner.cpp

@@ -0,0 +1,53 @@
+#include "PythonRunner.h"
+#include <Python.h>
+#include <mutex>
+
+#include <csignal>
+
+PythonRunner::PythonRunner(const std::string& script_path) : _script_path(script_path) {
+    // In order to get Python to properly find relative imports, the current location
+    // of the executable needs to be added to the Python path.
+    _import_path = std::filesystem::canonical("/proc/self/exe").parent_path();
+}
+
+PythonRunner::~PythonRunner() { uninit(); }
+
+void PythonRunner::init() {
+    _async_thread = new std::thread(&PythonRunner::_async_thread_function, this);
+    while (!_python_initialized) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+}
+
+void PythonRunner::uninit() {
+    if (Py_IsInitialized()) {
+        // This is a hack to get the Python interpreter to exit cleanly.
+        raise(SIGINT);
+    }
+    if (_async_thread) {
+        while (!_async_thread->joinable()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        }
+        _async_thread->join();
+        delete _async_thread;
+        _async_thread = nullptr;
+        _python_initialized = false;
+    }
+}
+
+void PythonRunner::_async_thread_function() {
+    Py_InitializeEx(0);
+
+    // Append the required import path to the Python path.
+    PyRun_SimpleString("import sys");
+    PyRun_SimpleString(("sys.path.append('" + _import_path.string() + "')").c_str());
+    _python_initialized = true;
+
+    // Run the script.
+    std::string full_script_path = (_import_path / _script_path).string();
+    FILE* fp = fopen(full_script_path.c_str(), "r");
+    PyRun_SimpleFile(fp, full_script_path.c_str());
+    fclose(fp);
+    Py_Finalize();
+}

data/vendor/simpleble/simplebluez/test/src/helpers/PythonRunner.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <atomic>
+#include <filesystem>
+#include <string>
+#include <thread>
+
+class PythonRunner {
+  public:
+    PythonRunner(const std::string& script_path);
+    ~PythonRunner();
+    PythonRunner(PythonRunner& other) = delete;    // Remove the copy constructor
+    void operator=(const PythonRunner&) = delete;  // Remove the copy assignment
+
+    void init();
+    void uninit();
+
+  private:
+    std::atomic_bool _python_initialized = {false};
+    std::filesystem::path _import_path;
+    std::string _script_path;
+    std::thread* _async_thread;
+    void _async_thread_function();
+};