simplejsble 0.0.18 → 0.0.19

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/Peripheral.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Service.h>
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+class PeripheralBase;
+
+class SIMPLEBLE_EXPORT Peripheral {
+  public:
+    Peripheral() = default;
+    virtual ~Peripheral() = default;
+
+    bool initialized() const;
+    void* underlying() const;
+
+    std::string identifier();
+    BluetoothAddress address();
+    BluetoothAddressType address_type();
+    int16_t rssi();
+
+    /**
+     * @brief Provides the advertised transmit power in dBm.
+     *
+     * @note If the field has not been advertised by the peripheral,
+     *       the returned value will be -32768.
+     */
+    int16_t tx_power();
+    uint16_t mtu();
+
+    void connect();
+    void disconnect();
+    bool is_connected();
+    bool is_connectable();
+    bool is_paired();
+    void unpair();
+
+    /**
+     * @brief Provides a list of all services that are available on the peripheral.
+     *
+     * @note If the peripheral is not connected, it will return a list of services
+     *       that were advertised by the device.
+     */
+    std::vector<Service> services();
+    std::map<uint16_t, ByteArray> manufacturer_data();
+
+    /* Calling any of the methods below when the device is not connected will throw
+       Exception::NotConnected */
+    // clang-format off
+    ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic);
+    void write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data);
+    void write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data);
+    void notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback);
+    void indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback);
+    void unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic);
+
+    ByteArray read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor);
+    void write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data);
+    // clang-format on
+
+    void set_callback_on_connected(std::function<void()> on_connected);
+    void set_callback_on_disconnected(std::function<void()> on_disconnected);
+
+  protected:
+    PeripheralBase* operator->();
+    const PeripheralBase* operator->() const;
+
+    std::shared_ptr<PeripheralBase> internal_;
+};
+
+}  // namespace SimpleBLE

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/PeripheralSafe.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Peripheral.h>
+#include <simpleble/Service.h>
+
+namespace SimpleBLE {
+
+namespace Safe {
+
+class SIMPLEBLE_EXPORT Peripheral {
+  public:
+    Peripheral(SimpleBLE::Peripheral& peripheral);
+    Peripheral(SimpleBLE::Peripheral&& peripheral);
+    virtual ~Peripheral() = default;
+
+    std::optional<std::string> identifier() noexcept;
+    std::optional<BluetoothAddress> address() noexcept;
+    std::optional<BluetoothAddressType> address_type() noexcept;
+    std::optional<int16_t> rssi() noexcept;
+    std::optional<int16_t> tx_power() noexcept;
+    std::optional<uint16_t> mtu() noexcept;
+
+    bool connect() noexcept;
+    bool disconnect() noexcept;
+    std::optional<bool> is_connected() noexcept;
+    std::optional<bool> is_connectable() noexcept;
+    std::optional<bool> is_paired() noexcept;
+    bool unpair() noexcept;
+
+    std::optional<std::vector<Service>> services() noexcept;
+    std::optional<std::map<uint16_t, ByteArray>> manufacturer_data() noexcept;
+
+    // clang-format off
+    std::optional<ByteArray> read(BluetoothUUID const& service, BluetoothUUID const& characteristic) noexcept;
+    bool write_request(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) noexcept;
+    bool write_command(BluetoothUUID const& service, BluetoothUUID const& characteristic, ByteArray const& data) noexcept;
+    bool notify(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) noexcept;
+    bool indicate(BluetoothUUID const& service, BluetoothUUID const& characteristic, std::function<void(ByteArray payload)> callback) noexcept;
+    bool unsubscribe(BluetoothUUID const& service, BluetoothUUID const& characteristic) noexcept;
+
+    std::optional<ByteArray> read(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor) noexcept;
+    bool write(BluetoothUUID const& service, BluetoothUUID const& characteristic, BluetoothUUID const& descriptor, ByteArray const& data) noexcept;
+    // clang-format on
+
+    bool set_callback_on_connected(std::function<void()> on_connected) noexcept;
+    bool set_callback_on_disconnected(std::function<void()> on_disconnected) noexcept;
+
+    /**
+     * Get the underlying peripheral object.
+     */
+    operator SimpleBLE::Peripheral() const noexcept;
+
+  protected:
+    SimpleBLE::Peripheral internal_;
+};
+
+}  // namespace Safe
+
+}  // namespace SimpleBLE

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/Service.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <simpleble/export.h>
+
+#include <simpleble/Exceptions.h>
+#include <simpleble/Types.h>
+#include "simpleble/Characteristic.h"
+
+namespace SimpleBLE {
+
+class ServiceBase;
+
+class SIMPLEBLE_EXPORT Service {
+  public:
+    Service() = default;
+    virtual ~Service() = default;
+
+    bool initialized() const;
+
+    BluetoothUUID uuid();
+    ByteArray data();
+    std::vector<Characteristic> characteristics();
+
+  protected:
+    const ServiceBase* operator->() const;
+    ServiceBase* operator->();
+
+    std::shared_ptr<ServiceBase> internal_;
+};
+
+}  // namespace SimpleBLE

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/SimpleBLE.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <simpleble/Config.h>
+#include <simpleble/Adapter.h>
+#include <simpleble/AdapterSafe.h>
+#include <simpleble/Peripheral.h>
+#include <simpleble/PeripheralSafe.h>
+#include <simpleble/Utils.h>

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/Types.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "kvn/kvn_bytearray.h"
+
+/**
+ * @file Types.h
+ * @brief Defines types and enumerations used throughout the SimpleBLE library.
+ */
+
+namespace SimpleBLE {
+
+using BluetoothAddress = std::string;
+
+// IDEA: Extend BluetoothUUID to include a `uuid` function that
+// returns the same string, but provides a homogeneous interface.
+using BluetoothUUID = std::string;
+
+/**
+ * @typedef ByteArray
+ * @brief Represents a byte array using kvn::bytearray from the external library.
+ */
+using ByteArray = kvn::bytearray;
+
+#ifdef ANDROID
+#pragma push_macro("ANDROID")
+#undef ANDROID
+#define ANDROID_WAS_DEFINED
+#endif
+
+enum class OperatingSystem {
+    WINDOWS,
+    MACOS,
+    IOS,
+    LINUX,
+    ANDROID,
+};
+
+#ifdef ANDROID_WAS_DEFINED
+#pragma pop_macro("ANDROID")
+#undef ANDROID_WAS_DEFINED
+#endif
+
+// TODO: Add to_string functions for all enums.
+enum BluetoothAddressType : int32_t { PUBLIC = 0, RANDOM = 1, UNSPECIFIED = 2 };
+
+}  // namespace SimpleBLE

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/Utils.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <simpleble/export.h>
+
+#include <simpleble/Types.h>
+
+namespace SimpleBLE {
+
+OperatingSystem SIMPLEBLE_EXPORT get_operating_system();
+
+std::string SIMPLEBLE_EXPORT get_simpleble_version();
+
+}  // namespace SimpleBLE

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/export.h

