@onekeyfe/react-native-range-downloader 3.0.81-alpha.1 → 3.0.81-alpha.11

package/ios/ReactNativeRangeDownloader.swift

@@ -2,6 +2,16 @@ import Foundation
 import NitroModules
 import ReactNativeNativeLogger
 
+private func settledFirmwareArtifactPromise<T>(
+  _ operation: () throws -> T
+) -> Promise<T> {
+  do {
+    return Promise.resolved(withResult: try operation())
+  } catch {
+    return Promise.rejected(withError: error)
+  }
+}
+
 // MARK: - Nitro HybridObject entry point
 //
 // Thin Nitro shim over `RangeDownloader.shared`. The heavy lifting — concurrent
@@ -98,8 +108,8 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
 
   func getFirmwareArtifactCapabilities() throws -> FirmwareArtifactCapabilities {
     FirmwareArtifactCapabilities(
-      firmwareArtifactProtocolVersion: 1,
-      supportedRouteTypes: ["domain", "pinnedIp"],
+      firmwareArtifactProtocolVersion: 4,
+      supportedRouteTypes: ["domain"],
       supportsArchiveMaterialization: true,
       maxReadBytes: Double(FirmwareArtifactStore.maxReadBytes)
     )
@@ -108,12 +118,27 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func downloadFirmwareArtifact(
     params: FirmwareArtifactDownloadParams
   ) throws -> Promise<FirmwareArtifactReceipt> {
-    Promise.async {
+    do {
+      if let artifact = try FirmwareArtifactStore.shared.cachedArtifact(params) {
+        return Promise.resolved(
+          withResult: FirmwareArtifactReceipt(
+            artifactRef: artifact.artifactRef,
+            size: Double(artifact.size),
+            sha256: artifact.sha256,
+            expectedSha256Verified: params.expectedSha256 != nil
+          )
+        )
+      }
+    } catch {
+      return Promise.rejected(withError: error)
+    }
+    return Promise.async {
       let artifact = try await FirmwareArtifactStore.shared.download(params)
       return FirmwareArtifactReceipt(
         artifactRef: artifact.artifactRef,
         size: Double(artifact.size),
-        sha256: artifact.sha256
+        sha256: artifact.sha256,
+        expectedSha256Verified: params.expectedSha256 != nil
       )
     }
   }
@@ -121,7 +146,14 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func cancelFirmwareArtifactDownloads(
     params: FirmwareArtifactCancelParams
   ) throws -> Promise<Void> {
-    Promise.async {
+    guard FirmwareArtifactStore.isSafeIdentifier(params.transactionId) else {
+      return Promise.rejected(
+        withError: FirmwareArtifactStoreError.invalidInput(
+          "Invalid firmware transactionId"
+        )
+      )
+    }
+    return Promise.async {
       try await FirmwareArtifactStore.shared.cancelDownloads(
         transactionId: params.transactionId
       )
@@ -131,7 +163,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func discardFirmwareArtifact(
     params: FirmwareArtifactRefParams
   ) throws -> Promise<Void> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       try FirmwareArtifactStore.shared.discard(artifactRef: params.artifactRef)
     }
   }
@@ -139,7 +171,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func openFirmwareArtifact(
     params: FirmwareArtifactRefParams
   ) throws -> Promise<FirmwareArtifactReaderInfo> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       let reader = try FirmwareArtifactStore.shared.open(
         artifactRef: params.artifactRef
       )
@@ -153,16 +185,18 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func readFirmwareArtifact(
     params: FirmwareArtifactReaderReadParams
   ) throws -> Promise<ArrayBuffer> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       guard
-        params.offset.isFinite,
-        params.offset >= 0,
-        params.offset <= Double(Int64.max),
-        params.offset.rounded() == params.offset,
-        params.length.isFinite,
-        params.length > 0,
-        params.length <= Double(Int.max),
-        params.length.rounded() == params.length
+        let offset = firmwareArtifactExactInt64(
+          params.offset,
+          minimum: 0,
+          maximum: FirmwareArtifactStore.maxArtifactBytes
+        ),
+        let length = firmwareArtifactExactInt64(
+          params.length,
+          minimum: 1,
+          maximum: firmwareArtifactMaxReadBytes
+        )
       else {
         throw FirmwareArtifactStoreError.readerInvalid(
           "Invalid firmware artifact read"
@@ -170,8 +204,8 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
       }
       let data = try FirmwareArtifactStore.shared.read(
         readerId: params.readerId,
-        offset: Int64(params.offset),
-        length: Int(params.length)
+        offset: offset,
+        length: Int(length)
       )
       return try ArrayBuffer.copy(data: data)
     }
@@ -180,7 +214,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func closeFirmwareArtifact(
     params: FirmwareArtifactReaderCloseParams
   ) throws -> Promise<Void> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       try FirmwareArtifactStore.shared.close(readerId: params.readerId)
     }
   }
@@ -188,7 +222,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func materializeFirmwareArchive(
     params: FirmwareArchiveMaterializeParams
   ) throws -> Promise<FirmwareArchiveMaterializeResult> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       let entries = try FirmwareArtifactStore.shared.materializeArchive(
         leaseRef: params.leaseRef,
         artifactRef: params.archiveArtifactRef,
@@ -201,7 +235,8 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
             receipt: FirmwareArtifactReceipt(
               artifactRef: entry.artifact.artifactRef,
               size: Double(entry.artifact.size),
-              sha256: entry.artifact.sha256
+              sha256: entry.artifact.sha256,
+              expectedSha256Verified: params.expectedEntries != nil
             )
           )
         }
