@blueid/access-capacitor 0.104.0 → 0.106.0

package/ios/Plugin/BlueIDAccessSDK/BlueDFU/BlueUpdateAccessDeviceFirmwareCommand.swift

@@ -0,0 +1,252 @@
+import CoreBluetooth
+import Foundation
+import NordicDFU
+
+/**
+ * @class BlueUpdateAccessDeviceFirmwareCommand
+ * A SDK command for updating firmware of nRF51 and nRF52 devices over Bluetooth LE.
+ */
+public class BlueUpdateAccessDeviceFirmwareCommand: BlueSdkAsyncCommand {
+    override func runAsync(arg0: Any?, arg1: Any?, arg2: Any?) async throws -> Any? {
+        return try await runAsync(
+            credentialID: blueCastArg(String.self, arg0),
+            deviceID: blueCastArg(String.self, arg1),
+            testVersion: blueCastArg(Bool.self, arg2)
+        )
+    }
+    
+    public func runAsync(credentialID: String, deviceID: String, testVersion: Bool? = false) async throws {
+        guard let credential = blueGetAccessCredential(credentialID: credentialID) else {
+            throw BlueError(.sdkCredentialNotFound)
+        }
+        
+        guard blueGetDevice(deviceID) != nil else {
+            throw BlueError(.sdkDeviceNotFound)
+        }
+        
+        try await BlueUpdateAccessDeviceFirmware(sdkService)
+            .update(credential, deviceID, testVersion)
+    }
+}
+
+internal class BlueUpdateAccessDeviceFirmware: LoggerDelegate, DFUServiceDelegate, DFUProgressDelegate {
+    public enum BlueUpdateAccessDeviceFirmwareTaskId {
+        case getAuthenticationToken
+        case checkLatestFirmware
+        case downloadLatestFirmware
+        case prepareUpdate
+        case startBootloader
+        case findDFUPeripheral
+        case updateFirmware
+        case waitRestart
+    }
+    
+    private let sdkService: BlueSdkService
+    
+    private var semaphore: DispatchSemaphore?
+    private var controller: DFUServiceController?
+    private var task: BlueTask?
+    private var error: BlueError? = nil
+    
+    init(_ sdkService: BlueSdkService) {
+        self.sdkService = sdkService
+    }
+    
+    public func update(_ credential: BlueAccessCredential, _ deviceID: String, _ testVersion: Bool? = false) async throws {
+        
+        let tasks = [
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.getAuthenticationToken,
+                label: blueI18n.dfuGetAuthenticationTokenTaskLabel
+            ) { _, _ in
+                .result(try await self.sdkService.authenticationTokenService.getTokenAuthentication(credential: credential))
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.checkLatestFirmware,
+                label: blueI18n.dfuCheckLatestFwlabel
+            ) { _, runner in
+                let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.getAuthenticationToken)
+                
+                return .result(try await self.sdkService.apiService.getLatestFirmware(deviceID: deviceID, with: tokenAuthentication).getData())
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.downloadLatestFirmware,
+                label: blueI18n.dfuDownloadLatestFwlabel
+            ) { task, runner in
+                let latestFW: BlueGetLatestFirmwareResult = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.checkLatestFirmware)
+                
+                task.updateLabel("\(blueI18n.dfuDownloadLatestFwlabel) (\(self.getFirmwareVersion(latestFW, testVersion)))")
+                
+                let url = testVersion == true ? latestFW.test?.url : latestFW.production?.url
+                
+                guard let url = url else {
+                    throw BlueError(.sdkInvalidFirmwareURL, detail: "NULL")
+                }
+                
+                return .result(try await self.downloadLatestFirmware(url: url))
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.prepareUpdate,
+                label: blueI18n.dfuPrepareUpdateLabel
+            ) { _, runner in
+                let zip: Data = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.downloadLatestFirmware)
+                
+                return .result(try self.prepareUpdate(zip))
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.startBootloader,
+                label: blueI18n.dfuStartBootloaderLabel
+            ) { _, _ in
+                return .result(try await self.startBootloader(deviceID))
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.findDFUPeripheral,
+                label: blueI18n.dfuInitializationLabel
+            ) { _, _ in
+                return .result(try await self.findPeripheral())
+            },
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.updateFirmware,
+                label: blueI18n.dfuUpdateFwlabel,
+                progress: 0,
+                cancelHandler: {
+                    _ = self.controller?.abort()
+                },
+                handler: { task, runner in
+                    let latestFW: BlueGetLatestFirmwareResult = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.checkLatestFirmware)
+                    let urlToZipFile: URL = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.prepareUpdate)
+                    let peripheral: CBPeripheral = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.findDFUPeripheral)
+                    
+                    task.updateLabel("\(blueI18n.dfuUpdateFwlabel) (\(self.getFirmwareVersion(latestFW, testVersion)))")
+                    
+                    self.task = task
+                    
+                    return .result(try self.update(peripheral, urlToZipFile))
+                }
+            ),
+            
+            BlueTask(
+                id: BlueUpdateAccessDeviceFirmwareTaskId.waitRestart,
+                label: blueI18n.dfuWaitForDeviceToRestartTaskLabel
+            ) { _, _ in
+                return .result(try await waitForDeviceAvailability(deviceID, timeout: 5, maxRetries: 6))
+            }
+        ]
+        
+        let runner = BlueSerialTaskRunner(tasks)
+        
+#if os(iOS) || os(watchOS)
+        try await blueShowUpdateAccessDeviceFirmwareModal(runner)
+#else
+        try await runner.execute(true)
+#endif
+    }
+    
+    private func getFirmwareVersion(_ latestFW: BlueGetLatestFirmwareResult, _ testVersion: Bool? = false) -> String {
+        if testVersion == true {
+            if let testFW = latestFW.test {
+                if let minor = testFW.testVersion {
+                    return "\(minor)"
+                }
+            }
+        } else if let prodFW = latestFW.production {
+            return "\(prodFW.version)"
+        }
+        
+        return "?"
+    }
+    
+    private func downloadLatestFirmware(url string: String) async throws -> Data {
+        guard let url = URL(string: string) else {
+            throw BlueError(.sdkInvalidFirmwareURL)
+        }
+        
+        return try await BlueFetch.get(url: url).getData()
+    }
+    
+    private func prepareUpdate(_ zip: Data) throws -> URL {
+        let extractedURL = try BlueZip.extract(data: zip)
+        
+        return extractedURL.appendingPathComponent("dfu_application.zip")
+    }
+    
+    private func startBootloader(_ deviceID: String) async throws {
+        try await blueTerminalRun(deviceID: deviceID, action: "BOOTLD")
+    }
+    
+    private func findPeripheral() async throws -> CBPeripheral {
+        let service = BlueDFUPeripheralService()
+        
+        defer {
+            service.destroy()
+        }
+        
+        return try await service.find()
+    }
+    
+    private func update(_ peripheral: CBPeripheral, _ urlToZipFile: URL) throws {
+        self.semaphore = DispatchSemaphore(value: 0)
+        
+        let firmware = try DFUFirmware(urlToZipFile: urlToZipFile)
+        
+        let initiator = DFUServiceInitiator()
+        initiator.logger = self
+        initiator.delegate = self
+        initiator.progressDelegate = self
+
+        self.controller = initiator
+            .with(firmware: firmware)
+            .start(targetWithIdentifier: peripheral.identifier)
+        
+        self.semaphore?.wait()
+        
+        if let error = error {
+            throw error
+        }
+    }
+    
+    // MARK: - LoggerDelegate API
+    
+    public func logWith(_ level: NordicDFU.LogLevel, message: String) {
+        switch (level) {
+            case .debug, .application, .verbose:
+                blueLogDebug(message)
+                break
+            case .info:
+                blueLogInfo(message)
+                break
+            case .warning:
+                blueLogWarn(message)
+                break
+            case .error:
+                blueLogError(message)
+                break
+        }
+    }
+    
+    // MARK: - DFUServiceDelegate API
+    
+    public func dfuStateDidChange(to state: NordicDFU.DFUState) {        
+        if state == .completed || state == .aborted {
+            semaphore?.signal()
+        }
+    }
+    
+    public func dfuError(_ error: NordicDFU.DFUError, didOccurWithMessage message: String) {
+        self.error = BlueError(.error, detail: message)
+        
+        semaphore?.signal()
+    }
+    
+    // MARK: - DFUProgressDelegate API
+    
+    public func dfuProgressDidChange(for part: Int, outOf totalParts: Int, to progress: Int, currentSpeedBytesPerSecond: Double, avgSpeedBytesPerSecond: Double) {
+        self.task?.updateProgress(Float(progress))
+    }
+}

