@blueid/access-capacitor 0.102.0 → 0.105.0

package/ios/CBlueIDAccess.xcframework/ios-arm64/Headers/core/BlueCore.pb.h

@@ -110,6 +110,8 @@ typedef enum BlueReturnCode {
     BlueReturnCode_SdkGetBlacklistEntriesFailed = -419,
     BlueReturnCode_SdkGetSystemStatusFailed = -420,
     BlueReturnCode_SdkWaitDeviceToRestartFailed = -421,
+    BlueReturnCode_SdkUnzipError = -422,
+    BlueReturnCode_SdkInvalidFirmwareURL = -423,
     BlueReturnCode_OssMAReturnCodeStart = -1000,
     BlueReturnCode_OssMAReturnCodeEnd = -1100
 } BlueReturnCode_t;

package/ios/CBlueIDAccess.xcframework/ios-arm64_x86_64-simulator/Headers/core/BlueCore.pb.h

@@ -110,6 +110,8 @@ typedef enum BlueReturnCode {
     BlueReturnCode_SdkGetBlacklistEntriesFailed = -419,
     BlueReturnCode_SdkGetSystemStatusFailed = -420,
     BlueReturnCode_SdkWaitDeviceToRestartFailed = -421,
+    BlueReturnCode_SdkUnzipError = -422,
+    BlueReturnCode_SdkInvalidFirmwareURL = -423,
     BlueReturnCode_OssMAReturnCodeStart = -1000,
     BlueReturnCode_OssMAReturnCodeEnd = -1100
 } BlueReturnCode_t;

package/ios/CBlueIDAccess.xcframework/macos-arm64_x86_64/Headers/core/BlueCore.pb.h

@@ -110,6 +110,8 @@ typedef enum BlueReturnCode {
     BlueReturnCode_SdkGetBlacklistEntriesFailed = -419,
     BlueReturnCode_SdkGetSystemStatusFailed = -420,
     BlueReturnCode_SdkWaitDeviceToRestartFailed = -421,
+    BlueReturnCode_SdkUnzipError = -422,
+    BlueReturnCode_SdkInvalidFirmwareURL = -423,
     BlueReturnCode_OssMAReturnCodeStart = -1000,
     BlueReturnCode_OssMAReturnCodeEnd = -1100
 } BlueReturnCode_t;

package/ios/Plugin/BlueIDAccessSDK/BlueAPI.swift

@@ -100,6 +100,13 @@ class BlueAPI: BlueAPIProtocol {
         )
     }
     
