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

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

@@ -0,0 +1,33 @@
+package dev.bota.sdk.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+public class BotaDeviceSDKPackage : BaseReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? =
+        if (name == BotaDeviceSDKModule.NAME) {
+            BotaDeviceSDKModule(reactContext)
+        } else {
+            null
+        }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+        ReactModuleInfoProvider {
+            mapOf(
+                BotaDeviceSDKModule.NAME to ReactModuleInfo(
+                    name = BotaDeviceSDKModule.NAME,
+                    className = BotaDeviceSDKModule::class.java.name,
+                    canOverrideExistingModule = false,
+                    needsEagerInit = false,
+                    isCxxModule = false,
+                    isTurboModule = true,
+                ),
+            )
+        }
+}

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidDevicesTest.kt

@@ -0,0 +1,211 @@
+package dev.bota.sdk.reactnative
+
+import dev.bota.sdk.DeviceReconnectHint
+import dev.bota.sdk.model.ConnectedDevice
+import dev.bota.sdk.model.ConnectionState
+import dev.bota.sdk.model.DeviceType
+import dev.bota.sdk.model.DiscoveredDevice
+import dev.bota.sdk.model.DeviceFlags
+import dev.bota.sdk.model.DeviceState
+import dev.bota.sdk.model.DeviceStatus
+import dev.bota.sdk.model.LteStatus
+import dev.bota.sdk.model.PairingState
+import dev.bota.sdk.model.WifiRadioStatus
+import dev.bota.sdk.model.WireValue
+import java.time.Instant
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class BotaDeviceSDKAndroidDevicesTest {
+    @Test
+    fun unknownPairingStateUsesTheFrozenUnpairedFallback() {
+        assertEquals("unpaired", PairingState.Unknown(0xFFu).toBridgeValue())
+    }
+
+    @Test
+    fun scanAndConnectionsDelegateToTheAndroidFacade() = runTest {
+        val selected = DiscoveredDevice(
+            id = "selected",
+            name = "Bota Pin",
+            deviceType = DeviceType.BotaPin,
+            rssi = -42,
+            discoveredAt = Instant.ofEpochMilli(1_788_200_000_000),
+        )
+        val verified = ConnectedDevice(
+            id = "selected",
+            serialNumber = "EVFXXW67KP",
+            deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.11",
+            isProvisioned = false,
+            connectionState = ConnectionState.Connected,
+            mtu = 247,
+        )
+        val client = FakeDeviceClient(selected, verified)
+        val devices = BotaDeviceSDKAndroidDevices(client, backgroundScope)
+        val received = CompletableDeferred<DiscoveredDevice>()
+
+        devices.startScan(5_000u, allowDuplicates = true) { received.complete(it) }
+        assertEquals("selected", received.await().id)
+        val connected = devices.connect(selected)
+        val reconnected = devices.reconnect(
+            "EVFXXW67KP",
+            DeviceReconnectHint(
+                scanTimeoutMilliseconds = 7_000u,
+                connectionTimeoutMilliseconds = 8_000u,
+            ),
+        )
+        devices.disconnect()
+
+        assertEquals(listOf(5_000uL to true), client.scanOptions)
+        assertEquals(listOf("selected"), client.selectedIds)
+        assertEquals(listOf("EVFXXW67KP"), client.reconnectSerials)
+        assertEquals(1, client.cancelCount)
+        assertEquals(1, client.disconnectCount)
+        assertEquals("EVFXXW67KP", connected.serialNumber)
+        assertEquals("EVFXXW67KP", reconnected.serialNumber)
+    }
+
+    @Test
+    fun scanFailureIsReportedWithoutEscapingTheOwnedTask() = runTest {
+        val selected = DiscoveredDevice(
+            id = "selected",
+            name = "Bota Pin",
+            deviceType = DeviceType.BotaPin,
+            rssi = -42,
+            discoveredAt = Instant.ofEpochMilli(1_788_200_000_000),
+        )
+        val verified = ConnectedDevice(
+            id = "selected",
+            serialNumber = "EVFXXW67KP",
+            deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.11",
+            isProvisioned = false,
+            connectionState = ConnectionState.Connected,
+            mtu = 247,
+        )
+        val failure = IllegalStateException("scan failed")
+        val client = FakeDeviceClient(selected, verified, scanFailure = failure)
+        val devices = BotaDeviceSDKAndroidDevices(client, backgroundScope)
+        val reported = CompletableDeferred<Throwable>()
+
+        devices.startScan(
+            timeoutMilliseconds = 5_000u,
+            allowDuplicates = false,
+            onDevice = {},
+            onError = { reported.complete(it) },
+        )
+
+        assertEquals(failure, reported.await())
+    }
+
+    @Test
+    fun statusReadAndSubscriptionDelegateToTheAndroidFacade() = runTest {
+        val selected = DiscoveredDevice(id = "selected", name = "Bota Pin", rssi = -42)
+        val verified = ConnectedDevice(
+            id = "selected",
+            serialNumber = "EVFXXW67KP",
+            deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.11",
+            isProvisioned = false,
+            connectionState = ConnectionState.Connected,
+            mtu = 247,
+        )
+        val expected = testDeviceStatus()
+        val client = FakeDeviceClient(selected, verified, status = expected)
+        val devices = BotaDeviceSDKAndroidDevices(client, backgroundScope)
+        val received = CompletableDeferred<DeviceStatus>()
+
+        assertEquals(expected, devices.readStatus())
+        devices.startStatusUpdates { received.complete(it) }
+        assertEquals(expected, received.await())
+        devices.stopStatusUpdates()
+
+        assertEquals(1, client.statusReadCount)
+        assertEquals(1, client.statusCancelCount)
+    }
+
+    private class FakeDeviceClient(
+        private val discovered: DiscoveredDevice,
+        private val connected: ConnectedDevice,
+        private val scanFailure: Throwable? = null,
+        private val status: DeviceStatus = testDeviceStatus(),
+    ) : BotaDeviceSDKAndroidDeviceClient {
+        val scanOptions = mutableListOf<Pair<ULong, Boolean>>()
+        val selectedIds = mutableListOf<String>()
+        val reconnectSerials = mutableListOf<String>()
+        var cancelCount = 0
+        var disconnectCount = 0
+        var statusReadCount = 0
+        var statusCancelCount = 0
+
+        override suspend fun startScan(
+            timeoutMilliseconds: ULong,
+            allowDuplicates: Boolean,
+        ): Flow<DiscoveredDevice> = flow {
+            scanOptions += timeoutMilliseconds to allowDuplicates
+            scanFailure?.let { throw it }
+            emit(discovered)
+            awaitCancellation()
+        }
+
+        override suspend fun cancelCurrentOperation() {
+            cancelCount += 1
+        }
+
+        override suspend fun connect(device: DiscoveredDevice): ConnectedDevice {
+            selectedIds += device.id
+            return connected
+        }
+
+        override suspend fun reconnect(serialNumber: String, hint: DeviceReconnectHint): ConnectedDevice {
+            reconnectSerials += serialNumber
+            return connected
+        }
+
+        override suspend fun disconnect() {
+            disconnectCount += 1
+        }
+
+        override suspend fun readStatus(): DeviceStatus {
+            statusReadCount += 1
+            return status
+        }
+
+        override suspend fun statusUpdates(): Flow<DeviceStatus> = flow {
+            try {
+                emit(status)
+                awaitCancellation()
+            } finally {
+                statusCancelCount += 1
+            }
+        }
+    }
+}
+
+private fun testDeviceStatus(): DeviceStatus = DeviceStatus(
+    batteryLevel = 72,
+    batteryMv = 3_842,
+    storageTotalMb = 8_192,
+    storageUsedMb = 512,
+    state = WireValue.Known(DeviceState.Idle),
+    pendingRecordings = 2,
+    lastTimeSyncAt = Instant.ofEpochSecond(1_788_200_000),
+    signalStrength = 4,
+    flags = DeviceFlags(
+        charging = false,
+        lowBattery = false,
+        storageFull = false,
+        wifiConnected = true,
+        lteConnected = false,
+        syncActive = false,
+    ),
+    timestamp = 1_788_200_000u,
+    lteStatus = WireValue.Known(LteStatus.Off),
+    lteSignalQuality = 99,
+    wifiStatus = WireValue.Known(WifiRadioStatus.Connected),
+)

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidLifecycleTest.kt

