react-native-nitro-fetch 0.1.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Szymon Kapala
+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/NitroFetch.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroFetch"
+  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 => "http://google.com.git", :tag => "#{s.version}" }
+
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/NitroFetch+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,134 @@
+<p align="center">
+  <img src="./assets/logo.png" alt="Nitro Fetch Logo" width="200" />
+</p>
+
+# react-native-nitro-fetch
+
+Nitro-powered fetch for React Native. Android uses Chromium Cronet (via `org.chromium.net:cronet-embedded`); iOS currently falls back to the built-in fetch. Includes helpers for background prefetching and off-thread parsing with worklets.
+
+## Installation
+
+```sh
+npm install react-native-nitro-fetch react-native-nitro-modules
+```
+
+- `react-native-nitro-modules` is required as this library relies on Nitro Modules. Rebuild your app after installing.
+
+## Quick Start
+
+```ts
+import { fetch } from 'react-native-nitro-fetch';
+
+const res = await fetch('https://httpbin.org/get');
+const json = await res.json();
+```
+
+## Features
+
+- Nitro-backed `fetch`: drop-in replacement for global fetch.
+- Android Cronet: fast HTTP stack via `org.chromium.net:cronet-embedded` (already wired in `android/build.gradle`).
+- Prefetch: start a background request tied to a `prefetchKey` and serve it later.
+- Android auto-prefetch: enqueue requests to MMKV so they warm up on next app start.
+- Worklets helper: run mapping/parsing off the JS thread with `react-native-worklets-core`.
+
+## Why Prefetch
+
+- Faster first paint of data: Prefetching lets you move network I/O earlier on the critical path so the screen can render with data sooner.
+- App start wins: With auto‑prefetch + MMKV, we can begin fetching immediately at process start. In our measurements on mid‑range Android devices (e.g., Samsung A16), this starts at least ~220 ms earlier than initiating the same request from JS after React is up.
+- UX hooks: Kick off prefetch on navigation intent (button press) and serve the result when the destination screen mounts.
+
+See `docs/prefetch.md` for patterns and examples.
+
+## Why Cronet
+
+- Performance: Enables HTTP/2 multiplexing and QUIC/HTTP/3, reducing latency and avoiding head‑of‑line blocking.
+- Efficiency: Advanced connection management, TLS/ALPN, Brotli, and robust on‑disk caching.
+- Battle‑tested: Built on Chromium’s networking stack (the same tech behind Chrome) and widely adopted across the ecosystem, including the Flutter community.
+
+## Philosophy
+
+- Nitro Fetch often outperforms built‑in fetch thanks to Cronet’s optimizations, but raw speed is not the primary goal.
+- The main goals are:
+  - High‑quality prefetching (including auto‑prefetch on app start)
+  - Enabling a multi‑threaded React Native architecture (e.g., off‑thread mapping with worklets)
+- Performance is a nice side‑effect.
+
+## Usage Examples
+
+- Basic fetch (drop-in replacement):
+
+```ts
+import { fetch } from 'react-native-nitro-fetch';
+const res = await fetch('https://jsonplaceholder.typicode.com/todos/1');
+console.log(await res.json());
+```
+
+- Prefetch and consume (Android or JS fallback):
+
+```ts
+import { fetch, prefetch } from 'react-native-nitro-fetch';
+
+await prefetch('https://httpbin.org/uuid', { headers: { prefetchKey: 'uuid' } });
+const res = await fetch('https://httpbin.org/uuid', { headers: { prefetchKey: 'uuid' } });
+console.log('prefetched header:', res.headers.get('nitroPrefetched'));
+```
+
+- Schedule auto-prefetch on Android (requires `react-native-mmkv` in your app):
+
+```ts
+import { prefetchOnAppStart } from 'react-native-nitro-fetch';
+await prefetchOnAppStart('https://httpbin.org/uuid', { prefetchKey: 'uuid' });
+```
+
+- Off-thread parsing with worklets:
+
+```ts
+import { nitroFetchOnWorklet } from 'react-native-nitro-fetch';
+
+const map = (payload: { bodyString?: string }) => {
+  'worklet';
+  return JSON.parse(payload.bodyString ?? '{}');
+};
+
+const data = await nitroFetchOnWorklet('https://httpbin.org/get', undefined, map, { preferBytes: false });
+```
+
+## Platform Notes
+
+- Android: Uses Cronet Java API; no extra setup needed beyond install and rebuild. Cronet engine is initialized once and enables HTTP/2, QUIC, Brotli, and disk cache.
+- iOS: Uses a native `URLSession` client for requests and prefetch (in‑memory cache). Cronet integration is still planned for future releases.
+
+## Limitations & Alternatives
+
+- HTTP streaming: Not supported yet. For streaming responses today, use Expo’s `expo-fetch`. Streaming is on the roadmap.
+- WebSockets: Not supported. For high‑performance sockets and binary streams, consider `react-native-fast-io`.
+
+## Documentation
+
+- Getting Started: `docs/getting-started.md`
+- API Reference: `docs/api.md`
+- Android Details: `docs/android.md`
+- iOS Details: `docs/ios.md`
+- Prefetch & Auto-Prefetch: `docs/prefetch.md`
+- Worklets: `docs/worklets.md`
+- Troubleshooting: `docs/troubleshooting.md`
+- Cronet (Android) notes: `docs/cronet-android.md`
+- Cronet (iOS) notes: `docs/cronet-ios.md`
+
+## Work With Margelo
+
+Need top‑notch React Native help or custom networking solutions? Reach out to Margelo: hello@margelo.com
+
+## 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/android/CMakeLists.txt