+    func getLatestFirmware(deviceID: String, with tokenAuthentication: BlueTokenAuthentication) async throws -> BlueFetchResponse<BlueGetLatestFirmwareResult> {
+        return try await post(
+            endpoint: .AccessGetLatestFirmware,
+            request: BlueGetLatestFirmwareRequest(deviceId: deviceID, tokenAuthentication: tokenAuthentication)
+        )
+    }
+    
     private func post<T>(endpoint: BlueAPIEndpoints, request: Encodable) async throws -> BlueFetchResponse<T> {
         guard #available(macOS 12.0, *) else {
             throw BlueError(.sdkUnsupportedPlatform)

package/ios/Plugin/BlueIDAccessSDK/BlueAPIProtocol.swift

@@ -18,6 +18,7 @@ public enum BlueAPIEndpoints: String {
     case AccessCredentials = "/access/credentials"
     case AccessSynchronizeOfflineAccess = "/access/synchronizeOfflineAccess"
     case AccessClaimCredential = "/access/cc"
+    case AccessGetLatestFirmware = "/access/getLatestFirmware"
     
     var url: URL {
         guard let url = URL(string: baseURL) else {
@@ -236,6 +237,17 @@ internal struct BlueAccessToken: Codable {
     var expiresAt: Int
 }
 
+/// [POST] /access/getLatestFirmware request
+internal struct BlueGetLatestFirmwareRequest: Encodable {
+    var deviceId: String
+    var tokenAuthentication: BlueTokenAuthentication
+}
+/// [POST] /access/getLatestFirmware response
+internal struct BlueGetLatestFirmwareResult: Decodable {
+    var version: Int
+    var url: String
+}
+
 protocol BlueAPIProtocol {
     func getAccessToken(credentialId: String) async throws -> BlueFetchResponse<BlueAccessToken>
     func synchronizeMobileAccess(with tokenAuthentication: BlueTokenAuthentication, forceRefresh: Bool?) async throws -> BlueFetchResponse<BlueMobileAccessSynchronizationResult>
@@ -250,4 +262,5 @@ protocol BlueAPIProtocol {
     func claimDevice(deviceID: String, objectID: String, with tokenAuthentication: BlueTokenAuthentication) async throws -> BlueFetchResponse<BlueClaimDeviceResult>
     func claimAccessCredential(activationToken: String) async throws -> BlueFetchResponse<BlueClaimAccessCredentialResult>
     func getAccessCredentials(with tokenAuthentication: BlueTokenAuthentication) async throws -> BlueFetchResponse<BlueGetAccessCredentialsResult>
+    func getLatestFirmware(deviceID: String, with tokenAuthentication: BlueTokenAuthentication) async throws -> BlueFetchResponse<BlueGetLatestFirmwareResult>
 }

package/ios/Plugin/BlueIDAccessSDK/BlueAccess.swift

@@ -162,14 +162,14 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.getAuthenticationToken,
                 label: blueI18n.syncDeviceGetAuthenticationTokenTaskLabel
-            ) { _ in
+            ) { _, _ in
                 .result(try await self.getAuthenticationToken(credential))
             },
             
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.getDeviceConfig,
                 label: blueI18n.syncDeviceRetrieveDeviceConfigurationTaskLabel
-            ) { runner in
+            ) { _, runner in
                 let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueSynchronizeAccessTaskId.getAuthenticationToken)
                 
                 return .result(try await self.getBlueSystemConfig(deviceID: deviceID, with: tokenAuthentication))
@@ -178,7 +178,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.updateDeviceConfig,
                 label: blueI18n.syncDeviceUpdateDeviceConfigurationTaskLabel
-            ) { runner in
+            ) { _, runner in
                 let config: BlueSystemConfig? = try runner.getResult(BlueSynchronizeAccessTaskId.getDeviceConfig)
                 
                 let status: BlueSystemStatus = try await self.updateDevice(deviceID, config)
@@ -191,7 +191,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.updateDeviceTime,
                 label: blueI18n.syncDeviceUpdateDeviceTimeTaskLabel
-            ) { runner in
+            ) { _, runner in
                 let status: BlueSystemStatus = try runner.getResult(BlueSynchronizeAccessTaskId.updateDeviceConfig)
                 
                 return .resultWithStatus(nil, status.settings.timeWasSet == true ? .succeeded : .skipped)
@@ -200,7 +200,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.waitForRestart,
                 label: blueI18n.syncDeviceWaitForDeviceToRestartTaskLabel
-            ) { _ in
+            ) { _, _ in
                 .result(try await self.waitUntilDeviceHasBeenRestarted(deviceID))
             },
             
@@ -208,7 +208,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
                 id: BlueSynchronizeAccessTaskId.pushEventLogs,
                 label: blueI18n.syncDevicePushEventLogsTaskLabel,
                 failable: true
-            ) { runner in                
+            ) { _, runner in
                 let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueSynchronizeAccessTaskId.getAuthenticationToken)
                 let status: BlueSystemStatus = try runner.getResult(BlueSynchronizeAccessTaskId.updateDeviceConfig)
                 
@@ -219,7 +219,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
                 id: BlueSynchronizeAccessTaskId.pushSystemLogs,
                 label: blueI18n.syncDevicePushSystemLogsTaskLabel,
                 failable: true
-            ) { runner in
+            ) { _, runner in
                 let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueSynchronizeAccessTaskId.getAuthenticationToken)
                 let status: BlueSystemStatus = try runner.getResult(BlueSynchronizeAccessTaskId.updateDeviceConfig)
                 
@@ -230,7 +230,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
                 id: BlueSynchronizeAccessTaskId.getBlacklistEntries,
                 label: blueI18n.syncDeviceRetrieveBlacklistEntriesTaskLabel,
                 failable: true
