simplejsble 0.0.41 → 0.0.43

package/cpp/HybridAdapter.cpp

@@ -2,19 +2,104 @@
 
 namespace margelo::nitro::simplejsble {
 
-std::string HybridAdapter::greet(const std::string& name) { return "Hello, " + name + "!"; }
+bool HybridAdapter::bluetooth_enabled() {
+    return SimpleBLE::Adapter::bluetooth_enabled();
+}
 
 std::vector<std::shared_ptr<HybridAdapterSpec>> HybridAdapter::get_adapters() {
     std::vector<std::shared_ptr<HybridAdapterSpec>> result;
-
     for (auto& adapter : SimpleBLE::Adapter::get_adapters()) {
-        auto hybrid_adapter = std::make_shared<HybridAdapter>(adapter);
-        result.push_back(hybrid_adapter);
+        result.push_back(std::make_shared<HybridAdapter>(std::move(adapter)));
     }
+    return result;
+}
+
+bool HybridAdapter::initialized() {
+    return _adapter.initialized();
+}
+
+std::string HybridAdapter::identifier() {
+    return _adapter.identifier();
+}
+
+std::string HybridAdapter::address() {
+    return _adapter.address();
+}
+
+bool HybridAdapter::is_powered() {
+    return _adapter.is_powered();
+}
+
+void HybridAdapter::scan_start() {
+    _adapter.scan_start();
+}
+
+void HybridAdapter::scan_stop() {
+    _adapter.scan_stop();
+}
 
+void HybridAdapter::scan_for(double timeout_ms) {
+    _adapter.scan_for(static_cast<int>(timeout_ms));
+}
+
+bool HybridAdapter::scan_is_active() {
+    return _adapter.scan_is_active();
+}
+
+std::vector<std::shared_ptr<HybridPeripheralSpec>> HybridAdapter::scan_get_results() {
+    std::vector<std::shared_ptr<HybridPeripheralSpec>> result;
+    for (auto& peripheral : _adapter.scan_get_results()) {
+        result.push_back(std::make_shared<HybridPeripheral>(std::move(peripheral)));
+    }
     return result;
 }
 
-bool HybridAdapter::bluetooth_enabled() { return SimpleBLE::Adapter::bluetooth_enabled(); }
+void HybridAdapter::set_callback_on_scan_start(const std::function<void()>& callback) {
+    _onScanStart = callback;
+    _adapter.set_callback_on_scan_start([this]() {
+        if (_onScanStart) {
+            _onScanStart();
+        }
+    });
+}
+
+void HybridAdapter::set_callback_on_scan_stop(const std::function<void()>& callback) {
+    _onScanStop = callback;
+    _adapter.set_callback_on_scan_stop([this]() {
+        if (_onScanStop) {
+            _onScanStop();
+        }
+    });
+}
+
+void HybridAdapter::set_callback_on_scan_updated(
+    const std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)>& callback) {
+    _onScanUpdated = callback;
+    _adapter.set_callback_on_scan_updated([this](SimpleBLE::Peripheral peripheral) {
+        if (_onScanUpdated) {
+            auto hybridPeripheral = std::make_shared<HybridPeripheral>(std::move(peripheral));
+            _onScanUpdated(hybridPeripheral);
+        }
+    });
+}
+
+void HybridAdapter::set_callback_on_scan_found(
+    const std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)>& callback) {
+    _onScanFound = callback;
+    _adapter.set_callback_on_scan_found([this](SimpleBLE::Peripheral peripheral) {
+        if (_onScanFound) {
+            auto hybridPeripheral = std::make_shared<HybridPeripheral>(std::move(peripheral));
+            _onScanFound(hybridPeripheral);
+        }
+    });
+}
+
+std::vector<std::shared_ptr<HybridPeripheralSpec>> HybridAdapter::get_paired_peripherals() {
+    std::vector<std::shared_ptr<HybridPeripheralSpec>> result;
+    for (auto& peripheral : _adapter.get_paired_peripherals()) {
+        result.push_back(std::make_shared<HybridPeripheral>(std::move(peripheral)));
+    }
+    return result;
+}
 
-}  // namespace margelo::nitro::simplejsble
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridAdapter.hpp

@@ -1,22 +1,51 @@
 #pragma once
 
 #include "HybridAdapterSpec.hpp"
+#include "HybridPeripheral.hpp"
 #include <simpleble/SimpleBLE.h>
+#include <functional>
 #include <string>