@@ -0,0 +1,70 @@
+project(nitrofetch)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME nitrofetch)
+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/nitrofetch+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+# Allow Gradle to pass a CRONET_ROOT pointing to extracted headers/libs (see build.gradle prepareCronet task)
+if (DEFINED CRONET_ROOT)
+    set(CRONET_ROOT_DIR ${CRONET_ROOT})
+else()
+    set(CRONET_ROOT_DIR ${CMAKE_SOURCE_DIR}/cronet)
+endif()
+
+# Optional: include Cronet headers if present (placed by script under android/cronet/include)
+if (EXISTS ${CRONET_ROOT_DIR}/include)
+    message(STATUS "Cronet headers base: ${CRONET_ROOT_DIR}/include")
+    include_directories(${CRONET_ROOT_DIR}/include)
+    # Some Cronet packages nest headers under include/cronet
+    if (EXISTS ${CRONET_ROOT_DIR}/include/cronet)
+        include_directories(${CRONET_ROOT_DIR}/include/cronet)
+        if (EXISTS ${CRONET_ROOT_DIR}/include/cronet/cronet_c.h)
+            message(STATUS "Found cronet_c.h: ${CRONET_ROOT_DIR}/include/cronet/cronet_c.h")
+        else()
+            message(WARNING "cronet_c.h not found under ${CRONET_ROOT_DIR}/include/cronet")
+        endif()
+        if (EXISTS ${CRONET_ROOT_DIR}/include/cronet/cronet.idl_c.h)
+            message(STATUS "Found cronet.idl_c.h: ${CRONET_ROOT_DIR}/include/cronet/cronet.idl_c.h")
+        else()
+            message(WARNING "cronet.idl_c.h not found under ${CRONET_ROOT_DIR}/include/cronet")
+        endif()
+    else()
+        message(WARNING "Cronet nested include dir not found: ${CRONET_ROOT_DIR}/include/cronet")
+    endif()
+endif()
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)
+
+## Kotlin-based implementation only; no custom C++ headers forced.
+
+# Optional: link Cronet if library file is present (drop-in via prepare script or Gradle task)
+set(CRONET_LIB_DIR ${CRONET_ROOT_DIR}/libs/${ANDROID_ABI})
+if (EXISTS ${CRONET_LIB_DIR})
+    file(GLOB CRONET_LIBS "${CRONET_LIB_DIR}/*cronet*.so")
+    if (CRONET_LIBS)
+        message(STATUS "Linking Cronet from ${CRONET_LIB_DIR}")
+        target_link_libraries(${PACKAGE_NAME} ${CRONET_LIBS})
+        target_compile_definitions(${PACKAGE_NAME} PRIVATE NITROFETCH_LINKS_CRONET=1)
+    else()
+        message(WARNING "Cronet libs not found in ${CRONET_LIB_DIR}")
+    endif()
+endif()

package/android/build.gradle

@@ -0,0 +1,131 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['NitroFetch_' + 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/nitrofetch+autolinking.gradle'
+
+// Do not apply React Gradle plugin in library to avoid RN codegen duplicating app classes
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroFetch_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.nitrofetch"
+
+  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())
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "**/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")
+// ---------- Cronet (Java API only) ----------
+def cronetVersion = (getExtOrDefault("cronetVersion") ?: "119.6045.31")
+
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+  // Provide org.chromium.net Java API for CronetEngine in Kotlin
+  // Cronet
+  api "org.chromium.net:cronet-embedded:${cronetVersion}"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+}
+
+configurations {
+  cronetAar
+}
+
+
+// No automatic fetching of Cronet headers/libs; library uses Cronet Java API only.

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroFetch_kotlinVersion=2.0.21
+NitroFetch_minSdkVersion=24
+NitroFetch_targetSdkVersion=34
+NitroFetch_compileSdkVersion=35
+NitroFetch_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

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

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

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