@@ -212,7 +247,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func createFirmwareArtifactLease(
     params: FirmwareArtifactLeaseCreateParams
   ) throws -> Promise<FirmwareArtifactLease> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       FirmwareArtifactLease(
         leaseRef: try FirmwareArtifactStore.shared.createLease(
           transactionId: params.transactionId
@@ -224,7 +259,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func retainFirmwareArtifact(
     params: FirmwareArtifactLeaseRetainParams
   ) throws -> Promise<Void> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       try FirmwareArtifactStore.shared.retain(
         leaseRef: params.leaseRef,
         artifactRef: params.artifactRef
@@ -235,7 +270,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
   func releaseFirmwareArtifactLease(
     params: FirmwareArtifactLeaseReleaseParams
   ) throws -> Promise<Void> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       try FirmwareArtifactStore.shared.releaseLease(
         leaseRef: params.leaseRef,
         disposition: params.disposition
@@ -243,18 +278,8 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
     }
   }
 
-  func reconcileFirmwareArtifactLeases(
-    params: FirmwareArtifactLeaseReconcileParams
-  ) throws -> Promise<Void> {
-    Promise.async {
-      try FirmwareArtifactStore.shared.reconcileLeases(
-        activeLeaseRefs: params.activeLeaseRefs
-      )
-    }
-  }
-
   func sweepFirmwareArtifactOrphans() throws -> Promise<FirmwareArtifactSweepResult> {
-    Promise.async {
+    settledFirmwareArtifactPromise {
       let result = try FirmwareArtifactStore.shared.sweepOrphans()
       return FirmwareArtifactSweepResult(
         deletedFiles: Double(result.deletedFiles),
@@ -323,79 +348,10 @@ extension RangeFallbackClass {
   }
 }
 
-private struct FirmwareBackgroundTaskDescriptor: Codable, Equatable {
-  let schemaVersion: Int
-  let taskId: String
-  let transactionId: String
-  let leaseRef: String
-  let expectedSize: Int64
-  let expectedSha256: String
-  let hostname: String
-  let deadlineAt: TimeInterval
-
-  var key: String {
-    "\(leaseRef)|\(taskId)|\(expectedSha256)"
-  }
-
-  func hasSameArtifactIdentity(
-    as other: FirmwareBackgroundTaskDescriptor
-  ) -> Bool {
-    taskId == other.taskId &&
-      transactionId == other.transactionId &&
-      leaseRef == other.leaseRef &&
-      expectedSize == other.expectedSize &&
-      expectedSha256 == other.expectedSha256 &&
-      hostname == other.hostname
-  }
-}
-
-private enum FirmwareBackgroundDownloadError: LocalizedError {
-  case cancelled
-  case invalidTask
-  case deadlineExceeded
-  case redirectRejected
-  case responseRejected
-  case sizeRejected
-  case transferFailed
-
-  var errorDescription: String? {
-    switch self {
-    case .cancelled:
-      return "ARTIFACT_CANCELLED: firmware background download was cancelled"
-    case .invalidTask:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware background task is invalid"
-    case .deadlineExceeded:
-      return "ARTIFACT_DEADLINE_EXCEEDED: firmware download exceeded its deadline"
-    case .redirectRejected:
-      return "ARTIFACT_REDIRECT_REJECTED: firmware redirect changed canonical identity"
-    case .responseRejected:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware response is invalid"
-    case .sizeRejected:
-      return "ARTIFACT_PROTOCOL_INVALID: firmware artifact size is invalid"
-    case .transferFailed:
-      return "ARTIFACT_NETWORK_FAILED: firmware background transfer failed"
-    }
-  }
-}
-
 public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
 
   public static let shared = RangeDownloader()
 
-  public static func routeFirmwareBackgroundEvents(
-    identifier: String,
-    completionHandler: @escaping () -> Void
-  ) -> Bool {
-    guard identifier == sessionIdentifier(for: .firmware) else {
-      return false
-    }
-    shared.attachBackgroundEvents(
-      identifier: identifier,
-      completionHandler: completionHandler
-    )
-    return true
-  }
-
   /// Posted by the AppDelegate from
   /// application(_:handleEventsForBackgroundURLSession:completionHandler:).
   /// userInfo: ["identifier": String, "completionHandler": () -> Void].
@@ -432,11 +388,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   /// notification), keyed by session identifier, so we can call each back once
   /// all its queued background events have been delivered.
   private var backgroundCompletionHandlers: [String: () -> Void] = [:]
-  private var firmwareWaiters: [
-    String: [CheckedContinuation<StoredFirmwareArtifact, Error>]
-  ] = [:]
-  private var firmwareTaskErrors: [Int: Error] = [:]
-  private var completedFirmwareTasks: Set<Int> = []
 
   // Per-run mutable state.
   private final class RunState {
@@ -694,240 +645,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     return (r, decoded.segIndex)
   }
 
-  private static let firmwareTaskDescriptionPrefix = "firmware-v1:"
-
-  private static func encodeFirmwareTaskDescription(
-    _ descriptor: FirmwareBackgroundTaskDescriptor
-  ) throws -> String {
-    let data = try JSONEncoder().encode(descriptor)
-    return firmwareTaskDescriptionPrefix + data.base64EncodedString()
-  }
-
-  private static func decodeFirmwareTaskDescription(
-    _ description: String?
-  ) -> FirmwareBackgroundTaskDescriptor? {
-    guard
-      let description,
-      description.hasPrefix(firmwareTaskDescriptionPrefix),
-      let data = Data(
-        base64Encoded: String(
-          description.dropFirst(firmwareTaskDescriptionPrefix.count)
-        )
-      ),
-      data.count <= 2048,
-      let descriptor = try? JSONDecoder().decode(
-        FirmwareBackgroundTaskDescriptor.self,
-        from: data
-      ),
-      descriptor.schemaVersion == 1,
-      descriptor.taskId.range(
-        of: "^[A-Za-z0-9._-]{1,100}$",
-        options: .regularExpression
-      ) != nil,
-      descriptor.transactionId.range(
-        of: "^[A-Za-z0-9._:-]{1,160}$",
-        options: .regularExpression
-      ) != nil,
-      descriptor.leaseRef.range(
-        of: "^fwlease:[a-f0-9-]{36}$",
-        options: .regularExpression
-      ) != nil,
-      descriptor.expectedSize > 0,
-      descriptor.expectedSize <= 512 * 1024 * 1024,
-      descriptor.expectedSha256.range(
-        of: "^[a-f0-9]{64}$",
-        options: .regularExpression
-      ) != nil,
-      !descriptor.hostname.isEmpty,
-      descriptor.hostname.count <= 253,
-      descriptor.deadlineAt.isFinite,
-      descriptor.deadlineAt > 0
-    else {
-      return nil
-    }
-    return descriptor
-  }
-
-  func downloadFirmwareArtifact(
-    params: FirmwareArtifactDownloadParams
-  ) async throws -> StoredFirmwareArtifact {
-    guard
-      params.routeType == "domain",
-      let url = URL(string: params.url),
-      let hostname = url.host?.lowercased()
-    else {
-      throw FirmwareBackgroundDownloadError.invalidTask
-    }
-    let deadlineSeconds = params.overallDeadlineSeconds ?? 180
-    guard
-      deadlineSeconds.isFinite,
-      deadlineSeconds > 0,
-      deadlineSeconds <= 24 * 60 * 60
-    else {
-      throw FirmwareBackgroundDownloadError.invalidTask
-    }
-    let descriptor = FirmwareBackgroundTaskDescriptor(
-      schemaVersion: 1,
-      taskId: params.taskId,
-      transactionId: params.transactionId,
-      leaseRef: params.leaseRef,
-      expectedSize: Int64(params.expectedSize),
-      expectedSha256: params.expectedSha256.lowercased(),
-      hostname: hostname,
-      deadlineAt: Date().timeIntervalSince1970 + deadlineSeconds
-    )
-    guard !FirmwareArtifactStore.shared.isTransactionCancelled(
-      descriptor.transactionId
-    ) else {
-      throw FirmwareBackgroundDownloadError.cancelled
-    }
-    if let stored = try FirmwareArtifactStore.shared.storedArtifact(
-      expectedSize: descriptor.expectedSize,
-      expectedSha256: descriptor.expectedSha256
-    ) {
-      return stored
-    }
-
-    return try await withCheckedThrowingContinuation { continuation in
-      lock.withLockValue {
-        firmwareWaiters[descriptor.key, default: []].append(continuation)
-      }
-      Task { [weak self] in
-        await self?.reconcileOrStartFirmwareTask(
-          descriptor: descriptor,
-          url: url
-        )
-      }
-    }
-  }
-
-  func cancelFirmwareArtifactDownloads(
-    transactionId: String
-  ) async throws {
-    guard transactionId.range(
-      of: "^[A-Za-z0-9._:-]{1,160}$",
-      options: .regularExpression
-    ) != nil else {
-      throw FirmwareBackgroundDownloadError.invalidTask
-    }
-    let session = session(forChannel: .firmware, segmentCount: 1)
-    let tasks = await allTasks(in: session)
-    for task in tasks {
-      guard
-        let descriptor = Self.decodeFirmwareTaskDescription(
-          task.taskDescription
-        ),
-        descriptor.transactionId == transactionId
-      else {
-        continue
-      }
-      recordFirmwareTaskError(
-        taskIdentifier: task.taskIdentifier,
-        error: FirmwareBackgroundDownloadError.cancelled
-      )
-      task.cancel()
-    }
-  }
-
-  private func reconcileOrStartFirmwareTask(
-    descriptor: FirmwareBackgroundTaskDescriptor,
-    url: URL
-  ) async {
-    guard !FirmwareArtifactStore.shared.isTransactionCancelled(
-      descriptor.transactionId
-    ) else {
-      finishFirmwareTask(
-        key: descriptor.key,
-        result: .failure(FirmwareBackgroundDownloadError.cancelled)
-      )
-      return
-    }
-    let session = session(forChannel: .firmware, segmentCount: 1)
-    let tasks = await allTasks(in: session)
-    var matchingTaskFound = false
-    for task in tasks {
-      guard
-        let candidate = Self.decodeFirmwareTaskDescription(
-          task.taskDescription
-        )
-      else {
-        continue
-      }
-      if candidate.hasSameArtifactIdentity(as: descriptor) {
-        matchingTaskFound = true
-      } else if candidate.taskId == descriptor.taskId {
-        task.cancel()
-      }
-    }
-    if matchingTaskFound {
-      return
-    }
-    do {
-      if let stored = try FirmwareArtifactStore.shared.storedArtifact(
-        expectedSize: descriptor.expectedSize,
-        expectedSha256: descriptor.expectedSha256
-      ) {
-        finishFirmwareTask(
-          key: descriptor.key,
-          result: .success(stored)
-        )
-        return
-      }
-      guard Date().timeIntervalSince1970 < descriptor.deadlineAt else {
-        throw FirmwareBackgroundDownloadError.deadlineExceeded
-      }
-      guard !FirmwareArtifactStore.shared.isTransactionCancelled(
-        descriptor.transactionId
-      ) else {
-        throw FirmwareBackgroundDownloadError.cancelled
-      }
-      var request = URLRequest(url: url)
-      request.cachePolicy = .reloadIgnoringLocalCacheData
-      request.timeoutInterval = max(
-        1,
-        descriptor.deadlineAt - Date().timeIntervalSince1970
-      )
-      request.setValue("identity", forHTTPHeaderField: "Accept-Encoding")
-      let task = session.downloadTask(with: request)
-      task.taskDescription = try Self.encodeFirmwareTaskDescription(
-        descriptor
-      )
-      task.resume()
-    } catch {
-      finishFirmwareTask(
-        key: descriptor.key,
-        result: .failure(error)
-      )
-    }
-  }
-
-  private func allTasks(in session: URLSession) async -> [URLSessionTask] {
-    await withCheckedContinuation { continuation in
-      session.getAllTasks { tasks in
-        continuation.resume(returning: tasks)
-      }
-    }
-  }
-
-  private func finishFirmwareTask(
-    key: String,
-    result: Result<StoredFirmwareArtifact, Error>
-  ) {
-    let continuations: [
-      CheckedContinuation<StoredFirmwareArtifact, Error>
-    ] = lock.withLockValue {
-      firmwareWaiters.removeValue(forKey: key) ?? []
-    }
-    for continuation in continuations {
-      switch result {
-      case let .success(artifact):
-        continuation.resume(returning: artifact)
-      case let .failure(error):
-        continuation.resume(throwing: error)
-      }
-    }
-  }
-
   // MARK: - Public entry
 
   /// Downloads [urlString] into [filePath] using concurrent background ranges.
@@ -1463,28 +1180,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   public func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
                   didWriteData bytesWritten: Int64, totalBytesWritten: Int64,
                   totalBytesExpectedToWrite: Int64) {
-    if let descriptor = Self.decodeFirmwareTaskDescription(
-      downloadTask.taskDescription
-    ) {
-      let exceedsBound =
-        totalBytesWritten > descriptor.expectedSize ||
-        (
-          totalBytesExpectedToWrite != NSURLSessionTransferSizeUnknown &&
-            totalBytesExpectedToWrite != descriptor.expectedSize
-        )
-      let expired =
-        Date().timeIntervalSince1970 >= descriptor.deadlineAt
-      if exceedsBound || expired {
-        recordFirmwareTaskError(
-          taskIdentifier: downloadTask.taskIdentifier,
-          error: exceedsBound
-            ? FirmwareBackgroundDownloadError.sizeRejected
-            : FirmwareBackgroundDownloadError.deadlineExceeded
-        )
-        downloadTask.cancel()
-      }
-      return
-    }
     guard let desc = downloadTask.taskDescription,
           let (state, idx) = run(for: desc) else { return }
     lock.lock()
@@ -1515,53 +1210,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
 
   public func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
                   didFinishDownloadingTo location: URL) {
-    if let descriptor = Self.decodeFirmwareTaskDescription(
-      downloadTask.taskDescription
-    ) {
-      guard firmwareTaskError(
-        taskIdentifier: downloadTask.taskIdentifier
-      ) == nil else {
-        return
-      }
-      do {
-        guard
-          !FirmwareArtifactStore.shared.isTransactionCancelled(
-            descriptor.transactionId
-          ),
-          Date().timeIntervalSince1970 < descriptor.deadlineAt,
-          let response = downloadTask.response as? HTTPURLResponse,
-          response.statusCode == 200,
-          response.url?.scheme?.lowercased() == "https",
-          response.url?.host?.lowercased() == descriptor.hostname,
-          response.url?.port == nil || response.url?.port == 443
-        else {
-          throw FirmwareBackgroundDownloadError.responseRejected
-        }
-        let artifact = try FirmwareArtifactStore.shared.acceptBackgroundDownload(
-          temporaryURL: location,
-          leaseRef: descriptor.leaseRef,
-          transactionId: descriptor.transactionId,
-          expectedSize: descriptor.expectedSize,
-          expectedSha256: descriptor.expectedSha256
-        )
-        lock.withLockValue {
-          firmwareTaskErrors.removeValue(
-            forKey: downloadTask.taskIdentifier
-          )
-          completedFirmwareTasks.insert(downloadTask.taskIdentifier)
-        }
-        finishFirmwareTask(
-          key: descriptor.key,
-          result: .success(artifact)
-        )
-      } catch {
-        recordFirmwareTaskError(
-          taskIdentifier: downloadTask.taskIdentifier,
-          error: error
-        )
-      }
-      return
-    }
     guard let desc = downloadTask.taskDescription,
           let (state, idx) = run(for: desc) else { return }
     let ranges = lock.withLockValue { state.ranges }
@@ -1660,39 +1308,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   }
 
   public func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
-    if let descriptor = Self.decodeFirmwareTaskDescription(
-      task.taskDescription
-    ) {
-      let completion: (completed: Bool, error: Error?) =
-        lock.withLockValue {
-          let completed = completedFirmwareTasks.remove(
-            task.taskIdentifier
-          ) != nil
-          let recordedError = firmwareTaskErrors.removeValue(
-            forKey: task.taskIdentifier
-          )
-          return (completed, recordedError)
-        }
-      if completion.completed {
-        return
-      }
-      finishFirmwareTask(
-        key: descriptor.key,
-        result: .failure(
-          completion.error ??
-            (
-              FirmwareArtifactStore.shared.isTransactionCancelled(
-                descriptor.transactionId
-              )
-                ? FirmwareBackgroundDownloadError.cancelled
-                : nil
-            ) ??
-            error ??
-            FirmwareBackgroundDownloadError.transferFailed
-        )
-      )
-      return
-    }
     guard let desc = task.taskDescription,
           let (state, idx) = run(for: desc) else { return }
     let ranges = lock.withLockValue { state.ranges }
@@ -1868,26 +1483,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
                          willPerformHTTPRedirection response: HTTPURLResponse,
                          newRequest request: URLRequest,
                          completionHandler: @escaping (URLRequest?) -> Void) {
-    if let descriptor = Self.decodeFirmwareTaskDescription(
-      task.taskDescription
-    ) {
-      guard
-        request.url?.scheme?.lowercased() == "https",
-        request.url?.host?.lowercased() == descriptor.hostname,
-        request.url?.port == nil || request.url?.port == 443,
-        request.url?.user == nil,
-        request.url?.password == nil
-      else {
-        recordFirmwareTaskError(
-          taskIdentifier: task.taskIdentifier,
-          error: FirmwareBackgroundDownloadError.redirectRejected
-        )
-        completionHandler(nil)
-        return
-      }
-      completionHandler(request)
-      return
-    }
     if request.url?.scheme?.lowercased() != "https" {
       OneKeyLog.error("RangeDownloader", "blocked redirect to non-HTTPS URL")
       if let desc = task.taskDescription, let (state, _) = run(for: desc) {
@@ -1899,25 +1494,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     }
   }
 
-  private func recordFirmwareTaskError(
-    taskIdentifier: Int,
-    error: Error
-  ) {
-    lock.withLockValue {
-      if firmwareTaskErrors[taskIdentifier] == nil {
-        firmwareTaskErrors[taskIdentifier] = error
-      }
-    }
-  }
-
-  private func firmwareTaskError(
-    taskIdentifier: Int
-  ) -> Error? {
-    lock.withLockValue {
-      firmwareTaskErrors[taskIdentifier]
-    }
-  }
-
   /// Called on the session delegate queue when all background events for this
   /// session have been delivered after a background relaunch.
   public func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {