simplejsble 0.0.4 → 0.0.6

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Agent.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <simplebluezlegacy/interfaces/Agent1.h>
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+namespace SimpleBluezLegacy {
+
+class Agent : public SimpleDBusLegacy::Proxy {
+  public:
+    typedef enum {
+        DisplayOnly,
+        DisplayYesNo,
+        KeyboardOnly,
+        NoInputNoOutput,
+        KeyboardDisplay,
+    } Capabilities;
+
+    Agent(std::shared_ptr<SimpleDBusLegacy::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 SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Bluez.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+#include <simpledbuslegacy/interfaces/ObjectManager.h>
+
+#include <simplebluezlegacy/BluezRoot.h>
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/Agent.h>
+
+#include <vector>
+
+namespace SimpleBluezLegacy {
+
+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<SimpleDBusLegacy::Connection> _conn;
+    std::shared_ptr<SimpleBluezLegacy::BluezRoot> _bluez_root;
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/BluezOrg.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/Agent.h>
+
+namespace SimpleBluezLegacy {
+
+class BluezOrg : public SimpleDBusLegacy::Proxy {
+  public:
+    BluezOrg(std::shared_ptr<SimpleDBusLegacy::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<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/BluezOrgBluez.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/Agent.h>
+
+#include <simplebluezlegacy/interfaces/AgentManager1.h>
+
+namespace SimpleBluezLegacy {
+
+class BluezOrgBluez : public SimpleDBusLegacy::Proxy {
+  public:
+    BluezOrgBluez(std::shared_ptr<SimpleDBusLegacy::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<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<AgentManager1> agentmanager1();
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/BluezRoot.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+#include <simpledbuslegacy/interfaces/ObjectManager.h>
+
+#include <simplebluezlegacy/Adapter.h>
+#include <simplebluezlegacy/Agent.h>
+
+#include <vector>
+
+namespace SimpleBluezLegacy {
+
+class BluezRoot : public SimpleDBusLegacy::Proxy {
+  public:
+
+    BluezRoot(std::shared_ptr<SimpleDBusLegacy::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<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<SimpleDBusLegacy::ObjectManager> object_manager();
+
+    std::shared_ptr<Agent> _agent;
+};
+
+}  // namespace SimpleBluez

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Characteristic.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Descriptor.h>
+#include <simplebluezlegacy/Types.h>
+#include <simplebluezlegacy/interfaces/GattCharacteristic1.h>
+
+#include <cstdlib>
+
+namespace SimpleBluezLegacy {
+
+class Characteristic : public SimpleDBusLegacy::Proxy {
+  public:
+    Characteristic(std::shared_ptr<SimpleDBusLegacy::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<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+
+    std::shared_ptr<GattCharacteristic1> gattcharacteristic1();
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Descriptor.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Types.h>
+#include <simplebluezlegacy/interfaces/GattDescriptor1.h>
+
+#include <cstdlib>
+
+namespace SimpleBluezLegacy {
+
+class Descriptor : public SimpleDBusLegacy::Proxy {
+  public:
+    Descriptor(std::shared_ptr<SimpleDBusLegacy::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 SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Device.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Characteristic.h>
+#include <simplebluezlegacy/Service.h>
+#include <simplebluezlegacy/interfaces/Battery1.h>
+#include <simplebluezlegacy/interfaces/Device1.h>
+
+namespace SimpleBluezLegacy {
+
+class Device : public SimpleDBusLegacy::Proxy {
+  public:
+    Device(std::shared_ptr<SimpleDBusLegacy::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<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+
+    std::shared_ptr<Device1> device1();
+    std::shared_ptr<Battery1> battery1();
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Exceptions.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include <simpledbuslegacy/base/Exceptions.h>
+
+namespace SimpleBluezLegacy {
+
+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 SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Service.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Proxy.h>
+
+#include <simplebluezlegacy/Characteristic.h>
+#include <simplebluezlegacy/interfaces/GattService1.h>
+
+namespace SimpleBluezLegacy {
+
+class Service : public SimpleDBusLegacy::Proxy {
+  public:
+    Service(std::shared_ptr<SimpleDBusLegacy::Connection> conn, const std::string& bus_name, const std::string& path);
+    virtual ~Service() = default;
+
+    std::shared_ptr<Characteristic> get_characteristic(const std::string& uuid);
+
+    // ----- PROPERTIES -----
+    std::vector<std::shared_ptr<Characteristic>> characteristics();
+
+    std::string uuid();
+
+  private:
+    std::shared_ptr<SimpleDBusLegacy::Proxy> path_create(const std::string& path) override;
+    std::shared_ptr<GattService1> gattservice1();
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/Types.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include "kvn/kvn_bytearray.h"
+
+namespace SimpleBluezLegacy {
+
+using ByteArray = kvn::bytearray;
+
+}

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/interfaces/Adapter1.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace SimpleBluezLegacy {
+
+class Adapter1 : public SimpleDBusLegacy::Interface {
+  public:
+    // ----- TYPES -----
+    struct DiscoveryFilter {
+        typedef enum { AUTO, BREDR, LE } TransportType;
+        std::vector<std::string> UUIDs = {};
+        std::optional<int16_t> RSSI;
+        std::optional<uint16_t> Pathloss;
+        TransportType Transport = TransportType::AUTO;
+        bool DuplicateData = true;
+        bool Discoverable = false;
+        std::string Pattern = "";
+    };
+
+    // ----- CONSTRUCTORS -----
+    Adapter1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path);
+    virtual ~Adapter1() = default;
+
+    // ----- METHODS -----
+    void RemoveDevice(std::string device_path);
+    void StartDiscovery();
+    void StopDiscovery();
+    void SetDiscoveryFilter(DiscoveryFilter filter);
+    SimpleDBusLegacy::Holder GetDiscoveryFilters();
+
+    // ----- PROPERTIES -----
+    bool Discovering(bool refresh = true);
+    bool Powered(bool refresh = true);
+    std::string Address();
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<Adapter1> registry;
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/interfaces/Agent1.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <cstdint>
+#include <string>
+
+namespace SimpleBluezLegacy {
+
+class Agent1 : public SimpleDBusLegacy::Interface {
+  public:
+    Agent1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path);
+    virtual ~Agent1() = default;
+
+    // ----- METHODS -----
+
+    // ----- PROPERTIES -----
+
+    // ----- CALLBACKS -----
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to get the passkey for an authentication.
+     *        The return value should be a string of 1-16 characters
+     *        length. The string can be alphanumeric.
+     *
+     * @note: Invalid values will cause a rejection of the request
+     *        be returned.
+     */
+    kvn::safe_callback<std::string()> OnRequestPinCode;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to display a pincode for an authentication.
+     *        Note that the PIN will always be a 6-digit number,
+     *        zero-padded to 6 digits.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(const std::string&)> OnDisplayPinCode;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to get the passkey for an authentication.
+     *        The return value should be a numeric value
+     *        between 0 and 999999.
+     *
+     * @note: Invalid values will cause a rejection of the request
+     *        be returned.
+     */
+    kvn::safe_callback<int32_t()> OnRequestPasskey;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to display a passkey for an authentication.
+     *        The entered parameter indicates the number of already
+     *        typed keys on the remote side.
+     */
+    kvn::safe_callback<void(uint32_t, uint16_t)> OnDisplayPasskey;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to confirm a passkey for an authentication.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(uint32_t)> OnRequestConfirmation;
+
+    /**
+     * @brief This method gets called to request the user to
+     *        authorize an incoming pairing attempt which
+     *        would in other circumstances trigger the just-works
+     *        model, or when the user plugged in a device that
+     *        implements cable pairing.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool()> OnRequestAuthorization;
+
+    /**
+     * @brief This method gets called when the service daemon
+     *        needs to authorize a connection/service request.
+     *
+     * @return false if the request should be rejected.
+     */
+    kvn::safe_callback<bool(const std::string&)> OnAuthorizeService;
+
+  protected:
+    void message_handle(SimpleDBusLegacy::Message& msg) override;
+
+    void reply_error(SimpleDBusLegacy::Message& msg, const std::string& error_name, const std::string& error_message);
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<Agent1> registry;
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/interfaces/AgentManager1.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include <string>
+
+namespace SimpleBluezLegacy {
+
+class AgentManager1 : public SimpleDBusLegacy::Interface {
+  public:
+    AgentManager1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path);
+    virtual ~AgentManager1() = default;
+
+    // ----- METHODS -----
+    void RegisterAgent(std::string agent, std::string capability);
+    void RequestDefaultAgent(std::string agent);
+    void UnregisterAgent(std::string agent);
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<AgentManager1> registry;
+};
+
+}  // namespace SimpleBluezLegacy

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/interfaces/Battery1.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <string>
+
+namespace SimpleBluezLegacy {
+
+class Battery1 : public SimpleDBusLegacy::Interface {
+  public:
+    Battery1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path);
+    virtual ~Battery1();
+
+    // ----- METHODS -----
+
+    // ----- PROPERTIES -----
+    uint8_t Percentage();
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnPercentageChanged;
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<Battery1> registry;
+};
+
+}  // namespace SimpleBluez

package/simpleble/src/backends/linux_legacy/include/simplebluezlegacy/interfaces/Device1.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <simpledbuslegacy/advanced/Interface.h>
+#include <simpledbuslegacy/advanced/InterfaceRegistry.h>
+
+#include "kvn/kvn_safe_callback.hpp"
+
+#include <string>
+
+#include "simplebluezlegacy/Types.h"
+
+namespace SimpleBluezLegacy {
+
+class Device1 : public SimpleDBusLegacy::Interface {
+  public:
+    Device1(std::shared_ptr<SimpleDBusLegacy::Connection> conn, std::string path);
+    virtual ~Device1();
+
+    // ----- METHODS -----
+    void Connect();
+    void Disconnect();
+    void Pair();
+    void CancelPairing();
+
+    // ----- PROPERTIES -----
+    int16_t RSSI();
+    int16_t TxPower();
+    uint16_t Appearance();  // On Bluez 5.53, this always returns 0.
+    std::string Address();
+    std::string AddressType();
+    std::string Alias();
+    std::string Name();
+    std::vector<std::string> UUIDs();
+    std::map<uint16_t, ByteArray> ManufacturerData(bool refresh = true);
+    std::map<std::string, ByteArray> ServiceData(bool refresh = true);
+    bool Paired(bool refresh = true);
+    bool Connected(bool refresh = true);
+    bool ServicesResolved(bool refresh = true);
+
+    // ----- CALLBACKS -----
+    kvn::safe_callback<void()> OnServicesResolved;
+    kvn::safe_callback<void()> OnDisconnected;
+
+  protected:
+    void property_changed(std::string option_name) override;
+
+    int16_t _rssi = INT16_MIN;
+    int16_t _tx_power = INT16_MIN;
+    std::string _name;
+    std::string _alias;
+    std::string _address;
+    std::string _address_type;
+    bool _connected;
+    bool _services_resolved;
+    std::map<uint16_t, ByteArray> _manufacturer_data;
+    std::map<std::string, ByteArray> _service_data;
+
+  private:
+    static const SimpleDBusLegacy::AutoRegisterInterface<Device1> registry;
+};
+
+}  // namespace SimpleBluezLegacy