@granite-js/image 0.1.34 → 1.0.1

package/android/src/main/java/run/granite/image/GraniteImageModule.kt

@@ -0,0 +1,131 @@
+package run.granite.image
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.module.annotations.ReactModule
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.Executors
+import java.util.concurrent.atomic.AtomicInteger
+
+@ReactModule(name = GraniteImageModule.NAME)
+class GraniteImageModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "GraniteImageModule"
+        private const val TAG = "GraniteImageModule"
+    }
+
+    private val executor = Executors.newFixedThreadPool(4)
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun preload(sourcesJson: String, promise: Promise) {
+        Log.d(TAG, "preload called with: $sourcesJson")
+
+        val provider = GraniteImageRegistry.provider
+        if (provider == null) {
+            Log.w(TAG, "No provider registered, cannot preload")
+            promise.reject("NO_PROVIDER", "No provider registered, cannot preload")
+            return
+        }
+
+        executor.execute {
+            try {
+                val sources = JSONArray(sourcesJson)
+                val totalCount = sources.length()
+                val completedCount = AtomicInteger(0)
+                val successCount = AtomicInteger(0)
+                val failCount = AtomicInteger(0)
+
+                if (totalCount == 0) {
+                    promise.resolve(null)
+                    return@execute
+                }
+
+                for (i in 0 until sources.length()) {
+                    val source = sources.getJSONObject(i)
+                    val uri = source.optString("uri", "")
+                    if (uri.isEmpty()) {
+                        if (completedCount.incrementAndGet() == totalCount) {
+                            Log.d(TAG, "Preload completed: ${successCount.get()} succeeded, ${failCount.get()} failed")
+                            promise.resolve(null)
+                        }
+                        continue
+                    }
+
+                    val headersObj = source.optJSONObject("headers")
+                    val headers = mutableMapOf<String, String>()
+                    headersObj?.let {
+                        val keys = it.keys()
+                        while (keys.hasNext()) {
+                            val key = keys.next()
+                            headers[key] = it.getString(key)
+                        }
+                    }
+
+                    val priorityStr = source.optString("priority", "normal")
+                    val priority = when (priorityStr) {
+                        "high" -> GraniteImagePriority.HIGH
+                        "low" -> GraniteImagePriority.LOW
+                        else -> GraniteImagePriority.NORMAL
+                    }
+
+                    val cacheStr = source.optString("cache", "")
+                    val cachePolicy = when (cacheStr) {
+                        "cacheOnly" -> GraniteImageCachePolicy.DISK
+                        "web" -> GraniteImageCachePolicy.NONE
+                        else -> GraniteImageCachePolicy.DISK
+                    }
+
+                    Log.d(TAG, "Preloading: $uri")
+
+                    // Call provider's preload method (loadImage with null view for preload)
+                    provider.loadImage(
+                        url = uri,
+                        imageView = null,
+                        contentMode = "cover",
+                        headers = headers.ifEmpty { null },
+                        priority = priority,
+                        cachePolicy = cachePolicy,
+                        onProgress = null,
+                        onCompletion = { success, width, height, error ->
+                            if (success) {
+                                Log.d(TAG, "Preloaded successfully: $uri (${width}x${height})")
+                                successCount.incrementAndGet()
+                            } else {
+                                Log.d(TAG, "Preload failed for $uri: $error")
+                                failCount.incrementAndGet()
+                            }
+                            if (completedCount.incrementAndGet() == totalCount) {
+                                Log.d(TAG, "Preload completed: ${successCount.get()} succeeded, ${failCount.get()} failed")
+                                promise.resolve(null)
+                            }
+                        }
+                    )
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to parse sources JSON: ${e.message}")
+                promise.reject("PARSE_ERROR", "Failed to parse sources JSON: ${e.message}")
+            }
+        }
+    }
+
+    @ReactMethod
+    fun clearMemoryCache(promise: Promise) {
+        Log.d(TAG, "clearMemoryCache called")
+        // Memory cache clearing depends on provider implementation
+        promise.resolve(null)
+    }
+
+    @ReactMethod
+    fun clearDiskCache(promise: Promise) {
+        Log.d(TAG, "clearDiskCache called")
+        // Disk cache clearing depends on provider implementation
+        promise.resolve(null)
+    }
+}

package/android/src/main/java/run/granite/image/GraniteImagePackage.kt