@@ -0,0 +1,43 @@
+
+#ifndef SIMPLEBLE_EXPORT_H
+#define SIMPLEBLE_EXPORT_H
+
+#ifdef SIMPLEBLE_STATIC_DEFINE
+#  define SIMPLEBLE_EXPORT
+#  define SIMPLEBLE_NO_EXPORT
+#else
+#  ifndef SIMPLEBLE_EXPORT
+#    ifdef simpleble_EXPORTS
+        /* We are building this library */
+#      define SIMPLEBLE_EXPORT 
+#    else
+        /* We are using this library */
+#      define SIMPLEBLE_EXPORT 
+#    endif
+#  endif
+
+#  ifndef SIMPLEBLE_NO_EXPORT
+#    define SIMPLEBLE_NO_EXPORT 
+#  endif
+#endif
+
+#ifndef SIMPLEBLE_DEPRECATED
+#  define SIMPLEBLE_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef SIMPLEBLE_DEPRECATED_EXPORT
+#  define SIMPLEBLE_DEPRECATED_EXPORT SIMPLEBLE_EXPORT SIMPLEBLE_DEPRECATED
+#endif
+
+#ifndef SIMPLEBLE_DEPRECATED_NO_EXPORT
+#  define SIMPLEBLE_DEPRECATED_NO_EXPORT SIMPLEBLE_NO_EXPORT SIMPLEBLE_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef SIMPLEBLE_NO_DEPRECATED
+#    define SIMPLEBLE_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* SIMPLEBLE_EXPORT_H */