package/android/src/main/java/com/margelo/nitro/nitrofetch/AutoPrefetcher.kt

@@ -0,0 +1,91 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.CompletableFuture
+
+object AutoPrefetcher {
+  @Volatile private var initialized = false
+
+  fun prefetchOnStart(app: Application) {
+    if (initialized) return
+    initialized = true
+    try {
+      val mmkv = getMMKV(app) ?: return
+      val raw = invokeMMKVDecodeString(mmkv, KEY_QUEUE) ?: return
+      if (raw.isEmpty()) return
+      val arr = JSONArray(raw)
+      for (i in 0 until arr.length()) {
+        val o = arr.optJSONObject(i) ?: continue
+        val url = o.optString("url", null) ?: continue
+        val prefetchKey = o.optString("prefetchKey", null) ?: continue
+        val headersObj = o.optJSONObject("headers") ?: JSONObject()
+        val headersList = mutableListOf<Pair<String, String>>()
+        headersObj.keys().forEachRemaining { k ->
+          headersList.add(k to headersObj.optString(k, ""))
+        }
+        // Ensure prefetchKey header is present
+        headersList.add("prefetchKey" to prefetchKey)
+
+        val headerObjs = headersList.map { (k, v) -> NitroHeader(k, v) }.toTypedArray()
+        val req = NitroRequest(
+          url = url,
+          method = null,
+          headers = headerObjs,
+          bodyString = null,
+          bodyBytes = null,
+          timeoutMs = null,
+          followRedirects = null
+        )
+
+        // If already pending or fresh, skip starting a new one
+        if (FetchCache.getPending(prefetchKey) != null) {
+          continue
+        }
+        if (FetchCache.getResultIfFresh(prefetchKey, 5_000L) != null) {
+          continue
+        }
+
+        val future = CompletableFuture<NitroResponse>()
+        FetchCache.setPending(prefetchKey, future)
+        NitroFetchClient.fetch(req,
+          onSuccess = { res ->
+            try {
+              FetchCache.complete(prefetchKey, res)
+              future.complete(res)
+            } catch (t: Throwable) {
+              FetchCache.completeExceptionally(prefetchKey, t)
+              future.completeExceptionally(t)
+            }
+          },
+          onFail = { err ->
+            FetchCache.completeExceptionally(prefetchKey, err)
+            future.completeExceptionally(err)
+          }
+        )
+      }
+    } catch (_: Throwable) {
+      // ignore – prefetch-on-start is best-effort
+    }
+  }
+
+  private const val KEY_QUEUE = "nitrofetch_autoprefetch_queue"
+
+  private fun getMMKV(app: Application): Any? {
+    return try {
+      val cls = Class.forName("com.tencent.mmkv.MMKV")
+      // Initialize if available
+      try { cls.getMethod("initialize", Application::class.java).invoke(null, app) } catch (_: Throwable) {}
+      // Get default instance
+      cls.getMethod("defaultMMKV").invoke(null)
+    } catch (_: Throwable) { null }
+  }
+
+  private fun invokeMMKVDecodeString(mmkv: Any, key: String): String? {
+    return try {
+      val m = mmkv.javaClass.getMethod("decodeString", String::class.java, String::class.java)
+      m.invoke(mmkv, key, null) as? String
+    } catch (_: Throwable) { null }
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/FetchCache.kt

@@ -0,0 +1,48 @@
+package com.margelo.nitro.nitrofetch
+
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.ConcurrentHashMap
+
+data class CachedEntry(val response: NitroResponse, val timestampMs: Long)
+
+object FetchCache {
+  private val pending = ConcurrentHashMap<String, CompletableFuture<NitroResponse>>()
+  private val results = ConcurrentHashMap<String, CachedEntry>()
+
+  fun getPending(key: String): CompletableFuture<NitroResponse>? = pending[key]
+
+  fun setPending(key: String, future: CompletableFuture<NitroResponse>) {
+    pending[key] = future
+    // Cleanup: remove pending entry when completed
+    future.whenComplete { _, _ ->
+      pending.remove(key)
+    }
+  }
+
+  fun complete(key: String, value: NitroResponse) {
+    results[key] = CachedEntry(value, System.currentTimeMillis())
+    pending[key]?.complete(value)
+    pending.remove(key)
+  }
+
+  fun completeExceptionally(key: String, t: Throwable) {
+    pending[key]?.completeExceptionally(t)
+    pending.remove(key)
+  }
+
+  fun getResult(key: String): NitroResponse? {
+    val entry = results.remove(key) ?: return null
+    return entry.response
+  }
+
+  fun getResultIfFresh(key: String, maxAgeMs: Long): NitroResponse? {
+    val entry = results.remove(key) ?: return null
+    val age = System.currentTimeMillis() - entry.timestampMs
+    return if (age <= maxAgeMs) entry.response else null
+  }
+
+  fun clear() {
+    pending.clear()
+    results.clear()
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitrofetch/NitroFetch.kt

@@ -0,0 +1,94 @@
+package com.margelo.nitro.nitrofetch
+
+import android.app.Application
+import android.util.Log
+import com.facebook.proguard.annotations.DoNotStrip
+import org.chromium.net.CronetEngine
+import org.chromium.net.CronetProvider
+import java.io.File
+import java.util.concurrent.Executor
+import java.util.concurrent.Executors
+
+@DoNotStrip
+class NitroFetch : HybridNitroFetchSpec() {
+  // Generated base may expect env-less createClient.
+  override fun createClient(): NitroFetchClient {
+    return NitroFetchClient(getEngine(), ioExecutor)
+  }
+
+  companion object {
+    @Volatile private var engineRef: CronetEngine? = null
+
+    // Simpler & safer for callbacks than a pool (avoid reentrancy races in glue code).
+    val ioExecutor: Executor by lazy {
+      val cores = Runtime.getRuntime().availableProcessors().coerceAtLeast(2)
+      Executors.newFixedThreadPool(cores) { r ->
+        Thread(r, "NitroCronet-io").apply {
+          isDaemon = true
+          priority = Thread.NORM_PRIORITY
+        }
+      }
+    }
+
+    fun getEngine(): CronetEngine {
+      engineRef?.let { return it }
+      synchronized(this) {
+        engineRef?.let { return it }
+
+        val app = currentApplication() ?: initialApplication()
+        ?: throw IllegalStateException("NitroFetch: Application not available")
+
+        // Log available providers and prefer the Native one (avoids Play-Services DNS quirks)
+        val providers = CronetProvider.getAllProviders(app)
+        providers.forEach { Log.i("NitroFetch", "Cronet provider: ${it.name} v=${it.version}") }
+        val nativeProvider = providers.firstOrNull { it.name.contains("Native", ignoreCase = true) }
+
+        val cacheDir = File(app.cacheDir, "nitrofetch_cronet_cache").apply { mkdirs() }
+        val builder = (nativeProvider?.createBuilder() ?: CronetEngine.Builder(app))
+          .enableHttp2(true)
+          .enableQuic(true)
+          .enableBrotli(true)
+          .setStoragePath(cacheDir.absolutePath)
+          .enableHttpCache(CronetEngine.Builder.HTTP_CACHE_DISK, 50 * 1024 * 1024)
+          .setUserAgent("NitroFetch/0.1")
+
+
+        // --- Optional debugging knobs (uncomment temporarily) ---
+        // Enable NetLog-like tracing in NetworkService:
+        // builder.setExperimentalOptions("""{"NetworkService":{"enable_network_logging":true}}""")
+        //
+        // Prove DNS issues by mapping a host (TESTING ONLY, remove in prod):
+        // builder.setExperimentalOptions("""{"HostResolverRules":{"host_resolver_rules":"MAP httpbin.org 54.167.17.38"}}""")
+
+        val engine = builder.build()
+        Log.i("NitroFetch", "CronetEngine initialized. Provider=${nativeProvider?.name ?: "Default"} Cache=${cacheDir.absolutePath}")
+        engineRef = engine
+        return engine
+      }
+    }
+
+    fun shutdown() {
+      synchronized(this) {
+        try {
+          engineRef?.shutdown()
+        } catch (_: Throwable) {
+          // ignore – shutdown is best-effort
+        } finally {
+          engineRef = null
+        }
+      }
+    }
+
+    private fun currentApplication(): Application? = try {
+      val cls = Class.forName("android.app.ActivityThread")
+      val m = cls.getMethod("currentApplication")
+      m.invoke(null) as? Application
+    } catch (_: Throwable) { null }
+
+    private fun initialApplication(): Application? = try {
+      val cls = Class.forName("android.app.AppGlobals")
+      val m = cls.getMethod("getInitialApplication")
+      m.invoke(null) as? Application
+    } catch (_: Throwable) { null }
+  }
+}