simpleble 0.0.1

data/vendor/simpleble/examples/simplebluez/ble_nus/ble_nus.cpp

@@ -0,0 +1,138 @@
+#include <simplebluez/Bluez.h>
+#include <simplebluez/Exceptions.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(10));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+void print_byte_array(SimpleBluez::ByteArray& bytes) {
+    for (auto byte : bytes) {
+        std::cout << std::hex << std::setfill('0') << (uint32_t)((uint8_t)byte) << " ";
+        break;
+    }
+    std::cout << std::endl;
+}
+
+std::vector<std::shared_ptr<SimpleBluez::Device>> peripherals;
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "Available adapters:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        if (device->name() == "") {
+            return;
+        }
+
+        if (std::find(peripherals.begin(), peripherals.end(), device) == peripherals.end()) {
+            std::cout << "Found device: " << device->name() << " [" << device->address() << "]" << std::endl;
+            peripherals.push_back(device);
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (int i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i]->name() << " [" << peripherals[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select a device to connect to: ";
+    std::cin >> selection;
+
+    if (selection >= 0 && selection < peripherals.size()) {
+        auto peripheral = peripherals[selection];
+        std::cout << "Connecting to " << peripheral->name() << " [" << peripheral->address() << "]" << std::endl;
+
+        for (int attempt = 0; attempt < 3; attempt++) {
+            try {
+                peripheral->connect();
+            } catch (SimpleDBus::Exception::SendFailed& e) {
+                millisecond_delay(100);
+            }
+        }
+
+        if (!peripheral->connected() || !peripheral->services_resolved()) {
+            std::cout << "Failed to connect to " << peripheral->name() << " [" << peripheral->address() << "]"
+                      << std::endl;
+            return 1;
+        }
+
+        std::cout << "Successfully connected, testing NUS service." << std::endl;
+
+        auto characteristic_rx = peripheral->get_characteristic("6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+                                                                "6e400002-b5a3-f393-e0a9-e50e24dcca9e");
+
+        characteristic_rx->write_command("Hello World");
+
+        auto characteristic_tx = peripheral->get_characteristic("6e400001-b5a3-f393-e0a9-e50e24dcca9e",
+                                                                "6e400003-b5a3-f393-e0a9-e50e24dcca9e");
+
+        characteristic_tx->set_on_value_changed([&](SimpleBluez::ByteArray new_value) { print_byte_array(new_value); });
+
+        characteristic_tx->start_notify();
+        millisecond_delay(3000);
+        characteristic_tx->stop_notify();
+        millisecond_delay(1000);
+
+        peripheral->disconnect();
+
+        // Sleep for an additional second before returning.
+        // If there are any unexpected events, this example will help debug them.
+        millisecond_delay(1000);
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplebluez/connect/connect.cpp

@@ -0,0 +1,119 @@
+#include <simplebluez/Bluez.h>
+#include <simplebluez/Exceptions.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+std::vector<std::shared_ptr<SimpleBluez::Device>> peripherals;
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "Available adapters:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        if (std::find(peripherals.begin(), peripherals.end(), device) == peripherals.end()) {
+            std::cout << "Found device: " << device->name() << " [" << device->address() << "]" << std::endl;
+            peripherals.push_back(device);
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (int i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i]->name() << " [" << peripherals[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select a device to connect to: ";
+    std::cin >> selection;
+
+    if (selection >= 0 && selection < peripherals.size()) {
+        auto peripheral = peripherals[selection];
+        std::cout << "Connecting to " << peripheral->name() << " [" << peripheral->address() << "]" << std::endl;
+
+        for (int attempt = 0; attempt < 3; attempt++) {
+            try {
+                peripheral->connect();
+            } catch (SimpleDBus::Exception::SendFailed& e) {
+                millisecond_delay(100);
+            }
+        }
+
+        if (!peripheral->connected() || !peripheral->services_resolved()) {
+            std::cout << "Failed to connect to " << peripheral->name() << " [" << peripheral->address() << "]"
+                      << std::endl;
+            return 1;
+        }
+
+        std::cout << "Successfully connected, listing services." << std::endl;
+        for (auto service : peripheral->services()) {
+            std::cout << "Service: " << service->uuid() << std::endl;
+            for (auto characteristic : service->characteristics()) {
+                std::cout << "  Characteristic: " << characteristic->uuid() << std::endl;
+                for (auto descriptor : characteristic->descriptors()) {
+                    std::cout << "    Descriptor: " << descriptor->uuid() << std::endl;
+                }
+            }
+        }
+        peripheral->disconnect();
+
+        // Sleep for an additional second before returning.
+        // If there are any unexpected events, this example will help debug them.
+        millisecond_delay(1000);
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplebluez/list_adapters/list_adapters.cpp

@@ -0,0 +1,44 @@
+#include <simplebluez/Bluez.h>
+
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+int main(int argc, char* argv[]) {
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "The following adapters were found:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplebluez/list_paired/list_paired.cpp

@@ -0,0 +1,48 @@
+#include <simplebluez/Bluez.h>
+
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+int main(int argc, char* argv[]) {
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "The following adapters were found:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+        auto paired_list = adapters[i]->device_paired_get();
+        for (auto& device : paired_list) {
+            std::cout << "\t" << device->address() << " " << device->name() << std::endl;
+        }
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplebluez/notify/notify.cpp

@@ -0,0 +1,145 @@
+#include <simplebluez/Bluez.h>
+#include <simplebluez/Exceptions.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+void print_byte_array(SimpleBluez::ByteArray& bytes) {
+    for (auto byte : bytes) {
+        std::cout << std::hex << std::setfill('0') << (uint32_t)((uint8_t)byte) << " ";
+        break;
+    }
+    std::cout << std::endl;
+}
+
+std::vector<std::shared_ptr<SimpleBluez::Device>> peripherals;
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "Available adapters:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        if (std::find(peripherals.begin(), peripherals.end(), device) == peripherals.end()) {
+            std::cout << "Found device: " << device->name() << " [" << device->address() << "]" << std::endl;
+            peripherals.push_back(device);
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (int i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i]->name() << " [" << peripherals[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select a device to connect to: ";
+    std::cin >> selection;
+
+    if (selection >= 0 && selection < peripherals.size()) {
+        auto peripheral = peripherals[selection];
+        std::cout << "Connecting to " << peripheral->name() << " [" << peripheral->address() << "]" << std::endl;
+
+        for (int attempt = 0; attempt < 3; attempt++) {
+            try {
+                peripheral->connect();
+            } catch (SimpleDBus::Exception::SendFailed& e) {
+                millisecond_delay(100);
+            }
+        }
+
+        if (!peripheral->connected() || !peripheral->services_resolved()) {
+            std::cout << "Failed to connect to " << peripheral->name() << " [" << peripheral->address() << "]"
+                      << std::endl;
+            return 1;
+        }
+
+        // Store all services and characteristics in a vector.
+        std::vector<std::pair<std::shared_ptr<SimpleBluez::Service>, std::shared_ptr<SimpleBluez::Characteristic>>>
+            char_list;
+        for (auto service : peripheral->services()) {
+            for (auto characteristic : service->characteristics()) {
+                char_list.push_back(std::make_pair(service, characteristic));
+            }
+        }
+
+        std::cout << "The following services and characteristics were found:" << std::endl;
+        for (int i = 0; i < char_list.size(); i++) {
+            std::cout << "[" << i << "] " << char_list[i].first->uuid() << " " << char_list[i].second->uuid()
+                      << std::endl;
+        }
+
+        std::cout << "Please select a characteristic to read: ";
+        std::cin >> selection;
+
+        if (selection >= 0 && selection < char_list.size()) {
+            auto characteristic = char_list[selection].second;
+            characteristic->set_on_value_changed(
+                [&](SimpleBluez::ByteArray new_value) { print_byte_array(new_value); });
+
+            characteristic->start_notify();
+            millisecond_delay(5000);
+            characteristic->stop_notify();
+        }
+
+        peripheral->disconnect();
+
+        // Sleep for an additional second before returning.
+        // If there are any unexpected events, this example will help debug them.
+        millisecond_delay(1000);
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplebluez/pair/pair.cpp

@@ -0,0 +1,181 @@
+#include <simplebluez/Bluez.h>
+#include <simplebluez/Exceptions.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+std::vector<std::shared_ptr<SimpleBluez::Device>> peripherals;
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto agent = bluez.get_agent();
+    agent->set_capabilities(SimpleBluez::Agent::Capabilities::KeyboardDisplay);
+
+    // Configure all callback handlers for the agent, as part of this example.
+    agent->set_on_request_pin_code([&]() {
+        std::cout << "Agent::RequestPinCode" << std::endl;
+        return "123456";
+    });
+
+    agent->set_on_display_pin_code([&](const std::string& pin_code) {
+        std::cout << "Agent::DisplayPinCode: " << pin_code << std::endl;
+        return true;
+    });
+
+    agent->set_on_request_passkey([&]() {
+        std::cout << "Agent::RequestPasskey" << std::endl;
+        return 123456;
+    });
+
+    agent->set_on_display_passkey([&](uint32_t passkey, uint16_t entered) {
+        std::cout << "Agent::DisplayPasskey: " << passkey << " (" << entered << " entered)" << std::endl;
+    });
+
+    agent->set_on_request_confirmation([&](uint32_t passkey) {
+        std::cout << "Agent::RequestConfirmation: " << passkey << std::endl;
+        return true;
+    });
+
+    agent->set_on_request_authorization([&]() {
+        std::cout << "Agent::RequestAuthorization" << std::endl;
+        return true;
+    });
+
+    agent->set_on_authorize_service([&](const std::string& uuid) {
+        std::cout << "Agent::AuthorizeService: " << uuid << std::endl;
+        return true;
+    });
+
+    bluez.register_agent();
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "Available adapters:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        if (std::find(peripherals.begin(), peripherals.end(), device) == peripherals.end()) {
+            std::cout << "Found device: " << device->name() << " [" << device->address() << "]" << std::endl;
+            peripherals.push_back(device);
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (int i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i]->name() << " [" << peripherals[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select a device to pair to: ";
+    std::cin >> selection;
+
+    if (selection >= 0 && selection < peripherals.size()) {
+        auto peripheral = peripherals[selection];
+        std::cout << "Pairing to " << peripheral->name() << " [" << peripheral->address() << "]" << std::endl;
+
+        for (int attempt = 0; attempt < 3; attempt++) {
+            try {
+                peripheral->connect();
+
+                // At this point, the connection will be established,
+                // but services might not be resolved yet
+
+                for (int i = 0; i < 10; i++) {
+                    std::cout << "Waiting for services to resolve..." << std::endl;
+                    millisecond_delay(100);
+                    if (peripheral->services_resolved()) {
+                        break;
+                    }
+                }
+
+                if (peripheral->connected() && peripheral->services_resolved()) {
+                    break;
+                }
+
+            } catch (SimpleDBus::Exception::SendFailed& e) {
+                millisecond_delay(100);
+            }
+        }
+
+        if (!peripheral->connected() || !peripheral->services_resolved()) {
+            std::cout << "Failed to connect to " << peripheral->name() << " [" << peripheral->address() << "]"
+                      << std::endl;
+            return 1;
+        }
+
+        std::cout << "Successfully connected, listing services." << std::endl;
+        for (auto service : peripheral->services()) {
+            std::cout << "Service: " << service->uuid() << std::endl;
+            for (auto characteristic : service->characteristics()) {
+                std::cout << "  Characteristic: " << characteristic->uuid() << std::endl;
+                for (auto descriptor : characteristic->descriptors()) {
+                    std::cout << "    Descriptor: " << descriptor->uuid() << std::endl;
+                }
+            }
+        }
+
+        millisecond_delay(2000);
+        peripheral->disconnect();
+
+        if (peripheral->paired()) {
+            adapter->device_remove(peripheral->path());
+        }
+
+        // Sleep for an additional second before returning.
+        // If there are any unexpected events, this example will help debug them.
+        millisecond_delay(1000);
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}