react-native-nitro-web-image 0.5.0-beta.5

package/NitroWebImage.podspec

@@ -0,0 +1,33 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NitroWebImage"
+  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, :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/mrousavy/nitro.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  load 'nitrogen/generated/ios/NitroWebImage+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  s.dependency 'SDWebImage'
+  s.dependency 'NitroImage'
+  install_modules_dependencies(s)
+end

package/android/CMakeLists.txt

@@ -0,0 +1,31 @@
+project(NitroWebImage)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME NitroWebImage)
+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/NitroWebImage+autolinking.cmake)
+
+# Set up local includes
+include_directories(
+        "src/main/cpp"
+        "../cpp"
+)
+
+find_library(LOG_LIB log)
+find_package(react-native-nitro-image REQUIRED)   # <-- for the HybridImage type
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android                                   # <-- Android core
+        react-native-nitro-image::NitroImage      # <-- NitroImage
+)

package/android/build.gradle

@@ -0,0 +1,145 @@
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.10.1"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: 'org.jetbrains.kotlin.android'
+apply from: '../nitrogen/generated/android/NitroWebImage+autolinking.gradle'
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["NitroImage_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["NitroImage_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.web.image"
+
+  ndkVersion getExtOrDefault("ndkVersion")
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -Wextra -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 {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          // React Codegen files
+          "${project.buildDir}/generated/source/codegen/java"
+        ]
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+
+  // Add a dependency on NitroModules
+  implementation project(":react-native-nitro-modules")
+  // Add a dependency on NitroImage
+  implementation project(":react-native-nitro-image")
+  // Coil
+  implementation("io.coil-kt.coil3:coil:3.3.0")
+  implementation("io.coil-kt.coil3:coil-network-okhttp:3.3.0")
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+NitroImage_kotlinVersion=2.0.21
+NitroImage_minSdkVersion=23
+NitroImage_targetSdkVersion=35
+NitroImage_compileSdkVersion=34
+NitroImage_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 "NitroWebImageOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::web::image::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/web/image/AsyncImagePriority+toCoroutineContext.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.web.image
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlin.coroutines.CoroutineContext
+
+
+fun AsyncImagePriority.toCoroutineContext(): CoroutineContext? {
+    // TODO: Does this look about right?
+    return when (this) {
+        AsyncImagePriority.LOW -> Dispatchers.IO.limitedParallelism(2)
+        AsyncImagePriority.DEFAULT -> null
+        AsyncImagePriority.HIGH -> Dispatchers.IO
+    }
+}

package/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageFactory.kt

@@ -0,0 +1,32 @@
+package com.margelo.nitro.web.image
+
+import androidx.annotation.Keep
+import coil3.ImageLoader
+import com.facebook.common.internal.DoNotStrip
+import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImageLoaderSpec
+import com.margelo.nitro.image.HybridImageSpec
+
+@DoNotStrip
+@Keep
+class HybridWebImageFactory: HybridWebImageFactorySpec() {
+    private val context: ReactApplicationContext
+        get() = NitroModules.applicationContext ?: throw Error("No context - NitroModules.applicationContext was null!")
+    private val imageLoader = ImageLoader(context)
+
+    override fun createWebImageLoader(
+        url: String,
+        options: AsyncImageLoadOptions?
+    ): HybridImageLoaderSpec {
+        return HybridWebImageLoader(imageLoader, url, options, context)
+    }
+
+    override fun loadFromURLAsync(
+        url: String,
+        options: AsyncImageLoadOptions?
+    ): Promise<HybridImageSpec> {
+        return imageLoader.loadImageAsync(url, options, context)
+    }
+}

package/android/src/main/java/com/margelo/nitro/web/image/HybridWebImageLoader.kt

@@ -0,0 +1,32 @@
+package com.margelo.nitro.web.image
+
+import android.content.Context
+import android.widget.ImageView
+import coil3.ImageLoader
+import coil3.load
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImageSpec
+import com.margelo.nitro.image.HybridImageLoaderSpec
+import com.margelo.nitro.image.HybridNitroImageViewSpec
+
+class HybridWebImageLoader(private val imageLoader: ImageLoader,
+                           private val url: String,
+                           private val options: AsyncImageLoadOptions?,
+                           private val context: Context) : HybridImageLoaderSpec() {
+    override fun loadImage(): Promise<HybridImageSpec> {
+        return imageLoader.loadImageAsync(url, options, context)
+    }
+
+    override fun requestImage(forView: HybridNitroImageViewSpec) {
+        val imageView = forView.view as? ImageView ?: return
+
+        imageView.load(url, imageLoader) {
+            this.applyOptions(options)
+        }
+        imageView.load(url)
+    }
+
+    override fun dropImage(forView: HybridNitroImageViewSpec) {
+        // Coil automatically handles recycling here - I _think_.
+    }
+}

package/android/src/main/java/com/margelo/nitro/web/image/ImageLoader+loadImageAsync.kt

@@ -0,0 +1,37 @@
+package com.margelo.nitro.web.image
+
+import android.content.Context
+import coil3.BitmapImage
+import coil3.Image
+import coil3.ImageLoader
+import coil3.request.ImageRequest
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.image.HybridImage
+import com.margelo.nitro.image.HybridImageSpec
+
+suspend fun ImageLoader.loadCoilImageAsync(url: String,
+                                           options: AsyncImageLoadOptions?,
+                                           context: Context): Image {
+    // 1. Create the Coil Request
+    val request = ImageRequest.Builder(context)
+        .data(url)
+        .applyOptions(options)
+        .build()
+    // 2. Execute it (async)
+    val result = this.execute(request)
+    val image = result.image ?: throw Error("Failed to load Image!")
+    return image
+}
+
+fun ImageLoader.loadImageAsync(url: String,
+                               options: AsyncImageLoadOptions?,
+                               context: Context
+): Promise<HybridImageSpec> {
+    return Promise.async {
+        // 1. Load the coil image
+        val image = loadCoilImageAsync(url, options, context)
+        // 3. Downcast to a Bitmap - if that fails, it might be an Animated Image...
+        val bitmap = image as? BitmapImage ?: throw Error("Requested Image is not a Bitmap!")
+        return@async HybridImage(bitmap.bitmap)
+    }
+}

package/android/src/main/java/com/margelo/nitro/web/image/ImageRequestBuilder+applyOptions.kt

@@ -0,0 +1,58 @@
+package com.margelo.nitro.web.image
+
+import coil3.annotation.ExperimentalCoilApi
+import coil3.decode.BlackholeDecoder
+import coil3.request.CachePolicy
+import coil3.request.ImageRequest
+import coil3.size.Precision
+
+@OptIn(ExperimentalCoilApi::class)
+fun ImageRequest.Builder.applyOptions(options: AsyncImageLoadOptions?): ImageRequest.Builder {
+    if (options == null) return this
+    var result = this
+
+    if (options.priority != null) {
+        options.priority.toCoroutineContext()?.let { context ->
+            result = result.coroutineContext(context)
+        }
+    }
+
+    if (options.forceRefresh == true) {
+        // don't allow reading from cache, only writing.
+        result = result.diskCachePolicy(CachePolicy.WRITE_ONLY)
+        result = result.memoryCachePolicy(CachePolicy.WRITE_ONLY)
+        result = result.networkCachePolicy(CachePolicy.WRITE_ONLY)
+    }
+
+    if (options.continueInBackground == true) {
+        // TODO: Implement .continueInBackground
+    }
+
+    if (options.allowInvalidSSLCertificates == true) {
+        // TODO: Implement .allowInvalidSSLCertificates
+    }
+
+    if (options.scaleDownLargeImages == true) {
+        // Limit to 4096x4096 (~60 MB)
+        result = result.size(4096, 4096)
+        result = result.precision(Precision.INEXACT)
+    }
+
+    if (options.queryMemoryDataSync == true) {
+        // TODO: Implement .queryMemoryDataSync
+    }
+
+    if (options.queryDiskDataSync == true) {
+        // TODO: Implement .queryDiskDataSync
+    }
+
+    if (options.decodeImage == false) {
+        result = result.decoderFactory(BlackholeDecoder.Factory())
+    }
+
+    if (options.cacheKey != null) {
+        result = result.diskCacheKey(options.cacheKey)
+    }
+
+    return result
+}

package/android/src/main/java/com/margelo/nitro/web/image/NitroWebImagePackage.java

@@ -0,0 +1,44 @@
+package com.margelo.nitro.web.image;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.uimanager.ViewManager;
+import com.margelo.nitro.core.HybridObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class NitroWebImagePackage extends TurboReactPackage {
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    return null;
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+        return new HashMap<>();
+    };
+  }
+
+
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    List<ViewManager> viewManagers = new ArrayList<>();
+    return viewManagers;
+  }
+
+  static {
+    NitroWebImageOnLoad.initializeNative();
+  }
+}

