simplejsble 0.0.30 → 0.0.32

package/NitroSimplejsble.podspec

@@ -11,116 +11,14 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   s.platforms    = {
-    :ios => min_ios_version_supported,
+    :ios => '13.4',
     :osx => '10.13'
   }
 
   s.source = { :path => "." }
 
-  # Build SimpleBLE from source only if XCFramework doesn't exist
-  # When installed from npm, the pre-built XCFramework is already included
-  s.prepare_command = <<-CMD
-    # Build iOS/macOS XCFramework if not present
-    if [ -d "ios/SimpleBLE.xcframework" ]; then
-      echo "SimpleBLE.xcframework already exists, skipping build"
-    else
-      echo "Building SimpleBLE for iOS and macOS..."
-      set -e
-      IOS_DIR="ios"
-      IOS_DEPLOYMENT_TARGET="${IOS_DEPLOYMENT_TARGET:-13.4}"
-      MACOS_DEPLOYMENT_TARGET="${MACOS_DEPLOYMENT_TARGET:-10.13}"
-
-      # Build for iOS platforms (iphoneos, iphonesimulator)
-      build_for_ios_platform() {
-          local PLATFORM=$1  # iphoneos or iphonesimulator
-          local ARCH=$2      # arm64 or x86_64
-
-          local BUILD_DIR="${IOS_DIR}/build_${PLATFORM}_${ARCH}"
-          local INSTALL_DIR="${IOS_DIR}/simpleble_${PLATFORM}_${ARCH}"
-
-          echo "Building SimpleBLE for ${PLATFORM} (${ARCH})..."
-
-          cmake -B "${BUILD_DIR}" -S "${IOS_DIR}" \
-              -DCMAKE_BUILD_TYPE=Release \
-              -DCMAKE_SYSTEM_NAME=iOS \
-              -DCMAKE_OSX_SYSROOT="${PLATFORM}" \
-              -DCMAKE_OSX_ARCHITECTURES="${ARCH}" \
-              -DCMAKE_OSX_DEPLOYMENT_TARGET="${IOS_DEPLOYMENT_TARGET}" \
-              -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
-              -DBUILD_SHARED_LIBS=OFF \
-              -DSIMPLEBLE_EXCLUDE_C=ON
-
-          cmake --build "${BUILD_DIR}" --config Release --parallel
-          cmake --install "${BUILD_DIR}" --config Release
-
-          echo "Installed to ${INSTALL_DIR}"
-      }
-
-      # Build for macOS platforms
-      build_for_macos_platform() {
-          local ARCH=$1  # arm64 or x86_64
-
-          local BUILD_DIR="${IOS_DIR}/build_macosx_${ARCH}"
-          local INSTALL_DIR="${IOS_DIR}/simpleble_macosx_${ARCH}"
-
-          echo "Building SimpleBLE for macOS (${ARCH})..."
-
-          cmake -B "${BUILD_DIR}" -S "${IOS_DIR}" \
-              -DCMAKE_BUILD_TYPE=Release \
-              -DCMAKE_SYSTEM_NAME=Darwin \
-              -DCMAKE_OSX_SYSROOT="macosx" \
-              -DCMAKE_OSX_ARCHITECTURES="${ARCH}" \
-              -DCMAKE_OSX_DEPLOYMENT_TARGET="${MACOS_DEPLOYMENT_TARGET}" \
-              -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
-              -DBUILD_SHARED_LIBS=OFF \
-              -DSIMPLEBLE_EXCLUDE_C=ON
-
-          cmake --build "${BUILD_DIR}" --config Release --parallel
-          cmake --install "${BUILD_DIR}" --config Release
-
-          echo "Installed to ${INSTALL_DIR}"
-      }
-
-      # Build for iOS device
-      build_for_ios_platform "iphoneos" "arm64"
-
-      # Build for iOS simulator (Apple Silicon)
-      build_for_ios_platform "iphonesimulator" "arm64"
-
-      # Build for macOS (Apple Silicon)
-      build_for_macos_platform "arm64"
-
-      # Build for macOS (Intel)
-      build_for_macos_platform "x86_64"
-
-      # Create universal macOS library
-      echo "Creating universal macOS library..."
-      MACOS_UNIVERSAL_DIR="${IOS_DIR}/simpleble_macosx_universal"
-      mkdir -p "${MACOS_UNIVERSAL_DIR}/lib"
-      cp -r "${IOS_DIR}/simpleble_macosx_arm64/include" "${MACOS_UNIVERSAL_DIR}/"
-      lipo -create \
-          "${IOS_DIR}/simpleble_macosx_arm64/lib/libsimpleble.a" \
-          "${IOS_DIR}/simpleble_macosx_x86_64/lib/libsimpleble.a" \
-          -output "${MACOS_UNIVERSAL_DIR}/lib/libsimpleble.a"
-
-      # Create XCFramework from the static libraries (iOS + macOS)
-      echo "Creating XCFramework..."
-      XCFRAMEWORK_PATH="${IOS_DIR}/SimpleBLE.xcframework"
-      rm -rf "${XCFRAMEWORK_PATH}"
-
-      xcodebuild -create-xcframework \
-          -library "${IOS_DIR}/simpleble_iphoneos_arm64/lib/libsimpleble.a" \
-          -headers "${IOS_DIR}/simpleble_iphoneos_arm64/include" \
-          -library "${IOS_DIR}/simpleble_iphonesimulator_arm64/lib/libsimpleble.a" \
-          -headers "${IOS_DIR}/simpleble_iphonesimulator_arm64/include" \
-          -library "${MACOS_UNIVERSAL_DIR}/lib/libsimpleble.a" \
-          -headers "${MACOS_UNIVERSAL_DIR}/include" \
-          -output "${XCFRAMEWORK_PATH}"
-
-      echo "SimpleBLE build complete!"
-      echo "XCFramework created at: ${XCFRAMEWORK_PATH}"
-    fi
-  CMD
+  # XCFramework is pre-built during npm publish (scripts/build-xcframework.sh)
+  # No prepare_command needed - the XCFramework is included in the npm package
 
   s.source_files = [
     # Implementation (Swift)
@@ -150,19 +48,16 @@ Pod::Spec.new do |s|
   s.ios.vendored_frameworks = 'ios/SimpleBLE.xcframework'
   s.osx.vendored_frameworks = 'ios/SimpleBLE.xcframework'
 
-  # Configure header search paths for SimpleBLE
+  # Configure header search paths for SimpleBLE XCFramework
+  # Headers are inside the XCFramework slices - we include all platforms so it works for any target
   current_pod_target_xcconfig = s.attributes_hash['pod_target_xcconfig'] || {}
   s.pod_target_xcconfig = current_pod_target_xcconfig.merge({
     'HEADER_SEARCH_PATHS' => [
       '"$(inherited)"',
-      # iOS header paths
-      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_iphoneos_arm64/include"',
-      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_iphonesimulator_arm64/include"',
-      # macOS header paths
-      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_macosx_arm64/include"',
-      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_macosx_x86_64/include"',
-      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_macosx_universal/include"',
+      # XCFramework headers for each platform slice
+      '"$(PODS_TARGET_SRCROOT)/ios/SimpleBLE.xcframework/ios-arm64/Headers"',
+      '"$(PODS_TARGET_SRCROOT)/ios/SimpleBLE.xcframework/ios-arm64-simulator/Headers"',
+      '"$(PODS_TARGET_SRCROOT)/ios/SimpleBLE.xcframework/macos-arm64_x86_64/Headers"',
     ].join(' '),
-    'GCC_PREPROCESSOR_DEFINITIONS' => ['$(inherited)', 'OS_OBJECT_USE_OBJC=1']
   })
 end

package/ios/SimpleBLE.xcframework/Info.plist

@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libsimpleble.a</string>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libsimpleble.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libsimpleble.a</string>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libsimpleble.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libsimpleble.a</string>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>macos-arm64_x86_64</string>
+			<key>LibraryPath</key>
+			<string>libsimpleble.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>macos</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Adapter.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Peripheral.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class AdapterBase;
+
+/**
+ * Bluetooth Adapter.
+ *
+ * A default-constructed Adapter object is not initialized. Calling any method
+ * other than `initialized()` on an uninitialized Adapter will throw an exception
+ * of type `SimpleBLE::NotInitialized`.
+ *
+ * NOTE: This class is intended to be used by the user only. Library developers
+ * should use shared pointers to `AdapterBase` instead.
+ */
+class SIMPLEBLE_EXPORT Adapter {
+  public:
+    Adapter() = default;
+    virtual ~Adapter() = default;
+
+    bool initialized() const;
+
+    /**
+     * Retrieve the underlying OS object/handle.
+     *
+     * For certain compatibility with external libraries, we sometimes need to
+     * expose the actual OS handle to the user. This is particularly important
+     * for MacOS right now.
+     */
+    void* underlying() const;
+
+    std::string identifier();
+    BluetoothAddress address();
+
+    /**
+     * Control the power state of the adapter.
+     *
+     * NOTE: The power on/off functionality is only supported on Windows and Linux (implementation pending).
+     *       On other platforms, this method will do nothing.
+     * NOTE: Callbacks are currently a placeholder for future implementation.
+     */
+    void power_on();
+    void power_off();
+    bool is_powered();
+    void set_callback_on_power_on(std::function<void()> on_power_on);
+    void set_callback_on_power_off(std::function<void()> on_power_off);
+
+    void scan_start();
+    void scan_stop();
+    void scan_for(int timeout_ms);
+    bool scan_is_active();
+    std::vector<Peripheral> scan_get_results();
+
+    void set_callback_on_scan_start(std::function<void()> on_scan_start);
+    void set_callback_on_scan_stop(std::function<void()> on_scan_stop);
+    void set_callback_on_scan_updated(std::function<void(Peripheral)> on_scan_updated);
+    void set_callback_on_scan_found(std::function<void(Peripheral)> on_scan_found);
+
+    /**
+     * Retrieve a list of all paired peripherals.
+     *
+     * NOTE:This method is currently only supported by the Linux, Windows and Android backends.
+     */
+    std::vector<Peripheral> get_paired_peripherals();
+
+    /**
+     * Retrieve a list of all connected peripherals.
+     *
+     * NOTE: This method is currently only supported by the Windows backend. (More backends coming soon.)
+     */
+    std::vector<Peripheral> get_connected_peripherals();
+
+    static bool bluetooth_enabled();
+
+    /**
+     * Fetches a list of all available adapters from all available backends.
+     *
+     * This will cause backends to be instantiated/initialized and adapters
+     * too.
+     */
+    static std::vector<Adapter> get_adapters();
+
+  protected:
+    AdapterBase* operator->();
+    const AdapterBase* operator->() const;
+
+    std::shared_ptr<AdapterBase> internal_;
+};
+
+}  // namespace SimpleBLE

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/AdapterSafe.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#include <simpleble/Adapter.h>
+#include <simpleble/PeripheralSafe.h>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace SimpleBLE {
+
+namespace Safe {
+
+/**
+ * Wrapper around the Adapter class that provides a noexcept interface.
+ *
+ * We use instances of this class directly and not through shared_ptr because
+ * this is just a wrapper around the Adapter class, which is already managed by
+ * shared_ptr.
+ */
+class SIMPLEBLE_EXPORT Adapter {
+  public:
+    Adapter(SimpleBLE::Adapter& adapter);
+    Adapter(SimpleBLE::Adapter&& adapter);
+    virtual ~Adapter() = default;
+
+    std::optional<std::string> identifier() noexcept;
+    std::optional<BluetoothAddress> address() noexcept;
+
+    bool scan_start() noexcept;
+    bool scan_stop() noexcept;
+    bool scan_for(int timeout_ms) noexcept;
+    std::optional<bool> scan_is_active() noexcept;
+    std::optional<std::vector<SimpleBLE::Safe::Peripheral>> scan_get_results() noexcept;
+
+    bool set_callback_on_scan_start(std::function<void()> on_scan_start) noexcept;
+    bool set_callback_on_scan_stop(std::function<void()> on_scan_stop) noexcept;
+    bool set_callback_on_scan_updated(std::function<void(SimpleBLE::Safe::Peripheral)> on_scan_updated) noexcept;
+    bool set_callback_on_scan_found(std::function<void(SimpleBLE::Safe::Peripheral)> on_scan_found) noexcept;
+
+    std::optional<std::vector<SimpleBLE::Safe::Peripheral>> get_paired_peripherals() noexcept;
+
+    static std::optional<bool> bluetooth_enabled() noexcept;
+    static std::optional<std::vector<SimpleBLE::Safe::Adapter>> get_adapters() noexcept;
+
+    /**
+     * Cast to the underlying adapter object.
+     */
+    operator SimpleBLE::Adapter() const noexcept;
+
+  protected:
+    SimpleBLE::Adapter internal_;
+};
+
+}  // namespace Safe
+
+}  // namespace SimpleBLE

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Advanced.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#if __APPLE__
+#include "TargetConditionals.h"
+#endif
+
+/**
+ * Advanced Features
+ *
+ * The functions presented in this namespace are OS-specific backdoors that are
+ * not part of the standard SimpleBLE API, which allow the user to access
+ * low-level details of the implementation for advanced use cases.
+ *
+ * These functions should be used with caution.
+ */
+
+#if defined(_WIN32)
+namespace SimpleBLE::Advanced::Windows {}
+
+#endif
+
+#if TARGET_OS_OSX
+namespace SimpleBLE::Advanced::MacOS {}
+
+#endif
+
+#if TARGET_OS_IOS
+namespace SimpleBLE::Advanced::iOS {}
+
+#endif
+
+#if defined(__ANDROID__)
+
+#include <jni.h>
+
+namespace SimpleBLE::Advanced::Android {
+
+JavaVM* SIMPLEBLE_EXPORT get_jvm();
+void SIMPLEBLE_EXPORT set_jvm(JavaVM* jvm);
+
+}  // namespace SimpleBLE::Advanced::Android
+
+#endif
+
+#if defined(__linux__) && !defined(__ANDROID__)
+namespace SimpleBLE::Advanced::Linux {}
+
+#endif

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Characteristic.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Descriptor.h>
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class CharacteristicBase;
+
+class SIMPLEBLE_EXPORT Characteristic {
+  public:
+    Characteristic() = default;
+    virtual ~Characteristic() = default;
+
+    bool initialized() const;
+
+    BluetoothUUID uuid();
+    std::vector<Descriptor> descriptors();
+    std::vector<std::string> capabilities();
+
+    bool can_read();
+    bool can_write_request();
+    bool can_write_command();
+    bool can_notify();
+    bool can_indicate();
+
+  protected:
+    CharacteristicBase* operator->();
+    const CharacteristicBase* operator->() const;
+
+    std::shared_ptr<CharacteristicBase> internal_;
+};
+
+}  // namespace SimpleBLE

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Config.h

