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

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/main/java/dev/bota/sdk/reactnative/BotaDeviceSDKPackage.kt

@@ -1,5 +1,6 @@
 package dev.bota.sdk.reactnative
 
+import dev.bota.sdk.reactnative.upload.BotaUploadV2BackendModule
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
@@ -13,6 +14,8 @@ public class BotaDeviceSDKPackage : BaseReactPackage() {
     ): NativeModule? =
         if (name == BotaDeviceSDKModule.NAME) {
             BotaDeviceSDKModule(reactContext)
+        } else if (name == BotaUploadV2BackendModule.NAME) {
+            BotaUploadV2BackendModule(reactContext)
         } else {
             null
         }
@@ -20,6 +23,12 @@ public class BotaDeviceSDKPackage : BaseReactPackage() {
     override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
         ReactModuleInfoProvider {
             mapOf(
+                BotaUploadV2BackendModule.NAME to ReactModuleInfo(
+                    name = BotaUploadV2BackendModule.NAME,
+                    className = BotaUploadV2BackendModule::class.java.name,
+                    canOverrideExistingModule = false, needsEagerInit = false,
+                    isCxxModule = false, isTurboModule = true,
+                ),
                 BotaDeviceSDKModule.NAME to ReactModuleInfo(
                     name = BotaDeviceSDKModule.NAME,
                     className = BotaDeviceSDKModule::class.java.name,

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

@@ -0,0 +1,66 @@
+package dev.bota.sdk.reactnative.upload
+
+import android.system.Os
+import android.system.OsConstants
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import dev.bota.sdk.reactnative.BotaDeviceSDKEncryptedUploadV2Materials
+import dev.bota.sdk.reactnative.NativeBotaUploadV2BackendSpec
+import java.io.File
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import org.json.JSONObject
+
+@ReactModule(name = BotaUploadV2BackendModule.NAME)
+internal class BotaUploadV2BackendModule(context: ReactApplicationContext) : NativeBotaUploadV2BackendSpec(context) {
+  companion object { const val NAME = "BotaUploadV2Backend" }
+  private val work = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+  private val credentials = CredentialBroker { requestId, operationId ->
+    emitOnCredentialsRequested(Arguments.createMap().apply {
+      putString("requestId", requestId); putString("operationId", operationId)
+    })
+  }
+  private val upload = NativeUpload(
+    UploadJournal(File(context.noBackupFilesDir, "BotaSDKUploadV2"), object : JournalDurability {
+      override fun syncDirectory(directory: File) {
+        val fd = Os.open(directory.absolutePath, OsConstants.O_RDONLY, 0)
+        try {
+          demand(OsConstants.S_ISDIR(Os.fstat(fd).st_mode), "PERSISTENCE")
+          Os.fsync(fd)
+        } finally { Os.close(fd) }
+      }
+    }), BackendUploadHttp(), credentials::request, BotaDeviceSDKEncryptedUploadV2Materials::readAuthNonce,
+  )
+  @Volatile private var destroyed = false
+
+  private fun invoke(promise: Promise, block: suspend () -> Any?) {
+    work.launch {
+      try { demand(!destroyed, "CANCELLED"); promise.resolve(block()) }
+      catch (error: Exception) {
+        val code = (error as? UploadFailure)?.code ?: "BOTA_UPLOAD_NATIVE"
+        promise.reject(code, code, null)
+      }
+    }
+  }
+  override fun prepare(inputJSON: String, promise: Promise) = invoke(promise) {
+    JSONObject(upload.prepare(inputJSON)).toString()
+  }
+  override fun cancel(operationId: String, promise: Promise) = invoke(promise) { upload.cancel(operationId); null }
+  override fun complete(operationId: String, promise: Promise) = invoke(promise) { upload.complete(operationId); null }
+  override fun resolveCredentials(requestId: String, token: String, promise: Promise) = invoke(promise) {
+    credentials.resolve(requestId, token); null
+  }
+  override fun rejectCredentials(requestId: String, promise: Promise) = invoke(promise) {
+    credentials.reject(requestId); null
+  }
+  override fun invalidate() {
+    destroyed = true
+    upload.cancelAll()
+    // Dispatched identity-creating requests must drain into their original journal.
+    super.invalidate()
+  }
+}