package/ios/AsyncImageLoadOptions+toSDWebImageOptions.swift

@@ -0,0 +1,66 @@
+//
+//  AsyncImageLoadOptions+toSDWebImageOptions.swift
+//  NitroWebImage
+//
+//  Created by Marc Rousavy on 30.06.25.
+//
+
+import Foundation
+import SDWebImage
+
+extension AsyncImageLoadOptions {
+  func toSDWebImageOptions() -> SDWebImageOptions {
+    var options: SDWebImageOptions = []
+
+    switch priority {
+    case .default, .none:
+      break
+    case .low:
+      options.insert(.lowPriority)
+    case .high:
+      options.insert(.highPriority)
+    }
+
+    if forceRefresh == true {
+      options.insert(.refreshCached)
+    }
+
+    if continueInBackground == true {
+      options.insert(.continueInBackground)
+    }
+
+    if allowInvalidSSLCertificates == true {
+      options.insert(.allowInvalidSSLCertificates)
+    }
+
+    if scaleDownLargeImages == true {
+      options.insert(.scaleDownLargeImages)
+    }
+
+    if queryMemoryDataSync == true {
+      options.insert(.queryMemoryDataSync)
+    }
+
+    if queryDiskDataSync == true {
+      options.insert(.queryDiskDataSync)
+    }
+
+    if decodeImage == false {
+      options.insert(.avoidDecodeImage)
+    }
+
+    return options
+  }
+
+  func toSDWebImageContext() -> [SDWebImageContextOption: Any] {
+    var context: [SDWebImageContextOption: Any] = [:]
+
+    if let cacheKey {
+      context[.cacheKeyFilter] = SDWebImageCacheKeyFilter { _ in
+        return cacheKey
+      }
+    }
+
+    return context
+  }
+}

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  NitroWebImage
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once

