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

package/ios/BotaDeviceSDKAppleDevices.swift

@@ -0,0 +1,191 @@
+import BotaAppSDK
+import Foundation
+
+protocol BotaDeviceSDKAppleDeviceClient: Sendable {
+    func startScan(
+        timeoutMilliseconds: UInt64,
+        allowDuplicates: Bool
+    ) async throws -> AsyncThrowingStream<DiscoveredDevice, Error>
+    func cancelCurrentOperation() async throws
+    func connect(device: DiscoveredDevice) async throws -> ConnectedDevice
+    func reconnect(
+        serialNumber: String,
+        hint: DeviceReconnectHint
+    ) async throws -> ConnectedDevice
+    func disconnect() async throws
+    func readStatus() async throws -> DeviceStatus
+    func statusUpdates() async throws -> AsyncThrowingStream<DeviceStatus, Error>
+}
+
+struct BotaDeviceSDKSharedAppleDeviceClient: BotaDeviceSDKAppleDeviceClient {
+    private let devices: DeviceManager
+
+    init(client: BotaDeviceClient = .shared) {
+        devices = client.devices
+    }
+
+    func startScan(
+        timeoutMilliseconds: UInt64,
+        allowDuplicates: Bool
+    ) async throws -> AsyncThrowingStream<DiscoveredDevice, Error> {
+        try await devices.startScan(
+            timeoutMilliseconds: timeoutMilliseconds,
+            allowDuplicates: allowDuplicates
+        )
+    }
+
+    func cancelCurrentOperation() async throws {
+        try await devices.cancelCurrentOperation()
+    }
+
+    func connect(device: DiscoveredDevice) async throws -> ConnectedDevice {
+        try await devices.connect(device: device)
+    }
+
+    func reconnect(
+        serialNumber: String,
+        hint: DeviceReconnectHint
+    ) async throws -> ConnectedDevice {
+        try await devices.reconnect(serialNumber: serialNumber, hint: hint)
+    }
+
+    func disconnect() async throws {
+        try await devices.disconnect()
+    }
+
+    func readStatus() async throws -> DeviceStatus {
+        try await devices.readStatus()
+    }
+
+    func statusUpdates() async throws -> AsyncThrowingStream<DeviceStatus, Error> {
+        try await devices.statusUpdates()
+    }
+}
+
+actor BotaDeviceSDKAppleDevices {
+    private struct ActiveScan {
+        let id: UUID
+        let task: Task<Void, Never>
+    }
+
+    private struct ActiveStatusUpdates {
+        let id: UUID
+        let task: Task<Void, Never>
+    }
+
+    private let client: any BotaDeviceSDKAppleDeviceClient
+    private var activeScan: ActiveScan?
+    private var activeStatusUpdates: ActiveStatusUpdates?
+
+    init(client: any BotaDeviceSDKAppleDeviceClient = BotaDeviceSDKSharedAppleDeviceClient()) {
+        self.client = client
+    }
+
+    func startScan(
+        timeoutMilliseconds: UInt64,
+        allowDuplicates: Bool,
+        onDevice: @escaping @Sendable (DiscoveredDevice) -> Void,
+        onError: @escaping @Sendable (Error) -> Void = { _ in }
+    ) async throws {
+        await stopScan()
+        let stream = try await client.startScan(
+            timeoutMilliseconds: timeoutMilliseconds,
+            allowDuplicates: allowDuplicates
+        )
+        let id = UUID()
+        let task = Task {
+            do {
+                for try await device in stream {
+                    try Task.checkCancellation()
+                    onDevice(device)
+                }
+            } catch is CancellationError {
+                // Explicit stop is not a scan failure.
+            } catch {
+                onError(error)
+            }
+            scanFinished(id: id)
+        }
+        activeScan = ActiveScan(id: id, task: task)
+    }
+
+    func stopScan() async {
+        guard let scan = activeScan else { return }
+        activeScan = nil
+        scan.task.cancel()
+        try? await client.cancelCurrentOperation()
+        await scan.task.value
+    }
+
+    func connect(_ device: DiscoveredDevice) async throws -> ConnectedDevice {
+        await stopScan()
+        await stopStatusUpdates()
+        return try await client.connect(device: device)
+    }
+
+    func reconnect(
+        serialNumber: String,
+        hint: DeviceReconnectHint
+    ) async throws -> ConnectedDevice {
+        await stopScan()
+        await stopStatusUpdates()
+        return try await client.reconnect(serialNumber: serialNumber, hint: hint)
+    }
+
+    func disconnect() async throws {
+        await stopScan()
+        await stopStatusUpdates()
+        try await client.disconnect()
+    }
+
+    func readStatus() async throws -> DeviceStatus {
+        try await client.readStatus()
+    }
+
+    func startStatusUpdates(
+        onStatus: @escaping @Sendable (DeviceStatus) -> Void,
+        onError: @escaping @Sendable (Error) -> Void = { _ in }
+    ) async throws {
+        await stopStatusUpdates()
+        let stream = try await client.statusUpdates()
+        let id = UUID()
+        let task = Task {
+            do {
+                for try await status in stream {
+                    try Task.checkCancellation()
+                    onStatus(status)
+                }
+            } catch is CancellationError {
+                // Explicit stop is not a status subscription failure.
+            } catch {
+                onError(error)
+            }
+            statusUpdatesFinished(id: id)
+        }
+        activeStatusUpdates = ActiveStatusUpdates(id: id, task: task)
+    }
+
+    func stopStatusUpdates() async {
+        guard let updates = activeStatusUpdates else { return }
+        activeStatusUpdates = nil
+        updates.task.cancel()
+        await updates.task.value
+    }
+
+    func stopAll() async {
+        await stopScan()
+        await stopStatusUpdates()
+    }
+
+    private func scanFinished(id: UUID) {
+        if activeScan?.id == id {
+            activeScan = nil
+        }
+    }
+
+    private func statusUpdatesFinished(id: UUID) {
+        if activeStatusUpdates?.id == id {
+            activeStatusUpdates = nil
+        }
+    }
+}