+#include <vector>
+#include <memory>
 
 namespace margelo::nitro::simplejsble {
 
 class HybridAdapter : public HybridAdapterSpec {
   public:
     HybridAdapter() : HybridObject(TAG) {}
-    HybridAdapter(SimpleBLE::Adapter adapter) : HybridObject(TAG), _adapter(adapter) {}
+    explicit HybridAdapter(SimpleBLE::Adapter adapter)
+        : HybridObject(TAG), _adapter(std::move(adapter)) {}
 
-    std::string greet(const std::string& name) override;
-    std::vector<std::shared_ptr<HybridAdapterSpec>> get_adapters() override;
     bool bluetooth_enabled() override;
+    std::vector<std::shared_ptr<HybridAdapterSpec>> get_adapters() override;
+
+    bool initialized() override;
+    std::string identifier() override;
+    std::string address() override;
+
+    bool is_powered() override;
+
+    void scan_start() override;
+    void scan_stop() override;
+    void scan_for(double timeout_ms) override;
+    bool scan_is_active() override;
+    std::vector<std::shared_ptr<HybridPeripheralSpec>> scan_get_results() override;
+    void set_callback_on_scan_start(const std::function<void()>& callback) override;
+    void set_callback_on_scan_stop(const std::function<void()>& callback) override;
+    void set_callback_on_scan_updated(
+        const std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)>& callback) override;
+    void set_callback_on_scan_found(
+        const std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)>& callback) override;
+
+    std::vector<std::shared_ptr<HybridPeripheralSpec>> get_paired_peripherals() override;
 
   private:
     SimpleBLE::Adapter _adapter;
+
+    std::function<void()> _onScanStart;
+    std::function<void()> _onScanStop;
+    std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)> _onScanUpdated;
+    std::function<void(const std::shared_ptr<HybridPeripheralSpec>&)> _onScanFound;
 };
 
-}  // namespace margelo::nitro::simplejsble
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridPeripheral.cpp

@@ -0,0 +1,83 @@
+#include "HybridPeripheral.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+bool HybridPeripheral::initialized() {
+    return _peripheral.initialized();
+}
+
+std::string HybridPeripheral::identifier() {
+    return _peripheral.identifier();
+}
+
+std::string HybridPeripheral::address() {
+    return _peripheral.address();
+}
+
+BluetoothAddressType HybridPeripheral::address_type() {
+    auto type = _peripheral.address_type();
+    switch (type) {
+        case SimpleBLE::BluetoothAddressType::PUBLIC:
+            return BluetoothAddressType::PUBLIC;
+        case SimpleBLE::BluetoothAddressType::RANDOM:
+            return BluetoothAddressType::RANDOM;
+        default:
+            return BluetoothAddressType::UNSPECIFIED;
+    }
+}
+
+double HybridPeripheral::rssi() {
+    return static_cast<double>(_peripheral.rssi());
+}
+
+double HybridPeripheral::tx_power() {
+    return static_cast<double>(_peripheral.tx_power());
+}
+
+double HybridPeripheral::mtu() {
+    return static_cast<double>(_peripheral.mtu());
+}
+
+void HybridPeripheral::connect() {
+    _peripheral.connect();
+}
+
+void HybridPeripheral::disconnect() {
+    _peripheral.disconnect();
+}
+
+bool HybridPeripheral::is_connected() {
+    return _peripheral.is_connected();
+}
+
+bool HybridPeripheral::is_connectable() {
+    return _peripheral.is_connectable();
+}
+
+bool HybridPeripheral::is_paired() {
+    return _peripheral.is_paired();
+}
+
+void HybridPeripheral::unpair() {
+    _peripheral.unpair();
+}
+
+void HybridPeripheral::set_callback_on_connected(const std::function<void()>& callback) {
+    _onConnected = callback;
+    _peripheral.set_callback_on_connected([this]() {
+        if (_onConnected) {
+            _onConnected();
+        }
+    });
+}
+
+void HybridPeripheral::set_callback_on_disconnected(const std::function<void()>& callback) {
+    _onDisconnected = callback;
+    _peripheral.set_callback_on_disconnected([this]() {
+        if (_onDisconnected) {
+            _onDisconnected();
+        }
+    });
+}
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridPeripheral.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "HybridPeripheralSpec.hpp"
+#include "BluetoothAddressType.hpp"
+#include <simpleble/SimpleBLE.h>
+#include <functional>
+#include <string>
+
+namespace margelo::nitro::simplejsble {
+
+class HybridPeripheral : public HybridPeripheralSpec {
+  public:
+    HybridPeripheral() : HybridObject(TAG) {}
+    explicit HybridPeripheral(SimpleBLE::Peripheral peripheral)
+        : HybridObject(TAG), _peripheral(std::move(peripheral)) {}
+
+    bool initialized() override;
+    std::string identifier() override;
+    std::string address() override;
+    BluetoothAddressType address_type() override;
+    double rssi() override;
+    double tx_power() override;
+    double mtu() override;
+
+    void connect() override;
+    void disconnect() override;
+    bool is_connected() override;
+    bool is_connectable() override;
+    bool is_paired() override;
+    void unpair() override;
+
+    void set_callback_on_connected(const std::function<void()>& callback) override;
+    void set_callback_on_disconnected(const std::function<void()>& callback) override;
+
+    SimpleBLE::Peripheral& getInternal() { return _peripheral; }
+    const SimpleBLE::Peripheral& getInternal() const { return _peripheral; }
+
+  private:
+    SimpleBLE::Peripheral _peripheral;
+
+    std::function<void()> _onConnected;
+    std::function<void()> _onDisconnected;
+};
+
+}  // namespace margelo::nitro::simplejsble