@@ -0,0 +1,64 @@
+#pragma once
+#include <chrono>
+
+namespace SimpleBLE {
+namespace Config {
+    namespace SimpleBluez {
+        extern bool use_legacy_bluez_backend;
+        extern std::chrono::steady_clock::duration connection_timeout;
+        extern std::chrono::steady_clock::duration disconnection_timeout;
+
+        static void reset() {
+            use_legacy_bluez_backend = true;
+            connection_timeout = std::chrono::seconds(2);
+            disconnection_timeout = std::chrono::seconds(1);
+        }
+    }
+
+    namespace WinRT {
+        extern bool experimental_use_own_mta_apartment;
+        extern bool experimental_reinitialize_winrt_apartment_on_main_thread;
+
+        static void reset() {
+            experimental_use_own_mta_apartment = true;
+            experimental_reinitialize_winrt_apartment_on_main_thread = false;
+        }
+    }
+
+    namespace CoreBluetooth {
+        static void reset() {}
+    }
+
+    namespace Android {
+        enum class ConnectionPriorityRequest {
+            DISABLED = -1,
+            BALANCED = 0,
+            HIGH = 1,
+            LOW_POWER = 2,
+            DCK = 3
+        };
+
+        extern ConnectionPriorityRequest connection_priority_request;
+
+        static void reset() {
+            connection_priority_request = ConnectionPriorityRequest::DISABLED;
+        }
+    }
+
+    namespace Dongl {
+        extern bool use_dongl_backend;
+        static void reset() {
+            use_dongl_backend = false;
+        }
+    }
+
+    namespace Base {
+        static void reset_all() {
+            SimpleBluez::reset();
+            WinRT::reset();
+            CoreBluetooth::reset();
+            Android::reset();
+        }
+    }
+}  // namespace Config
+}  // namespace SimpleBLE

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Descriptor.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class DescriptorBase;
+
+class SIMPLEBLE_EXPORT Descriptor {
+  public:
+    Descriptor() = default;
+    virtual ~Descriptor() = default;
+
+    bool initialized() const;
+
+    BluetoothUUID uuid();
+
+  protected:
+    DescriptorBase* operator->();
+    const DescriptorBase* operator->() const;
+
+    std::shared_ptr<DescriptorBase> internal_;
+};
+
+}  // namespace SimpleBLE

