@onekeyfe/react-native-range-downloader 3.0.39

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OneKey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# react-native-range-downloader
+
+react-native-range-downloader
+
+## Installation
+
+```sh
+npm install react-native-range-downloader react-native-nitro-modules
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+```
+
+## Usage
+
+```js
+import { ReactNativeRangeDownloader } from 'react-native-range-downloader';
+
+// ...
+
+const result = await ReactNativeRangeDownloader.hello({ message: 'World' });
+console.log(result); // { success: true, data: 'Hello, World!' }
+```
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/ReactNativeRangeDownloader.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "ReactNativeRangeDownloader"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/OneKeyHQ/app-modules/react-native-range-downloader.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'ReactNativeNativeLogger'
+
+  load 'nitrogen/generated/ios/ReactNativeRangeDownloader+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(reactnativerangedownloader)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME reactnativerangedownloader)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/reactnativerangedownloader+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,132 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['ReactNativeRangeDownloader_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/reactnativerangedownloader+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["ReactNativeRangeDownloader_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.reactnativerangedownloader"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+
+  implementation project(":onekeyfe_react-native-native-logger")
+
+  implementation "com.squareup.okhttp3:okhttp:4.12.0"
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+ReactNativeRangeDownloader_kotlinVersion=1.9.25
+ReactNativeRangeDownloader_compileSdkVersion=35
+ReactNativeRangeDownloader_targetSdkVersion=35
+ReactNativeRangeDownloader_minSdkVersion=24

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "reactnativerangedownloaderOnLoad.hpp"
+
+extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::reactnativerangedownloader::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ConcurrentRangeDownloader.kt

@@ -0,0 +1,340 @@
+package com.margelo.nitro.reactnativerangedownloader
+
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import java.io.File
+import java.io.RandomAccessFile
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.atomic.AtomicReference
+
+/**
+ * Splits a Range-capable download into [segmentCount] byte ranges fetched in
+ * parallel, each written directly into its own offset of ONE pre-allocated
+ * `.partial` file (no merge pass, 1x disk). A sidecar `<partial>.progress`
+ * manifest records each segment's durably-written cursor so an interrupted
+ * download resumes by re-requesting only the unfinished tail of each segment.
+ *
+ * Mirrors the desktop DesktopApiBundleUpdate concurrent path. This class is
+ * intentionally free of Android/OneKey dependencies (logging is injected) so
+ * it can be unit/type-checked standalone; the whole-file SHA256 check the
+ * caller already performs after promotion is the final correctness backstop.
+ *
+ * Invariant: the manifest is only meaningful as metadata for an existing
+ * `.partial`. Either both exist (resume) or neither does (fresh) — any other
+ * combination is treated as "no resumable state".
+ */
+class ConcurrentRangeDownloader(
+    private val httpClient: OkHttpClient,
+    private val segmentCount: Int = 8,
+    private val minConcurrentBytes: Long = 2L * 1024 * 1024,
+    private val maxPartRetry: Int = 3,
+    private val manifestFlushBytes: Long = 4L * 1024 * 1024,
+    private val log: (String) -> Unit = {},
+) {
+    enum class Outcome {
+        /** `.partial` is fully on disk; caller should promote (rename) + verify. */
+        COMPLETED,
+
+        /** Concurrency unusable — caller should use its single-stream path. */
+        FALLBACK,
+    }
+
+    /** Thrown internally when a segment proves concurrency can't be used. */
+    private class FallbackException(message: String) : Exception(message)
+
+    private class Part(val index: Int, val start: Long, val end: Long, @Volatile var done: Long) {
+        val length: Long get() = end - start + 1
+    }
+
+    private class Probe(val totalSize: Long, val etag: String?, val supportsRange: Boolean)
+
+    /**
+     * Fills [partialFilePath] completely with the resource at [url] using
+     * concurrent ranges. See [Outcome]. Throws on a transient/IO error after
+     * per-segment retries, leaving the partial + manifest in place so a later
+     * attempt resumes.
+     */
+    fun download(
+        url: String,
+        partialFilePath: String,
+        onProgress: (transferred: Long, total: Long) -> Unit,
+    ): Outcome {
+        val partialFile = File(partialFilePath)
+        val manifestFile = File("$partialFilePath.progress")
+
+        // A bare `.partial` with no manifest is a single-stream leftover; let
+        // the caller's single-stream path resume it instead of discarding it.
+        if (partialFile.exists() && !manifestFile.exists()) {
+            log("concurrent: single-stream partial present, deferring to single-stream")
+            return Outcome.FALLBACK
+        }
+
+        val probe = probe(url) ?: return Outcome.FALLBACK
+        if (!probe.supportsRange || probe.totalSize < minConcurrentBytes) {
+            log("concurrent: not eligible (supportsRange=${probe.supportsRange}, size=${probe.totalSize})")
+            return Outcome.FALLBACK
+        }
+        val total = probe.totalSize
+        val etag = probe.etag
+
+        partialFile.parentFile?.let { if (!it.exists()) it.mkdirs() }
+        dropOrphanManifest(partialFile, manifestFile)
+        val parts = loadOrInitManifest(manifestFile, partialFile, total, etag)
+
+        val transferred = AtomicLong(parts.sumOf { it.done })
+        onProgress(transferred.get(), total)
+
+        val aborted = AtomicBoolean(false)
+        val fallback = AtomicBoolean(false)
+        val firstError = AtomicReference<Exception?>(null)
+        val lastFlushed = LongArray(parts.size) { parts[it].done }
+
+        val pool = Executors.newFixedThreadPool(minOf(segmentCount, parts.size))
+        try {
+            val futures = parts.map { part ->
+                pool.submit {
+                    try {
+                        downloadPart(url, etag, partialFile, part, aborted) { delta ->
+                            val t = transferred.addAndGet(delta)
+                            synchronized(lastFlushed) {
+                                if (part.done - lastFlushed[part.index] >= manifestFlushBytes) {
+                                    lastFlushed[part.index] = part.done
+                                    flushManifest(manifestFile, total, etag, parts)
+                                }
+                            }
+                            onProgress(t, total)
+                        }
+                    } catch (e: FallbackException) {
+                        fallback.set(true)
+                        aborted.set(true)
+                        firstError.compareAndSet(null, e)
+                    } catch (e: Exception) {
+                        aborted.set(true)
+                        firstError.compareAndSet(null, e)
+                    }
+                }
+            }
+            futures.forEach { it.get() }
+        } finally {
+            pool.shutdownNow()
+        }
+
+        if (fallback.get()) {
+            // Stale/unusable bytes — clear before the caller falls back.
+            discard(partialFile, manifestFile)
+            return Outcome.FALLBACK
+        }
+        val err = firstError.get()
+        if (err != null) {
+            // Transient — persist progress so the next attempt resumes, then bubble up.
+            flushManifest(manifestFile, total, etag, parts)
+            throw err
+        }
+        val got = parts.sumOf { it.done }
+        if (got < total) {
+            flushManifest(manifestFile, total, etag, parts)
+            throw java.io.IOException("Concurrent download incomplete ($got/$total)")
+        }
+
+        // Success: `.partial` is fully filled. The manifest's job is done and it
+        // must never outlive the `.partial` it describes (caller is about to
+        // promote it), so drop it now.
+        manifestFile.delete()
+        log("concurrent: completed ($total bytes)")
+        return Outcome.COMPLETED
+    }
+
+    // Single round-trip probe: a one-byte Range request that confirms Range
+    // support and captures total size + ETag. OkHttp follows redirects (the
+    // caller's client enforces HTTPS on each hop).
+    private fun probe(url: String): Probe? {
+        return try {
+            val req = Request.Builder().url(url).addHeader("Range", "bytes=0-0").build()
+            httpClient.newCall(req).execute().use { response ->
+                val etag = response.header("ETag")
+                when (response.code) {
+                    206 -> {
+                        val total = response.header("Content-Range")
+                            ?.let { Regex("""bytes \d+-\d+/(\d+)""").find(it)?.groupValues?.getOrNull(1)?.toLongOrNull() }
+                        if (total != null) Probe(total, etag, true) else Probe(0, etag, false)
+                    }
+                    200 -> {
+                        // Server ignored Range — single-stream only.
+                        val len = response.body?.contentLength() ?: -1L
+                        Probe(if (len > 0) len else 0, etag, false)
+                    }
+                    else -> null
+                }
+            }
+        } catch (e: Exception) {
+            log("concurrent: probe failed: ${e.javaClass.simpleName}")
+            null
+        }
+    }
+
+    private fun dropOrphanManifest(partialFile: File, manifestFile: File) {
+        if (!partialFile.exists() && manifestFile.exists()) {
+            log("concurrent: dropping orphan manifest")
+            manifestFile.delete()
+        }
+    }
+
+    private fun discard(partialFile: File, manifestFile: File) {
+        // Manifest first so it never outlives the partial it describes.
+        manifestFile.delete()
+        partialFile.delete()
+    }
+
+    // Resume from a manifest whose size/ETag still match, else (re)create a
+    // fresh pre-allocated partial + manifest. Manifest is removed before the
+    // partial is (re)created, and written only after the partial exists.
+    private fun loadOrInitManifest(
+        manifestFile: File,
+        partialFile: File,
+        total: Long,
+        etag: String?,
+    ): List<Part> {
+        if (manifestFile.exists() && partialFile.exists()) {
+            val parsed = parseManifest(manifestFile, total, etag, partialFile.length())
+            if (parsed != null) {
+                log("concurrent: resuming, transferred=${parsed.sumOf { it.done }}/$total")
+                return parsed
+            }
+        }
+        discard(partialFile, manifestFile)
+        RandomAccessFile(partialFile, "rw").use { it.setLength(total) }
+        val parts = ArrayList<Part>()
+        val chunk = (total + segmentCount - 1) / segmentCount
+        var i = 0
+        while (i < segmentCount) {
+            val start = i * chunk
+            if (start >= total) break
+            val end = minOf(start + chunk - 1, total - 1)
+            parts.add(Part(parts.size, start, end, 0))
+            i += 1
+        }
+        writeManifest(manifestFile, total, etag, parts)
+        return parts
+    }
+
+    // Manifest format (dependency-free, internal): line 0 "<size>|<etag>",
+    // then one "<index>,<start>,<end>,<done>" line per segment.
+    private fun writeManifest(manifestFile: File, total: Long, etag: String?, parts: List<Part>) {
+        val sb = StringBuilder()
+        sb.append(total).append('|').append(etag ?: "").append('\n')
+        for (p in parts) {
+            sb.append(p.index).append(',').append(p.start).append(',')
+                .append(p.end).append(',').append(p.done).append('\n')
+        }
+        manifestFile.writeText(sb.toString())
+    }
+
+    @Synchronized
+    private fun flushManifest(manifestFile: File, total: Long, etag: String?, parts: List<Part>) {
+        try {
+            writeManifest(manifestFile, total, etag, parts)
+        } catch (e: Exception) {
+            log("concurrent: manifest flush failed: ${e.javaClass.simpleName}")
+        }
+    }
+
+    private fun parseManifest(manifestFile: File, total: Long, etag: String?, partialSize: Long): List<Part>? {
+        return try {
+            val lines = manifestFile.readText().trim().split('\n')
+            if (lines.isEmpty()) return null
+            val head = lines[0].split('|')
+            val savedSize = head.getOrNull(0)?.toLongOrNull() ?: return null
+            val savedEtag = head.getOrNull(1)?.takeIf { it.isNotEmpty() }
+            // Object must be identical to what's on disk and on the CDN.
+            if (savedSize != total || partialSize != total) return null
+            if (etag != null && savedEtag != null && etag != savedEtag) return null
+            val parts = ArrayList<Part>()
+            for (idx in 1 until lines.size) {
+                val cols = lines[idx].split(',')
+                if (cols.size != 4) return null
+                val i = cols[0].toIntOrNull() ?: return null
+                val s = cols[1].toLongOrNull() ?: return null
+                val e = cols[2].toLongOrNull() ?: return null
+                var d = cols[3].toLongOrNull() ?: return null
+                val segLen = e - s + 1
+                if (d < 0) d = 0
+                if (d > segLen) d = segLen
+                parts.add(Part(i, s, e, d))
+            }
+            if (parts.isEmpty()) null else parts
+        } catch (e: Exception) {
+            log("concurrent: manifest parse failed: ${e.javaClass.simpleName}")
+            null
+        }
+    }
+
+    // Download [start+done, end] of [part] into its own RandomAccessFile handle
+    // (each segment gets its own fd so concurrent positioned writes don't race),
+    // resuming from part.done and retrying transient failures in place.
+    private fun downloadPart(
+        url: String,
+        etag: String?,
+        partialFile: File,
+        part: Part,
+        aborted: AtomicBoolean,
+        onBytes: (delta: Long) -> Unit,
+    ) {
+        var retry = 0
+        while (true) {
+            if (aborted.get()) throw java.io.IOException("aborted")
+            val rangeStart = part.start + part.done
+            if (rangeStart > part.end) return
+            try {
+                fetchSegment(url, etag, partialFile, part, rangeStart, aborted, onBytes)
+                return
+            } catch (e: FallbackException) {
+                throw e
+            } catch (e: Exception) {
+                if (aborted.get() || retry >= maxPartRetry) throw e
+                retry += 1
+                log("concurrent: segment ${part.index} retry $retry: ${e.javaClass.simpleName}")
+            }
+        }
+    }
+
+    private fun fetchSegment(
+        url: String,
+        etag: String?,
+        partialFile: File,
+        part: Part,
+        rangeStart: Long,
+        aborted: AtomicBoolean,
+        onBytes: (delta: Long) -> Unit,
+    ) {
+        val builder = Request.Builder().url(url)
+            .addHeader("Range", "bytes=$rangeStart-${part.end}")
+        // If-Range: a mismatched ETag makes the CDN reply 200 (full body)
+        // instead of 206, which we treat as a fallback signal.
+        if (etag != null) builder.addHeader("If-Range", etag)
+        httpClient.newCall(builder.build()).execute().use { response ->
+            if (response.code == 200) {
+                throw FallbackException("server returned 200 to a Range request")
+            }
+            if (response.code != 206) {
+                throw java.io.IOException("HTTP ${response.code}")
+            }
+            val body = response.body ?: throw java.io.IOException("Empty segment body")
+            RandomAccessFile(partialFile, "rw").use { raf ->
+                raf.seek(rangeStart)
+                body.byteStream().use { input ->
+                    val buffer = ByteArray(8192)
+                    while (true) {
+                        if (aborted.get()) throw java.io.IOException("aborted")
+                        val read = input.read(buffer)
+                        if (read == -1) break
+                        raf.write(buffer, 0, read)
+                        part.done += read
+                        onBytes(read.toLong())
+                    }
+                }
+            }
+        }
+    }
+}