package/lib/index.d.ts

@@ -1,3 +1,6 @@
 import type { Adapter } from "./specs/Adapter.nitro";
+import type { Peripheral, BluetoothAddressType } from "./specs/Peripheral.nitro";
+export type { Adapter, Peripheral, BluetoothAddressType };
 export declare const HybridAdapter: Adapter;
+export declare const HybridPeripheral: Peripheral;
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGrD,eAAO,MAAM,aAAa,SAAsD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEjF,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,CAAC;AAE1D,eAAO,MAAM,aAAa,SAAsD,CAAC;AACjF,eAAO,MAAM,gBAAgB,YAA4D,CAAC"}

package/lib/index.js

@@ -1,2 +1,3 @@
 import { NitroModules } from "react-native-nitro-modules";
 export const HybridAdapter = NitroModules.createHybridObject("Adapter");
+export const HybridPeripheral = NitroModules.createHybridObject("Peripheral");

package/lib/specs/Adapter.nitro.d.ts

@@ -1,10 +1,80 @@
 import { type HybridObject } from 'react-native-nitro-modules';
+import { type Peripheral } from './Peripheral.nitro';
+/**
+ * Wraps SimpleBLE::Adapter
+ */
 export interface Adapter extends HybridObject<{
     ios: 'c++';
     android: 'c++';
 }> {
-    greet(name: string): string;
-    get_adapters(): Adapter[];
+    /**
+     * Check if Bluetooth is enabled on the system.
+     */
     bluetooth_enabled(): boolean;
+    /**
+     * Retrieve a list of all available Bluetooth adapters.
+     */
+    get_adapters(): Adapter[];
+    /**
+     * Check if the adapter is initialized (has a valid internal handle).
+     */
+    initialized(): boolean;
+    /**
+     * Human-readable identifier for the adapter.
+     */
+    identifier(): string;
+    /**
+     * Bluetooth address of the adapter (MAC on Android/Linux, identifier on IOS/Macos).
+     */
+    address(): string;
+    /**
+     * Check if the adapter is currently powered on.
+     */
+    is_powered(): boolean;
+    /**
+     * Start scanning for peripherals.
+     */
+    scan_start(): void;
+    /**
+     * Stop scanning for peripherals.
+     */
+    scan_stop(): void;
+    /**
+     * Scan for peripherals for a specified duration (blocking).
+     * @param timeout_ms Duration in milliseconds.
+     */
+    scan_for(timeout_ms: number): void;
+    /**
+     * Check if a scan is currently in progress.
+     */
+    scan_is_active(): boolean;
+    /**
+     * Get the list of peripherals discovered during the last scan.
+     */
+    scan_get_results(): Peripheral[];
+    /**
+     * Set callback to be invoked when scanning starts.
+     */
+    set_callback_on_scan_start(callback: () => void): void;
+    /**
+     * Set callback to be invoked when scanning stops.
+     */
+    set_callback_on_scan_stop(callback: () => void): void;
+    /**
+     * Set callback to be invoked when a known peripheral's advertisement is updated.
+     */
+    set_callback_on_scan_updated(callback: (peripheral: Peripheral) => void): void;
+    /**
+     * Set callback to be invoked when a new peripheral is discovered.
+     */
+    set_callback_on_scan_found(callback: (peripheral: Peripheral) => void): void;
+    /**
+     * Retrieve a list of all paired peripherals.
+     * - Android: Supported (uses BluetoothAdapter.getBondedDevices())
+     * - iOS: Not supported - CoreBluetooth does not expose a direct API to list paired devices.
+     *   Pairing is handled at the OS level, and CoreBluetooth only exposes devices discovered via scanning
+     *   or those you've connected to.
+     */
+    get_paired_peripherals(): Peripheral[];
 }
 //# sourceMappingURL=Adapter.nitro.d.ts.map

package/lib/specs/Adapter.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Adapter.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Adapter.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,MAAM,WAAW,OAAQ,SAAQ,YAAY,CAAC;IAC5C,GAAG,EAAE,KAAK,CAAC;IACX,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACA,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,YAAY,IAAI,OAAO,EAAE,CAAA;IACzB,iBAAiB,IAAI,OAAO,CAAA;CAC7B"}
+{"version":3,"file":"Adapter.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Adapter.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;GAEG;AACH,MAAM,WAAW,OACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,iBAAiB,IAAI,OAAO,CAAA;IAE5B;;OAEG;IACH,YAAY,IAAI,OAAO,EAAE,CAAA;IAEzB;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,UAAU,IAAI,MAAM,CAAA;IAEpB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAA;IAEjB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAA;IAErB;;OAEG;IACH,UAAU,IAAI,IAAI,CAAA;IAElB;;OAEG;IACH,SAAS,IAAI,IAAI,CAAA;IAEjB;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IAElC;;OAEG;IACH,cAAc,IAAI,OAAO,CAAA;IAEzB;;OAEG;IACH,gBAAgB,IAAI,UAAU,EAAE,CAAA;IAEhC;;OAEG;IACH,0BAA0B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAEtD;;OAEG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAA;IAE9E;;OAEG;IACH,0BAA0B,CAAC,QAAQ,EAAE,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAA;IAE5E;;;;;;OAMG;IACH,sBAAsB,IAAI,UAAU,EAAE,CAAA;CACvC"}