-            ) { runner in
+            ) { _, runner in
                 let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueSynchronizeAccessTaskId.getAuthenticationToken)
                 
                 return .result(try await self.getBlacklistEntries(deviceID, tokenAuthentication))
@@ -240,7 +240,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
                 id: BlueSynchronizeAccessTaskId.deployBlacklistEntries,
                 label: blueI18n.syncDeviceDeployBlacklistEntriesTaskLabel,
                 failable: true
-            ) { runner in
+            ) { _, runner in
                 let entries: BlueBlacklistEntries? = try runner.getResult(BlueSynchronizeAccessTaskId.getBlacklistEntries)
                 
                 guard let entries = entries else {
@@ -253,14 +253,14 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.getSystemStatus,
                 label: blueI18n.syncDeviceRetrieveSystemStatusTaskLabel
-            ) { _ in
+            ) { _, _ in
                 .result(try await self.getSystemStatus(deviceID))
             },
             
             BlueTask(
                 id: BlueSynchronizeAccessTaskId.pushSystemStatus,
                 label: blueI18n.syncDevicePushSystemStatusTaskLabel
-            ) { runner in
+            ) { _, runner in
                 let tokenAuthentication: BlueTokenAuthentication = try runner.getResult(BlueSynchronizeAccessTaskId.getAuthenticationToken)
                 let status: BlueSystemStatus = try runner.getResult(BlueSynchronizeAccessTaskId.getSystemStatus)
                 
@@ -321,19 +321,7 @@ public class BlueSynchronizeAccessDeviceCommand: BlueSdkAsyncCommand {
     
     private func waitUntilDeviceHasBeenRestarted(_ deviceID: String) async throws {
         do {
-            var attempts = 0
-            
-            while attempts <= 2 {
-                try? await Task.sleep(nanoseconds: UInt64(blueSecondsToNanoseconds(10)))
-                
-                if blueGetDevice(deviceID) != nil {
-                    return
-                }
-                
-                attempts += 1
-            }
-            
-            throw BlueError(.sdkDeviceNotFound)
+            try await waitForDeviceAvailability(deviceID)
         } catch {
             throw BlueError(.sdkWaitDeviceToRestartFailed, cause: error)
         }

package/ios/Plugin/BlueIDAccessSDK/BlueCommands.swift

@@ -93,6 +93,9 @@ public struct BlueCommands {
     
     public let openAppSettings = BlueOpenAppSettingsCommand()
     
+    // MARK: - DFU commands
+    public let updateAccessDeviceFirmware = BlueUpdateAccessDeviceFirmwareCommand(defaultSdkService)
+    
     // TODO: Make it available only for dev environment
     public let UNSAFE_clearData = BlueClearDataCommand()
     

package/ios/Plugin/BlueIDAccessSDK/BlueCore.pb.swift

@@ -129,6 +129,8 @@ public enum BlueReturnCode: SwiftProtobuf.Enum {
   case sdkGetBlacklistEntriesFailed // = -419
   case sdkGetSystemStatusFailed // = -420
   case sdkWaitDeviceToRestartFailed // = -421
+  case sdkUnzipError // = -422
+  case sdkInvalidFirmwareURL // = -423
   case ossMareturnCodeStart // = -1000
   case ossMareturnCodeEnd // = -1100
 
@@ -140,6 +142,8 @@ public enum BlueReturnCode: SwiftProtobuf.Enum {
     switch rawValue {
     case -1100: self = .ossMareturnCodeEnd
     case -1000: self = .ossMareturnCodeStart
+    case -423: self = .sdkInvalidFirmwareURL
+    case -422: self = .sdkUnzipError
     case -421: self = .sdkWaitDeviceToRestartFailed
     case -420: self = .sdkGetSystemStatusFailed
     case -419: self = .sdkGetBlacklistEntriesFailed
@@ -243,6 +247,8 @@ public enum BlueReturnCode: SwiftProtobuf.Enum {
     switch self {
     case .ossMareturnCodeEnd: return -1100
     case .ossMareturnCodeStart: return -1000
+    case .sdkInvalidFirmwareURL: return -423
+    case .sdkUnzipError: return -422
     case .sdkWaitDeviceToRestartFailed: return -421
     case .sdkGetSystemStatusFailed: return -420
     case .sdkGetBlacklistEntriesFailed: return -419
@@ -3643,6 +3649,8 @@ extension BlueReturnCode: SwiftProtobuf._ProtoNameProviding {
   public static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
     -1100: .same(proto: "OssMAReturnCodeEnd"),
     -1000: .same(proto: "OssMAReturnCodeStart"),
+    -423: .same(proto: "SdkInvalidFirmwareURL"),
+    -422: .same(proto: "SdkUnzipError"),
     -421: .same(proto: "SdkWaitDeviceToRestartFailed"),
     -420: .same(proto: "SdkGetSystemStatusFailed"),
     -419: .same(proto: "SdkGetBlacklistEntriesFailed"),

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

@@ -0,0 +1,73 @@
+import CoreBluetooth
+import Foundation
+import NordicDFU
+
+/**
+ * @class BlueDFUPeripheralService
+ * A utility class for looking up peripherals that are advertising DFU service.
+ */
+internal class BlueDFUPeripheralService: NSObject, CBCentralManagerDelegate {
+    private var centralManager: CBCentralManager? = nil
+    private var discoveredPeripheral: CBPeripheral?
+    private var continuation: CheckedContinuation<CBPeripheral, any Error>?
+    
+    /// Finds a peripheral that is advertising DFU service asynchronously within the specified timeout period.
+    ///
+    /// - parameter timeout: The duration in seconds to wait for the peripheral to be discovered. Default value is 10.0 seconds.
+    /// - returns: A `CBPeripheral` object representing the DFU peripheral if found.
+    /// - throws: An error of type `BlueError` if the timeout period elapses without finding the peripheral.
+    func find(_ timeout: TimeInterval = 10.0) async throws -> CBPeripheral {
+        if self.centralManager != nil {
+            throw BlueError(.invalidState)
+        }
+        
+        self.centralManager = CBCentralManager(delegate: self, queue: nil)
+        
+        return try await withCheckedThrowingContinuation { continuation in
+            self.continuation = continuation
+            
+            self.startScan()
+            
+            DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
+                if self.discoveredPeripheral == nil {
+                    continuation.resume(throwing: BlueError(.sdkTimeout))
+                }
+            }
+        }
+    }
+    
+    /// Destroys the BlueDFUPeripheralService instance, releasing any resources it holds.
+    func destroy() {
+        if let centralManager = centralManager {
+            if centralManager.isScanning {
+                centralManager.stopScan()
+            }
+            centralManager.delegate = nil
+        }
+    }
+    
+    /// Starts scanning for peripherals that are that are advertising DFU service.
+    private func startScan() {
+        if let centralManager = centralManager {
+            if (centralManager.isScanning) {
+                centralManager.stopScan()
+            }
+            
+            if centralManager.state == .poweredOn {
+                centralManager.scanForPeripherals(withServices: [DFUUuidHelper().secureDFUService], options: [CBCentralManagerScanOptionAllowDuplicatesKey: true])
+            }
+        }
+    }
+    
+    // MARK: - CBCentralManagerDelegate API
+    
+    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
+        self.discoveredPeripheral = peripheral
+        self.continuation?.resume(returning: peripheral)
+        self.destroy()
+    }
+    
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        self.startScan()
+    }
+}

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

@@ -0,0 +1,226 @@
+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)
+        )
+    }
+    
+    public func runAsync(credentialID: String, deviceID: String) 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)
+    }
+}
+
+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) 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
+            ) { _, runner in
+                let latestFW: BlueGetLatestFirmwareResult = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.checkLatestFirmware)
+                
+                return .result(try await self.downloadLatestFirmware(url: latestFW.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.dfuFindDfuperipheralLabel
+            ) { _, _ 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 urlToZipFile: URL = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.prepareUpdate)
+                    let peripheral: CBPeripheral = try runner.getResult(BlueUpdateAccessDeviceFirmwareTaskId.findDFUPeripheral)
+                    
+                    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 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 {