simplejsble 0.0.1 → 0.0.3

package/NitroSimplejsble.podspec

@@ -0,0 +1,58 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroSimplejsble"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported, :visionos => 1.0 }
+
+  s.source = { :path => "." }
+
+  # Build SimpleBLE from source using CMake during pod install
+  s.prepare_command = <<-CMD
+    echo "Building SimpleBLE for iOS..."
+    chmod +x ios/build_simpleble.sh
+    ios/build_simpleble.sh
+  CMD
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  # Exclude CMakeLists.txt from source files
+  s.exclude_files = ["ios/CMakeLists.txt"]
+
+  load 'nitrogen/generated/ios/NitroSimplejsble+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+
+  # Required frameworks for SimpleBLE iOS backend
+  s.frameworks = ['Foundation', 'CoreBluetooth']
+
+  # Vendored XCFramework containing all architectures
+  s.ios.vendored_frameworks = 'ios/SimpleBLE.xcframework'
+
+  # Configure header search paths for SimpleBLE
+  current_pod_target_xcconfig = s.attributes_hash['pod_target_xcconfig'] || {}
+  s.pod_target_xcconfig = current_pod_target_xcconfig.merge({
+    'HEADER_SEARCH_PATHS' => [
+      '"$(inherited)"',
+      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_iphoneos_arm64/include"',
+      '"$(PODS_TARGET_SRCROOT)/ios/simpleble_iphonesimulator_arm64/include"',
+    ].join(' '),
+  })
+end

package/android/CMakeLists.txt

@@ -0,0 +1,35 @@
+project(NitroSimplejsble)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroSimplejsble)
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED
+        src/main/cpp/cpp-adapter.cpp
+        ../cpp/HybridAdapter.cpp
+)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroSimplejsble+autolinking.cmake)
+
+# Add simpleble 
+# Path: packages/simplejsble/android → ../../../../simpleble
+add_subdirectory(${CMAKE_SOURCE_DIR}/../../../../simpleble ${CMAKE_BINARY_DIR}/simpleble)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        simpleble::simpleble                      # <-- SimpleBLE library
+        android                                   # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,142 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.2"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroSimplejsble+autolinking.gradle'
+apply from: "./fix-prefab.gradle"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroSimplejsble_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroSimplejsble_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.simplejsble"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    multiDexEnabled true
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+}
+

package/android/fix-prefab.gradle

@@ -0,0 +1,51 @@
+tasks.configureEach { task ->
+  // Make sure that we generate our prefab publication file only after having built the native library
+  // so that not a header publication file, but a full configuration publication will be generated, which
+  // will include the .so file
+
+  def prefabConfigurePattern = ~/^prefab(.+)ConfigurePackage$/
+  def matcher = task.name =~ prefabConfigurePattern
+  if (matcher.matches()) {
+    def variantName = matcher[0][1]
+    task.outputs.upToDateWhen { false }
+    task.dependsOn("externalNativeBuild${variantName}")
+  }
+}
+
+afterEvaluate {
+  def abis = reactNativeArchitectures()
+  rootProject.allprojects.each { proj ->
+    if (proj === rootProject) return
+
+    def dependsOnThisLib = proj.configurations.findAll { it.canBeResolved }.any { config ->
+      config.dependencies.any { dep ->
+        dep.group == project.group && dep.name == project.name
+      }
+    }
+    if (!dependsOnThisLib && proj != project) return
+
+    if (!proj.plugins.hasPlugin('com.android.application') && !proj.plugins.hasPlugin('com.android.library')) {
+      return
+    }
+
+    def variants = proj.android.hasProperty('applicationVariants') ? proj.android.applicationVariants : proj.android.libraryVariants
+    // Touch the prefab_config.json files to ensure that in ExternalNativeJsonGenerator.kt we will re-trigger the prefab CLI to
+    // generate a libnameConfig.cmake file that will contain our native library (.so).
+    // See this condition: https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:build-system/gradle-core/src/main/java/com/android/build/gradle/tasks/ExternalNativeJsonGenerator.kt;l=207-219?q=createPrefabBuildSystemGlue
+    variants.all { variant ->
+      def variantName = variant.name
+      abis.each { abi ->
+        def searchDir = new File(proj.projectDir, ".cxx/${variantName}")
+        if (!searchDir.exists()) return
+        def matches = []
+        searchDir.eachDir { randomDir ->
+          def prefabFile = new File(randomDir, "${abi}/prefab_config.json")
+          if (prefabFile.exists()) matches << prefabFile
+        }
+        matches.each { prefabConfig ->
+          prefabConfig.setLastModified(System.currentTimeMillis())
+        }
+      }
+    }
+  }
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroSimplejsble_kotlinVersion=2.1.20
+NitroSimplejsble_minSdkVersion=23
+NitroSimplejsble_targetSdkVersion=36
+NitroSimplejsble_compileSdkVersion=36
+NitroSimplejsble_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "NitroSimplejsbleOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::simplejsble::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/simplejsble/NitroSimplejsblePackage.kt

@@ -0,0 +1,18 @@
+package com.margelo.nitro.simplejsble
+
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.BaseReactPackage
+
+class NitroSimplejsblePackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            NitroSimplejsbleOnLoad.initializeNative()
+        }
+    }
+}