package/lib/specs/Adapter.nitro.js

@@ -1 +1,2 @@
 import {} from 'react-native-nitro-modules';
+import {} from './Peripheral.nitro';

package/lib/specs/Peripheral.nitro.d.ts

@@ -0,0 +1,78 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+/**
+ * Bluetooth address type enumeration.
+ * Maps to SimpleBLE::BluetoothAddressType
+ */
+export type BluetoothAddressType = 'public' | 'random' | 'unspecified';
+/**
+ * Minimal wrapper for SimpleBLE::Peripheral.
+ * Exposes core properties and connection methods without
+ * introducing Service/ByteArray types.
+ */
+export interface Peripheral extends HybridObject<{
+    ios: 'c++';
+    android: 'c++';
+}> {
+    /**
+     * Check if the peripheral is initialized (has a valid internal handle).
+     */
+    initialized(): boolean;
+    /**
+     * Human- able identifier (device name or fallback).
+     */
+    identifier(): string;
+    /**
+     * Bluetooth address (MAC on Android, UUID on IOS/Macos).
+     */
+    address(): string;
+    /**
+     * Address type (public, random, or unspecified).
+     */
+    address_type(): BluetoothAddressType;
+    /**
+     * Received Signal Strength Indicator in dBm.
+     */
+    rssi(): number;
+    /**
+     * Advertised transmit power in dBm.
+     * Returns -32768 if not advertised.
+     */
+    tx_power(): number;
+    /**
+     * Maximum Transmission Unit size.
+     */
+    mtu(): number;
+    /**
+     * Initiate a connection to the peripheral.
+     */
+    connect(): void;
+    /**
+     * Disconnect from the peripheral.
+     */
+    disconnect(): void;
+    /**
+     * Check if the peripheral is currently connected.
+     */
+    is_connected(): boolean;
+    /**
+     * Check if the peripheral is connectable.
+     */
+    is_connectable(): boolean;
+    /**
+     * Check if the peripheral is paired with the system.
+     */
+    is_paired(): boolean;
+    /**
+     * Remove the pairing/bond with the peripheral.
+     */
+    unpair(): void;
+    /**
+     * Set callback to be invoked when a connection is established.
+     */
+    set_callback_on_connected(callback: () => void): void;
+    /**
+     * Set callback to be invoked when the peripheral disconnects.
+     */
+    set_callback_on_disconnected(callback: () => void): void;
+}
+//# sourceMappingURL=Peripheral.nitro.d.ts.map

package/lib/specs/Peripheral.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Peripheral.nitro.d.ts","sourceRoot":"","sources":["../../src/specs/Peripheral.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,aAAa,CAAA;AAEtE;;;;GAIG;AACH,MAAM,WAAW,UACf,SAAQ,YAAY,CAAC;IACnB,GAAG,EAAE,KAAK,CAAA;IACV,OAAO,EAAE,KAAK,CAAA;CACf,CAAC;IACF;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,UAAU,IAAI,MAAM,CAAA;IAEpB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAA;IAEjB;;OAEG;IACH,YAAY,IAAI,oBAAoB,CAAA;IAEpC;;OAEG;IACH,IAAI,IAAI,MAAM,CAAA;IAEd;;;OAGG;IACH,QAAQ,IAAI,MAAM,CAAA;IAElB;;OAEG;IACH,GAAG,IAAI,MAAM,CAAA;IAEb;;OAEG;IACH,OAAO,IAAI,IAAI,CAAA;IAEf;;OAEG;IACH,UAAU,IAAI,IAAI,CAAA;IAElB;;OAEG;IACH,YAAY,IAAI,OAAO,CAAA;IAEvB;;OAEG;IACH,cAAc,IAAI,OAAO,CAAA;IAEzB;;OAEG;IACH,SAAS,IAAI,OAAO,CAAA;IAEpB;;OAEG;IACH,MAAM,IAAI,IAAI,CAAA;IAEd;;OAEG;IACH,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;IAErD;;OAEG;IACH,4BAA4B,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI,CAAA;CACzD"}

package/lib/specs/Peripheral.nitro.js

@@ -0,0 +1 @@
+import {} from 'react-native-nitro-modules';

package/nitro.json