package/ios/BotaDeviceSDKAppleLifecycle.swift

@@ -0,0 +1,167 @@
+import BotaAppSDK
+import Foundation
+
+protocol BotaDeviceSDKAppleClient: Sendable {
+    func configure(applicationSupportDirectory: URL?) async throws
+    func destroy() async
+}
+
+struct BotaDeviceSDKSharedAppleClient: BotaDeviceSDKAppleClient {
+    private let client: BotaDeviceClient
+
+    init(client: BotaDeviceClient = .shared) {
+        self.client = client
+    }
+
+    func configure(applicationSupportDirectory: URL?) async throws {
+        try await client.configure(
+            BotaConfiguration(applicationSupportDirectory: applicationSupportDirectory)
+        )
+    }
+
+    func destroy() async {
+        await client.destroy()
+    }
+}
+
+struct BotaDeviceSDKAppleCapabilities: Equatable, Sendable {
+    let backgroundReconnect: Bool
+    let backgroundScan: Bool
+    let bluetooth: Bool
+    let nativeFileTransfer: Bool
+    let platform: String
+
+    static let current = Self(
+        backgroundReconnect: false,
+        backgroundScan: false,
+        bluetooth: true,
+        nativeFileTransfer: true,
+        platform: "ios"
+    )
+}
+
+actor BotaDeviceSDKAppleLifecycle {
+    private enum Phase {
+        case uninitialized
+        case configuring(UUID, Task<Void, Error>)
+        case ready
+        case error
+        case destroying(UUID, Task<Void, Never>)
+    }
+
+    private let client: any BotaDeviceSDKAppleClient
+    private var phase = Phase.uninitialized
+    private var destroyingWaiters: [CheckedContinuation<Void, Never>] = []
+
+    init(client: any BotaDeviceSDKAppleClient = BotaDeviceSDKSharedAppleClient()) {
+        self.client = client
+    }
+
+    func configure(applicationSupportDirectory: URL?) async throws {
+        while true {
+            switch phase {
+            case .ready:
+                return
+            case let .configuring(id, task):
+                try await finishConfigure(id: id, task: task)
+                return
+            case let .destroying(id, task):
+                await task.value
+                finishDestroy(id: id)
+            case .uninitialized, .error:
+                let id = UUID()
+                let task = Task {
+                    try await client.configure(
+                        applicationSupportDirectory: applicationSupportDirectory
+                    )
+                }
+                phase = .configuring(id, task)
+                try await finishConfigure(id: id, task: task)
+                return
+            }
+        }
+    }
+
+    func destroy() async {
+        while true {
+            switch phase {
+            case .uninitialized:
+                return
+            case let .configuring(_, configureTask):
+                let id = UUID()
+                let task = Task {
+                    _ = try? await configureTask.value
+                    await client.destroy()
+                }
+                beginDestroying(id: id, task: task)
+                await task.value
+                finishDestroy(id: id)
+                return
+            case let .destroying(id, task):
+                await task.value
+                finishDestroy(id: id)
+                return
+            case .ready, .error:
+                let id = UUID()
+                let task = Task { await client.destroy() }
+                beginDestroying(id: id, task: task)
+                await task.value
+                finishDestroy(id: id)
+                return
+            }
+        }
+    }
+
+    func state() -> String {
+        switch phase {
+        case .uninitialized, .destroying:
+            "uninitialized"
+        case .configuring:
+            "initializing"
+        case .ready:
+            "ready"
+        case .error:
+            "error"
+        }
+    }
+
+    func capabilities() -> BotaDeviceSDKAppleCapabilities {
+        .current
+    }
+
+    func waitUntilDestroying() async {
+        if case .destroying = phase {
+            return
+        }
+        await withCheckedContinuation { continuation in
+            destroyingWaiters.append(continuation)
+        }
+    }
+
+    private func finishConfigure(id: UUID, task: Task<Void, Error>) async throws {
+        do {
+            try await task.value
+            if case let .configuring(activeID, _) = phase, activeID == id {
+                phase = .ready
+            }
+        } catch {
+            if case let .configuring(activeID, _) = phase, activeID == id {
+                phase = .error
+            }
+            throw error
+        }
+    }
+
+    private func beginDestroying(id: UUID, task: Task<Void, Never>) {
+        phase = .destroying(id, task)
+        let waiters = destroyingWaiters
+        destroyingWaiters.removeAll()
+        waiters.forEach { $0.resume() }
+    }
+
+    private func finishDestroy(id: UUID) {
+        if case let .destroying(activeID, _) = phase, activeID == id {
+            phase = .uninitialized
+        }
+    }
+}

