simpleble 0.0.1

data/vendor/simpleble/simpleble/test/src/test_bytearray.cpp

@@ -0,0 +1,246 @@
+#include <gtest/gtest.h>
+#include "kvn/kvn_bytearray.h"
+
+using namespace kvn;
+
+TEST(ByteArrayTest, DefaultConstructor) {
+    bytearray byteArray;
+    EXPECT_EQ(byteArray.size(), 0);
+}
+
+TEST(ByteArrayTest, VectorConstructor) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4};
+    bytearray byteArray(vec);
+    EXPECT_EQ(byteArray.size(), 4);
+    EXPECT_EQ(byteArray[0], 1);
+    EXPECT_EQ(byteArray[1], 2);
+    EXPECT_EQ(byteArray[2], 3);
+    EXPECT_EQ(byteArray[3], 4);
+}
+
+TEST(ByteArrayTest, PointerConstructor) {
+    uint8_t data[] = {1, 2, 3, 4};
+    bytearray byteArray(data, 4);
+    EXPECT_EQ(byteArray.size(), 4);
+    EXPECT_EQ(byteArray[0], 1);
+    EXPECT_EQ(byteArray[1], 2);
+    EXPECT_EQ(byteArray[2], 3);
+    EXPECT_EQ(byteArray[3], 4);
+}
+
+TEST(ByteArrayTest, StringConstructor) {
+    std::string str = "Hello";
+    bytearray byteArray(str);
+    EXPECT_EQ(byteArray.size(), 5);
+    EXPECT_EQ(byteArray[0], 'H');
+    EXPECT_EQ(byteArray[1], 'e');
+    EXPECT_EQ(byteArray[2], 'l');
+    EXPECT_EQ(byteArray[3], 'l');
+    EXPECT_EQ(byteArray[4], 'o');
+}
+
+TEST(ByteArrayTest, CharArrayConstructor) {
+    const char str[] = {'H', 'e', 'l', 'l', 'o'};
+    bytearray byteArray(str, 5);
+    EXPECT_EQ(byteArray.size(), 5);
+    EXPECT_EQ(byteArray[0], 'H');
+    EXPECT_EQ(byteArray[1], 'e');
+    EXPECT_EQ(byteArray[2], 'l');
+    EXPECT_EQ(byteArray[3], 'l');
+    EXPECT_EQ(byteArray[4], 'o');
+}
+
+TEST(ByteArrayTest, CStringConstructor) {
+    const char* str = "Hello";
+    bytearray byteArray(str);
+    EXPECT_EQ(byteArray.size(), 5);
+    EXPECT_EQ(byteArray[0], 'H');
+    EXPECT_EQ(byteArray[1], 'e');
+    EXPECT_EQ(byteArray[2], 'l');
+    EXPECT_EQ(byteArray[3], 'l');
+    EXPECT_EQ(byteArray[4], 'o');
+}
+
+TEST(ByteArrayTest, FromHexValid) {
+    bytearray byteArray = bytearray::fromHex("48656c6C6f");
+    EXPECT_EQ(byteArray.size(), 5);
+    EXPECT_EQ(byteArray[0], 'H');
+    EXPECT_EQ(byteArray[1], 'e');
+    EXPECT_EQ(byteArray[2], 'l');
+    EXPECT_EQ(byteArray[3], 'l');
+    EXPECT_EQ(byteArray[4], 'o');
+}
+
+TEST(ByteArrayTest, FromHexValidWithPrefix) {
+    bytearray byteArray = bytearray::fromHex("0x48656c6C6f");
+    EXPECT_EQ(byteArray.size(), 5);
+    EXPECT_EQ(byteArray[0], 'H');
+    EXPECT_EQ(byteArray[1], 'e');
+    EXPECT_EQ(byteArray[2], 'l');
+    EXPECT_EQ(byteArray[3], 'l');
+    EXPECT_EQ(byteArray[4], 'o');
+}
+
+TEST(ByteArrayTest, FromHexInvalid) {
+    EXPECT_THROW(bytearray::fromHex("123"), std::length_error);
+    EXPECT_THROW(bytearray::fromHex("G123"), std::invalid_argument);
+}
+
+TEST(ByteArrayTest, ToHex) {
+    bytearray byteArray("Hello");
+    EXPECT_EQ(byteArray.toHex(), "48656c6c6f");
+    EXPECT_EQ(byteArray.toHex(true), "48 65 6c 6c 6f ");
+}
+
+TEST(ByteArrayTest, StingConversion) {
+    bytearray byteArray = bytearray::fromHex("48656c6C6f");
+    std::string str = static_cast<std::string>(byteArray);
+    EXPECT_EQ(str, "Hello");
+}
+
+TEST(ByteArrayTest, StreamOperator) {
+    bytearray byteArray("Hello");
+    std::ostringstream oss;
+    oss << byteArray;
+    EXPECT_EQ(oss.str(), "48 65 6c 6c 6f ");
+}
+
+TEST(ByteArrayTest, DefaultConstructor_Empty) {
+    bytearray byteArray;
+    EXPECT_TRUE(byteArray.empty());
+}
+
+TEST(ByteArrayTest, PushBackIncreasesSize) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    EXPECT_EQ(1, byteArray.size());
+    byteArray.push_back(0x02);
+    EXPECT_EQ(2, byteArray.size());
+}
+
+TEST(ByteArrayTest, ClearEmptiesArray) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    byteArray.push_back(0x02);
+    byteArray.clear();
+    EXPECT_TRUE(byteArray.empty());
+}
+
+TEST(ByteArrayTest, IndexOperatorAccessesCorrectElement) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    byteArray.push_back(0x02);
+    EXPECT_EQ(0x01, byteArray[0]);
+    EXPECT_EQ(0x02, byteArray[1]);
+}
+
+TEST(ByteArrayTest, DataPointerIsValid) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    byteArray.push_back(0x02);
+    const uint8_t* data_ptr = byteArray.data();
+    ASSERT_NE(nullptr, data_ptr);
+    EXPECT_EQ(0x01, data_ptr[0]);
+    EXPECT_EQ(0x02, data_ptr[1]);
+}
+
+TEST(ByteArrayTest, BeginEndIterators) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    byteArray.push_back(0x02);
+    auto it = byteArray.begin();
+    EXPECT_EQ(0x01, *it);
+    ++it;
+    EXPECT_EQ(0x02, *it);
+    ++it;
+    EXPECT_EQ(byteArray.end(), it);
+}
+
+TEST(ByteArrayTest, ConstIndexOperatorAccessesCorrectElement) {
+    bytearray byteArray;
+    byteArray.push_back(0x01);
+    byteArray.push_back(0x02);
+    const bytearray constByteArray = byteArray;
+    EXPECT_EQ(0x01, constByteArray[0]);
+    EXPECT_EQ(0x02, constByteArray[1]);
+}
+
+TEST(ByteArrayTest, SliceValidRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+    bytearray slicedArray = byteArray.slice(1, 3);
+
+    ASSERT_EQ(slicedArray.size(), 2);
+    EXPECT_EQ(slicedArray[0], 0x02);
+    EXPECT_EQ(slicedArray[1], 0x03);
+}
+
+TEST(ByteArrayTest, SliceFullRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+    bytearray slicedArray = byteArray.slice(0, byteArray.size());
+
+    ASSERT_EQ(slicedArray.size(), byteArray.size());
+    EXPECT_EQ(slicedArray[0], 0x01);
+    EXPECT_EQ(slicedArray[4], 0x05);
+}
+
+TEST(ByteArrayTest, SliceSingleElement) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+    bytearray slicedArray = byteArray.slice(2, 3);
+
+    ASSERT_EQ(slicedArray.size(), 1);
+    EXPECT_EQ(slicedArray[0], 0x03);
+}
+
+TEST(ByteArrayTest, SliceOutOfRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+
+    EXPECT_THROW(byteArray.slice(1, 6), std::out_of_range);
+    EXPECT_THROW(byteArray.slice(6, 7), std::out_of_range);
+}
+
+TEST(ByteArrayTest, SliceInvalidRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+
+    EXPECT_THROW(byteArray.slice(3, 2), std::out_of_range);
+}
+
+TEST(ByteArrayTest, SliceFromIndexToEnd) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+    bytearray slicedArray = byteArray.slice_from(2);
+
+    ASSERT_EQ(slicedArray.size(), 3);
+    EXPECT_EQ(slicedArray[0], 0x03);
+    EXPECT_EQ(slicedArray[1], 0x04);
+    EXPECT_EQ(slicedArray[2], 0x05);
+}
+
+TEST(ByteArrayTest, SliceFromBeginningToIndex) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+    bytearray slicedArray = byteArray.slice_to(3);
+
+    ASSERT_EQ(slicedArray.size(), 3);
+    EXPECT_EQ(slicedArray[0], 0x01);
+    EXPECT_EQ(slicedArray[1], 0x02);
+    EXPECT_EQ(slicedArray[2], 0x03);
+}
+
+TEST(ByteArrayTest, SliceFromIndexToEndOutOfRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+
+    EXPECT_THROW(byteArray.slice_from(6), std::out_of_range);
+}
+
+TEST(ByteArrayTest, SliceFromBeginningToIndexOutOfRange) {
+    std::vector<uint8_t> vec = {1, 2, 3, 4, 5};
+    bytearray byteArray(vec);
+
+    EXPECT_THROW(byteArray.slice_to(6), std::out_of_range);
+}

