simpleble 0.0.1

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Descriptor.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Descriptor Java class.
+ *
+ * This class provides basic JNI registration functionality for the Descriptor class.
+ */
+class Descriptor {
+  public:
+    /**
+     * @brief Default constructor.
+     */
+    Descriptor() = default;
+
+    /**
+     * @brief Constructor that takes a string UUID.
+     *
+     * @param uuid The UUID string for the descriptor.
+     */
+    explicit Descriptor(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid);
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const;
+
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _init_method;
+
+    /**
+     * @brief JNI descriptor defining the Descriptor class.
+     */
+    static const SimpleJNI::JNIDescriptor descriptor;
+
+    /**
+     * @brief Automatic registration of the descriptor with Registrar.
+     */
+    static const SimpleJNI::AutoRegister<Descriptor> registrar;
+
+    SimpleJNI::Object<SimpleJNI::ReleasableLocalRef> _obj;  ///< Wrapped Java object with ReleasableLocalRef lifetime.
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/PeripheralCallback.cpp

@@ -0,0 +1,41 @@
+#include "PeripheralCallback.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> PeripheralCallback::_cls;
+jmethodID PeripheralCallback::_method_on_connected = nullptr;
+jmethodID PeripheralCallback::_method_on_disconnected = nullptr;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor PeripheralCallback::descriptor{
+    "org/simplejavable/Peripheral$Callback",  // Java interface name (inner class notation)
+    &_cls,                                    // Where to store the jclass
+    {                                         // Methods to preload
+     {"onConnected", "()V", &_method_on_connected},
+     {"onDisconnected", "()V", &_method_on_disconnected}}};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<PeripheralCallback> PeripheralCallback::registrar{&descriptor};
+
+PeripheralCallback::PeripheralCallback(jobject obj) : _obj(obj, _cls.get()) {
+    if (!_cls.get()) {
+        throw std::runtime_error("PeripheralCallback JNI resources not preloaded");
+    }
+}
+
+void PeripheralCallback::on_connected() {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_connected);
+    }
+}
+
+void PeripheralCallback::on_disconnected() {
+    if (_obj.is_valid()) {
+        _obj.to_local().call_void_method(_method_on_disconnected);
+    }
+}
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/PeripheralCallback.h