@@ -15,6 +15,9 @@
   "autolinking": {
     "Adapter": {
       "cpp": "HybridAdapter"
+    },
+    "Peripheral": {
+      "cpp": "HybridPeripheral"
     }
   },
   "ignorePaths": [

package/nitrogen/generated/android/NitroSimplejsble+autolinking.cmake

@@ -34,6 +34,7 @@ target_sources(
   ../nitrogen/generated/android/NitroSimplejsbleOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridAdapterSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridPeripheralSpec.cpp
   # Android-specific Nitrogen C++ sources
   
 )

package/nitrogen/generated/android/NitroSimplejsbleOnLoad.cpp

@@ -16,6 +16,7 @@
 #include <NitroModules/HybridObjectRegistry.hpp>
 
 #include "HybridAdapter.hpp"
+#include "HybridPeripheral.hpp"
 
 namespace margelo::nitro::simplejsble {
 
@@ -38,6 +39,15 @@ int initialize(JavaVM* vm) {
         return std::make_shared<HybridAdapter>();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "Peripheral",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridPeripheral>,
+                      "The HybridObject \"HybridPeripheral\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridPeripheral>();
+      }
+    );
   });
 }
 

package/nitrogen/generated/ios/NitroSimplejsbleAutolinking.mm

@@ -11,6 +11,7 @@
 #import <type_traits>
 
 #include "HybridAdapter.hpp"
+#include "HybridPeripheral.hpp"
 
 @interface NitroSimplejsbleAutolinking : NSObject
 @end
@@ -30,6 +31,15 @@
       return std::make_shared<HybridAdapter>();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Peripheral",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPeripheral>,
+                    "The HybridObject \"HybridPeripheral\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPeripheral>();
+    }
+  );
 }
 
 @end

package/nitrogen/generated/shared/c++/BluetoothAddressType.hpp