package/ios/HybridWebImageFactory.swift

@@ -0,0 +1,32 @@
+//
+//  HybridWebImageFactory.swift
+//  react-native-nitro-web-image
+//
+//  Created by Marc Rousavy on 10.06.25.
+//
+
+import Foundation
+import NitroModules
+import SDWebImage
+import NitroImage
+
+class HybridWebImageFactory: HybridWebImageFactorySpec {
+  func loadFromURLAsync(url: String, options: AsyncImageLoadOptions?) throws -> Promise<any HybridImageSpec> {
+    throw RuntimeError.error(withMessage: "Not yet implemented!")
+  }
+
+  private let queue = DispatchQueue(label: "image-loader",
+                                    qos: .default,
+                                    attributes: .concurrent)
+
+  /**
+   * Load Image from URL
+   */
+  func createWebImageLoader(url urlString: String, options: AsyncImageLoadOptions?) throws -> any HybridImageLoaderSpec {
+    guard let url = URL(string: urlString) else {
+      throw RuntimeError.error(withMessage: "URL string \"\(urlString)\" is not a valid URL!")
+    }
+
+    return HybridWebImageLoader(url: url, options: options)
+  }
+}

package/ios/HybridWebImageLoader.swift

@@ -0,0 +1,54 @@
+//
+//  HybridWebImageLoader.swift
+//  NitroWebImage
+//
+//  Created by Marc Rousavy on 28.07.25.
+//
+
+import NitroModules
+import SDWebImage
+import NitroImage
+
+fileprivate class HybridImage: HybridImageSpec, NativeImage {
+  let uiImage: UIImage
+  init(uiImage: UIImage) {
+    self.uiImage = uiImage
+    super.init()
+  }
+}
+
+class HybridWebImageLoader: HybridImageLoaderSpec {
+  private let url: URL
+  private let options: AsyncImageLoadOptions?
+
+  init(url: URL, options: AsyncImageLoadOptions?) {
+    self.url = url
+    self.options = options
+    super.init()
+  }
+
+  func loadImage() throws -> Promise<(any HybridImageSpec)> {
+    return Promise.async {
+      let webImageOptions = self.options?.toSDWebImageOptions() ?? []
+      let webImageContext = self.options?.toSDWebImageContext() ?? [:]
+      let uiImage = try await SDWebImageManager.shared.loadImage(with: self.url,
+                                                                 options: webImageOptions,
+                                                                 context: webImageContext)
+      return HybridImage(uiImage: uiImage)
+    }
+  }
+
+  func requestImage(forView view: (any HybridNitroImageViewSpec)) throws {
+    guard let view = view as? NativeImageView else { throw RuntimeError.error(withMessage: "Invalid view type!") }
+
+    let webImageOptions = options?.toSDWebImageOptions() ?? []
+    view.imageView.sd_setImage(with: url,
+                               placeholderImage: nil,
+                               options: webImageOptions,
+                               context: nil)
+  }
+
+  func dropImage(forView view: (any HybridNitroImageViewSpec)) throws {
+    // TODO: Do we need to reset the image here or not?
+  }
+}