package/cpp/HybridAdapter.cpp

@@ -0,0 +1,20 @@
+#include "HybridAdapter.hpp"
+
+namespace margelo::nitro::simplejsble {
+
+std::string HybridAdapter::greet(const std::string& name) { return "Hello, " + name + "!"; }
+
+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);
+    }
+
+    return result;
+}
+
+bool HybridAdapter::bluetooth_enabled() { return SimpleBLE::Adapter::bluetooth_enabled(); }
+
+}  // namespace margelo::nitro::simplejsble

package/cpp/HybridAdapter.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "HybridAdapterSpec.hpp"
+#include <simpleble/SimpleBLE.h>
+#include <string>
+
+namespace margelo::nitro::simplejsble {
+
+class HybridAdapter : public HybridAdapterSpec {
+  public:
+    HybridAdapter() : HybridObject(TAG) {}
+    HybridAdapter(SimpleBLE::Adapter adapter) : HybridObject(TAG), _adapter(adapter) {}
+
+    std::string greet(const std::string& name) override;
+    std::vector<std::shared_ptr<HybridAdapterSpec>> get_adapters() override;
+    bool bluetooth_enabled() override;
+
+  private:
+    SimpleBLE::Adapter _adapter;
+};
+
+}  // namespace margelo::nitro::simplejsble

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroSimplejsble
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/CMakeLists.txt

@@ -0,0 +1,21 @@
+cmake_minimum_required(VERSION 3.21)
+
+# Path: packages/simplejsble/ios → ../../../.. → repo root (where simpleble/ lives)
+set(PROJECT_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../..)
+set(BUILD_SHARED_LIBS OFF)  # Static library for iOS
+
+include(${PROJECT_ROOT_DIR}/cmake/prelude.cmake)
+
+project(simpleble-ios VERSION ${SIMPLEBLE_VERSION_BASE} LANGUAGES CXX C OBJCXX)
+
+include(${PROJECT_ROOT_DIR}/cmake/epilogue.cmake)
+
+add_subdirectory(${PROJECT_ROOT_DIR}/simpleble ${CMAKE_BINARY_DIR}/simpleble)
+
+# Install library
+install(TARGETS simpleble ARCHIVE DESTINATION lib)
+
+# Install headers (including generated export.h)
+install(DIRECTORY ${PROJECT_ROOT_DIR}/simpleble/include/simpleble/ DESTINATION include/simpleble)
+install(DIRECTORY ${CMAKE_BINARY_DIR}/simpleble/export/simpleble/ DESTINATION include/simpleble)
+install(FILES ${PROJECT_ROOT_DIR}/dependencies/external/kvn/kvn_bytearray.h DESTINATION include/simpleble/kvn)

package/ios/SimpleBLE.xcframework/Info.plist

@@ -0,0 +1,47 @@
+<?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</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>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>
+	</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