@@ -0,0 +1,80 @@
+///
+/// BluetoothAddressType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::simplejsble {
+
+  /**
+   * An enum which can be represented as a JavaScript union (BluetoothAddressType).
+   */
+  enum class BluetoothAddressType {
+    PUBLIC      SWIFT_NAME(public) = 0,
+    RANDOM      SWIFT_NAME(random) = 1,
+    UNSPECIFIED      SWIFT_NAME(unspecified) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::simplejsble
+
+namespace margelo::nitro {
+
+  // C++ BluetoothAddressType <> JS BluetoothAddressType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::simplejsble::BluetoothAddressType> final {
+    static inline margelo::nitro::simplejsble::BluetoothAddressType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("public"): return margelo::nitro::simplejsble::BluetoothAddressType::PUBLIC;
+        case hashString("random"): return margelo::nitro::simplejsble::BluetoothAddressType::RANDOM;
+        case hashString("unspecified"): return margelo::nitro::simplejsble::BluetoothAddressType::UNSPECIFIED;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum BluetoothAddressType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::simplejsble::BluetoothAddressType arg) {
+      switch (arg) {
+        case margelo::nitro::simplejsble::BluetoothAddressType::PUBLIC: return JSIConverter<std::string>::toJSI(runtime, "public");
+        case margelo::nitro::simplejsble::BluetoothAddressType::RANDOM: return JSIConverter<std::string>::toJSI(runtime, "random");
+        case margelo::nitro::simplejsble::BluetoothAddressType::UNSPECIFIED: return JSIConverter<std::string>::toJSI(runtime, "unspecified");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert BluetoothAddressType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("public"):
+        case hashString("random"):
+        case hashString("unspecified"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridAdapterSpec.cpp

@@ -14,9 +14,22 @@ namespace margelo::nitro::simplejsble {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
-      prototype.registerHybridMethod("greet", &HybridAdapterSpec::greet);
-      prototype.registerHybridMethod("get_adapters", &HybridAdapterSpec::get_adapters);
       prototype.registerHybridMethod("bluetooth_enabled", &HybridAdapterSpec::bluetooth_enabled);
+      prototype.registerHybridMethod("get_adapters", &HybridAdapterSpec::get_adapters);
+      prototype.registerHybridMethod("initialized", &HybridAdapterSpec::initialized);
+      prototype.registerHybridMethod("identifier", &HybridAdapterSpec::identifier);
+      prototype.registerHybridMethod("address", &HybridAdapterSpec::address);
+      prototype.registerHybridMethod("is_powered", &HybridAdapterSpec::is_powered);
+      prototype.registerHybridMethod("scan_start", &HybridAdapterSpec::scan_start);
+      prototype.registerHybridMethod("scan_stop", &HybridAdapterSpec::scan_stop);
+      prototype.registerHybridMethod("scan_for", &HybridAdapterSpec::scan_for);
+      prototype.registerHybridMethod("scan_is_active", &HybridAdapterSpec::scan_is_active);
+      prototype.registerHybridMethod("scan_get_results", &HybridAdapterSpec::scan_get_results);
+      prototype.registerHybridMethod("set_callback_on_scan_start", &HybridAdapterSpec::set_callback_on_scan_start);
+      prototype.registerHybridMethod("set_callback_on_scan_stop", &HybridAdapterSpec::set_callback_on_scan_stop);
+      prototype.registerHybridMethod("set_callback_on_scan_updated", &HybridAdapterSpec::set_callback_on_scan_updated);
+      prototype.registerHybridMethod("set_callback_on_scan_found", &HybridAdapterSpec::set_callback_on_scan_found);
+      prototype.registerHybridMethod("get_paired_peripherals", &HybridAdapterSpec::get_paired_peripherals);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridAdapterSpec.hpp

@@ -15,11 +15,15 @@
 
 // Forward declaration of `HybridAdapterSpec` to properly resolve imports.
 namespace margelo::nitro::simplejsble { class HybridAdapterSpec; }
+// Forward declaration of `HybridPeripheralSpec` to properly resolve imports.
+namespace margelo::nitro::simplejsble { class HybridPeripheralSpec; }
 
-#include <string>
 #include <memory>
 #include "HybridAdapterSpec.hpp"
 #include <vector>
+#include <string>
+#include "HybridPeripheralSpec.hpp"
+#include <functional>
 
 namespace margelo::nitro::simplejsble {
 
@@ -52,9 +56,22 @@ namespace margelo::nitro::simplejsble {
 
     public:
       // Methods
-      virtual std::string greet(const std::string& name) = 0;
-      virtual std::vector<std::shared_ptr<HybridAdapterSpec>> get_adapters() = 0;
       virtual bool bluetooth_enabled() = 0;
+      virtual std::vector<std::shared_ptr<HybridAdapterSpec>> get_adapters() = 0;
+      virtual bool initialized() = 0;
+      virtual std::string identifier() = 0;
+      virtual std::string address() = 0;
+      virtual bool is_powered() = 0;
+      virtual void scan_start() = 0;
+      virtual void scan_stop() = 0;
+      virtual void scan_for(double timeout_ms) = 0;
+      virtual bool scan_is_active() = 0;
+      virtual std::vector<std::shared_ptr<HybridPeripheralSpec>> scan_get_results() = 0;
+      virtual void set_callback_on_scan_start(const std::function<void()>& callback) = 0;
+      virtual void set_callback_on_scan_stop(const std::function<void()>& callback) = 0;
+      virtual void set_callback_on_scan_updated(const std::function<void(const std::shared_ptr<HybridPeripheralSpec>& /* peripheral */)>& callback) = 0;
+      virtual void set_callback_on_scan_found(const std::function<void(const std::shared_ptr<HybridPeripheralSpec>& /* peripheral */)>& callback) = 0;
+      virtual std::vector<std::shared_ptr<HybridPeripheralSpec>> get_paired_peripherals() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/HybridPeripheralSpec.cpp

@@ -0,0 +1,35 @@
+///
+/// HybridPeripheralSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridPeripheralSpec.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+  void HybridPeripheralSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("initialized", &HybridPeripheralSpec::initialized);
+      prototype.registerHybridMethod("identifier", &HybridPeripheralSpec::identifier);
+      prototype.registerHybridMethod("address", &HybridPeripheralSpec::address);
+      prototype.registerHybridMethod("address_type", &HybridPeripheralSpec::address_type);
+      prototype.registerHybridMethod("rssi", &HybridPeripheralSpec::rssi);
+      prototype.registerHybridMethod("tx_power", &HybridPeripheralSpec::tx_power);
+      prototype.registerHybridMethod("mtu", &HybridPeripheralSpec::mtu);
+      prototype.registerHybridMethod("connect", &HybridPeripheralSpec::connect);
+      prototype.registerHybridMethod("disconnect", &HybridPeripheralSpec::disconnect);
+      prototype.registerHybridMethod("is_connected", &HybridPeripheralSpec::is_connected);
+      prototype.registerHybridMethod("is_connectable", &HybridPeripheralSpec::is_connectable);
+      prototype.registerHybridMethod("is_paired", &HybridPeripheralSpec::is_paired);
+      prototype.registerHybridMethod("unpair", &HybridPeripheralSpec::unpair);
+      prototype.registerHybridMethod("set_callback_on_connected", &HybridPeripheralSpec::set_callback_on_connected);
+      prototype.registerHybridMethod("set_callback_on_disconnected", &HybridPeripheralSpec::set_callback_on_disconnected);
+    });
+  }
+
+} // namespace margelo::nitro::simplejsble

package/nitrogen/generated/shared/c++/HybridPeripheralSpec.hpp

@@ -0,0 +1,79 @@
+///
+/// HybridPeripheralSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `BluetoothAddressType` to properly resolve imports.
+namespace margelo::nitro::simplejsble { enum class BluetoothAddressType; }
+
+#include <string>
+#include "BluetoothAddressType.hpp"
+#include <functional>
+
+namespace margelo::nitro::simplejsble {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Peripheral`
+   * Inherit this class to create instances of `HybridPeripheralSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridPeripheral: public HybridPeripheralSpec {
+   * public:
+   *   HybridPeripheral(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridPeripheralSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridPeripheralSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridPeripheralSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual bool initialized() = 0;
+      virtual std::string identifier() = 0;
+      virtual std::string address() = 0;
+      virtual BluetoothAddressType address_type() = 0;
+      virtual double rssi() = 0;
+      virtual double tx_power() = 0;
+      virtual double mtu() = 0;
+      virtual void connect() = 0;
+      virtual void disconnect() = 0;
+      virtual bool is_connected() = 0;
+      virtual bool is_connectable() = 0;
+      virtual bool is_paired() = 0;
+      virtual void unpair() = 0;
+      virtual void set_callback_on_connected(const std::function<void()>& callback) = 0;
+      virtual void set_callback_on_disconnected(const std::function<void()>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Peripheral";
+  };
+
+} // namespace margelo::nitro::simplejsble

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simplejsble",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "React Native Bluetooth Low Energy library using SimpleBLE with Nitro Modules",
   "main": "lib/index",
   "module": "lib/index",
@@ -27,7 +27,7 @@
     "README.md"
   ],
   "scripts": {
-    "postinstall": "bash scripts/patch-nitro-modules.sh",
+    "postinstall": "bash scripts/patch-platforms-definition.sh",
     "prepack": "npm run build && npx nitrogen && bash scripts/prepare-package.sh",
     "typecheck": "tsc --noEmit",
     "build": "tsc",
@@ -64,9 +64,6 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "dependencies": {
-    "react-native-nitro-modules": ">=0.20.0"
-  },
   "devDependencies": {
     "@react-native/eslint-config": "0.82.0",
     "@types/react": "^19.1.03",
@@ -77,12 +74,12 @@
     "prettier": "^3.3.3",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "react-native-nitro-modules": "*",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-nitro-modules": ">=0.20.0"
   },
   "eslintConfig": {
     "root": true,

package/scripts/{patch-nitro-modules.sh → patch-platforms-definition.sh}

@@ -12,9 +12,7 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SCRIPT_NAME="[simplejsble]"
 
-# Possible locations for NitroModules.podspec
 PATHS=(
-  # When simplejsble is in node_modules (user's project)
   "$SCRIPT_DIR/../../react-native-nitro-modules/NitroModules.podspec"
 )
 
@@ -31,35 +29,27 @@ if [ -z "$PODSPEC_PATH" ]; then
   exit 0
 fi
 
-# Check if already patched
 if grep -q "s\.ios\.deployment_target" "$PODSPEC_PATH" || grep -q "s\.macos\.deployment_target" "$PODSPEC_PATH"; then
   echo "$SCRIPT_NAME NitroModules.podspec already using standard syntax"
   exit 0
 fi
 
-# Check if has the old syntax
 if ! grep -q "s\.platforms" "$PODSPEC_PATH"; then
   echo "$SCRIPT_NAME NitroModules.podspec format not recognized, skipping patch"
   exit 0
 fi
 
-# Create the replacement
 NEW_SYNTAX="s.ios.deployment_target = '15.8'
   s.macos.deployment_target = '13.0'
   s.tvos.deployment_target = '13.4'
   s.visionos.deployment_target = '1.0'"
 
-# Use sed to replace the s.platforms = {...} block
-# This handles multiline replacement
-# Note: We use hardcoded values because min_ios_version_supported is only available
-# in React Native's Podfile context, not when CocoaPods validates the podspec directly
 sed -i.bak '/s\.platforms.*=.*{/,/}/c\
   s.ios.deployment_target = '"'"'15.8'"'"'\
   s.macos.deployment_target = '"'"'13.0'"'"'\
   s.tvos.deployment_target = '"'"'13.4'"'"'\
   s.visionos.deployment_target = '"'"'1.0'"'"'' "$PODSPEC_PATH"
 
-# Remove backup file
 rm -f "${PODSPEC_PATH}.bak"
 
-echo "$SCRIPT_NAME ✓ Patched NitroModules.podspec deployment targets"
+echo "$SCRIPT_NAME ✓ Patched NitroModules.podspec platforms definition"

package/src/index.ts

@@ -1,5 +1,8 @@
 import { NitroModules } from "react-native-nitro-modules";
 import type { Adapter } from "./specs/Adapter.nitro";
+import type { Peripheral, BluetoothAddressType } from "./specs/Peripheral.nitro";
 
+export type { Adapter, Peripheral, BluetoothAddressType };
 
-export const HybridAdapter = NitroModules.createHybridObject<Adapter>("Adapter");
+export const HybridAdapter = NitroModules.createHybridObject<Adapter>("Adapter");
+export const HybridPeripheral = NitroModules.createHybridObject<Peripheral>("Peripheral");

package/src/specs/Adapter.nitro.ts

@@ -1,9 +1,96 @@
 import { type HybridObject } from 'react-native-nitro-modules'
-export interface Adapter extends HybridObject<{
-  ios: 'c++',
-  android: 'c++'
-}> {
-  greet(name: string): string
-  get_adapters(): Adapter[]
+import { type Peripheral } from './Peripheral.nitro'
+
+/**
+ * Wraps SimpleBLE::Adapter
+ */
+export interface Adapter
+  extends HybridObject<{
+    ios: 'c++'
+    android: 'c++'
+  }> {
+  /**
+   * Check if Bluetooth is enabled on the system.
+   */
   bluetooth_enabled(): boolean
-}
+
+  /**
+   * Retrieve a list of all available Bluetooth adapters.
+   */
+  get_adapters(): Adapter[]
+
+  /**
+   * Check if the adapter is initialized (has a valid internal handle).
+   */
+  initialized(): boolean
+
+  /**
+   * Human-readable identifier for the adapter.
+   */
+  identifier(): string
+
+  /**
+   * Bluetooth address of the adapter (MAC on Android/Linux, identifier on IOS/Macos).
+   */
+  address(): string
+
+  /**
+   * Check if the adapter is currently powered on.
+   */
+  is_powered(): boolean
+
+  /**
+   * Start scanning for peripherals.
+   */
+  scan_start(): void
+
+  /**
+   * Stop scanning for peripherals.
+   */
+  scan_stop(): void
+
+  /**
+   * Scan for peripherals for a specified duration (blocking).
+   * @param timeout_ms Duration in milliseconds.
+   */
+  scan_for(timeout_ms: number): void
+
+  /**
+   * Check if a scan is currently in progress.
+   */
+  scan_is_active(): boolean
+
+  /**
+   * Get the list of peripherals discovered during the last scan.
+   */
+  scan_get_results(): Peripheral[]
+
+  /**
+   * Set callback to be invoked when scanning starts.
+   */
+  set_callback_on_scan_start(callback: () => void): void
+
+  /**
+   * Set callback to be invoked when scanning stops.
+   */
+  set_callback_on_scan_stop(callback: () => void): void
+
+  /**
+   * Set callback to be invoked when a known peripheral's advertisement is updated.
+   */
+  set_callback_on_scan_updated(callback: (peripheral: Peripheral) => void): void
+
+  /**
+   * Set callback to be invoked when a new peripheral is discovered.
+   */
+  set_callback_on_scan_found(callback: (peripheral: Peripheral) => void): void
+
+  /**
+   * Retrieve a list of all paired peripherals.
+   * - Android: Supported (uses BluetoothAdapter.getBondedDevices())
+   * - iOS: Not supported - CoreBluetooth does not expose a direct API to list paired devices.
+   *   Pairing is handled at the OS level, and CoreBluetooth only exposes devices discovered via scanning
+   *   or those you've connected to.
+   */
+  get_paired_peripherals(): Peripheral[]
+}

package/src/specs/Peripheral.nitro.ts

@@ -0,0 +1,94 @@
+import { type HybridObject } from 'react-native-nitro-modules'
+
+/**
+ * Bluetooth address type enumeration.
+ * Maps to SimpleBLE::BluetoothAddressType
+ */
+export type BluetoothAddressType = 'public' | 'random' | 'unspecified'
+
+/**
+ * Minimal wrapper for SimpleBLE::Peripheral.
+ * Exposes core properties and connection methods without
+ * introducing Service/ByteArray types.
+ */
+export interface Peripheral
+  extends HybridObject<{
+    ios: 'c++'
+    android: 'c++'
+  }> {
+  /**
+   * Check if the peripheral is initialized (has a valid internal handle).
+   */
+  initialized(): boolean
+
+  /**
+   * Human- able identifier (device name or fallback).
+   */
+  identifier(): string
+
+  /**
+   * Bluetooth address (MAC on Android, UUID on IOS/Macos).
+   */
+  address(): string
+
+  /**
+   * Address type (public, random, or unspecified).
+   */
+  address_type(): BluetoothAddressType
+
+  /**
+   * Received Signal Strength Indicator in dBm.
+   */
+  rssi(): number
+
+  /**
+   * Advertised transmit power in dBm.
+   * Returns -32768 if not advertised.
+   */
+  tx_power(): number
+
+  /**
+   * Maximum Transmission Unit size.
+   */
+  mtu(): number
+
+  /**
+   * Initiate a connection to the peripheral.
+   */
+  connect(): void
+
+  /**
+   * Disconnect from the peripheral.
+   */
+  disconnect(): void
+
+  /**
+   * Check if the peripheral is currently connected.
+   */
+  is_connected(): boolean
+
+  /**
+   * Check if the peripheral is connectable.
+   */
+  is_connectable(): boolean
+
+  /**
+   * Check if the peripheral is paired with the system.
+   */
+  is_paired(): boolean
+
+  /**
+   * Remove the pairing/bond with the peripheral.
+   */
+  unpair(): void
+
+  /**
+   * Set callback to be invoked when a connection is established.
+   */
+  set_callback_on_connected(callback: () => void): void
+
+  /**
+   * Set callback to be invoked when the peripheral disconnects.
+   */
+  set_callback_on_disconnected(callback: () => void): void
+}