@@ -0,0 +1,59 @@
+package run.granite.image
+
+import android.util.Log
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native Package that registers the GraniteImage component and GraniteImageModule.
+ */
+class GraniteImagePackage : ReactPackage {
+    companion object {
+        private const val TAG = "GraniteImagePackage"
+        private var providerRegistered = false
+
+        init {
+            registerDefaultProvider()
+        }
+
+        private fun registerDefaultProvider() {
+            if (providerRegistered) return
+
+            // Try to auto-register a provider based on available implementations
+            val providerClasses = listOf(
+                "run.granite.image.providers.OkHttpImageProvider",
+                "run.granite.image.providers.GlideImageProvider",
+                "run.granite.image.providers.CoilImageProvider"
+            )
+
+            for (className in providerClasses) {
+                try {
+                    val clazz = Class.forName(className)
+                    val provider = clazz.getDeclaredConstructor().newInstance() as GraniteImageProvider
+                    GraniteImageRegistry.registerProvider(provider)
+                    Log.d(TAG, "Auto-registered provider: $className")
+                    providerRegistered = true
+                    break
+                } catch (e: ClassNotFoundException) {
+                    // Provider not available, try next
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to instantiate provider $className: ${e.message}")
+                }
+            }
+
+            if (!providerRegistered) {
+                Log.w(TAG, "No image provider found. Make sure to include one of: okhttp, glide, or coil flavor.")
+            }
+        }
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(GraniteImageModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(GraniteImageManager())
+    }
+}

package/android/src/main/java/run/granite/image/GraniteImageProvider.kt

@@ -0,0 +1,105 @@
+package run.granite.image
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.view.View
+import android.widget.ImageView
+
+/**
+ * Priority levels for image loading
+ */
+enum class GraniteImagePriority {
+    LOW, NORMAL, HIGH
+}
+
+/**
+ * Cache policy for image loading
+ */
+enum class GraniteImageCachePolicy {
+    MEMORY, DISK, NONE
+}
+
+/**
+ * Progress callback
+ */
+typealias GraniteImageProgressCallback = (loaded: Long, total: Long) -> Unit
+
+/**
+ * Completion callback with image dimensions
+ */
+typealias GraniteImageCompletionCallback = (bitmap: Bitmap?, error: Exception?, width: Int, height: Int) -> Unit
+
+/**
+ * Interface that defines the contract for image loading providers.
+ * Implementations can use any image loading library (OkHttp, Glide, Coil, etc.)
+ */
+interface GraniteImageProvider {
+    /**
+     * Creates and returns a new View that will be used to display the image.
+     * The returned view should be capable of displaying images (typically ImageView).
+     */
+    fun createImageView(context: Context): View
+
+    /**
+     * Loads an image from the given URL into the provided view.
+     * @param url The URL string of the image to load
+     * @param view The view returned from createImageView where the image should be displayed
+     * @param scaleType The scale type to use when displaying the image
+     */
+    fun loadImage(url: String, into: View, scaleType: ImageView.ScaleType)
+
+    /**
+     * Cancels any ongoing image load for the given view.
+     * @param view The view whose image load should be cancelled
+     */
+    fun cancelLoad(view: View)
+
+    /**
+     * Loads an image with full options support including headers, priority, cache policy, and callbacks.
+     * Default implementation delegates to simple loadImage.
+     */
+    fun loadImage(
+        url: String,
+        into: View?,
+        scaleType: ImageView.ScaleType,
+        headers: Map<String, String>?,
+        priority: GraniteImagePriority,
+        cachePolicy: GraniteImageCachePolicy,
+        defaultSource: String?,
+        progressCallback: GraniteImageProgressCallback?,
+        completionCallback: GraniteImageCompletionCallback?
+    ) {
+        if (into != null) {
+            // Default implementation - just use simple load
+            loadImage(url, into, scaleType)
+        }
+        // Notify completion with unknown dimensions
+        completionCallback?.invoke(null, null, 0, 0)
+    }
+
+    /**
+     * Preloads an image without displaying it.
+     * Uses the extended loadImage with null view.
+     */
+    fun loadImage(
+        url: String,
+        imageView: Nothing?,
+        contentMode: String,
+        headers: Map<String, String>?,
+        priority: GraniteImagePriority,
+        cachePolicy: GraniteImageCachePolicy,
+        onProgress: GraniteImageProgressCallback?,
+        onCompletion: ((success: Boolean, width: Int, height: Int, error: String?) -> Unit)?
+    ) {
+        // Default implementation does nothing for preload
+        onCompletion?.invoke(false, 0, 0, "Provider does not support preloading")
+    }
+
+    /**
+     * Applies a tint color to the image view.
+     * Default implementation does nothing.
+     */
+    fun applyTintColor(color: Int, view: View) {
+        // Default implementation - do nothing
+    }
+}

package/android/src/main/java/run/granite/image/GraniteImageRegistry.kt

@@ -0,0 +1,29 @@
+package run.granite.image
+
+/**
+ * Singleton registry for managing the current GraniteImageProvider.
+ * Applications should register their provider implementation at app startup.
+ */
+object GraniteImageRegistry {
+    /**
+     * The currently registered image provider.
+     * If null, GraniteImage will display an error state.
+     */
+    var provider: GraniteImageProvider? = null
+        private set
+
+    /**
+     * Registers an image provider to be used by all GraniteImage instances.
+     * @param provider The provider implementation to register
+     */
+    fun registerProvider(provider: GraniteImageProvider) {
+        this.provider = provider
+    }
+
+    /**
+     * Clears the currently registered provider.
+     */
+    fun clearProvider() {
+        this.provider = null
+    }
+}

package/android/src/okhttp/java/run/granite/image/providers/OkHttpImageProvider.kt

@@ -0,0 +1,228 @@
+package run.granite.image.providers
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffColorFilter
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.widget.ImageView
+import run.granite.image.GraniteImageProvider
+import run.granite.image.GraniteImagePriority
+import run.granite.image.GraniteImageCachePolicy
+import run.granite.image.GraniteImageProgressCallback
+import run.granite.image.GraniteImageCompletionCallback
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.CacheControl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import java.io.IOException
+import java.util.WeakHashMap
+import java.util.concurrent.TimeUnit
+
+/**
+ * GraniteImageProvider implementation using OkHttp.
+ * This is analogous to iOS's URLSessionImageProvider.
+ */
+class OkHttpImageProvider : GraniteImageProvider {
+    companion object {
+        private const val TAG = "OkHttpImageProvider"
+    }
+
+    private val client = OkHttpClient.Builder()
+        .connectTimeout(30, TimeUnit.SECONDS)
+        .readTimeout(30, TimeUnit.SECONDS)
+        .build()
+    private val activeCalls = WeakHashMap<View, Call>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    override fun createImageView(context: Context): View {
+        return ImageView(context).apply {
+            setBackgroundColor(android.graphics.Color.LTGRAY)
+        }
+    }
+
+    override fun loadImage(url: String, into: View, scaleType: ImageView.ScaleType) {
+        loadImage(url, into, scaleType, null, GraniteImagePriority.NORMAL, GraniteImageCachePolicy.DISK, null, null, null)
+    }
+
+    override fun loadImage(
+        url: String,
+        into: View?,
+        scaleType: ImageView.ScaleType,
+        headers: Map<String, String>?,
+        priority: GraniteImagePriority,
+        cachePolicy: GraniteImageCachePolicy,
+        defaultSource: String?,
+        progressCallback: GraniteImageProgressCallback?,
+        completionCallback: GraniteImageCompletionCallback?
+    ) {
+        // Allow null view for preloading
+        val imageView: ImageView? = if (into != null) {
+            if (into !is ImageView) {
+                Log.e(TAG, "View is not an ImageView")
+                completionCallback?.invoke(null, Exception("View is not an ImageView"), 0, 0)
+                return
+            }
+            into.scaleType = scaleType
+            // Cancel any existing request for this view
+            cancelLoad(into)
+            into
+        } else {
+            null
+        }
+
+        // Apply default source (placeholder) before loading
+        if (imageView != null && !defaultSource.isNullOrEmpty()) {
+            val resourceId = imageView.context.resources.getIdentifier(defaultSource, "drawable", imageView.context.packageName)
+            if (resourceId != 0) {
+                imageView.setImageResource(resourceId)
+            }
+        }
+
+        val requestBuilder = Request.Builder().url(url)
+
+        // Add headers
+        headers?.forEach { (key, value) ->
+            requestBuilder.addHeader(key, value)
+        }
+
+        // Apply cache policy
+        when (cachePolicy) {
+            GraniteImageCachePolicy.NONE -> {
+                requestBuilder.cacheControl(CacheControl.FORCE_NETWORK)
+            }
+            GraniteImageCachePolicy.MEMORY, GraniteImageCachePolicy.DISK -> {
+                // Use default caching
+            }
+        }
+
+        val request = requestBuilder.build()
+        val call = client.newCall(request)
+        if (into != null) {
+            activeCalls[into] = call
+        }
+
+        call.enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
+                Log.e(TAG, "Error loading image: ${e.message}")
+                if (into != null) {
+                    activeCalls.remove(into)
+                }
+                mainHandler.post {
+                    completionCallback?.invoke(null, e, 0, 0)
+                }
+            }
+
+            override fun onResponse(call: Call, response: Response) {
+                if (into != null) {
+                    activeCalls.remove(into)
+                }
+
+                if (!response.isSuccessful) {
+                    val error = Exception("HTTP error: ${response.code}")
+                    Log.e(TAG, "HTTP error: ${response.code}")
+                    mainHandler.post {
+                        completionCallback?.invoke(null, error, 0, 0)
+                    }
+                    return
+                }
+
+                val body = response.body
+                if (body == null) {
+                    val error = Exception("No data received")
+                    Log.e(TAG, "No data received")
+                    mainHandler.post {
+                        completionCallback?.invoke(null, error, 0, 0)
+                    }
+                    return
+                }
+
+                // Get content length for progress
+                val contentLength = body.contentLength()
+
+                // Read bytes with progress reporting
+                val inputStream = body.byteStream()
+                val bytes = ByteArray(contentLength.toInt().coerceAtLeast(1024))
+                var totalBytesRead = 0L
+                val buffer = ByteArray(8192)
+                var bytesRead: Int
+
+                try {
+                    val outputStream = java.io.ByteArrayOutputStream()
+                    while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                        outputStream.write(buffer, 0, bytesRead)
+                        totalBytesRead += bytesRead
+                        if (contentLength > 0) {
+                            progressCallback?.invoke(totalBytesRead, contentLength)
+                        }
+                    }
+                    val imageBytes = outputStream.toByteArray()
+
+                    val bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+                    if (bitmap == null) {
+                        val error = Exception("Failed to decode image data")
+                        Log.e(TAG, "Failed to decode image data")
+                        mainHandler.post {
+                            completionCallback?.invoke(null, error, 0, 0)
+                        }
+                        return
+                    }
+
+                    mainHandler.post {
+                        imageView?.setImageBitmap(bitmap)
+                        Log.d(TAG, "Loaded with OkHttp: $url")
+                        completionCallback?.invoke(bitmap, null, bitmap.width, bitmap.height)
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error reading image data: ${e.message}")
+                    mainHandler.post {
+                        completionCallback?.invoke(null, e, 0, 0)
+                    }
+                }
+            }
+        })
+    }
+
+    override fun cancelLoad(view: View) {
+        activeCalls[view]?.cancel()
+        activeCalls.remove(view)
+    }
+
+    override fun applyTintColor(color: Int, view: View) {
+        if (view is ImageView) {
+            view.colorFilter = PorterDuffColorFilter(color, PorterDuff.Mode.SRC_IN)
+        }
+    }
+
+    override fun loadImage(
+        url: String,
+        imageView: Nothing?,
+        contentMode: String,
+        headers: Map<String, String>?,
+        priority: GraniteImagePriority,
+        cachePolicy: GraniteImageCachePolicy,
+        onProgress: GraniteImageProgressCallback?,
+        onCompletion: ((success: Boolean, width: Int, height: Int, error: String?) -> Unit)?
+    ) {
+        // Preload implementation - load without displaying
+        loadImage(
+            url = url,
+            into = null,
+            scaleType = ImageView.ScaleType.CENTER_CROP,
+            headers = headers,
+            priority = priority,
+            cachePolicy = cachePolicy,
+            defaultSource = null,
+            progressCallback = onProgress,
+            completionCallback = { bitmap, error, width, height ->
+                onCompletion?.invoke(bitmap != null, width, height, error?.message)
+            }
+        )
+    }
+}