@@ -0,0 +1,51 @@
+#pragma once
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Peripheral$Callback Java interface.
+ *
+ * This class encapsulates a jobject representing an instance of the Callback interface
+ * from the org.simplejavable.Peripheral class. It provides methods to invoke the interface's
+ * Java methods (onConnected, onDisconnected) via JNI. JNI resources are preloaded during
+ * JNI_OnLoad using the AutoRegister mechanism.
+ */
+class PeripheralCallback {
+  public:
+    PeripheralCallback() = default;
+
+    /**
+     * @brief Construct a Callback from a Java object.
+     *
+     * @param obj The Java object implementing the Callback interface.
+     * @throws std::runtime_error if JNI resources are not preloaded.
+     */
+    explicit PeripheralCallback(jobject obj);
+
+    /**
+     * @brief Invoke the onConnected method on the Java Callback object.
+     */
+    void on_connected();
+
+    /**
+     * @brief Invoke the onDisconnected method on the Java Callback object.
+     */
+    void on_disconnected();
+
+  private:
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _method_on_connected;
+    static jmethodID _method_on_disconnected;
+
+    static const SimpleJNI::JNIDescriptor descriptor;
+    static const SimpleJNI::AutoRegister<PeripheralCallback> registrar;
+
+    SimpleJNI::Object<SimpleJNI::WeakRef> _obj;
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Service.cpp

@@ -0,0 +1,33 @@
+#include "Service.h"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+// Define static JNI resources
+SimpleJNI::GlobalRef<jclass> Service::_cls;
+jmethodID Service::_init_method;
+
+// Define the JNI descriptor
+const SimpleJNI::JNIDescriptor Service::descriptor{
+    "org/simplejavable/Service",  // Java class name
+    &_cls,                        // Where to store the jclass
+    {
+        {"<init>", "(Ljava/lang/String;Ljava/util/List;)V", &_init_method}  // Constructor method
+    }};
+
+// Define the AutoRegister instance
+const SimpleJNI::AutoRegister<Service> Service::registrar{&descriptor};
+
+// Constructor implementation
+Service::Service(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid,
+                 const Java::Util::ArrayList<SimpleJNI::LocalRef>& characteristics) {
+    // Use call_new_object to create a new Java Service object
+    _obj = SimpleJNI::Object<SimpleJNI::ReleasableLocalRef>::call_new_object(_cls.get(), _init_method, uuid.get(),
+                                                                             characteristics.get());
+}
+
+// Implement the conversion operator as a member function
+Service::operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const { return _obj; }
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/org/simplejavable/Service.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "Characteristic.h"
+#include "java/lang/ArrayList.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+
+namespace Org {
+namespace SimpleJavaBLE {
+
+/**
+ * @brief C++ wrapper for the org.simplejavable.Service Java class.
+ *
+ * This class provides basic JNI registration functionality for the Service class.
+ */
+class Service {
+  public:
+    /**
+     * @brief Default constructor.
+     */
+    Service() = default;
+
+    /**
+     * @brief Constructor that creates a Service with the specified properties.
+     *
+     * @param uuid The UUID string for the service.
+     * @param characteristics List of characteristics associated with this service.
+     */
+    Service(const SimpleJNI::String<SimpleJNI::LocalRef>& uuid,
+            const Java::Util::ArrayList<SimpleJNI::LocalRef>& characteristics);
+
+    // Implicit conversion to SimpleJNI::Object
+    operator SimpleJNI::Object<SimpleJNI::ReleasableLocalRef, jobject>() const;
+
+  private:
+    // Static JNI resources, populated by Registrar during JNI_OnLoad
+    static SimpleJNI::GlobalRef<jclass> _cls;
+    static jmethodID _init_method;
+
+    /**
+     * @brief JNI descriptor defining the Service class.
+     */
+    static const SimpleJNI::JNIDescriptor descriptor;
+
+    /**
+     * @brief Automatic registration of the descriptor with Registrar.
+     */
+    static const SimpleJNI::AutoRegister<Service> registrar;
+
+    SimpleJNI::Object<SimpleJNI::ReleasableLocalRef> _obj;  ///< Wrapped Java object with ReleasableLocalRef lifetime.
+};
+
+}  // namespace SimpleJavaBLE
+}  // namespace Org

data/vendor/simpleble/simplejavable/cpp/src/simplejavable.cpp

@@ -0,0 +1,361 @@
+#include <jni.h>
+#include <string>
+
+#include "fmt/core.h"
+#include <simpleble/Logging.h>
+#include <simpleble/SimpleBLE.h>
+#include <map>
+#include <memory>
+#include <unordered_map>
+#include <vector>
+
+#include "core/AdapterWrapper.h"
+#include "core/Cache.h"
+#include "java/lang/ArrayList.h"
+#include "java/lang/HashMap.h"
+#include "java/lang/Integer.h"
+#include "java/lang/Iterator.h"
+#include "simplejni/Common.hpp"
+#include "simplejni/Registry.hpp"
+#include "org/simplejavable/AdapterCallback.h"
+#include "org/simplejavable/Characteristic.h"
+#include "org/simplejavable/DataCallback.h"
+#include "org/simplejavable/Descriptor.h"
+#include "org/simplejavable/PeripheralCallback.h"
+#include "org/simplejavable/Service.h"
+
+using namespace SimpleJNI;
+
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    SimpleJNI::Env env;
+    try {
+        SimpleJNI::Registrar::get().preload(env);
+    } catch (const std::exception& e) {
+        return JNI_ERR;
+    }
+
+    return JNI_VERSION_1_6;
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_org_simplejavable_Adapter_00024Companion_nativeIsBluetoothEnabled(JNIEnv* env, jobject thiz) {
+    return SimpleBLE::Adapter::bluetooth_enabled();
+}
+
+extern "C" JNIEXPORT jlongArray JNICALL Java_org_simplejavable_Adapter_nativeGetAdapters(JNIEnv* env, jclass clazz) {
+    std::vector<SimpleBLE::Adapter> adapters = SimpleBLE::Adapter::get_adapters();
+    if (adapters.empty()) return env->NewLongArray(0);
+
+    std::vector<int64_t> adapter_hashes;
+    for (SimpleBLE::Adapter& adapter : adapters) {
+        AdapterWrapper adapter_wrapper(adapter);
+        adapter_hashes.push_back(adapter_wrapper.getHash());
+        Cache::get().addAdapter(adapter_wrapper.getHash(), adapter_wrapper);
+    }
+
+    LongArray<ReleasableLocalRef> adapter_hashes_array(adapter_hashes);
+    return adapter_hashes_array.release();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Adapter_nativeAdapterRegister(JNIEnv* env, jobject thiz,
+                                                                                       jlong adapter_id,
+                                                                                       jobject callback) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    Org::SimpleJavaBLE::AdapterCallback adapter_callback(callback);
+    adapter_wrapper->setCallback(adapter_callback);
+}
+
+extern "C" JNIEXPORT jstring JNICALL Java_org_simplejavable_Adapter_nativeAdapterIdentifier(JNIEnv* env, jobject thiz,
+                                                                                            jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    return String<ReleasableLocalRef>(adapter_wrapper->get().identifier()).release();
+}
+
+extern "C" JNIEXPORT jstring JNICALL Java_org_simplejavable_Adapter_nativeAdapterAddress(JNIEnv* env, jobject thiz,
+                                                                                         jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    return String<ReleasableLocalRef>(adapter_wrapper->get().address()).release();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Adapter_nativeAdapterScanStart(JNIEnv* env, jobject thiz,
+                                                                                        jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    adapter_wrapper->get().scan_start();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Adapter_nativeAdapterScanStop(JNIEnv* env, jobject thiz,
+                                                                                       jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    adapter_wrapper->get().scan_stop();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Adapter_nativeAdapterScanFor(JNIEnv* env, jobject thiz,
+                                                                                      jlong adapter_id, jint timeout) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    adapter_wrapper->get().scan_for(timeout);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL Java_org_simplejavable_Adapter_nativeAdapterScanIsActive(JNIEnv* env,
+                                                                                               jobject thiz,
+                                                                                               jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    return adapter_wrapper->get().scan_is_active();
+}
+
+extern "C" JNIEXPORT jlongArray JNICALL Java_org_simplejavable_Adapter_nativeAdapterScanGetResults(JNIEnv* env,
+                                                                                                   jobject thiz,
+                                                                                                   jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    std::vector<SimpleBLE::Peripheral> peripherals = adapter_wrapper->get().scan_get_results();
+
+    std::vector<int64_t> peripheral_hashes;
+    for (SimpleBLE::Peripheral& peripheral : peripherals) {
+        PeripheralWrapper peripheral_wrapper(peripheral);
+        peripheral_hashes.push_back(peripheral_wrapper.getHash());
+        Cache::get().addPeripheral(adapter_wrapper->getHash(), peripheral_wrapper.getHash(), peripheral_wrapper);
+    }
+
+    LongArray<ReleasableLocalRef> peripheral_hashes_array(peripheral_hashes);
+    return peripheral_hashes_array.release();
+}
+
+extern "C" JNIEXPORT jlongArray JNICALL
+Java_org_simplejavable_Adapter_nativeAdapterGetPairedPeripherals(JNIEnv* env, jobject thiz, jlong adapter_id) {
+    AdapterWrapper* adapter_wrapper = Cache::get().getAdapter(adapter_id);
+    std::vector<SimpleBLE::Peripheral> peripherals = adapter_wrapper->get().get_paired_peripherals();
+
+    std::vector<int64_t> peripheral_hashes;
+    for (SimpleBLE::Peripheral& peripheral : peripherals) {
+        PeripheralWrapper peripheral_wrapper(peripheral);
+        peripheral_hashes.push_back(peripheral_wrapper.getHash());
+        Cache::get().addPeripheral(adapter_wrapper->getHash(), peripheral_wrapper.getHash(), peripheral_wrapper);
+    }
+
+    LongArray<ReleasableLocalRef> peripheral_hashes_array(peripheral_hashes);
+    return peripheral_hashes_array.release();
+}
+
+// PERIPHERAL
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralRegister(JNIEnv* env, jobject thiz,
+                                                                                             jlong adapter_id,
+                                                                                             jlong peripheral_id,
+                                                                                             jobject callback) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    Org::SimpleJavaBLE::PeripheralCallback peripheral_callback(callback);
+    peripheral_wrapper->setCallback(peripheral_callback);
+}
+
+extern "C" JNIEXPORT jstring JNICALL Java_org_simplejavable_Peripheral_nativePeripheralIdentifier(JNIEnv* env,
+                                                                                                  jobject thiz,
+                                                                                                  jlong adapter_id,
+                                                                                                  jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return String<ReleasableLocalRef>(peripheral_wrapper->get().identifier()).release();
+}
+
+extern "C" JNIEXPORT jstring JNICALL Java_org_simplejavable_Peripheral_nativePeripheralAddress(JNIEnv* env,
+                                                                                               jobject thiz,
+                                                                                               jlong adapter_id,
+                                                                                               jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return String<ReleasableLocalRef>(peripheral_wrapper->get().address()).release();
+}
+
+extern "C" JNIEXPORT jint JNICALL Java_org_simplejavable_Peripheral_nativePeripheralAddressType(JNIEnv* env,
+                                                                                                jobject thiz,
+                                                                                                jlong adapter_id,
+                                                                                                jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().address_type();
+}
+
+extern "C" JNIEXPORT jint JNICALL Java_org_simplejavable_Peripheral_nativePeripheralRssi(JNIEnv* env, jobject thiz,
+                                                                                         jlong adapter_id,
+                                                                                         jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().rssi();
+}
+
+extern "C" JNIEXPORT jint JNICALL Java_org_simplejavable_Peripheral_nativePeripheralTxPower(JNIEnv* env, jobject thiz,
+                                                                                            jlong adapter_id,
+                                                                                            jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().tx_power();
+}
+
+extern "C" JNIEXPORT jint JNICALL Java_org_simplejavable_Peripheral_nativePeripheralMtu(JNIEnv* env, jobject thiz,
+                                                                                        jlong adapter_id,
+                                                                                        jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().mtu();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralConnect(JNIEnv* env, jobject thiz,
+                                                                                            jlong adapter_id,
+                                                                                            jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    peripheral_wrapper->get().connect();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralDisconnect(JNIEnv* env,
+                                                                                               jobject thiz,
+                                                                                               jlong adapter_id,
+                                                                                               jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    peripheral_wrapper->get().disconnect();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralNotify(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jobject callback) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    Org::SimpleJavaBLE::DataCallback data_callback(callback);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    peripheral_wrapper->get().notify(service.str(), characteristic.str(),
+                                     [data_callback](SimpleBLE::ByteArray payload) {
+                                         Org::SimpleJavaBLE::DataCallback data_callback_local(data_callback);
+                                         ByteArray<ReleasableLocalRef> j_payload(payload);
+                                         data_callback_local.on_data_received(j_payload.release());
+                                     });
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralIndicate(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jobject callback) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    Org::SimpleJavaBLE::DataCallback data_callback(callback);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    peripheral_wrapper->get().indicate(service.str(), characteristic.str(),
+                                       [data_callback](SimpleBLE::ByteArray payload) {
+                                           Org::SimpleJavaBLE::DataCallback data_callback_local(data_callback);
+                                           ByteArray<ReleasableLocalRef> j_payload(payload);
+                                           data_callback_local.on_data_received(j_payload.release());
+                                       });
+}
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralUnsubscribe(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    peripheral_wrapper->get().unsubscribe(service.str(), characteristic.str());
+}
+
+extern "C" JNIEXPORT jboolean JNICALL Java_org_simplejavable_Peripheral_nativePeripheralIsConnected(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().is_connected();
+}
+
+extern "C" JNIEXPORT jboolean JNICALL Java_org_simplejavable_Peripheral_nativePeripheralIsConnectable(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().is_connectable();
+}
+
+extern "C" JNIEXPORT jboolean JNICALL Java_org_simplejavable_Peripheral_nativePeripheralIsPaired(JNIEnv* env,
+                                                                                                 jobject thiz,
+                                                                                                 jlong adapter_id,
+                                                                                                 jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    return peripheral_wrapper->get().is_paired();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralUnpair(JNIEnv* env, jobject thiz,
+                                                                                           jlong adapter_id,
+                                                                                           jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    peripheral_wrapper->get().unpair();
+}
+
+extern "C" JNIEXPORT jobject JNICALL Java_org_simplejavable_Peripheral_nativePeripheralServices(JNIEnv* env,
+                                                                                                jobject thiz,
+                                                                                                jlong adapter_id,
+                                                                                                jlong peripheral_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+
+    Java::Util::ArrayList<ReleasableLocalRef> services_list;
+    for (auto& service : peripheral_wrapper->get().services()) {
+        Java::Util::ArrayList<ReleasableLocalRef> characteristics_list;
+        for (auto& characteristic : service.characteristics()) {
+            Java::Util::ArrayList<ReleasableLocalRef> descriptors_list;
+            for (auto& descriptor : characteristic.descriptors()) {
+                Org::SimpleJavaBLE::Descriptor descriptor_obj(descriptor.uuid());
+                descriptors_list.add(descriptor_obj);
+            }
+            Org::SimpleJavaBLE::Characteristic characteristic_obj(
+                characteristic.uuid(), descriptors_list.to_local(), characteristic.can_read(),
+                characteristic.can_write_request(), characteristic.can_write_command(), characteristic.can_notify(),
+                characteristic.can_indicate());
+            characteristics_list.add(characteristic_obj);
+        }
+        Org::SimpleJavaBLE::Service service_obj(service.uuid(), characteristics_list.to_local());
+        services_list.add(service_obj);
+    }
+    return services_list.release();
+}
+
+extern "C" JNIEXPORT jobject JNICALL Java_org_simplejavable_Peripheral_nativePeripheralManufacturerData(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong instance_id) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, instance_id);
+    auto manufacturer_data = peripheral_wrapper->get().manufacturer_data();
+
+    Java::Util::HashMap<ReleasableLocalRef> hash_map;
+    for (const auto& [key, value] : manufacturer_data) {
+        hash_map.put<LocalRef, LocalRef>(Java::Util::Integer<LocalRef>(key), ByteArray<LocalRef>(value));
+    }
+    return hash_map.release();
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL Java_org_simplejavable_Peripheral_nativePeripheralRead(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    return ByteArray<ReleasableLocalRef>(peripheral_wrapper->get().read(service.str(), characteristic.str())).release();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralWriteRequest(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jbyteArray j_data) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    ByteArray<LocalRef> data(j_data);
+    peripheral_wrapper->get().write_request(service.str(), characteristic.str(), data.bytes());
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralWriteCommand(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jbyteArray j_data) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    ByteArray<LocalRef> data(j_data);
+    peripheral_wrapper->get().write_command(service.str(), characteristic.str(), data.bytes());
+}
+
+extern "C" JNIEXPORT jbyteArray JNICALL Java_org_simplejavable_Peripheral_nativePeripheralDescriptorRead(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jstring j_descriptor) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    String<LocalRef> descriptor(j_descriptor);
+    return ByteArray<ReleasableLocalRef>(
+               peripheral_wrapper->get().read(service.str(), characteristic.str(), descriptor.str()))
+        .release();
+}
+
+extern "C" JNIEXPORT void JNICALL Java_org_simplejavable_Peripheral_nativePeripheralDescriptorWrite(
+    JNIEnv* env, jobject thiz, jlong adapter_id, jlong peripheral_id, jstring j_service, jstring j_characteristic,
+    jstring j_descriptor, jbyteArray j_data) {
+    PeripheralWrapper* peripheral_wrapper = Cache::get().getPeripheral(adapter_id, peripheral_id);
+    String<LocalRef> service(j_service);
+    String<LocalRef> characteristic(j_characteristic);
+    String<LocalRef> descriptor(j_descriptor);
+    ByteArray<LocalRef> data(j_data);
+    peripheral_wrapper->get().write(service.str(), characteristic.str(), descriptor.str(), data.bytes());
+}

data/vendor/simpleble/simplepyble/src/main.cpp

@@ -0,0 +1,55 @@
+#include <pybind11/functional.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "simpleble/SimpleBLE.h"
+
+/**
+ * Useful links for documentation while I figure this one out.
+ * https://www.sphinx-doc.org/en/master/usage/extensions/autodoc.html
+ * https://www.sphinx-doc.org/en/master/usage/extensions/napoleon.html
+ * https://www.sphinx-doc.org/en/master/usage/extensions/autosummary.html
+ */
+
+namespace py = pybind11;
+
+void wrap_types(py::module& m);
+void wrap_descriptor(py::module& m);
+void wrap_characteristic(py::module& m);
+void wrap_service(py::module& m);
+void wrap_peripheral(py::module& m);
+void wrap_adapter(py::module& m);
+void wrap_config(py::module& m);
+
+PYBIND11_MODULE(_simplepyble, m) {
+    m.attr("__version__") = SIMPLEPYBLE_VERSION;
+
+    // m.doc() = R"pbdoc(
+    //     ====================
+    //     Python API Reference
+    //     ====================
+
+    //     .. currentmodule:: simplepyble
+    //     .. autosummary::
+    //        :toctree: _build
+
+    //         get_operating_system
+
+    // )pbdoc";
+
+    m.def("get_operating_system", &SimpleBLE::get_operating_system, R"pbdoc(
+        Returns the currently-running operating system.
+    )pbdoc");
+
+    m.def("get_simpleble_version", &SimpleBLE::get_simpleble_version, R"pbdoc(
+        Returns the version of SimpleBLE.
+    )pbdoc");
+
+    wrap_types(m);
+    wrap_descriptor(m);
+    wrap_characteristic(m);
+    wrap_service(m);
+    wrap_peripheral(m);
+    wrap_adapter(m);
+    wrap_config(m);
+}