@bota.dev/react-native-app-sdk 2.0.0-beta.1 → 2.0.0-beta.10

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

@@ -11,6 +11,7 @@ import dev.bota.sdk.EncryptedUploadV2Material
 import dev.bota.sdk.EncryptedUploadV2ProfileProvider
 import dev.bota.sdk.EncryptedUploadV2ProviderContext
 import dev.bota.sdk.EncryptedUploadV2Recording
+import dev.bota.sdk.PendingRecording
 import dev.bota.sdk.RecordingSyncEvent
 import dev.bota.sdk.RecordingTransferMetadata
 import dev.bota.sdk.UploadOwnershipEvent
@@ -28,11 +29,19 @@ import dev.bota.sdk.model.StreamingUploadMethod
 import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
+import kotlinx.coroutines.job
+import kotlinx.coroutines.withContext
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.collect
 
 internal interface BotaDeviceSDKAndroidRecordingClient {
     suspend fun listRecordings(device: ConnectedDevice): List<DeviceRecording>
+    suspend fun listPendingRecordings(device: ConnectedDevice): List<PendingRecording>
 
     fun syncRecording(
         device: ConnectedDevice,
@@ -45,9 +54,12 @@ internal interface BotaDeviceSDKAndroidRecordingClient {
     suspend fun syncEncryptedRecordingV2(
         device: ConnectedDevice,
         recording: EncryptedUploadV2Recording,
+        operationId: UUID,
         provider: EncryptedUploadV2ProfileProvider,
     )
 
+    suspend fun cancelEncryptedRecordingV2(operationId: UUID)
+
     suspend fun confirmRecording(device: ConnectedDevice, recordingUuid: String)
 
     fun observeUploadOwnership(
@@ -74,6 +86,7 @@ internal fun BotaDeviceSDKAndroidRecordings.BotaRecordingFile.toWritableMap(): W
     Arguments.createMap().apply {
         putString("localPath", localPath)
         putBoolean("e2eEncrypted", isE2EEncrypted)
+        putDouble("fileSizeBytes", fileSizeBytes.toDouble())
         contentSha256Hex?.let { putString("contentSha256", it) }
     }
 
@@ -89,6 +102,10 @@ internal data class BotaEncryptedUploadV2Recording(
     val generation: UInt,
     val ciphertextLength: String,
     val ciphertextSha256: String,
+    val startedAtMs: String,
+    val durationMs: String,
+    val plaintextLength: String,
+    val storageFormat: Int,
 )
 
 internal data class BotaEncryptedUploadV2Capability(
@@ -199,11 +216,15 @@ internal fun BotaEncryptedUploadV2Progress.toWritableMap(): WritableMap = Argume
     protocolStatus?.let { putDouble("protocolStatus", it.toDouble()) }
 }
 
-private fun BotaEncryptedUploadV2Recording.toWritableMap(): WritableMap = Arguments.createMap().apply {
+internal fun BotaEncryptedUploadV2Recording.toWritableMap(): WritableMap = Arguments.createMap().apply {
     putString("uuid", uuid)
     putDouble("generation", generation.toDouble())
     putString("ciphertextLength", ciphertextLength)
     putString("ciphertextSha256", ciphertextSha256)
+    putString("startedAtMs", startedAtMs)
+    putString("durationMs", durationMs)
+    putString("plaintextLength", plaintextLength)
+    putInt("storageFormat", storageFormat)
 }
 
 private fun BotaEncryptedUploadV2Capability.toWritableMap(): WritableMap = Arguments.createMap().apply {
@@ -240,6 +261,9 @@ internal class BotaDeviceSDKSharedAndroidRecordingClient(
     override suspend fun listRecordings(device: ConnectedDevice): List<DeviceRecording> =
         client.recordings.listRecordings(device)
 
+    override suspend fun listPendingRecordings(device: ConnectedDevice): List<PendingRecording> =
+        client.recordings.listPendingRecordings(device)
+
     override fun syncRecording(
         device: ConnectedDevice,
         recording: DeviceRecording,
@@ -257,9 +281,14 @@ internal class BotaDeviceSDKSharedAndroidRecordingClient(
     override suspend fun syncEncryptedRecordingV2(
         device: ConnectedDevice,
         recording: EncryptedUploadV2Recording,
+        operationId: UUID,
         provider: EncryptedUploadV2ProfileProvider,
     ) {
-        client.recordings.syncEncryptedRecordingV2(device, recording, provider)
+        client.recordings.syncEncryptedRecordingV2(device, recording, operationId, provider)
+    }
+
+    override suspend fun cancelEncryptedRecordingV2(operationId: UUID) {
+        client.recordings.cancelEncryptedRecordingV2(operationId)
     }
 
     override suspend fun confirmRecording(device: ConnectedDevice, recordingUuid: String) {
@@ -304,17 +333,28 @@ internal class BotaDeviceSDKSharedAndroidRecordingClient(
 internal class BotaDeviceSDKAndroidRecordings(
     private val client: BotaDeviceSDKAndroidRecordingClient =
         BotaDeviceSDKSharedAndroidRecordingClient(),
+    private val fileSize: (String) -> Long = { path ->
+        val file = java.nio.file.Paths.get(path)
+        check(java.nio.file.Files.isRegularFile(file)) { "recording transfer did not produce a regular file" }
+        java.nio.file.Files.size(file)
+    },
 ) {
     private val destinationRequests = ConcurrentHashMap<
         String,
         CompletableDeferred<StreamingUploadDestination>
     >()
     private data class EncryptedUploadV2Request(
+        val operationId: String,
         val recording: EncryptedUploadV2Recording,
         val material: CompletableDeferred<EncryptedUploadV2Material>,
-    )
+    ) {
+        @Volatile var selectedMaterial: EncryptedUploadV2Material? = null
+    }
     private val encryptedUploadV2Requests =
         ConcurrentHashMap<String, EncryptedUploadV2Request>()
+    private data class EncryptedUploadV2Operation(val id: UUID, val job: Job)
+    private val encryptedUploadV2Operations = ConcurrentHashMap<String, EncryptedUploadV2Operation>()
+    private val cancelledEncryptedUploadV2Operations = ConcurrentHashMap.newKeySet<String>()
     private val finalizeRequests = ConcurrentHashMap<String, CompletableDeferred<Unit>>()
     @Volatile private var activeStreamingSessionId: String? = null
 
@@ -322,11 +362,37 @@ internal class BotaDeviceSDKAndroidRecordings(
         val localPath: String,
         val isE2EEncrypted: Boolean,
         val contentSha256Hex: String?,
+        val fileSizeBytes: Long,
     )
 
     suspend fun listRecordings(device: ConnectedDevice): List<DeviceRecording> =
         client.listRecordings(device)
 
+    suspend fun listPendingRecordings(device: ConnectedDevice): List<PendingRecording> =
+        client.listPendingRecordings(device)
+
+    suspend fun cancelEncryptedRecordingV2(operationId: String) {
+        val caller = currentCoroutineContext().job
+        cancelledEncryptedUploadV2Operations.add(operationId)
+        val operation = encryptedUploadV2Operations[operationId]
+        operation?.job?.cancel()
+        encryptedUploadV2Requests.entries.forEach { (id, request) ->
+            if (request.operationId == operationId && encryptedUploadV2Requests.remove(id, request)) {
+                request.material.completeExceptionally(CancellationException())
+            }
+        }
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(operationId)
+        if (operation != null) {
+            withContext(NonCancellable) {
+                try {
+                    client.cancelEncryptedRecordingV2(operation.id)
+                } finally {
+                    if (operation.job !== caller) operation.job.join()
+                }
+            }
+        }
+    }
+
     suspend fun syncRecording(
         device: ConnectedDevice,
         recording: DeviceRecording,
@@ -346,6 +412,7 @@ internal class BotaDeviceSDKAndroidRecordings(
             localPath,
             metadata?.isE2EEncrypted ?: false,
             metadata?.contentSha256Hex,
+            fileSize(localPath),
         )
     }
 
@@ -356,10 +423,16 @@ internal class BotaDeviceSDKAndroidRecordings(
         onProfileRequest: (BotaEncryptedUploadV2ProfileRequest) -> Unit,
         onProgress: (BotaEncryptedUploadV2Progress) -> Unit,
     ) {
+        val operation = EncryptedUploadV2Operation(UUID.randomUUID(), currentCoroutineContext().job)
+        check(encryptedUploadV2Operations.putIfAbsent(operationId, operation) == null) {
+            "encrypted upload v2 operation is already active"
+        }
         try {
+            if (cancelledEncryptedUploadV2Operations.contains(operationId)) throw CancellationException()
             client.syncEncryptedRecordingV2(
                 device,
                 recording,
+                operation.id,
                 EncryptedUploadV2ProfileProvider { context ->
                     val completedBytes = context.checkpoint?.nextCiphertextOffset?.toString() ?: "0"
                     val checkpointRevision = context.checkpoint?.revision
@@ -376,17 +449,24 @@ internal class BotaDeviceSDKAndroidRecordings(
                         context,
                         onProfileRequest,
                     )
-                    onProgress(BotaEncryptedUploadV2Progress(
-                        operationId,
-                        recording.uuid,
-                        "transferring",
-                        completedBytes,
-                        recording.ciphertextLength.toString(),
-                        checkpointRevision,
-                    ))
-                    material
+                    try {
+                        currentCoroutineContext().ensureActive()
+                        onProgress(BotaEncryptedUploadV2Progress(
+                            operationId,
+                            recording.uuid,
+                            "transferring",
+                            completedBytes,
+                            recording.ciphertextLength.toString(),
+                            checkpointRevision,
+                        ))
+                        material
+                    } catch (error: Throwable) {
+                        withContext(NonCancellable) { material.cancelPreparation() }
+                        throw error
+                    }
                 },
             )
+            currentCoroutineContext().ensureActive()
             onProgress(BotaEncryptedUploadV2Progress(
                 operationId,
                 recording.uuid,
@@ -407,10 +487,13 @@ internal class BotaDeviceSDKAndroidRecordings(
                 protocolStatus = failure.protocolStatus,
             ))
             throw error
+        } finally {
+            BotaDeviceSDKEncryptedUploadV2Materials.removeContext(operationId)
+            encryptedUploadV2Operations.remove(operationId, operation)
         }
     }
 
-    fun resolveEncryptedUploadV2Profile(
+    suspend fun resolveEncryptedUploadV2Profile(
         requestId: String,
         profile: String,
         uploadSessionId: String,
@@ -419,26 +502,41 @@ internal class BotaDeviceSDKAndroidRecordings(
         materialRegistrationId: String,
     ) {
         val request = encryptedUploadV2Requests.remove(requestId)
-            ?: error("encrypted upload v2 profile request is no longer pending")
-        runCatching {
+        if (request == null) {
+            withContext(NonCancellable) { BotaDeviceSDKEncryptedUploadV2Materials.release(materialRegistrationId) }
+            error("encrypted upload v2 profile request is no longer pending")
+        }
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(request.operationId)
+        var selected: EncryptedUploadV2Material? = null
+        try {
             require(profile == "encrypted_upload_v2") {
                 "encrypted upload v2 requires an explicit matching profile"
             }
-            BotaDeviceSDKEncryptedUploadV2Materials.consume(
+            selected = BotaDeviceSDKEncryptedUploadV2Materials.consume(
                 materialRegistrationId,
                 request.recording,
                 UUID.fromString(uploadSessionId),
                 ownerRevision,
                 securityPolicy,
             )
-        }.onSuccess { request.material.complete(it) }
-            .onFailure { request.material.completeExceptionally(it) }
-            .getOrThrow()
+            request.selectedMaterial = selected
+            check(request.material.complete(selected)) {
+                "encrypted upload v2 profile request is no longer pending"
+            }
+        } catch (error: Throwable) {
+            request.material.completeExceptionally(error)
+            withContext(NonCancellable) {
+                if (selected != null) selected.cancelPreparation()
+                else BotaDeviceSDKEncryptedUploadV2Materials.release(materialRegistrationId)
+            }
+            throw error
+        }
     }
 
     fun rejectEncryptedUploadV2Profile(requestId: String, errorCode: String) {
         val request = encryptedUploadV2Requests.remove(requestId)
             ?: error("encrypted upload v2 profile request is no longer pending")
+        BotaDeviceSDKEncryptedUploadV2Materials.removeContext(request.operationId)
         val error = if (errorCode == "application_material_rejected") {
             IllegalStateException("encrypted upload v2 material was rejected")
         } else {
@@ -567,6 +665,9 @@ internal class BotaDeviceSDKAndroidRecordings(
     }
 
     suspend fun cancelAll() {
+        val operations = encryptedUploadV2Operations.toMap()
+        operations.values.forEach { it.job.cancel() }
+        operations.keys.forEach { runCatching { cancelEncryptedRecordingV2(it) } }
         rejectPendingRequests("recording operations were cancelled")
         runCatching { client.cancelCurrentOperation() }
     }
@@ -600,21 +701,34 @@ internal class BotaDeviceSDKAndroidRecordings(
         val requestId = UUID.randomUUID().toString()
         val deferred = CompletableDeferred<EncryptedUploadV2Material>()
         val request = EncryptedUploadV2Request(
+            operationId,
             context.recording,
             deferred,
         )
+        BotaDeviceSDKEncryptedUploadV2Materials.registerContext(operationId, context)
         encryptedUploadV2Requests[requestId] = request
-        onRequest(BotaEncryptedUploadV2ProfileRequest(
-            requestId,
-            operationId,
-            context.recording.toBridgeValue(),
-            context.capability.toBridgeValue(),
-            context.checkpoint?.toBridgeValue(),
-        ))
+        var delivered = false
         return try {
-            deferred.await()
+            if (cancelledEncryptedUploadV2Operations.contains(operationId)) throw CancellationException()
+            onRequest(BotaEncryptedUploadV2ProfileRequest(
+                requestId,
+                operationId,
+                context.recording.toBridgeValue(),
+                context.capability.toBridgeValue(),
+                context.checkpoint?.toBridgeValue(),
+            ))
+            deferred.await().also {
+                currentCoroutineContext().ensureActive()
+                delivered = true
+            }
         } finally {
             encryptedUploadV2Requests.remove(requestId, request)
+            BotaDeviceSDKEncryptedUploadV2Materials.removeContext(operationId)
+            if (!delivered) {
+                // A completed deferred can still lose to prompt coroutine cancellation.
+                deferred.cancel()
+                withContext(NonCancellable) { request.selectedMaterial?.cancelPreparation() }
+            }
         }
     }
 
@@ -643,7 +757,10 @@ internal class BotaDeviceSDKAndroidRecordings(
 
     private fun rejectPendingRequests(message: String) {
         val error = IllegalStateException(message)
-        encryptedUploadV2Requests.values.forEach { it.material.completeExceptionally(error) }
+        encryptedUploadV2Requests.values.forEach {
+            BotaDeviceSDKEncryptedUploadV2Materials.removeContext(it.operationId)
+            it.material.completeExceptionally(error)
+        }
         destinationRequests.values.forEach { it.completeExceptionally(error) }
         finalizeRequests.values.forEach { it.completeExceptionally(error) }
         destinationRequests.clear()
@@ -652,12 +769,16 @@ internal class BotaDeviceSDKAndroidRecordings(
     }
 }
 
-private fun EncryptedUploadV2Recording.toBridgeValue(): BotaEncryptedUploadV2Recording =
+internal fun EncryptedUploadV2Recording.toBridgeValue(): BotaEncryptedUploadV2Recording =
     BotaEncryptedUploadV2Recording(
         uuid,
         generation,
         ciphertextLength.toString(),
         ciphertextSha256.toHex(),
+        startedAtMs.toString(),
+        durationMs.toString(),
+        plaintextLength.toString(),
+        storageFormat.toInt(),
     )
 
 private fun EncryptedUploadV2CapabilitySnapshot.toBridgeValue(): BotaEncryptedUploadV2Capability {

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

@@ -1,6 +1,7 @@
 package dev.bota.sdk.reactnative
 
 import dev.bota.sdk.EncryptedUploadV2Material
+import dev.bota.sdk.EncryptedUploadV2ProviderContext
 import dev.bota.sdk.EncryptedUploadV2Recording
 import dev.bota.sdk.EncryptedUploadV2SecurityPolicy
 import java.util.UUID
@@ -9,6 +10,32 @@ import java.util.concurrent.ConcurrentHashMap
 /** Holds v2 application material in native memory and exposes only opaque IDs to JavaScript. */
 public object BotaDeviceSDKEncryptedUploadV2Materials {
     private val materials = ConcurrentHashMap<String, EncryptedUploadV2Material>()
+    private data class Context(val lease: UUID, val value: EncryptedUploadV2ProviderContext)
+    private val contexts = ConcurrentHashMap<String, Context>()
+
+    public suspend fun readAuthNonce(operationId: String): ByteArray {
+        val context = contexts[operationId]
+            ?: error("encrypted upload v2 provider context is unavailable")
+        val nonce = context.value.readAuthNonce()
+        check(contexts[operationId]?.lease == context.lease) {
+            "encrypted upload v2 provider context is unavailable"
+        }
+        return nonce.copyOf()
+    }
+
+    public suspend fun release(registrationId: String) {
+        materials.remove(registrationId)?.cancelPreparation()
+    }
+
+    internal fun registerContext(operationId: String, context: EncryptedUploadV2ProviderContext) {
+        check(contexts.putIfAbsent(operationId, Context(UUID.randomUUID(), context)) == null) {
+            "encrypted upload v2 provider context is already active"
+        }
+    }
+
+    internal fun removeContext(operationId: String) {
+        contexts.remove(operationId)
+    }
 
     public fun register(material: EncryptedUploadV2Material): String =
         UUID.randomUUID().toString().also { materials[it] = material }

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

@@ -4,6 +4,7 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.module.annotations.ReactModule
 import dev.bota.sdk.DeviceReconnectHint
 import dev.bota.sdk.DeviceApiEnvironment
@@ -42,7 +43,13 @@ internal class BotaDeviceSDKModule(
             } else {
                 null
             }
-        launch(promise) { lifecycle.configure(storageDirectory) }
+        launch(promise) {
+            lifecycle.configure(storageDirectory)
+            recordingUploads.configure(storageDirectory)
+            devices.startConnectionUpdates {
+                emitOnDeviceDisconnected(Arguments.createMap())
+            }
+        }
     }
 
     override fun destroy(promise: Promise) {
@@ -223,6 +230,37 @@ internal class BotaDeviceSDKModule(
         }
     }
 
+    override fun listPendingRecordings(device: ReadableMap, promise: Promise) {
+        launchValue(promise) {
+            Arguments.createArray().apply {
+                recordings.listPendingRecordings(device.toConnectedDevice()).forEach { recording ->
+                    pushMap(Arguments.createMap().apply {
+                        when (recording) {
+                            is dev.bota.sdk.PendingRecording.Legacy -> {
+                                putString("profile", "legacy")
+                                putMap("legacy", recording.recording.toWritableMap())
+                            }
+                            is dev.bota.sdk.PendingRecording.EncryptedV2 -> {
+                                putString("profile", "encrypted_upload_v2")
+                                putMap("encrypted", recording.recording.toBridgeValue().toWritableMap())
+                            }
+                        }
+                    })
+                }
+            }
+        }
+    }
+
+    override fun cancelEncryptedRecordingV2(operationId: String, promise: Promise) {
+        launchEncryptedUploadV2(promise) { recordings.cancelEncryptedRecordingV2(operationId) }
+    }
+
+    override fun releaseEncryptedUploadV2Material(materialRegistrationId: String, promise: Promise) {
+        launchEncryptedUploadV2(promise) {
+            BotaDeviceSDKEncryptedUploadV2Materials.release(materialRegistrationId)
+        }
+    }
+
     override fun syncRecording(
         device: ReadableMap,
         recording: ReadableMap,
@@ -264,7 +302,7 @@ internal class BotaDeviceSDKModule(
         decision: ReadableMap,
         promise: Promise,
     ) {
-        launch(promise) {
+        launchEncryptedUploadV2(promise) {
             recordings.resolveEncryptedUploadV2Profile(
                 requestId,
                 decision.getString("profile")
@@ -285,7 +323,7 @@ internal class BotaDeviceSDKModule(
         errorCode: String,
         promise: Promise,
     ) {
-        launch(promise) { recordings.rejectEncryptedUploadV2Profile(requestId, errorCode) }
+        launchEncryptedUploadV2(promise) { recordings.rejectEncryptedUploadV2Profile(requestId, errorCode) }
     }
 
     override fun startStreaming(
@@ -385,6 +423,10 @@ internal class BotaDeviceSDKModule(
         launch(promise) { recordingUploads.cancel(taskId) }
     }
 
+    override fun releaseRecordingFile(taskId: String, localPath: String, promise: Promise) {
+        launch(promise) { recordingUploads.release(taskId, localPath) }
+    }
+
     override fun loadCompatibilityUploadQueue(promise: Promise) {
         launchValue(promise) { recordingUploads.loadQueue() }
     }
@@ -453,10 +495,36 @@ internal class BotaDeviceSDKModule(
         launch(promise) { logs.stop() }
     }
 
+    override fun readDiagnosticEvents(device: ReadableMap, promise: Promise) {
+        launchValue(promise) { logs.readDiagnosticEvents(device.toConnectedDevice()).toWritableMap() }
+    }
+
+    override fun acknowledgeDiagnosticEvents(device: ReadableMap, acceptedEventIds: ReadableArray, promise: Promise) {
+        launch(promise) {
+            val ids = (0 until acceptedEventIds.size()).map { acceptedEventIds.getString(it) ?: error("diagnostic event ID is required") }
+            logs.acknowledgeDiagnosticEvents(device.toConnectedDevice(), ids)
+        }
+    }
+
     override fun readStatus(promise: Promise) {
         launchValue(promise) { devices.readStatus().toWritableMap() }
     }
 
+    override fun nextClientPresence(deviceId: String, promise: Promise) {
+        launchValue(promise) {
+            devices.nextClientPresence(deviceId)?.let { report ->
+                Arguments.createMap().apply {
+                    putInt("schemaVersion", report.schemaVersion)
+                    putString("sessionId", report.sessionId)
+                    putDouble("sequence", report.sequence.toDouble())
+                    putString("platform", report.platform)
+                    putString("sdkPackage", report.sdkPackage)
+                    putString("sdkVersion", report.sdkVersion)
+                }
+            }
+        }
+    }
+
     override fun startStatusUpdates(promise: Promise) {
         launch(promise) {
             devices.startStatusUpdates(
@@ -712,9 +780,24 @@ private fun ReadableMap.toEncryptedUploadV2Recording(): EncryptedUploadV2Recordi
         getDouble("generation").toUnsignedInt(),
         length,
         digest,
+        optionalCatalogInteger("startedAtMs"),
+        optionalCatalogInteger("durationMs"),
+        optionalCatalogInteger("plaintextLength"),
+        if (hasKey("storageFormat") && !isNull("storageFormat")) {
+            getDouble("storageFormat").toUnsignedInt().also { require(it <= 255u) }.toUByte()
+        } else 3u,
     )
 }
 
+private fun ReadableMap.optionalCatalogInteger(key: String): ULong {
+    if (!hasKey(key) || isNull(key)) return 0u
+    val value = getString(key) ?: error("encrypted upload v2 catalog integer is required")
+    require(value.matches(Regex("0|[1-9][0-9]*"))) {
+        "encrypted upload v2 catalog integer is invalid"
+    }
+    return value.toULongOrNull() ?: error("encrypted upload v2 catalog integer exceeds its bound")
+}
+
 private fun String.sha256Bytes(): ByteArray {
     require(length == 64 && all { it in '0'..'9' || it in 'a'..'f' || it in 'A'..'F' }) {
         "encrypted upload v2 ciphertext SHA-256 must contain exactly 32 hexadecimal bytes"

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

@@ -22,6 +22,38 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class BotaDeviceSDKAndroidDevicesTest {
+    @Test
+    fun transportLossIsForwardedWithoutAStatusSubscription() = runTest {
+        val verified = ConnectedDevice(
+            id = "selected", serialNumber = "EVFXXW67KP", deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.19", isProvisioned = false,
+            connectionState = ConnectionState.Connected, mtu = 247,
+        )
+        val stopped = CompletableDeferred<Unit>()
+        val client = FakeDeviceClient(
+            DiscoveredDevice("selected", rssi = -30), verified,
+            connections = flow {
+                try {
+                    emit(null)
+                    emit(verified)
+                    emit(null)
+                    emit(null)
+                    awaitCancellation()
+                } finally {
+                    stopped.complete(Unit)
+                }
+            },
+        )
+        val devices = BotaDeviceSDKAndroidDevices(client, backgroundScope)
+        var losses = 0
+        devices.startConnectionUpdates { losses += 1 }
+        assertEquals(1, losses)
+        assertEquals(0, client.statusReadCount)
+        devices.stopAll()
+        stopped.await()
+        assertEquals(1, losses)
+    }
+
     @Test
     fun unknownPairingStateUsesTheFrozenUnpairedFallback() {
         assertEquals("unpaired", PairingState.Unknown(0xFFu).toBridgeValue())
@@ -134,7 +166,10 @@ class BotaDeviceSDKAndroidDevicesTest {
         private val connected: ConnectedDevice,
         private val scanFailure: Throwable? = null,
         private val status: DeviceStatus = testDeviceStatus(),
+        private val connections: Flow<ConnectedDevice?> = kotlinx.coroutines.flow.emptyFlow(),
     ) : BotaDeviceSDKAndroidDeviceClient {
+        override fun connectionUpdates(): Flow<ConnectedDevice?> = connections
+        override suspend fun nextClientPresence(deviceId: String): dev.bota.sdk.SDKClientContext? = null
         val scanOptions = mutableListOf<Pair<ULong, Boolean>>()
         val selectedIds = mutableListOf<String>()
         val reconnectSerials = mutableListOf<String>()

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

@@ -4,6 +4,8 @@ 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 dev.bota.sdk.model.DeviceDiagnosticEvent
+import dev.bota.sdk.model.DeviceDiagnosticsBatch
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.awaitCancellation
@@ -16,6 +18,23 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class BotaDeviceSDKAndroidLogsTest {
+    @Test
+    fun diagnosticReadDoesNotAcknowledgeAndPreservesEventIDs() = runTest {
+        val client = TestAndroidLogClient()
+        val logs = BotaDeviceSDKAndroidLogs(client, CoroutineScope(coroutineContext))
+        val device = ConnectedDevice(
+            id = "selected", serialNumber = "EVFXXW67KP", deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.11", isProvisioned = true,
+            connectionState = ConnectionState.Connected, mtu = 247,
+        )
+        val batch = logs.readDiagnosticEvents(device)
+        assertTrue(client.acceptedIDs.isEmpty())
+        assertEquals("ffffffffffffffff", batch.events.single().eventId)
+        assertEquals(UInt.MAX_VALUE, batch.events.single().uptimeMs)
+        logs.acknowledgeDiagnosticEvents(device, listOf("ffffffffffffffff"))
+        assertEquals(listOf("ffffffffffffffff"), client.acceptedIDs)
+    }
+
     @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     fun logStreamEmitsSanitizedLinesAndOwnsStop() = runTest {
@@ -44,6 +63,20 @@ class BotaDeviceSDKAndroidLogsTest {
 
     private class TestAndroidLogClient : BotaDeviceSDKAndroidLogClient {
         var stopped = false
+        val acceptedIDs = mutableListOf<String>()
+
+        override suspend fun readDiagnosticEvents(device: ConnectedDevice) = DeviceDiagnosticsBatch(
+            schemaVersion = 1,
+            events = listOf(DeviceDiagnosticEvent(
+                eventId = "ffffffffffffffff", eventType = "crash", reasonCode = "exception",
+                uptimeMs = UInt.MAX_VALUE, signature = "0123456789abcdef", firmwareBuildId = "1.0.11",
+                subsystem = "system", stateBeforeEvent = "idle",
+            )),
+        )
+
+        override suspend fun acknowledgeDiagnosticEvents(device: ConnectedDevice, acceptedEventIds: List<String>) {
+            acceptedIDs.addAll(acceptedEventIds)
+        }
 
         override fun streamLogs(device: ConnectedDevice): Flow<DeviceLogLine> = flow {
             emit(DeviceLogLine("boot pass", isBacklog = true))