package/dist/module/GraniteImage.js

@@ -0,0 +1,127 @@
+"use strict";
+
+import React, { useCallback } from 'react';
+import { NativeModules } from 'react-native';
+import GraniteImageNativeComponent from './GraniteImageNativeComponent';
+import { jsx as _jsx } from "react/jsx-runtime";
+const {
+  GraniteImageModule
+} = NativeModules;
+
+// Source types matching GraniteImage
+
+// Map resizeMode to contentMode for native
+const resizeModeToContentMode = resizeMode => {
+  return resizeMode || 'cover';
+};
+
+// Map GraniteImage cache to native cachePolicy
+const mapCachePolicy = cache => {
+  switch (cache) {
+    case 'cacheOnly':
+      return 'disk';
+    case 'web':
+      return 'none';
+    case 'immutable':
+    default:
+      return 'disk';
+  }
+};
+
+// Type declarations for static methods
+
+// Static methods for cache management
+const clearMemoryCache = () => {
+  if (GraniteImageModule?.clearMemoryCache) {
+    return GraniteImageModule.clearMemoryCache();
+  }
+  console.warn('GraniteImage.clearMemoryCache: Native module not available');
+  return Promise.resolve();
+};
+const clearDiskCache = () => {
+  if (GraniteImageModule?.clearDiskCache) {
+    return GraniteImageModule.clearDiskCache();
+  }
+  console.warn('GraniteImage.clearDiskCache: Native module not available');
+  return Promise.resolve();
+};
+const preload = sources => {
+  if (GraniteImageModule?.preload) {
+    const sourcesJson = JSON.stringify(sources);
+    return GraniteImageModule.preload(sourcesJson);
+  } else {
+    console.warn('GraniteImage.preload: Native module not available');
+    return Promise.resolve();
+  }
+};
+const GraniteImageBase = ({
+  source,
+  resizeMode = 'cover',
+  tintColor,
+  style,
+  defaultSource,
+  fallbackSource,
+  priority = 'normal',
+  cachePolicy = 'disk',
+  onLoadStart,
+  onProgress,
+  onLoad,
+  onError,
+  onLoadEnd,
+  ...viewProps
+}) => {
+  // Parse source
+  const uri = typeof source === 'string' ? source : (source && typeof source === 'object' ? source.uri : '') ?? '';
+  const headers = typeof source === 'object' && source.headers ? JSON.stringify(source.headers) : undefined;
+  const sourcePriority = typeof source === 'object' ? source.priority : undefined;
+  const sourceCache = typeof source === 'object' ? source.cache : undefined;
+
+  // Handle defaultSource
+  const defaultSourceUri = typeof defaultSource === 'string' ? defaultSource : typeof defaultSource === 'number' ? undefined // Local require() - need native handling
+  : undefined;
+
+  // Handle fallbackSource
+  const fallbackSourceUri = typeof fallbackSource === 'string' ? fallbackSource : typeof fallbackSource === 'number' ? undefined // Local require() - need native handling
+  : undefined;
+
+  // Event handlers
+  const handleLoadStart = useCallback(event => {
+    onLoadStart?.(event);
+  }, [onLoadStart]);
+  const handleProgress = useCallback(event => {
+    onProgress?.(event);
+  }, [onProgress]);
+  const handleLoad = useCallback(event => {
+    onLoad?.(event);
+  }, [onLoad]);
+  const handleError = useCallback(event => {
+    onError?.(event);
+  }, [onError]);
+  const handleLoadEnd = useCallback(event => {
+    onLoadEnd?.(event);
+  }, [onLoadEnd]);
+  return /*#__PURE__*/_jsx(GraniteImageNativeComponent, {
+    ...viewProps,
+    uri: uri,
+    headers: headers,
+    contentMode: resizeModeToContentMode(resizeMode),
+    tintColor: tintColor,
+    defaultSource: defaultSourceUri,
+    fallbackSource: fallbackSourceUri,
+    priority: sourcePriority || priority,
+    cachePolicy: sourceCache ? mapCachePolicy(sourceCache) : cachePolicy,
+    style: style,
+    onGraniteLoadStart: onLoadStart ? handleLoadStart : undefined,
+    onGraniteProgress: onProgress ? handleProgress : undefined,
+    onGraniteLoad: onLoad ? handleLoad : undefined,
+    onGraniteError: onError ? handleError : undefined,
+    onGraniteLoadEnd: onLoadEnd ? handleLoadEnd : undefined
+  });
+};
+export const GraniteImage = Object.assign(GraniteImageBase, {
+  clearMemoryCache,
+  clearDiskCache,
+  preload
+});
+export default GraniteImage;
+//# sourceMappingURL=GraniteImage.js.map

package/dist/module/GraniteImage.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["React","useCallback","NativeModules","GraniteImageNativeComponent","jsx","_jsx","GraniteImageModule","resizeModeToContentMode","resizeMode","mapCachePolicy","cache","clearMemoryCache","console","warn","Promise","resolve","clearDiskCache","preload","sources","sourcesJson","JSON","stringify","GraniteImageBase","source","tintColor","style","defaultSource","fallbackSource","priority","cachePolicy","onLoadStart","onProgress","onLoad","onError","onLoadEnd","viewProps","uri","headers","undefined","sourcePriority","sourceCache","defaultSourceUri","fallbackSourceUri","handleLoadStart","event","handleProgress","handleLoad","handleError","handleLoadEnd","contentMode","onGraniteLoadStart","onGraniteProgress","onGraniteLoad","onGraniteError","onGraniteLoadEnd","GraniteImage","Object","assign"],"sourceRoot":"../../src","sources":["GraniteImage.tsx"],"mappings":"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","ignoreList":[]}