package/ios/SDWebImageManager+loadImage.swift

@@ -0,0 +1,30 @@
+//
+//  SDWebImageManager+loadImage.swift
+//  NitroWebImage
+//
+//  Created by Marc Rousavy on 30.06.25.
+//
+
+import Foundation
+import SDWebImage
+import NitroModules
+
+extension SDWebImageManager {
+  func loadImage(with url: URL, options: SDWebImageOptions) async throws -> UIImage {
+    return try await withUnsafeThrowingContinuation { continuation in
+      self.loadImage(with: url, options: options) { current, total, url in
+        print("\(url): Loaded \(current)/\(total) bytes")
+      } completed: { image, data, error, cacheType, finished, url in
+        if let image {
+          continuation.resume(returning: image)
+        } else {
+          if let error {
+            continuation.resume(throwing: error)
+          } else {
+            continuation.resume(throwing: RuntimeError.error(withMessage: "No Image or error was returned!"))
+          }
+        }
+      }
+    }
+  }
+}

package/lib/commonjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.WebImages = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+const WebImages = exports.WebImages = _reactNativeNitroModules.NitroModules.createHybridObject("WebImageFactory");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","WebImages","exports","NitroModules","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAGO,MAAMC,SAAS,GAAAC,OAAA,CAAAD,SAAA,GAClBE,qCAAY,CAACC,kBAAkB,CAAkB,iBAAiB,CAAC","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/specs/WebImageFactory.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=WebImageFactory.nitro.js.map

package/lib/commonjs/specs/WebImageFactory.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/WebImageFactory.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { NitroModules } from "react-native-nitro-modules";
+export const WebImages = NitroModules.createHybridObject("WebImageFactory");
+//# sourceMappingURL=index.js.map