@bota.dev/react-native-app-sdk 2.0.0-beta.0

package/BotaDeviceSDK.podspec

@@ -0,0 +1,55 @@
+require "json"
+require_relative "scripts/bota_device_sdk_spm_workaround"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+apple = package.fetch("bota").fetch("apple")
+version = package.fetch("version")
+
+Pod::Spec.new do |spec|
+  spec.name = apple.fetch("podName")
+  spec.module_name = apple.fetch("moduleName")
+  spec.version = version
+  spec.summary = package.fetch("description")
+  spec.homepage = "https://docs.bota.dev"
+  spec.license = { type: package.fetch("license") }
+  spec.author = package.fetch("author")
+  spec.source = {
+    git: package.fetch("repository").fetch("url"),
+    tag: "v#{version}",
+  }
+  spec.platforms = { ios: apple.fetch("deploymentTarget") }
+  spec.cocoapods_version = ">= #{apple.fetch("cocoapodsVersion")}"
+  spec.swift_version = apple.fetch("swiftVersion")
+  spec.source_files = "ios/**/*.{h,m,mm,swift}"
+  spec.pod_target_xcconfig = {
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "DEFINES_MODULE" => "YES",
+    "SWIFT_STRICT_CONCURRENCY" => "complete",
+    "SWIFT_TREAT_WARNINGS_AS_ERRORS" => "YES",
+  }
+
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(spec)
+  else
+    spec.dependency "React-Core"
+    spec.dependency "React-Codegen"
+    spec.dependency "ReactCommon/turbomodule/core"
+  end
+
+  if respond_to?(:spm_dependency, true)
+    BotaDeviceSDKSPMWorkaround.install!(SPM)
+    local_path = ENV[apple.fetch("localPackagePathEnvironment")]
+    source = local_path.nil? || local_path.empty? ? apple.fetch("packageUrl") : File.expand_path(local_path)
+    requirement = local_path.nil? || local_path.empty? ? {
+      kind: apple.fetch("packageRequirement"),
+      version: version,
+    } : {}
+
+    spm_dependency(
+      spec,
+      url: source,
+      requirement: requirement,
+      products: [apple.fetch("packageProduct")],
+    )
+  end
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bota
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# Bota SDK for React Native
+
+Bluetooth device SDK for Bota Pin and Bota Note applications. The 2.x candidate
+preserves the public TypeScript API of `@bota.dev/react-native-sdk@0.0.65`
+while moving Bluetooth workflows and recording, streaming, and firmware bytes
+into the native Apple and Android SDKs.
+
+## Requirements
+
+- React Native `0.86.3` or newer with the New Architecture enabled
+- iOS `15.1` or newer
+- Android API `26` or newer
+- Node.js `22` or newer for installation and application builds
+
+## Install
+
+Prepared instructions for `2.0.0-beta.0`; registry publication is pending.
+Remove `@bota.dev/react-native-sdk` before adding the replacement; do not
+co-install both. Production maintenance 0.0.x consumers need not migrate.
+
+```bash
+npm install --save-exact @bota.dev/react-native-app-sdk@2.0.0-beta.0
+npx pod-install
+```
+
+Rebuild the native iOS and Android applications after installation. An Expo Go
+runtime cannot load this native module; use a development or production build.
+
+Expo prebuild and EAS projects must set the Android minimum SDK explicitly. Add
+the Expo-compatible `expo-build-properties` package and configure it in the app
+config:
+
+```ts
+plugins: [
+  [
+    'expo-build-properties',
+    {
+      android: {
+        minSdkVersion: 26,
+      },
+    },
+  ],
+],
+```
+
+## Configure
+
+```ts
+import { BotaClient } from '@bota.dev/react-native-app-sdk';
+
+await BotaClient.configure({
+  environment: 'production',
+});
+
+await BotaClient.waitForBluetooth();
+```
+
+The `BotaClient.devices`, `BotaClient.recordings`, and `BotaClient.ota`
+managers become available after configuration completes.
+
+## Encrypted upload v2
+
+The target encrypted-upload-v2 runtime is an additive `BotaDeviceSDK` API; it
+does not change the legacy `BotaClient` recording providers or events:
+
+```ts
+import { BotaDeviceSDK } from '@bota.dev/react-native-app-sdk';
+
+await BotaDeviceSDK.recordings.syncEncryptedRecordingV2(
+  device,
+  recording,
+  async (request) => selectNativeEncryptedUploadV2(request),
+  (progress) => updateUploadProgress(progress),
+);
+```
+
+The provider receives a fresh native capability snapshot, immutable recording
+identity, and optional versioned checkpoint. It returns only the upload
+session, owner revision, security policy, and an opaque native material
+registration ID. Before returning that ID, application-native Swift or Kotlin
+code must register the complete material once with
+`BotaDeviceSDKEncryptedUploadV2Materials.register(...)`. Authorization,
+manifest, receipt, staging URL/header/credentials, native file bytes/paths,
+keys, nonces, tags, ciphertext, and plaintext must remain in that native
+adapter and never cross JavaScript or Codegen. Selection is explicit and never
+downgrades to a legacy profile.
+
+Runtime compatibility metadata remains disabled until the separate firmware,
+release, and hardware gates pass; this API does not advertise device support.
+Its target-facade tests and the maintenance SDK `0.0.67` runtime tests are
+cross-referenced by the same canonical v2 workflow evidence in CI and tagged
+release verification. The frozen public compatibility surface remains `0.0.65`.
+
+## Documentation
+
+See [docs.bota.dev](https://docs.bota.dev) for pairing, provisioning,
+recording transfer, WiFi, OTA, and device-management guides.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,76 @@
+import groovy.json.JsonSlurper
+
+def packageJson = new JsonSlurper().parse(file("../package.json"))
+def androidMetadata = packageJson.bota.android
+def packageVersion = packageJson.version
+
+buildscript {
+  ext.BotaDeviceSDK = [
+    kotlinVersion: "2.1.20",
+    minSdkVersion: 26,
+    compileSdkVersion: 36,
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+    return BotaDeviceSDK[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.13.2"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+apply plugin: "com.facebook.react"
+
+react {
+  root = file("..")
+  reactNativeDir = file("../node_modules/react-native")
+  codegenDir = file("../node_modules/@react-native/codegen")
+  jsRootDir = file("../src")
+  libraryName = "BotaDeviceSDKSpec"
+  codegenJavaPackageName = "dev.bota.sdk.reactnative"
+}
+
+android {
+  namespace "dev.bota.sdk.reactnative"
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = "17"
+    allWarningsAsErrors = true
+  }
+
+  lint {
+    abortOnError = true
+    checkReleaseBuilds = true
+    warningsAsErrors = true
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "${androidMetadata.mavenCoordinate}:${packageVersion}"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:${androidMetadata.coroutinesVersion}"
+  testImplementation "junit:junit:4.13.2"
+  testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:${androidMetadata.coroutinesVersion}"
+}

package/android/src/main/AndroidManifest.xml

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

package/android/src/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidDevices.kt

@@ -0,0 +1,172 @@
+package dev.bota.sdk.reactnative
+
+import dev.bota.sdk.BotaDeviceClient
+import dev.bota.sdk.DeviceReconnectHint
+import dev.bota.sdk.model.ConnectedDevice
+import dev.bota.sdk.model.DeviceStatus
+import dev.bota.sdk.model.DiscoveredDevice
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+internal interface BotaDeviceSDKAndroidDeviceClient {
+    suspend fun startScan(timeoutMilliseconds: ULong, allowDuplicates: Boolean): Flow<DiscoveredDevice>
+
+    suspend fun cancelCurrentOperation()
+
+    suspend fun connect(device: DiscoveredDevice): ConnectedDevice
+
+    suspend fun reconnect(serialNumber: String, hint: DeviceReconnectHint): ConnectedDevice
+
+    suspend fun disconnect()
+
+    suspend fun readStatus(): DeviceStatus
+
+    suspend fun statusUpdates(): Flow<DeviceStatus>
+}
+
+internal class BotaDeviceSDKSharedAndroidDeviceClient(
+    private val client: BotaDeviceClient = BotaDeviceClient.shared,
+) : BotaDeviceSDKAndroidDeviceClient {
+    override suspend fun startScan(
+        timeoutMilliseconds: ULong,
+        allowDuplicates: Boolean,
+    ): Flow<DiscoveredDevice> = client.devices.startScan(timeoutMilliseconds, allowDuplicates)
+
+    override suspend fun cancelCurrentOperation() {
+        client.devices.cancelCurrentOperation()
+    }
+
+    override suspend fun connect(device: DiscoveredDevice): ConnectedDevice = client.devices.connect(device)
+
+    override suspend fun reconnect(
+        serialNumber: String,
+        hint: DeviceReconnectHint,
+    ): ConnectedDevice = client.devices.reconnect(serialNumber, hint)
+
+    override suspend fun disconnect() {
+        client.devices.disconnect()
+    }
+
+    override suspend fun readStatus(): DeviceStatus = client.devices.readStatus()
+
+    override suspend fun statusUpdates(): Flow<DeviceStatus> = client.devices.statusUpdates()
+}
+
+internal class BotaDeviceSDKAndroidDevices(
+    private val client: BotaDeviceSDKAndroidDeviceClient,
+    private val scope: CoroutineScope,
+) {
+    private val operations = Mutex()
+    private val scanLock = Any()
+    private val statusLock = Any()
+    private var activeScan: Job? = null
+    private var activeStatusUpdates: Job? = null
+
+    suspend fun startScan(
+        timeoutMilliseconds: ULong,
+        allowDuplicates: Boolean,
+        onError: (Throwable) -> Unit = {},
+        onDevice: (DiscoveredDevice) -> Unit,
+    ) = operations.withLock {
+        stopScanOwned()
+        val stream = client.startScan(timeoutMilliseconds, allowDuplicates)
+        lateinit var task: Job
+        task = scope.launch(start = CoroutineStart.LAZY) {
+            try {
+                stream.collect(onDevice)
+            } catch (_: CancellationException) {
+                // Explicit stop is not a scan failure.
+            } catch (error: Throwable) {
+                onError(error)
+            } finally {
+                synchronized(scanLock) {
+                    if (activeScan === task) activeScan = null
+                }
+            }
+        }
+        synchronized(scanLock) { activeScan = task }
+        task.start()
+    }
+
+    suspend fun stopScan() = operations.withLock {
+        stopScanOwned()
+    }
+
+    suspend fun connect(device: DiscoveredDevice): ConnectedDevice = operations.withLock {
+        stopScanOwned()
+        stopStatusUpdatesOwned()
+        client.connect(device)
+    }
+
+    suspend fun reconnect(serialNumber: String, hint: DeviceReconnectHint): ConnectedDevice = operations.withLock {
+        stopScanOwned()
+        stopStatusUpdatesOwned()
+        client.reconnect(serialNumber, hint)
+    }
+
+    suspend fun disconnect() = operations.withLock {
+        stopScanOwned()
+        stopStatusUpdatesOwned()
+        client.disconnect()
+    }
+
+    suspend fun readStatus(): DeviceStatus = operations.withLock {
+        client.readStatus()
+    }
+
+    suspend fun startStatusUpdates(
+        onError: (Throwable) -> Unit = {},
+        onStatus: (DeviceStatus) -> Unit,
+    ) = operations.withLock {
+        stopStatusUpdatesOwned()
+        val stream = client.statusUpdates()
+        lateinit var task: Job
+        task = scope.launch(start = CoroutineStart.LAZY) {
+            try {
+                stream.collect(onStatus)
+            } catch (_: CancellationException) {
+                // Explicit stop is not a status subscription failure.
+            } catch (error: Throwable) {
+                onError(error)
+            } finally {
+                synchronized(statusLock) {
+                    if (activeStatusUpdates === task) activeStatusUpdates = null
+                }
+            }
+        }
+        synchronized(statusLock) { activeStatusUpdates = task }
+        task.start()
+    }
+
+    suspend fun stopStatusUpdates() = operations.withLock {
+        stopStatusUpdatesOwned()
+    }
+
+    suspend fun stopAll() = operations.withLock {
+        stopScanOwned()
+        stopStatusUpdatesOwned()
+    }
+
+    private suspend fun stopScanOwned() {
+        val scan = synchronized(scanLock) {
+            activeScan.also { activeScan = null }
+        } ?: return
+        scan.cancelAndJoin()
+        runCatching { client.cancelCurrentOperation() }
+    }
+
+    private suspend fun stopStatusUpdatesOwned() {
+        val updates = synchronized(statusLock) {
+            activeStatusUpdates.also { activeStatusUpdates = null }
+        } ?: return
+        updates.cancelAndJoin()
+    }
+}

package/android/src/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidLifecycle.kt

@@ -0,0 +1,100 @@
+package dev.bota.sdk.reactnative
+
+import android.content.Context
+import dev.bota.sdk.BotaConfiguration
+import dev.bota.sdk.BotaDeviceClient
+import java.io.File
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+internal interface BotaDeviceSDKAndroidClient {
+    suspend fun configure(storageDirectory: File?)
+
+    suspend fun destroy()
+}
+
+internal class BotaDeviceSDKSharedAndroidClient(
+    context: Context,
+    private val client: BotaDeviceClient = BotaDeviceClient.shared,
+) : BotaDeviceSDKAndroidClient {
+    private val applicationContext = context.applicationContext
+
+    override suspend fun configure(storageDirectory: File?) {
+        client.configure(
+            BotaConfiguration(
+                context = applicationContext,
+                storageDirectory = storageDirectory,
+            ),
+        )
+    }
+
+    override suspend fun destroy() {
+        client.destroy()
+    }
+}
+
+internal data class BotaDeviceSDKAndroidCapabilities(
+    val backgroundReconnect: Boolean,
+    val backgroundScan: Boolean,
+    val bluetooth: Boolean,
+    val nativeFileTransfer: Boolean,
+    val platform: String,
+) {
+    companion object {
+        val current = BotaDeviceSDKAndroidCapabilities(
+            backgroundReconnect = false,
+            backgroundScan = false,
+            bluetooth = true,
+            nativeFileTransfer = true,
+            platform = "android",
+        )
+    }
+}
+
+internal class BotaDeviceSDKAndroidLifecycle(
+    private val client: BotaDeviceSDKAndroidClient,
+) {
+    private enum class Phase(val externalName: String) {
+        UNINITIALIZED("uninitialized"),
+        INITIALIZING("initializing"),
+        READY("ready"),
+        ERROR("error"),
+        DESTROYING("uninitialized"),
+    }
+
+    private val lifecycle = Mutex()
+
+    @Volatile
+    private var phase = Phase.UNINITIALIZED
+
+    suspend fun configure(storageDirectory: File?) {
+        lifecycle.withLock {
+            if (phase == Phase.READY) return
+            phase = Phase.INITIALIZING
+            try {
+                client.configure(storageDirectory)
+                phase = Phase.READY
+            } catch (error: Throwable) {
+                phase = Phase.ERROR
+                throw error
+            }
+        }
+    }
+
+    suspend fun destroy() {
+        lifecycle.withLock {
+            if (phase == Phase.UNINITIALIZED) return
+            phase = Phase.DESTROYING
+            try {
+                client.destroy()
+            } finally {
+                phase = Phase.UNINITIALIZED
+            }
+        }
+    }
+
+    fun state(): String = phase.externalName
+
+    fun capabilities(): BotaDeviceSDKAndroidCapabilities =
+        BotaDeviceSDKAndroidCapabilities.current
+}

package/android/src/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidLogs.kt

@@ -0,0 +1,82 @@
+package dev.bota.sdk.reactnative
+
+import dev.bota.sdk.BotaDeviceClient
+import dev.bota.sdk.model.ConnectedDevice
+import dev.bota.sdk.model.DeviceLogLine
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+internal interface BotaDeviceSDKAndroidLogClient {
+    fun streamLogs(device: ConnectedDevice): Flow<DeviceLogLine>
+
+    suspend fun stop()
+}
+
+internal class BotaDeviceSDKSharedAndroidLogClient(
+    private val client: BotaDeviceClient = BotaDeviceClient.shared,
+) : BotaDeviceSDKAndroidLogClient {
+    override fun streamLogs(device: ConnectedDevice): Flow<DeviceLogLine> =
+        client.logs.streamLogs(device)
+
+    override suspend fun stop() {
+        client.logs.stop()
+    }
+}
+
+internal class BotaDeviceSDKAndroidLogs(
+    private val client: BotaDeviceSDKAndroidLogClient,
+    private val scope: CoroutineScope,
+) {
+    private val operations = Mutex()
+    private val streamLock = Any()
+    private var activeStream: Job? = null
+
+    suspend fun start(
+        device: ConnectedDevice,
+        onError: (Throwable) -> Unit = {},
+        onLine: (DeviceLogLine) -> Unit,
+    ) = operations.withLock {
+        stopOwned()
+        val stream = client.streamLogs(device)
+        lateinit var task: Job
+        task = scope.launch(start = CoroutineStart.LAZY) {
+            try {
+                stream.collect(onLine)
+            } catch (_: CancellationException) {
+                // Explicit stop is not a log-stream failure.
+            } catch (error: Throwable) {
+                onError(error)
+            } finally {
+                synchronized(streamLock) {
+                    if (activeStream === task) activeStream = null
+                }
+            }
+        }
+        synchronized(streamLock) { activeStream = task }
+        task.start()
+    }
+
+    suspend fun stop() = operations.withLock {
+        stopOwned()
+    }
+
+    suspend fun cancelAll() {
+        runCatching { stop() }
+    }
+
+    private suspend fun stopOwned() {
+        val stream = synchronized(streamLock) {
+            activeStream.also { activeStream = null }
+        } ?: return
+        stream.cancelAndJoin()
+        client.stop()
+    }
+}