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

package/ios/ReactNativeRangeDownloader.swift

@@ -2,16 +2,6 @@ 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
@@ -105,176 +95,6 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
     }
     return NSTemporaryDirectory()
   }
-
-  func getFirmwareArtifactCapabilities() throws -> FirmwareArtifactCapabilities {
-    FirmwareArtifactCapabilities(
-      firmwareArtifactProtocolVersion: 2,
-      supportedRouteTypes: ["domain", "pinnedIp"],
-      supportsArchiveMaterialization: true,
-      maxReadBytes: Double(FirmwareArtifactStore.maxReadBytes)
-    )
-  }
-
-  func downloadFirmwareArtifact(
-    params: FirmwareArtifactDownloadParams
-  ) throws -> Promise<FirmwareArtifactReceipt> {
-    do {
-      if let artifact = try FirmwareArtifactStore.shared.cachedArtifact(params) {
-        return Promise.resolved(
-          withResult: FirmwareArtifactReceipt(
-            artifactRef: artifact.artifactRef,
-            size: Double(artifact.size),
-            sha256: artifact.sha256
-          )
-        )
-      }
-    } 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
-      )
-    }
-  }
-
-  func cancelFirmwareArtifactDownloads(
-    params: FirmwareArtifactCancelParams
-  ) throws -> Promise<Void> {
-    Promise.async {
-      try await FirmwareArtifactStore.shared.cancelDownloads(
-        transactionId: params.transactionId
-      )
-    }
-  }
-
-  func discardFirmwareArtifact(
-    params: FirmwareArtifactRefParams
-  ) throws -> Promise<Void> {
-    settledFirmwareArtifactPromise {
-      try FirmwareArtifactStore.shared.discard(artifactRef: params.artifactRef)
-    }
-  }
-
-  func openFirmwareArtifact(
-    params: FirmwareArtifactRefParams
-  ) throws -> Promise<FirmwareArtifactReaderInfo> {
-    settledFirmwareArtifactPromise {
-      let reader = try FirmwareArtifactStore.shared.open(
-        artifactRef: params.artifactRef
-      )
-      return FirmwareArtifactReaderInfo(
-        readerId: reader.readerId,
-        size: Double(reader.size)
-      )
-    }
-  }
-
-  func readFirmwareArtifact(
-    params: FirmwareArtifactReaderReadParams
-  ) throws -> Promise<ArrayBuffer> {
-    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
-      else {
-        throw FirmwareArtifactStoreError.readerInvalid(
-          "Invalid firmware artifact read"
-        )
-      }
-      let data = try FirmwareArtifactStore.shared.read(
-        readerId: params.readerId,
-        offset: Int64(params.offset),
-        length: Int(params.length)
-      )
-      return try ArrayBuffer.copy(data: data)
-    }
-  }
-
-  func closeFirmwareArtifact(
-    params: FirmwareArtifactReaderCloseParams
-  ) throws -> Promise<Void> {
-    settledFirmwareArtifactPromise {
-      try FirmwareArtifactStore.shared.close(readerId: params.readerId)
-    }
-  }
-
-  func materializeFirmwareArchive(
-    params: FirmwareArchiveMaterializeParams
-  ) throws -> Promise<FirmwareArchiveMaterializeResult> {
-    settledFirmwareArtifactPromise {
-      let entries = try FirmwareArtifactStore.shared.materializeArchive(
-        leaseRef: params.leaseRef,
-        artifactRef: params.archiveArtifactRef,
-        expectedEntries: params.expectedEntries
-      )
-      return FirmwareArchiveMaterializeResult(
-        artifacts: entries.map { entry in
-          FirmwareArchiveMaterializedArtifact(
-            entryName: entry.entryName,
-            receipt: FirmwareArtifactReceipt(
-              artifactRef: entry.artifact.artifactRef,
-              size: Double(entry.artifact.size),
-              sha256: entry.artifact.sha256
-            )
-          )
-        }
-      )
-    }
-  }
-
-  func createFirmwareArtifactLease(
-    params: FirmwareArtifactLeaseCreateParams
-  ) throws -> Promise<FirmwareArtifactLease> {
-    settledFirmwareArtifactPromise {
-      FirmwareArtifactLease(
-        leaseRef: try FirmwareArtifactStore.shared.createLease(
-          transactionId: params.transactionId
-        )
-      )
-    }
-  }
-
-  func retainFirmwareArtifact(
-    params: FirmwareArtifactLeaseRetainParams
-  ) throws -> Promise<Void> {
-    settledFirmwareArtifactPromise {
-      try FirmwareArtifactStore.shared.retain(
-        leaseRef: params.leaseRef,
-        artifactRef: params.artifactRef
-      )
-    }
-  }
-
-  func releaseFirmwareArtifactLease(
-    params: FirmwareArtifactLeaseReleaseParams
-  ) throws -> Promise<Void> {
-    settledFirmwareArtifactPromise {
-      try FirmwareArtifactStore.shared.releaseLease(
-        leaseRef: params.leaseRef,
-        disposition: params.disposition
-      )
-    }
-  }
-
-  func sweepFirmwareArtifactOrphans() throws -> Promise<FirmwareArtifactSweepResult> {
-    settledFirmwareArtifactPromise {
-      let result = try FirmwareArtifactStore.shared.sweepOrphans()
-      return FirmwareArtifactSweepResult(
-        deletedFiles: Double(result.deletedFiles),
-        deletedBytes: Double(result.deletedBytes)
-      )
-    }
-  }
 }
 
 // MARK: - RangeDownloader (migrated core)