package/macos/SimpleBLE-macos.xcframework/macos-arm64_x86_64/Headers/simpleble/kvn/kvn_bytearray.h

@@ -0,0 +1,297 @@
+#ifndef KVN_BYTEARRAY_H
+#define KVN_BYTEARRAY_H
+
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+namespace kvn {
+
+/**
+ * @class bytearray
+ * @brief A class to handle byte arrays and their conversion from/to hex strings.
+ */
+class bytearray {
+  public:
+    /**
+     * @brief Default constructor.
+     */
+    bytearray() = default;
+
+    /**
+     * @brief Constructs byte array from a vector of uint8_t.
+     * @param vec A vector of uint8_t.
+     */
+    bytearray(const std::vector<uint8_t>& vec) : data_(vec) {}
+
+    /**
+     * @brief Constructs byte array from a raw pointer and size.
+     * @param ptr A pointer to uint8_t data.
+     * @param size The size of the data.
+     */
+    bytearray(const uint8_t* ptr, size_t size) : data_(ptr, ptr + size) {}
+
+    /**
+     * @brief Constructs byte array from iterators.
+     * @tparam InputIt Iterator type.
+     * @param first Iterator to the first element.
+     * @param last Iterator to one past the last element.
+     */
+    template <typename InputIt>
+    bytearray(InputIt first, InputIt last) : data_(first, last) {}
+
+    /**
+     * @brief Constructs byte array from a std::string.
+     * @param byteArr A string containing byte data.
+     */
+    bytearray(const std::string& byteArr) : data_(byteArr.begin(), byteArr.end()) {}
+
+    /**
+     * @brief Constructs byte array from a C-style string and size.
+     * @param byteArr A C-style string.
+     * @param size The size of the string.
+     */
+    bytearray(const char* byteArr, size_t size) : bytearray(std::string(byteArr, size)) {}
+
+    /**
+     * @brief Constructs byte array from a C-style string.
+     * @param byteArr A C-style string.
+     */
+    bytearray(const char* byteArr) : bytearray(std::string(byteArr)) {}
+
+    /**
+     * @brief Constructs a byte array of specified size, initialized with zeros.
+     * @param size The number of bytes to allocate.
+     */
+    explicit bytearray(size_t size) : data_(size) {}
+
+    /**
+     * @brief Creates a ByteArray from a hex string.
+     *
+     * Case is ignored and the string may have a '0x' hex prefix or not.
+     *
+     * @param hexStr A string containing hex data.
+     * @return A ByteArray object.
+     * @throws std::invalid_argument If the hex string contains non-hexadecimal characters.
+     * @throws std::length_error If the hex string length is not even.
+     */
+    static bytearray fromHex(const std::string& hexStr) {
+        std::string cleanString(hexStr);
+
+        // Check and skip the '0x' prefix if present
+        if (cleanString.size() >= 2 && cleanString.substr(0, 2) == "0x") {
+            cleanString = cleanString.substr(2);
+        }
+
+        size_t size = cleanString.size();
+        if (size % 2 != 0) {
+            throw std::length_error("Hex string length must be even.");
+        }
+
+        bytearray byteArray;
+        byteArray.data_.reserve(size / 2);
+
+        for (size_t i = 0; i < size; i += 2) {
+            uint8_t byte = static_cast<uint8_t>(std::stoi(cleanString.substr(i, 2), nullptr, 16));
+            byteArray.data_.push_back(byte);
+        }
+
+        return byteArray;
+    }
+
+    /**
+     * @overload
+     */
+    static bytearray fromHex(const char* byteArr) { return fromHex(std::string(byteArr)); }
+
+    /**
+     * @overload
+     */
+    static bytearray fromHex(const char* byteArr, size_t size) { return fromHex(std::string(byteArr, size)); }
+
+    /**
+     * @brief Converts the byte array to a lowercase hex string without '0x' prefix.
+     * @param spacing Whether to include spaces between bytes.
+     *
+     * @return A hex string representation of the byte array.
+     */
+    std::string toHex(bool spacing = false) const {
+        std::ostringstream oss;
+        for (auto byte : data_) {
+            oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
+            if (spacing) {
+                oss << " ";
+            }
+        }
+        return oss.str();
+    }
+
+    /**
+     * @brief Slices  the byte array from a specified start index to an end index.
+     *
+     * This method creates a new byte array containing bytes from the specified range.
+     * The start index is inclusive, while the end index is exclusive.
+     *
+     * @param start The starting index from which to begin slicing.
+     * @param end The ending index up to which to slice (exclusive).
+     * @return byte array A new byte array containing the sliced segment.
+     * @throws std::out_of_range If the start index is greater than the end index or if the end index is out of bounds.
+     */
+    bytearray slice(size_t start, size_t end) const {
+        if (start > end || end > data_.size()) {
+            throw std::out_of_range("Invalid slice range");
+        }
+        return bytearray(std::vector<uint8_t>(data_.begin() + start, data_.begin() + end));
+    }
+
+    /**
+     * @brief Slices the byte array from a specified start index to the end of the array.
+     *
+     * This method creates a new byte array containing all bytes from the specified start index to the end of the
+     * byte array.
+     *
+     * @param start The starting index from which to begin slicing.
+     * @return byte array A new byte array containing the sliced segment from the start index to the end.
+     * @throws std::out_of_range If the start index is out of the bounds of the byte array.
+     */
+    bytearray slice_from(size_t start) const { return slice(start, data_.size()); }
+
+    /**
+     * @brief Slices the byte array from the beginning to a specified end index.
+     *
+     * This method creates a new byte array containing all bytes from the beginning of the byte array to the specified
+     * end index.
+     *
+     * @param end The ending index up to which to slice (exclusive).
+     * @return byte array A new byte array containing the sliced segment from the beginning to the end index.
+     * @throws std::out_of_range If the end index is out of the bounds of the byte array.
+     */
+    bytearray slice_to(size_t end) const { return slice(0, end); }
+
+    /**
+     * @brief Overloaded stream insertion operator for byte array.
+     * @param os The output stream.
+     * @param byteArray The byte array object.
+     * @return The output stream.
+     */
+    friend std::ostream& operator<<(std::ostream& os, const bytearray& byteArray) {
+        os << byteArray.toHex(true);
+        return os;
+    }
+
+    /**
+     * @brief Conversion operator to convert byte array to std::string.
+     *
+     * @note This is provided to support code that relies on byte array
+     *       being representd as a string.
+     * @return String containing the raw bytes of the byte array
+     */
+    operator std::string() const { return std::string(data_.begin(), data_.end()); }
+
+    /**
+     * @brief Conversion operator to convert byte array to std::vector<uint8_t>.
+     * @return Vector containing the raw bytes of the byte array
+     */
+    operator std::vector<uint8_t>() const { return data_; }
+
+    //! @cond Doxygen_Suppress
+    // Expose vector-like functionality
+    size_t size() const { return data_.size(); }
+    const uint8_t* data() const { return data_.data(); }
+    uint8_t* data() { return data_.data(); }
+    bool empty() const { return data_.empty(); }
+    void clear() { data_.clear(); }
+    uint8_t& operator[](size_t index) { return data_[index]; }
+    const uint8_t& operator[](size_t index) const { return data_[index]; }
+    void push_back(uint8_t byte) { data_.push_back(byte); }
+
+    /**
+     * @brief Appends a uint16_t value as 2 little-endian bytes.
+     * @param value The uint16_t value to append.
+     */
+    void push_back(uint16_t value) {
+        for (size_t i = 0; i < 2; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+
+    /**
+     * @brief Appends a uint32_t value as 4 little-endian bytes.
+     * @param value The uint32_t value to append.
+     */
+    void push_back(uint32_t value) {
+        for (size_t i = 0; i < 4; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+
+    /**
+     * @brief Appends a uint64_t value as 8 little-endian bytes.
+     * @param value The uint64_t value to append.
+     */
+    void push_back(uint64_t value) {
+        for (size_t i = 0; i < 8; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+    auto begin() { return data_.begin(); }
+    auto begin() const { return data_.begin(); }
+    auto end() { return data_.end(); }
+    auto end() const { return data_.end(); }
+
+    /**
+     * @brief Inserts a single byte at the specified position.
+     * @param pos Iterator to the position where the element is inserted.
+     * @param value The byte to insert.
+     * @return Iterator pointing to the inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, uint8_t value) { return data_.insert(pos, value); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, uint8_t value) { return data_.insert(pos, value); }
+
+    /**
+     * @brief Inserts multiple copies of a byte at the specified position.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param count Number of copies to insert.
+     * @param value The byte to insert.
+     * @return Iterator pointing to the first inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, size_t count, uint8_t value) { return data_.insert(pos, count, value); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, size_t count, uint8_t value) { return data_.insert(pos, count, value); }
+
+    /**
+     * @brief Inserts elements from a range at the specified position.
+     * @tparam InputIt Iterator type.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param first Iterator to the first element of the range.
+     * @param last Iterator to one past the last element of the range.
+     * @return Iterator pointing to the first inserted element.
+     */
+    template <typename InputIt>
+    auto insert(typename std::vector<uint8_t>::iterator pos, InputIt first, InputIt last) { return data_.insert(pos, first, last); }
+    template <typename InputIt>
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, InputIt first, InputIt last) { return data_.insert(pos, first, last); }
+
+    /**
+     * @brief Inserts another bytearray at the specified position.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param other The bytearray to insert.
+     * @return Iterator pointing to the first inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, const bytearray& other) { return data_.insert(pos, other.begin(), other.end()); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, const bytearray& other) { return data_.insert(pos, other.begin(), other.end()); }
+
+    //! @endcond
+
+  private:
+    std::vector<uint8_t> data_;
+};
+
+}  // namespace kvn
+
+#endif  // KVN_BYTEARRAY_H

package/macos/build_simpleble.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+MACOS_DEPLOYMENT_TARGET="${MACOS_DEPLOYMENT_TARGET:-13.0}"
+
+build_for_arch() {
+    local ARCH=$1  # arm64 or x86_64
+
+    local BUILD_DIR="${SCRIPT_DIR}/build_macosx_${ARCH}"
+    local INSTALL_DIR="${SCRIPT_DIR}/simpleble_macosx_${ARCH}"
+
+    echo "Building SimpleBLE for macOS (${ARCH})..."
+
+    cmake -B "${BUILD_DIR}" -S "${SCRIPT_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 Apple Silicon
+build_for_arch "arm64"
+
+# Build for Intel
+build_for_arch "x86_64"
+
+# Create XCFramework from the static libraries
+echo "Creating XCFramework..."
+XCFRAMEWORK_PATH="${SCRIPT_DIR}/SimpleBLE-macos.xcframework"
+rm -rf "${XCFRAMEWORK_PATH}"
+
+# Create a universal (fat) library first, then wrap in XCFramework
+# This is needed because XCFramework expects one library per platform
+UNIVERSAL_DIR="${SCRIPT_DIR}/simpleble_macosx_universal"
+mkdir -p "${UNIVERSAL_DIR}/lib"
+
+lipo -create \
+    "${SCRIPT_DIR}/simpleble_macosx_arm64/lib/libsimpleble.a" \
+    "${SCRIPT_DIR}/simpleble_macosx_x86_64/lib/libsimpleble.a" \
+    -output "${UNIVERSAL_DIR}/lib/libsimpleble.a"
+
+# Copy headers from arm64 build (headers are the same for both architectures)
+cp -R "${SCRIPT_DIR}/simpleble_macosx_arm64/include" "${UNIVERSAL_DIR}/"
+
+xcodebuild -create-xcframework \
+    -library "${UNIVERSAL_DIR}/lib/libsimpleble.a" \
+    -headers "${UNIVERSAL_DIR}/include" \
+    -output "${XCFRAMEWORK_PATH}"
+
+echo "SimpleBLE macOS build complete!"
+echo "XCFramework created at: ${XCFRAMEWORK_PATH}"