package/ios/SimpleBLE.xcframework/ios-arm64/Headers/simpleble/Exceptions.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+
+#include <simpleble/export.h>
+
+#include "Types.h"
+
+namespace SimpleBLE {
+
+namespace Exception {
+
+class SIMPLEBLE_EXPORT BaseException : public std::runtime_error {
+  public:
+    BaseException(const std::string& __arg) : std::runtime_error(__arg) {}
+};
+
+class SIMPLEBLE_EXPORT NotInitialized : public BaseException {
+  public:
+    NotInitialized();
+};
+
+class SIMPLEBLE_EXPORT NotConnected : public BaseException {
+  public:
+    NotConnected();
+};
+
+class SIMPLEBLE_EXPORT InvalidReference : public BaseException {
+  public:
+    InvalidReference();
+};
+
+class SIMPLEBLE_EXPORT ServiceNotFound : public BaseException {
+  public:
+    ServiceNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT CharacteristicNotFound : public BaseException {
+  public:
+    CharacteristicNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT DescriptorNotFound : public BaseException {
+  public:
+    DescriptorNotFound(BluetoothUUID uuid);
+};
+
+class SIMPLEBLE_EXPORT OperationNotSupported : public BaseException {
+  public:
+    OperationNotSupported();
+};
+
+class SIMPLEBLE_EXPORT OperationFailed : public BaseException {
+  public:
+    OperationFailed();
+    OperationFailed(const std::string& err_msg);
+};
+
+class SIMPLEBLE_EXPORT WinRTException : public BaseException {
+  public:
+    WinRTException(int32_t err_code, const std::string& err_msg);
+};
+
+class SIMPLEBLE_EXPORT CoreBluetoothException : public BaseException {
+  public:
+    CoreBluetoothException(const std::string& err_msg);
+};
+
+}  // namespace Exception
+
+}  // namespace SimpleBLE