@@ -336,50 +156,10 @@ extension RangeFallbackClass {
   }
 }
 
-private struct FirmwareBackgroundTaskDescriptor: Codable, Equatable {
-  let schemaVersion: Int
-  let taskId: String
-  let transactionId: String
-  let expectedSize: Int64
-  let expectedSha256: String
-  let hostname: String
-  let deadlineAt: TimeInterval
-
-  var key: String {
-    firmwareArtifactDownloadKey(
-      transactionId: transactionId,
-      expectedSize: expectedSize,
-      expectedSha256: expectedSha256
-    )
-  }
-
-  func hasSameDownloadIdentity(
-    as other: FirmwareBackgroundTaskDescriptor
-  ) -> Bool {
-    transactionId == other.transactionId &&
-      expectedSize == other.expectedSize &&
-      expectedSha256 == other.expectedSha256
-  }
-}
-
 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].
@@ -416,11 +196,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 {
@@ -551,30 +326,14 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   @objc private func handleBackgroundEventsNotification(_ note: Notification) {
     guard let identifier = note.userInfo?["identifier"] as? String,
           Self.channel(forIdentifier: identifier) != nil else { return }
+    // Re-create the session with this delegate so queued completion events are
+    // delivered here on a background relaunch.
+    _ = session(forIdentifier: identifier)
     if let handler = note.userInfo?["completionHandler"] as? () -> Void {
-      attachBackgroundEvents(
-        identifier: identifier,
-        completionHandler: handler
-      )
-    }
-  }
-
-  private func attachBackgroundEvents(
-    identifier: String,
-    completionHandler: @escaping () -> Void
-  ) {
-    let replacedHandler: (() -> Void)? = lock.withLockValue {
-      backgroundCompletionHandlers.updateValue(
-        completionHandler,
-        forKey: identifier
-      )
+      lock.lock()
+      backgroundCompletionHandlers[identifier] = handler
+      lock.unlock()
     }
-    // UIKit should provide one live handler per session. Complete an older
-    // handler instead of leaking it if the callback is unexpectedly repeated.
-    replacedHandler?()
-    // Store the handler before creating the session. Delegate delivery can
-    // begin immediately when a background relaunch reattaches this identifier.
-    _ = session(forIdentifier: identifier)
   }
 
   // MARK: - Session cache
@@ -678,238 +437,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     return (r, decoded.segIndex)
   }
 
-  private static let firmwareTaskDescriptionPrefix = "firmware-v2:"
-
-  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 == 2,
-      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.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: 2,
-      taskId: params.taskId,
-      transactionId: params.transactionId,
-      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.hasSameDownloadIdentity(as: descriptor) {
-        matchingTaskFound = true
-      } else if
-        candidate.transactionId == descriptor.transactionId &&
-        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.
@@ -1445,28 +972,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()
@@ -1497,52 +1002,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,
-          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 }
@@ -1641,43 +1100,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
-      }
-      let failure: Error
-      if let recordedError = completion.error {
-        failure = recordedError
-      } else if FirmwareArtifactStore.shared.isTransactionCancelled(
-        descriptor.transactionId
-      ) {
-        failure = FirmwareBackgroundDownloadError.cancelled
-      } else if let taskError = error {
-        failure =
-          isFirmwareArtifactTLSError(taskError)
-            ? FirmwareBackgroundDownloadError.tlsRejected
-            : FirmwareBackgroundDownloadError.transferFailed
-      } else {
-        failure = FirmwareBackgroundDownloadError.transferFailed
-      }
-      finishFirmwareTask(
-        key: descriptor.key,
-        result: .failure(failure)
-      )
-      return
-    }
     guard let desc = task.taskDescription,
           let (state, idx) = run(for: desc) else { return }
     let ranges = lock.withLockValue { state.ranges }
@@ -1853,26 +1275,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) {
@@ -1884,25 +1286,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) {

package/lib/module/index.js

@@ -10,7 +10,6 @@ export const ReactNativeRangeDownloader = ReactNativeRangeDownloaderHybridObject
 export const RangeDownloadChannel = {
   Bundle: 'bundle',
   Apk: 'apk',
-  Chart: 'chart',
-  Firmware: 'firmware'
+  Chart: 'chart'
 };
 //# sourceMappingURL=index.js.map