@@ -0,0 +1,132 @@
+package dev.bota.sdk.reactnative
+
+import java.io.File
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BotaDeviceSDKAndroidLifecycleTest {
+    @Test
+    fun initialStateAndCapabilitiesDescribeAndroidAdapter() = runTest {
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(FakeClient())
+
+        assertEquals("uninitialized", lifecycle.state())
+        assertEquals(
+            BotaDeviceSDKAndroidCapabilities(
+                backgroundReconnect = false,
+                backgroundScan = false,
+                bluetooth = true,
+                nativeFileTransfer = true,
+                platform = "android",
+            ),
+            lifecycle.capabilities(),
+        )
+    }
+
+    @Test
+    fun configureForwardsExactStorageDirectoryAndBecomesReady() = runTest {
+        val client = FakeClient()
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(client)
+        val directory = File("/tmp/bota-rn-android-lifecycle")
+
+        lifecycle.configure(directory)
+
+        assertEquals(listOf(directory), client.configuredDirectories)
+        assertEquals("ready", lifecycle.state())
+    }
+
+    @Test
+    fun concurrentConfigureCallsShareOneAndroidConfiguration() = runTest {
+        val client = FakeClient(blockConfigure = true)
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(client)
+
+        val first = async { lifecycle.configure(null) }
+        client.configureStarted.await()
+        val second = async { lifecycle.configure(null) }
+
+        assertEquals("initializing", lifecycle.state())
+        client.allowConfigure.complete(Unit)
+        first.await()
+        second.await()
+
+        assertEquals(1, client.configureCalls)
+        assertEquals("ready", lifecycle.state())
+    }
+
+    @Test
+    fun configureFailureIsRecoverable() = runTest {
+        val client = FakeClient(failConfigure = true)
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(client)
+
+        val first = runCatching { lifecycle.configure(null) }
+
+        assertTrue(first.isFailure)
+        assertEquals("error", lifecycle.state())
+        client.failConfigure = false
+        lifecycle.configure(null)
+        assertEquals(2, client.configureCalls)
+        assertEquals("ready", lifecycle.state())
+    }
+
+    @Test
+    fun destroyWaitsForConfigurationAndReturnsToUninitialized() = runTest {
+        val client = FakeClient(blockConfigure = true)
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(client)
+
+        val configure = launch { lifecycle.configure(null) }
+        client.configureStarted.await()
+        val destroy = launch { lifecycle.destroy() }
+
+        assertFalse(client.destroyed.isCompleted)
+        client.allowConfigure.complete(Unit)
+        configure.join()
+        destroy.join()
+
+        assertEquals(1, client.destroyCalls)
+        assertTrue(client.destroyed.isCompleted)
+        assertEquals("uninitialized", lifecycle.state())
+    }
+
+    @Test
+    fun destroyIsIdempotent() = runTest {
+        val client = FakeClient()
+        val lifecycle = BotaDeviceSDKAndroidLifecycle(client)
+
+        lifecycle.configure(null)
+        lifecycle.destroy()
+        lifecycle.destroy()
+
+        assertEquals(1, client.destroyCalls)
+        assertEquals("uninitialized", lifecycle.state())
+    }
+
+    private class FakeClient(
+        private val blockConfigure: Boolean = false,
+        var failConfigure: Boolean = false,
+    ) : BotaDeviceSDKAndroidClient {
+        val allowConfigure = CompletableDeferred<Unit>()
+        val configureStarted = CompletableDeferred<Unit>()
+        val configuredDirectories = mutableListOf<File?>()
+        val destroyed = CompletableDeferred<Unit>()
+        var configureCalls = 0
+        var destroyCalls = 0
+
+        override suspend fun configure(storageDirectory: File?) {
+            configureCalls += 1
+            configuredDirectories += storageDirectory
+            configureStarted.complete(Unit)
+            if (blockConfigure) allowConfigure.await()
+            if (failConfigure) error("configure failed")
+        }
+
+        override suspend fun destroy() {
+            destroyCalls += 1
+            destroyed.complete(Unit)
+        }
+    }
+}

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidLogsTest.kt

@@ -0,0 +1,57 @@
+package dev.bota.sdk.reactnative
+
+import dev.bota.sdk.model.ConnectedDevice
+import dev.bota.sdk.model.ConnectionState
+import dev.bota.sdk.model.DeviceLogLine
+import dev.bota.sdk.model.DeviceType
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.awaitCancellation
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.test.runCurrent
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BotaDeviceSDKAndroidLogsTest {
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun logStreamEmitsSanitizedLinesAndOwnsStop() = runTest {
+        val client = TestAndroidLogClient()
+        val logs = BotaDeviceSDKAndroidLogs(client, CoroutineScope(coroutineContext))
+        val lines = mutableListOf<DeviceLogLine>()
+
+        logs.start(
+            ConnectedDevice(
+                id = "selected",
+                serialNumber = "EVFXXW67KP",
+                deviceType = DeviceType.BotaPin,
+                firmwareVersion = "1.0.11",
+                isProvisioned = true,
+                connectionState = ConnectionState.Connected,
+                mtu = 247,
+            ),
+            onLine = lines::add,
+        )
+        runCurrent()
+
+        assertEquals(listOf(DeviceLogLine("boot pass", isBacklog = true)), lines)
+        logs.stop()
+        assertTrue(client.stopped)
+    }
+
+    private class TestAndroidLogClient : BotaDeviceSDKAndroidLogClient {
+        var stopped = false
+
+        override fun streamLogs(device: ConnectedDevice): Flow<DeviceLogLine> = flow {
+            emit(DeviceLogLine("boot pass", isBacklog = true))
+            awaitCancellation()
+        }
+
+        override suspend fun stop() {
+            stopped = true
+        }
+    }
+}

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidOTATest.kt

@@ -0,0 +1,75 @@
+package dev.bota.sdk.reactnative
+
+import dev.bota.sdk.FirmwareImage
+import dev.bota.sdk.model.ConnectedDevice
+import dev.bota.sdk.model.ConnectionState
+import dev.bota.sdk.model.DeviceType
+import dev.bota.sdk.model.FirmwareUpdatePhase
+import dev.bota.sdk.model.FirmwareUpdateProgress
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BotaDeviceSDKAndroidOTATest {
+    @Test
+    fun firmwareDownloadAndTransferStayNative() = runTest {
+        val client = TestAndroidOTAClient()
+        val ota = BotaDeviceSDKAndroidOTA(client)
+        val progress = mutableListOf<FirmwareUpdateProgress>()
+
+        ota.updateFirmware(
+            device = ConnectedDevice(
+                id = "selected",
+                serialNumber = "EVFXXW67KP",
+                deviceType = DeviceType.BotaPin,
+                firmwareVersion = "1.0.11",
+                isProvisioned = true,
+                connectionState = ConnectionState.Connected,
+                mtu = 247,
+            ),
+            version = "1.0.12",
+            sizeBytes = 1_024_000u,
+            crc32 = 0x1234_5678u,
+            url = "https://firmware.bota.dev/update.ufw",
+            onProgress = progress::add,
+        )
+
+        val image = requireNotNull(client.image)
+        assertEquals("1.0.12", image.version)
+        assertEquals(1_024_000u, image.sizeBytes)
+        assertEquals(0x1234_5678u, image.crc32)
+        assertEquals("https://firmware.bota.dev/update.ufw", image.request.url.toString())
+        assertEquals(
+            listOf(
+                FirmwareUpdateProgress(FirmwareUpdatePhase.Downloading, 512_000u, 1_024_000u),
+                FirmwareUpdateProgress(FirmwareUpdatePhase.Complete, 1_024_000u, 1_024_000u),
+            ),
+            progress,
+        )
+        ota.cancelAll()
+        assertTrue(client.cancelled)
+    }
+
+    private class TestAndroidOTAClient : BotaDeviceSDKAndroidOTAClient {
+        var image: FirmwareImage? = null
+        var cancelled = false
+
+        override fun updateFirmware(
+            device: ConnectedDevice,
+            image: FirmwareImage,
+        ): Flow<FirmwareUpdateProgress> {
+            this.image = image
+            return flowOf(
+                FirmwareUpdateProgress(FirmwareUpdatePhase.Downloading, 512_000u, 1_024_000u),
+                FirmwareUpdateProgress(FirmwareUpdatePhase.Complete, 1_024_000u, 1_024_000u),
+            )
+        }
+
+        override suspend fun cancelCurrentOperation() {
+            cancelled = true
+        }
+    }
+}

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidRecordingUploadsTest.kt