data/vendor/simpleble/simpleble/test/src/test_utils.cpp

@@ -0,0 +1,24 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <iostream>
+
+#include <simpleble/Utils.h>
+
+TEST(Utils, GetOS) {
+    switch (SimpleBLE::get_operating_system()) {
+        case SimpleBLE::OperatingSystem::WINDOWS:
+            std::cout << "Windows" << std::endl;
+            break;
+        case SimpleBLE::OperatingSystem::LINUX:
+            std::cout << "Linux" << std::endl;
+            break;
+        case SimpleBLE::OperatingSystem::MACOS:
+            std::cout << "MacOS" << std::endl;
+            break;
+    }
+}
+
+TEST(Utils, GetSimpleBLEVersion) {
+    std::cout << "SimpleBLE version: " << SimpleBLE::get_simpleble_version() << std::endl;
+}

data/vendor/simpleble/simplebluez/include/simplebluez/Adapter.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Device.h>
+#include <simplebluez/interfaces/Adapter1.h>
+
+#include <kvn/kvn_safe_callback.hpp>
+
+#include <functional>
+
+namespace SimpleBluez {
+
+class Adapter : public SimpleDBus::Proxy {
+  public:
+    typedef Adapter1::DiscoveryFilter DiscoveryFilter;
+
+    Adapter(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Adapter();
+
+    std::string identifier() const;
+    std::string address();
+    bool discovering();
+    bool powered();
+
+    void discovery_filter(const DiscoveryFilter& filter);
+    void discovery_start();
+    void discovery_stop();
+
+    std::shared_ptr<Device> device_get(const std::string& path);
+    void device_remove(const std::string& path);
+    void device_remove(const std::shared_ptr<Device>& device);
+    std::vector<std::shared_ptr<Device>> device_paired_get();
+
+    void set_on_device_updated(std::function<void(std::shared_ptr<Device> device)> callback);
+    void clear_on_device_updated();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+
+    std::shared_ptr<Adapter1> adapter1();
+
+    kvn::safe_callback<void(std::shared_ptr<Device> device)> _on_device_updated;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Agent.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <simplebluez/interfaces/Agent1.h>
+#include <simpledbus/advanced/Proxy.h>
+
+namespace SimpleBluez {
+
+class Agent : public SimpleDBus::Proxy {
+  public:
+    typedef enum {
+        DisplayOnly,
+        DisplayYesNo,
+        KeyboardOnly,
+        NoInputNoOutput,
+        KeyboardDisplay,
+    } Capabilities;
+
+    Agent(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Agent() = default;
+
+    // ----- PROPERTIES -----
+    std::string capabilities() const;
+    void set_capabilities(Capabilities capabilities);
+
+    // ----- METHODS -----
+    void set_on_request_pin_code(std::function<std::string()> callback);
+    void clear_on_request_pin_code();
+
+    void set_on_display_pin_code(std::function<bool(const std::string&)> callback);
+    void clear_on_display_pin_code();
+
+    void set_on_request_passkey(std::function<uint32_t()> callback);
+    void clear_on_request_passkey();
+
+    void set_on_display_passkey(std::function<void(uint32_t, uint16_t)> callback);
+    void clear_on_display_passkey();
+
+    void set_on_request_confirmation(std::function<bool(uint32_t)> callback);
+    void clear_on_request_confirmation();
+
+    void set_on_request_authorization(std::function<bool()> callback);
+    void clear_on_request_authorization();
+
+    void set_on_authorize_service(std::function<bool(const std::string&)> callback);
+    void clear_on_authorize_service();
+
+  private:
+    std::shared_ptr<Agent1> agent1();
+    Capabilities _capabilities;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Bluez.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+#include <simpledbus/interfaces/ObjectManager.h>
+
+#include <simplebluez/BluezRoot.h>
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Agent.h>
+
+#include <vector>
+
+namespace SimpleBluez {
+
+class Bluez {
+  public:
+    Bluez();
+    virtual ~Bluez();
+
+    // Delete copy and move operations
+    Bluez(const Bluez&) = delete;
+    Bluez& operator=(const Bluez&) = delete;
+    Bluez(Bluez&&) = delete;
+    Bluez& operator=(Bluez&&) = delete;
+
+    void init();
+    void run_async();
+
+    std::vector<std::shared_ptr<Adapter>> get_adapters();
+    std::shared_ptr<Agent> get_agent();
+    void register_agent();
+
+  private:
+    std::shared_ptr<SimpleDBus::Connection> _conn;
+    std::shared_ptr<SimpleBluez::BluezRoot> _bluez_root;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/BluezOrg.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Agent.h>
+
+namespace SimpleBluez {
+
+class BluezOrg : public SimpleDBus::Proxy {
+  public:
+    BluezOrg(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~BluezOrg() = default;
+
+    std::vector<std::shared_ptr<Adapter>> get_adapters();
+    void register_agent(std::shared_ptr<Agent> agent);
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/BluezOrgBluez.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Agent.h>
+
+#include <simplebluez/interfaces/AgentManager1.h>
+
+namespace SimpleBluez {
+
+class BluezOrgBluez : public SimpleDBus::Proxy {
+  public:
+    BluezOrgBluez(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~BluezOrgBluez() = default;
+
+    void register_agent(std::shared_ptr<Agent> agent);
+
+    std::vector<std::shared_ptr<Adapter>> get_adapters();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<AgentManager1> agentmanager1();
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/BluezRoot.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+#include <simpledbus/interfaces/ObjectManager.h>
+
+#include <simplebluez/Adapter.h>
+#include <simplebluez/Agent.h>
+
+#include <vector>
+
+namespace SimpleBluez {
+
+class BluezRoot : public SimpleDBus::Proxy {
+  public:
+
+    BluezRoot(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~BluezRoot() = default;
+
+    void load_managed_objects();
+
+    std::vector<std::shared_ptr<Adapter>> get_adapters();
+    std::shared_ptr<Agent> get_agent();
+    void register_agent();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<SimpleDBus::ObjectManager> object_manager();
+
+    std::shared_ptr<Agent> _agent;
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Characteristic.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Descriptor.h>
+#include <simplebluez/Types.h>
+#include <simplebluez/interfaces/GattCharacteristic1.h>
+
+#include <cstdlib>
+
+namespace SimpleBluez {
+
+class Characteristic : public SimpleDBus::Proxy {
+  public:
+    Characteristic(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Characteristic();
+
+    std::shared_ptr<Descriptor> get_descriptor(const std::string& uuid);
+
+    // ----- METHODS -----
+    ByteArray read();
+    void write_request(ByteArray value);
+    void write_command(ByteArray value);
+    void start_notify();
+    void stop_notify();
+
+    // ----- PROPERTIES -----
+    std::vector<std::shared_ptr<Descriptor>> descriptors();
+
+    std::string uuid();
+    ByteArray value();
+    bool notifying();
+    std::vector<std::string> flags();
+    uint16_t mtu();
+
+    // ----- CALLBACKS -----
+    void set_on_value_changed(std::function<void(ByteArray new_value)> callback);
+    void clear_on_value_changed();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+
+    std::shared_ptr<GattCharacteristic1> gattcharacteristic1();
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Descriptor.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Types.h>
+#include <simplebluez/interfaces/GattDescriptor1.h>
+
+#include <cstdlib>
+
+namespace SimpleBluez {
+
+class Descriptor : public SimpleDBus::Proxy {
+  public:
+    Descriptor(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Descriptor();
+
+    // ----- METHODS -----
+    ByteArray read();
+    void write(ByteArray value);
+
+    // ----- PROPERTIES -----
+    std::string uuid();
+    ByteArray value();
+
+    // ----- CALLBACKS -----
+    void set_on_value_changed(std::function<void(ByteArray new_value)> callback);
+    void clear_on_value_changed();
+
+  private:
+    std::shared_ptr<GattDescriptor1> gattdescriptor1();
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Device.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <simpledbus/advanced/Proxy.h>
+
+#include <simplebluez/Characteristic.h>
+#include <simplebluez/Service.h>
+#include <simplebluez/interfaces/Battery1.h>
+#include <simplebluez/interfaces/Device1.h>
+
+namespace SimpleBluez {
+
+class Device : public SimpleDBus::Proxy {
+  public:
+    Device(std::shared_ptr<SimpleDBus::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Device();
+
+    std::shared_ptr<Service> get_service(const std::string& uuid);
+    std::shared_ptr<Characteristic> get_characteristic(const std::string& service_uuid,
+                                                       const std::string& characteristic_uuid);
+
+    // ----- PROPERTIES -----
+    std::vector<std::shared_ptr<Service>> services();
+    std::vector<std::string> uuids();
+
+    std::string address();
+    std::string address_type();
+    std::string name();
+    std::string alias();
+    int16_t rssi();
+    int16_t tx_power();
+
+    std::map<uint16_t, ByteArray> manufacturer_data();
+    std::map<std::string, ByteArray> service_data();
+
+    bool paired();
+    bool connected();
+    bool services_resolved();
+
+    // ----- METHODS -----
+    void connect();
+    void disconnect();
+    void pair();
+    void cancel_pairing();
+
+    // ----- CALLBACKS -----
+    void set_on_services_resolved(std::function<void()> callback);
+    void clear_on_services_resolved();
+    void set_on_disconnected(std::function<void()> callback);
+    void clear_on_disconnected();
+
+    // ----- BATTERY INTERFACE -----
+    bool has_battery_interface();
+    uint8_t battery_percentage();
+    void set_on_battery_percentage_changed(std::function<void(uint8_t new_value)> callback);
+    void clear_on_battery_percentage_changed();
+
+  private:
+    std::shared_ptr<SimpleDBus::Proxy> path_create(const std::string& path) override;
+
+    std::shared_ptr<Device1> device1();
+    std::shared_ptr<Battery1> battery1();
+};
+
+}  // namespace SimpleBluez

data/vendor/simpleble/simplebluez/include/simplebluez/Exceptions.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include <simpledbus/base/Exceptions.h>
+
+namespace SimpleBluez {
+
+namespace Exception {
+
+class BaseException : public std::exception {};
+
+class ServiceNotFoundException : public BaseException {
+  public:
+    ServiceNotFoundException(const std::string& service);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+class CharacteristicNotFoundException : public BaseException {
+  public:
+    CharacteristicNotFoundException(const std::string& characteristic);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+class DescriptorNotFoundException : public BaseException {
+  public:
+    DescriptorNotFoundException(const std::string& descriptor);
+    const char* what() const noexcept override;
+
+  private:
+    std::string _message;
+};
+
+}  // namespace Exception
+
+}  // namespace SimpleBluez