package/ios/Plugin/BlueIDAccessSDK/BlueDevices.swift

@@ -10,6 +10,30 @@ internal func blueSetMaxDeviceAgeSeconds(_ newMaxDeviceAgeSeconds: Double) {
     maxDeviceAgeSeconds = max(newMaxDeviceAgeSeconds, 1)
 }
 
+/// Waits asynchronously for a device with the specified ID to become available.
+/// This function waits for a device with the given ID to be discovered within a predefined timeout period, with a maximum number of retries.
+/// - parameters:
+///   - deviceID: The ID of the device to wait for.
+///   - timeout: The duration in seconds to wait for the device to be discovered each time. Default value is 10 seconds.
+///   - maxRetries: The maximum number of retries before giving up. Default value is 3.
+/// - throws: An error of type `BlueError` if the device is not found within the specified timeout period and maximum retries.
+
+internal func waitForDeviceAvailability(_ deviceID: String, timeout: Int = 10, maxRetries: Int = 3) async throws {
+    var attempts = 0
+    
+    while attempts < maxRetries {
+        try? await Task.sleep(nanoseconds: UInt64(blueSecondsToNanoseconds(timeout)))
+        
+        if blueGetDevice(deviceID) != nil {
+            return
+        }
+        
+        attempts += 1
+    }
+    
+    throw BlueError(.sdkDeviceNotFound)
+}
+
 internal func blueGetDevice(_ deviceID: String) -> BlueDevice? {
     for device in blueDevices {
         if (device.info.deviceID == deviceID) {

package/ios/Plugin/BlueIDAccessSDK/BlueError.swift

@@ -45,7 +45,7 @@ public final class BlueError: Error, LocalizedError, Equatable {
         self.detail = nil
     }
     
-    public init(_ returnCode: BlueReturnCode, cause: Error, detail: String? = nil) {
+    public init(_ returnCode: BlueReturnCode, cause: Error? = nil, detail: String? = nil) {
         self.returnCode = returnCode
         self.cause = cause
         self.detail = detail

package/ios/Plugin/BlueIDAccessSDK/BlueFetch.swift

@@ -15,6 +15,10 @@ struct BlueFetchResponse<T> where T: Decodable {
     
     func getData() throws -> T {
         guard let data = data else {
+            if let rawData = rawData as? T {
+                return rawData
+            }
+            
             let status: String = statusCode?.description ?? "Unknown"
             var description = ""
             
@@ -40,7 +44,6 @@ struct BlueFetchResponse<T> where T: Decodable {
     }
 }
 
-@available(macOS 12.0, *)
 class BlueFetch {
     
     static func post<T>(url: URL, data: Data?, config: BlueFetchConfig? = nil) async throws -> BlueFetchResponse<T> where T: Decodable {
@@ -65,18 +68,23 @@ class BlueFetch {
         
         var statusCode: Int?
         var decodedData: T?
+        var contentType: String?
         
         do {
             let (data, response) = try await URLSession.shared.data(for: request)
             
             if let httpResponse = response as? HTTPURLResponse {
                 statusCode = httpResponse.statusCode
+                contentType = httpResponse.value(forHTTPHeaderField: "content-type")
                 
                 blueLogDebug("Status code: \(httpResponse.statusCode)")
+                blueLogDebug("Content-Type: \(String(describing: contentType))")
                 blueLogDebug("Data: \(String(describing: String(data: data, encoding: .utf8)))")
             }
             
-            if (statusCode == 200) {
+            let isJSON = contentType == "application/json"
+            
+            if (statusCode == 200 && isJSON) {
                 do {
                     decodedData = try JSONDecoder().decode(T.self, from: data)
                 } catch {

package/ios/Plugin/BlueIDAccessSDK/BlueModal/BlueModal.swift

@@ -60,11 +60,36 @@ public func blueShowAccessDeviceModal(_ task: @escaping () async throws -> BlueO
 /// Displays a modal view (sheet) which performs tasks related to synchronizing a device.
 /// - parameter runner: The Task Runner.
 public func blueShowSynchronizeAccessDeviceModal(_ runner: BlueTaskRunner) async throws {
-    let session = BlueSynchronizeAccessDeviceModalSession()
+    try await blueShowStepProgressModal(
+        title: blueI18n.syncDeviceInProgressTitle,
+        failedTitle: blueI18n.syncDeviceFailedTitle,
+        completedTitle: blueI18n.syncDeviceCompletedTitle,
+        runner: runner
+    )
+}
+
+/// Displays a modal view (sheet) which performs tasks related to updating a device firmware.
+/// - parameter runner: The Task Runner.
+public func blueShowUpdateAccessDeviceFirmwareModal(_ runner: BlueTaskRunner) async throws {
+    try await blueShowStepProgressModal(
+        title: blueI18n.dfuInProgressTitle,
+        failedTitle: blueI18n.dfuFailedTitle,
+        completedTitle: blueI18n.dfuCompletedTitle,
+        runner: runner
+    )
+}
+
+private func blueShowStepProgressModal(
+    title: String,
+    failedTitle: String,
+    completedTitle: String,
+    runner: BlueTaskRunner
+) async throws {
+    let session = BlueStepProgressModalSession()
 
     blueRunInMainThread {
         session.begin(
-            title: blueI18n.syncDeviceInProgressTitle,
+            title: title,
             tasks: runner.getTasks(),
             dismiss: blueI18n.cmnCancelLabel
         ) {
@@ -87,17 +112,17 @@ public func blueShowSynchronizeAccessDeviceModal(_ runner: BlueTaskRunner) async
                 session.updateDismiss(blueI18n.cmnCloseLabel)
                 
                 if runner.isFailed() {
-                    session.updateTitle(blueI18n.syncDeviceFailedTitle)
+                    session.updateTitle(failedTitle)
                     BlueSound.shared.play(BlueNegativeSoundSystemID)
                 } else {
-                    session.updateTitle(blueI18n.syncDeviceCompletedTitle)
+                    session.updateTitle(completedTitle)
                     BlueSound.shared.play(BluePositiveSoundSystemID)
                 }
             }
         }
     } catch {
         blueRunInMainThread {
-            session.updateTitle(blueI18n.syncDeviceFailedTitle)
+            session.updateTitle(failedTitle)
             session.updateDismiss(blueI18n.cmnCloseLabel)
             BlueSound.shared.play(BlueNegativeSoundSystemID)
         }

package/ios/Plugin/BlueIDAccessSDK/BlueModal/{BlueSynchronizeAccessDeviceModalSession.swift → BlueStepProgressModalSession.swift}

@@ -2,14 +2,14 @@
 import AVFoundation
 import SwiftUI
 
-private class HostingController: UIHostingController<BlueSynchronizeAccessDeviceModalView> {
+private class HostingController: UIHostingController<BlueStepProgressModalView> {
     override var prefersHomeIndicatorAutoHidden: Bool {
         return true
     }
 }
 
-internal class BlueSynchronizeAccessDeviceModalSession {
-    private let viewModel = BlueSynchronizeAccessDeviceModalViewModel()
+internal class BlueStepProgressModalSession {
+    private let viewModel = BlueStepProgressModalViewModel()
     private var isInvalidated: Bool = false
     
     func begin(title: String, tasks: [BlueTask], dismiss: String, _ onDismiss: @escaping () -> Void) {
@@ -18,7 +18,7 @@ internal class BlueSynchronizeAccessDeviceModalSession {
         viewModel.dismiss = dismiss
         
         let hostingController = HostingController(
-            rootView: BlueSynchronizeAccessDeviceModalView(viewModel) { onDismiss() }
+            rootView: BlueStepProgressModalView(viewModel) { onDismiss() }
         )
         
         hostingController.view.backgroundColor = .clear

package/ios/Plugin/BlueIDAccessSDK/BlueModal/{BlueSynchronizeAccessDeviceModalView.swift → BlueStepProgressModalView.swift}

@@ -42,24 +42,28 @@ private func getSymbol(_ status: BlueTaskStatus) -> String {
 class BlueTaskModel: ObservableObject, Identifiable {
     @Published var label: String
     @Published var status: BlueTaskStatus
+    @Published var progress: Float?
     @Published var statusColor: Color
     @Published var textColor: Color
     @Published var symbol: String
     @Published var errorDescription: String
     @Published var isLast: Bool
     
-    private var subscriber: AnyCancellable?
+    private var labelSubscriber: AnyCancellable?
+    private var statusSubscriber: AnyCancellable?
+    private var progressSubscriber: AnyCancellable?
     
     init(_ task: BlueTask, _ isLast: Bool) {
-        self.label = task.label
+        self.label = task.label.value
         self.status = task.status.value
+        self.progress = task.progress?.value
         self.textColor = getTextColor(task.status.value)
         self.statusColor = getColor(task.status.value)
         self.symbol = getSymbol(task.status.value)
         self.errorDescription = task.errorDescription ?? ""
         self.isLast = isLast
         
-        self.subscriber = task.status.sink{ [weak self] status in
+        self.statusSubscriber = task.status.sink{ [weak self] status in
             guard let self = self else { return }
             
             self.status = status
@@ -70,6 +74,20 @@ class BlueTaskModel: ObservableObject, Identifiable {
             
             self.objectWillChange.send()
         }
+        
+        self.progressSubscriber = task.progress?.sink{ [weak self] progress in
+            guard let self = self else { return }
+            
+            self.progress = progress
+            self.objectWillChange.send()
+        }
+        
+        self.labelSubscriber = task.label.sink{ [weak self] label in
+            guard let self = self else { return }
+            
+            self.label = label
+            self.objectWillChange.send()
+        }
     }
 }
 
@@ -98,11 +116,12 @@ struct TaskView: View {
             
             HStack(alignment: .center, spacing: 0) {
                 ZStack(alignment: .leading) {
-                    Rectangle()
-                        .fill(task.statusColor)
-                        .frame(width: 2)
-                        .padding(.horizontal, 10.5)
-                        .hidden(task.isLast)
+                    if (!task.isLast) {
+                        Rectangle()
+                            .fill(task.statusColor)
+                            .frame(width: 2)
+                            .padding(.horizontal, 10.5)
+                    }
                     
                     if !task.errorDescription.isEmpty {
                         Text(task.errorDescription)
@@ -112,6 +131,12 @@ struct TaskView: View {
                             .padding(.bottom, 5)
                             .fixedSize(horizontal: false, vertical: true)
                             .alignmentGuide(.leading) { d in d[.leading] }
+                    } else {
+                        if task.status == .started && task.progress != nil {
+                            ProgressView(value: task.progress, total: 100)
+                                .padding(.leading, 32)
+                                .alignmentGuide(.leading) { d in d[.leading] }
+                        }
                     }
                 }
             }
@@ -119,7 +144,7 @@ struct TaskView: View {
     }
 }
 
-class BlueSynchronizeAccessDeviceModalViewModel: ObservableObject {
+class BlueStepProgressModalViewModel: ObservableObject {
     @Published var title = ""
     @Published var dismiss: String = ""
     @Published var dismissEnabled: Bool = true
@@ -133,10 +158,10 @@ class BlueSynchronizeAccessDeviceModalViewModel: ObservableObject {
     }
 }
 
-struct BlueSynchronizeAccessDeviceModalView: View {
-    @ObservedObject private var vm: BlueSynchronizeAccessDeviceModalViewModel
+struct BlueStepProgressModalView: View {
+    @ObservedObject private var vm: BlueStepProgressModalViewModel
     
-    internal var height: CGFloat = 550
+    internal var height: CGFloat = 570
     internal var backgroundColor: UIColor = .white
     internal var foregroundColor: UIColor = .black
     
@@ -144,7 +169,7 @@ struct BlueSynchronizeAccessDeviceModalView: View {
     private let cornerRadius: CGFloat = 35
     
     public init(
-        _ vm: BlueSynchronizeAccessDeviceModalViewModel,
+        _ vm: BlueStepProgressModalViewModel,
         _ onDismiss: @escaping () -> Void)
     {
         self.vm = vm
@@ -212,12 +237,12 @@ struct BlueSynchronizeAccessDeviceModalView: View {
     }
 }
 
-let noop: (BlueSerialTaskRunner) async throws -> BlueTaskResult = { _ in .result(nil) }
+let noop: (BlueTask, BlueSerialTaskRunner) async throws -> BlueTaskResult = { _, _ in .result(nil) }
 
-struct BlueSynchronizeAccessDeviceModalView_Preview: PreviewProvider {
+struct BlueStepProgressModalView_Preview: PreviewProvider {
     static var previews: some View {
-        BlueSynchronizeAccessDeviceModalView(
-            BlueSynchronizeAccessDeviceModalViewModel(
+        BlueStepProgressModalView(
+            BlueStepProgressModalViewModel(
                 title: "Synchronization has failed (Worst case)",
                 dismiss: "Done",
                 tasks: Array(1..<12).map { element in
@@ -232,8 +257,8 @@ struct BlueSynchronizeAccessDeviceModalView_Preview: PreviewProvider {
             )
         ) {}
         
-        BlueSynchronizeAccessDeviceModalView(
-            BlueSynchronizeAccessDeviceModalViewModel(
+        BlueStepProgressModalView(
+            BlueStepProgressModalViewModel(
                 title: "Cancelling...",
                 dismiss: "Cancel",
                 dismissEnabled: false,
@@ -248,6 +273,21 @@ struct BlueSynchronizeAccessDeviceModalView_Preview: PreviewProvider {
                 }
             )
         ) {}
+        
+        BlueStepProgressModalView(
+            BlueStepProgressModalViewModel(
+                title: "DFU",
+                dismiss: "Cancel",
+                tasks: Array(1..<7).enumerated().map { (index, element) in
+                    BlueTask(
+                        id: element.description,
+                        label: "Task label - \(element.description)",
+                        status: .ready,
+                        handler: noop
+                    )
+                }
+            )
+        ) {}
     }
 }
 #endif