@@ -0,0 +1,147 @@
+package dev.bota.sdk.reactnative
+
+import java.io.File
+import java.nio.file.Files
+import java.util.Collections
+import kotlinx.coroutines.test.runTest
+import okhttp3.OkHttpClient
+import okhttp3.Protocol
+import okhttp3.Response
+import okhttp3.ResponseBody.Companion.toResponseBody
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Test
+
+class BotaDeviceSDKAndroidRecordingUploadsTest {
+    @Test
+    fun plaintextUploadUsesPutCompletesAndDeletesNativeFile() = runTest {
+        val fixture = UploadFixture()
+        val requests = Collections.synchronizedList(mutableListOf<CapturedRequest>())
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(
+            fixture.queueFile,
+            stubbedClient(requests),
+        )
+        val progress = mutableListOf<BotaRecordingUploadProgress>()
+
+        uploads.upload(
+            fixture.request(
+                taskId = "task-1",
+                completeUrl = "https://api.example/complete",
+                uploadToken = "up-token",
+            ),
+            progress::add,
+        )
+
+        assertFalse(fixture.recordingFile.exists())
+        assertEquals(
+            listOf(
+                CapturedRequest("PUT", "https://s3.example/recording", null),
+                CapturedRequest(
+                    "POST",
+                    "https://api.example/complete",
+                    "Bearer up-token",
+                ),
+            ),
+            requests,
+        )
+        assertEquals(listOf(0L, 4L), progress.map { it.completedBytes })
+        assertEquals(listOf(4L, 4L), progress.map { it.totalBytes })
+    }
+
+    @Test
+    fun encryptedUploadUsesRelayAndSkipsCompletion() = runTest {
+        val fixture = UploadFixture()
+        val requests = Collections.synchronizedList(mutableListOf<CapturedRequest>())
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(
+            fixture.queueFile,
+            stubbedClient(requests),
+        )
+
+        uploads.upload(
+            fixture.request(
+                taskId = "task-2",
+                completeUrl = "https://api.example/unused",
+                uploadToken = "up-token",
+                relayUrl = "https://api.example/upload-relay",
+                relayBearerToken = "device-token",
+            ),
+        ) {}
+
+        assertEquals(
+            listOf(
+                CapturedRequest(
+                    "POST",
+                    "https://api.example/upload-relay",
+                    "Bearer device-token",
+                ),
+            ),
+            requests,
+        )
+    }
+
+    @Test
+    fun queueSaveAtomicallyReplacesExistingMetadata() = runTest {
+        val fixture = UploadFixture()
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(
+            fixture.queueFile,
+            stubbedClient(mutableListOf()),
+        )
+
+        uploads.saveQueue("[{\"id\":\"first\"}]")
+        uploads.saveQueue("[{\"id\":\"second\"}]")
+
+        assertEquals("[{\"id\":\"second\"}]", uploads.loadQueue())
+    }
+
+    private fun stubbedClient(requests: MutableList<CapturedRequest>): OkHttpClient =
+        OkHttpClient.Builder()
+            .addInterceptor { chain ->
+                val request = chain.request()
+                requests += CapturedRequest(
+                    request.method,
+                    request.url.toString(),
+                    request.header("Authorization"),
+                )
+                Response.Builder()
+                    .request(request)
+                    .protocol(Protocol.HTTP_1_1)
+                    .code(200)
+                    .message("OK")
+                    .body("".toResponseBody())
+                    .build()
+            }
+            .build()
+}
+
+private data class CapturedRequest(
+    val method: String,
+    val url: String,
+    val authorization: String?,
+)
+
+private class UploadFixture {
+    private val directory = Files.createTempDirectory("bota-recording-upload").toFile()
+    val recordingFile = File(directory, "recording.bin").apply {
+        writeBytes(byteArrayOf(1, 2, 3, 4))
+    }
+    val queueFile = File(directory, "queue.json")
+
+    fun request(
+        taskId: String,
+        completeUrl: String? = null,
+        uploadToken: String? = null,
+        relayUrl: String? = null,
+        relayBearerToken: String? = null,
+    ): BotaRecordingUploadRequest = BotaRecordingUploadRequest(
+        taskId = taskId,
+        recordingId = "rec-1",
+        localPath = recordingFile.path,
+        uploadUrl = "https://s3.example/recording",
+        uploadToken = uploadToken,
+        completeUrl = completeUrl,
+        contentType = "audio/ogg",
+        contentSha256 = "abc123",
+        relayUrl = relayUrl,
+        relayBearerToken = relayBearerToken,
+    )
+}