package/ios/BotaDeviceSDKAppleLogs.swift

@@ -0,0 +1,79 @@
+import BotaAppSDK
+import Foundation
+
+protocol BotaDeviceSDKAppleLogClient: Sendable {
+    func streamLogs(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<DeviceLogLine, Error>
+    func stop() async throws
+}
+
+struct BotaDeviceSDKSharedAppleLogClient: BotaDeviceSDKAppleLogClient {
+    private let logs: DeviceLogManager
+
+    init(client: BotaDeviceClient = .shared) {
+        logs = client.logs
+    }
+
+    func streamLogs(
+        _ device: ConnectedDevice
+    ) async throws -> AsyncThrowingStream<DeviceLogLine, Error> {
+        try await logs.streamLogs(device)
+    }
+
+    func stop() async throws {
+        try await logs.stop()
+    }
+}
+
+actor BotaDeviceSDKAppleLogs {
+    private struct ActiveStream {
+        let id: UUID
+        let task: Task<Void, Never>
+    }
+
+    private let client: any BotaDeviceSDKAppleLogClient
+    private var activeStream: ActiveStream?
+
+    init(client: any BotaDeviceSDKAppleLogClient = BotaDeviceSDKSharedAppleLogClient()) {
+        self.client = client
+    }
+
+    func start(
+        _ device: ConnectedDevice,
+        onLine: @escaping @Sendable (DeviceLogLine) -> Void,
+        onError: @escaping @Sendable (Error) -> Void = { _ in }
+    ) async throws {
+        await stop()
+        let stream = try await client.streamLogs(device)
+        let id = UUID()
+        let task = Task {
+            do {
+                for try await line in stream {
+                    try Task.checkCancellation()
+                    onLine(line)
+                }
+            } catch is CancellationError {
+                // Explicit stop is not a log-stream failure.
+            } catch {
+                onError(error)
+            }
+            streamFinished(id: id)
+        }
+        activeStream = ActiveStream(id: id, task: task)
+    }
+
+    func stop() async {
+        guard let stream = activeStream else { return }
+        activeStream = nil
+        stream.task.cancel()
+        try? await client.stop()
+        await stream.task.value
+    }
+
+    private func streamFinished(id: UUID) {
+        if activeStream?.id == id {
+            activeStream = nil
+        }
+    }
+}

package/ios/BotaDeviceSDKAppleOTA.swift

@@ -0,0 +1,73 @@
+import BotaAppSDK
+import Foundation
+
+protocol BotaDeviceSDKAppleOTAClient: Sendable {
+    func updateFirmware(
+        _ device: ConnectedDevice,
+        image: FirmwareImage
+    ) async throws -> AsyncThrowingStream<FirmwareUpdateProgress, Error>
+    func cancelCurrentOperation() async throws
+}
+
+struct BotaDeviceSDKSharedAppleOTAClient: BotaDeviceSDKAppleOTAClient {
+    private let ota: OTAManager
+
+    init(client: BotaDeviceClient = .shared) {
+        ota = client.ota
+    }
+
+    func updateFirmware(
+        _ device: ConnectedDevice,
+        image: FirmwareImage
+    ) async throws -> AsyncThrowingStream<FirmwareUpdateProgress, Error> {
+        try await ota.updateFirmware(device, image: image)
+    }
+
+    func cancelCurrentOperation() async throws {
+        try await ota.cancelCurrentOperation()
+    }
+}
+
+actor BotaDeviceSDKAppleOTA {
+    private enum OTAError: LocalizedError {
+        case invalidURL
+
+        var errorDescription: String? {
+            "firmware URL is invalid"
+        }
+    }
+
+    private let client: any BotaDeviceSDKAppleOTAClient
+
+    init(
+        client: any BotaDeviceSDKAppleOTAClient = BotaDeviceSDKSharedAppleOTAClient()
+    ) {
+        self.client = client
+    }
+
+    func updateFirmware(
+        _ device: ConnectedDevice,
+        version: String,
+        sizeBytes: UInt32,
+        crc32: UInt32,
+        url: String,
+        onProgress: @escaping @Sendable (FirmwareUpdateProgress) -> Void
+    ) async throws {
+        guard let url = URL(string: url) else { throw OTAError.invalidURL }
+        let image = FirmwareImage(
+            version: version,
+            sizeBytes: sizeBytes,
+            crc32: crc32,
+            downloadID: UInt64.random(in: 1 ... UInt64.max),
+            request: URLRequest(url: url)
+        )
+        let progress = try await client.updateFirmware(device, image: image)
+        for try await value in progress {
+            onProgress(value)
+        }
+    }
+
+    func cancelAll() async {
+        try? await client.cancelCurrentOperation()
+    }
+}

package/ios/BotaDeviceSDKAppleRecordingUploads.swift

@@ -0,0 +1,178 @@
+import Foundation
+
+struct BotaDeviceSDKAppleRecordingUploadRequest: Sendable {
+    let taskID: String
+    let recordingID: String
+    let localPath: String
+    let uploadURL: String
+    let uploadToken: String?
+    let completeURL: String?
+    let contentType: String?
+    let contentSHA256: String?
+    let relayURL: String?
+    let relayBearerToken: String?
+}
+
+struct BotaDeviceSDKAppleRecordingUploadProgress: Equatable, Sendable {
+    let taskID: String
+    let completedBytes: Int64
+    let totalBytes: Int64
+}
+
+actor BotaDeviceSDKAppleRecordingUploads {
+    private enum UploadError: LocalizedError {
+        case alreadyActive(String)
+        case invalidResponse
+        case missingFile(String)
+        case requestFailed(Int)
+
+        var errorDescription: String? {
+            switch self {
+            case let .alreadyActive(taskID):
+                "recording upload is already active: \(taskID)"
+            case .invalidResponse:
+                "recording upload returned an invalid HTTP response"
+            case let .missingFile(path):
+                "recording file does not exist: \(path)"
+            case let .requestFailed(statusCode):
+                "recording upload failed with HTTP \(statusCode)"
+            }
+        }
+    }
+
+    private var queueFile: URL
+    private let session: URLSession
+    private var operations: [String: Task<Void, Error>] = [:]
+
+    init(
+        queueFile: URL = BotaDeviceSDKAppleRecordingUploads.defaultQueueFile(),
+        session: URLSession = .shared
+    ) {
+        self.queueFile = queueFile
+        self.session = session
+    }
+
+    func configure(applicationSupportDirectory: URL?) {
+        guard let applicationSupportDirectory else { return }
+        queueFile = applicationSupportDirectory
+            .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
+            .appendingPathComponent("compat-upload-queue.json")
+    }
+
+    func upload(
+        _ upload: BotaDeviceSDKAppleRecordingUploadRequest,
+        onProgress: @escaping @Sendable (BotaDeviceSDKAppleRecordingUploadProgress) -> Void
+    ) async throws {
+        guard operations[upload.taskID] == nil else {
+            throw UploadError.alreadyActive(upload.taskID)
+        }
+        let session = session
+        let operation = Task {
+            try await Self.performUpload(upload, session: session, onProgress: onProgress)
+        }
+        operations[upload.taskID] = operation
+        defer { operations.removeValue(forKey: upload.taskID) }
+        try await operation.value
+    }
+
+    func cancel(taskID: String) {
+        operations.removeValue(forKey: taskID)?.cancel()
+    }
+
+    func cancelAll() {
+        operations.values.forEach { $0.cancel() }
+        operations.removeAll()
+    }
+
+    func loadQueue() throws -> String {
+        guard FileManager.default.fileExists(atPath: queueFile.path) else { return "[]" }
+        return try String(contentsOf: queueFile, encoding: .utf8)
+    }
+
+    func saveQueue(_ serializedTasks: String) throws {
+        try FileManager.default.createDirectory(
+            at: queueFile.deletingLastPathComponent(),
+            withIntermediateDirectories: true
+        )
+        try Data(serializedTasks.utf8).write(to: queueFile, options: .atomic)
+    }
+
+    private static func performUpload(
+        _ upload: BotaDeviceSDKAppleRecordingUploadRequest,
+        session: URLSession,
+        onProgress: @escaping @Sendable (BotaDeviceSDKAppleRecordingUploadProgress) -> Void
+    ) async throws {
+        let fileURL = URL(fileURLWithPath: upload.localPath)
+        guard FileManager.default.fileExists(atPath: fileURL.path) else {
+            throw UploadError.missingFile(upload.localPath)
+        }
+        let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
+        let totalBytes = (attributes[.size] as? NSNumber)?.int64Value ?? 0
+        onProgress(.init(taskID: upload.taskID, completedBytes: 0, totalBytes: totalBytes))
+
+        let relay = upload.relayURL != nil
+        let destination = try Self.requiredURL(upload.relayURL ?? upload.uploadURL)
+        var request = URLRequest(url: destination)
+        request.httpMethod = relay ? "POST" : "PUT"
+        request.setValue(
+            relay ? "application/octet-stream" : (upload.contentType ?? "audio/opus"),
+            forHTTPHeaderField: "Content-Type"
+        )
+        if relay, let token = upload.relayBearerToken {
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        }
+        let (_, response) = try await session.upload(for: request, fromFile: fileURL)
+        try Self.requireSuccess(response)
+
+        if !relay,
+           let completeURL = upload.completeURL,
+           let uploadToken = upload.uploadToken
+        {
+            var completeRequest = URLRequest(url: try requiredURL(completeURL))
+            completeRequest.httpMethod = "POST"
+            completeRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            completeRequest.setValue(
+                "Bearer \(uploadToken)",
+                forHTTPHeaderField: "Authorization"
+            )
+            var body: [String: String] = ["recording_id": upload.recordingID]
+            if let contentSHA256 = upload.contentSHA256 {
+                body["content_sha256"] = contentSHA256
+            }
+            completeRequest.httpBody = try JSONSerialization.data(withJSONObject: body)
+            let (_, completeResponse) = try await session.data(for: completeRequest)
+            try requireSuccess(completeResponse)
+        }
+
+        onProgress(.init(
+            taskID: upload.taskID,
+            completedBytes: totalBytes,
+            totalBytes: totalBytes
+        ))
+        try FileManager.default.removeItem(at: fileURL)
+    }
+
+    private static func requiredURL(_ value: String) throws -> URL {
+        guard let url = URL(string: value) else { throw UploadError.invalidResponse }
+        return url
+    }
+
+    private static func requireSuccess(_ response: URLResponse) throws {
+        guard let http = response as? HTTPURLResponse else {
+            throw UploadError.invalidResponse
+        }
+        guard (200 ... 299).contains(http.statusCode) else {
+            throw UploadError.requestFailed(http.statusCode)
+        }
+    }
+
+    private static func defaultQueueFile() -> URL {
+        let base = FileManager.default.urls(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask
+        ).first ?? FileManager.default.temporaryDirectory
+        return base
+            .appendingPathComponent("BotaDeviceSDK", isDirectory: true)
+            .appendingPathComponent("compat-upload-queue.json")
+    }
+}