@granite-js/image 1.0.12 → 1.0.13

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @granite-js/image
 
+## 1.0.13
+
+### Patch Changes
+
+- e26b4ea: refactor(android): improve GraniteImage code quality - fix bugs, reduce complexity, introduce DI
+- eddab4b: feat(android): implement clearMemoryCache/clearDiskCache for GraniteImage Android
+
 ## 1.0.12
 
 ## 1.0.11

package/android/src/coil/java/run/granite/image/providers/CoilImageProvider.kt

@@ -4,6 +4,8 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffColorFilter
+import android.graphics.drawable.BitmapDrawable
+import android.net.Uri
 import android.util.Log
 import android.view.View
 import android.widget.ImageView
@@ -12,34 +14,26 @@ import run.granite.image.GraniteImagePriority
 import run.granite.image.GraniteImageCachePolicy
 import run.granite.image.GraniteImageProgressCallback
 import run.granite.image.GraniteImageCompletionCallback
+import coil.Coil
 import coil.load
 import coil.request.CachePolicy
 import coil.request.ErrorResult
+import coil.request.ImageRequest
 import coil.request.SuccessResult
 
 /**
  * GraniteImageProvider implementation using Coil.
  */
 class CoilImageProvider : GraniteImageProvider {
-    companion object {
-        private const val TAG = "CoilImageProvider"
-    }
-
-    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)
     }
 
     private fun isValidImageUrl(url: String): Boolean {
         return try {
-            val uri = android.net.Uri.parse(url)
+            val uri = Uri.parse(url)
             val scheme = uri.scheme?.lowercase()
-            scheme == "http" || scheme == "https"
+            scheme == "http" || scheme == "https" || scheme == "file" || scheme == "content"
         } catch (e: Exception) {
             false
         }
@@ -56,22 +50,7 @@ class CoilImageProvider : GraniteImageProvider {
         progressCallback: GraniteImageProgressCallback?,
         completionCallback: GraniteImageCompletionCallback?
     ) {
-        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
-            into
-        } else {
-            null
-        }
-
-        if (imageView == null) {
-            completionCallback?.invoke(null, Exception("No view provided"), 0, 0)
-            return
-        }
+        val imageView = validateImageView(into, scaleType, completionCallback) ?: return
 
         if (!isValidImageUrl(url)) {
             Log.e(TAG, "Invalid URL: $url")
@@ -80,54 +59,74 @@ class CoilImageProvider : GraniteImageProvider {
         }
 
         imageView.load(url) {
-            // Add headers if provided
-            headers?.forEach { (key, value) ->
-                addHeader(key, value)
-            }
+            headers?.forEach { (key, value) -> addHeader(key, value) }
+            applyCachePolicy(cachePolicy)
+            applyPlaceholder(imageView.context, defaultSource)
+            listener(
+                onStart = { Log.d(TAG, "Loading started: $url") },
+                onSuccess = { _, result -> handleSuccess(result, url, completionCallback) },
+                onError = { _, result -> handleError(result, completionCallback) }
+            )
+        }
+    }
 
-            // Apply cache policy
-            when (cachePolicy) {
-                GraniteImageCachePolicy.NONE -> {
-                    memoryCachePolicy(CachePolicy.DISABLED)
-                    diskCachePolicy(CachePolicy.DISABLED)
-                }
-                GraniteImageCachePolicy.MEMORY -> {
-                    memoryCachePolicy(CachePolicy.ENABLED)
-                    diskCachePolicy(CachePolicy.DISABLED)
-                }
-                GraniteImageCachePolicy.DISK -> {
-                    memoryCachePolicy(CachePolicy.ENABLED)
-                    diskCachePolicy(CachePolicy.ENABLED)
-                }
-            }
+    private fun validateImageView(
+        into: View?,
+        scaleType: ImageView.ScaleType,
+        completionCallback: GraniteImageCompletionCallback?
+    ): ImageView? {
+        if (into == null) {
+            completionCallback?.invoke(null, Exception("No view provided"), 0, 0)
+            return 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 null
+        }
+        into.scaleType = scaleType
+        return into
+    }
 
-            // Apply default source (placeholder)
-            if (!defaultSource.isNullOrEmpty()) {
-                val resourceId = imageView.context.resources.getIdentifier(defaultSource, "drawable", imageView.context.packageName)
-                if (resourceId != 0) {
-                    placeholder(resourceId)
-                }
+    private fun ImageRequest.Builder.applyCachePolicy(cachePolicy: GraniteImageCachePolicy) {
+        when (cachePolicy) {
+            GraniteImageCachePolicy.NONE -> {
+                memoryCachePolicy(CachePolicy.DISABLED)
+                diskCachePolicy(CachePolicy.DISABLED)
+            }
+            GraniteImageCachePolicy.MEMORY -> {
+                memoryCachePolicy(CachePolicy.ENABLED)
+                diskCachePolicy(CachePolicy.DISABLED)
             }
+            GraniteImageCachePolicy.DISK -> {
+                memoryCachePolicy(CachePolicy.ENABLED)
+                diskCachePolicy(CachePolicy.ENABLED)
+            }
+        }
+    }
 
-            listener(
-                onStart = {
-                    Log.d(TAG, "Loading started: $url")
-                },
-                onSuccess = { _, result ->
-                    val bitmap = (result.drawable as? android.graphics.drawable.BitmapDrawable)?.bitmap
-                    val width = bitmap?.width ?: 0
-                    val height = bitmap?.height ?: 0
-                    Log.d(TAG, "Loaded with Coil: $url")
-                    completionCallback?.invoke(bitmap, null, width, height)
-                },
-                onError = { _, result ->
-                    Log.e(TAG, "Error loading image: ${result.throwable.message}")
-                    completionCallback?.invoke(null, result.throwable as? Exception, 0, 0)
-                }
-            )
+    private fun ImageRequest.Builder.applyPlaceholder(context: Context, defaultSource: String?) {
+        if (!defaultSource.isNullOrEmpty()) {
+            val resourceId = context.resources.getIdentifier(defaultSource, "drawable", context.packageName)
+            if (resourceId != 0) placeholder(resourceId)
         }
     }
 
+    private fun handleSuccess(
+        result: SuccessResult,
+        url: String,
+        completionCallback: GraniteImageCompletionCallback?
+    ) {
+        val bitmap = (result.drawable as? BitmapDrawable)?.bitmap
+        Log.d(TAG, "Loaded with Coil: $url")
+        completionCallback?.invoke(bitmap, null, bitmap?.width ?: 0, bitmap?.height ?: 0)
+    }
+
+    private fun handleError(result: ErrorResult, completionCallback: GraniteImageCompletionCallback?) {
+        Log.e(TAG, "Error loading image: ${result.throwable.message}")
+        completionCallback?.invoke(null, result.throwable as? Exception, 0, 0)
+    }
+
     override fun cancelLoad(view: View) {
         if (view is ImageView) {
             view.load(null as String?)
@@ -153,4 +152,18 @@ class CoilImageProvider : GraniteImageProvider {
         // Coil preload is not directly supported without a context
         onCompletion?.invoke(false, 0, 0, "Preload not supported without context")
     }
+
+    override fun clearMemoryCache(context: Context) {
+        Coil.imageLoader(context).memoryCache?.clear()
+        Log.d(TAG, "Memory cache cleared (Coil 2.x)")
+    }
+
+    override fun clearDiskCache(context: Context) {
+        // Coil 2.x: no public API for diskCache — no-op
+        Log.d(TAG, "Disk cache clear not supported (Coil 2.x)")
+    }
+
+    companion object {
+        private const val TAG = "CoilImageProvider"
+    }
 }

package/android/src/glide/java/run/granite/image/providers/GlideImageProvider.kt

@@ -4,15 +4,11 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffColorFilter
-import android.graphics.drawable.Drawable
+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 com.bumptech.glide.Glide
 import com.bumptech.glide.load.DataSource
 import com.bumptech.glide.load.engine.DiskCacheStrategy
@@ -22,21 +18,17 @@ import com.bumptech.glide.load.model.LazyHeaders
 import com.bumptech.glide.request.RequestListener
 import com.bumptech.glide.request.target.Target
 import com.bumptech.glide.Priority as GlidePriority
+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 java.util.concurrent.Executors
 
 /**
  * GraniteImageProvider implementation using Glide.
  */
 class GlideImageProvider : GraniteImageProvider {
-    companion object {
-        private const val TAG = "GlideImageProvider"
-    }
-
-    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)
     }
@@ -52,91 +44,94 @@ class GlideImageProvider : GraniteImageProvider {
         progressCallback: GraniteImageProgressCallback?,
         completionCallback: GraniteImageCompletionCallback?
     ) {
-        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
-            into
-        } else {
-            null
+        val imageView = validateImageView(into, scaleType, completionCallback) ?: return
+        val context = imageView.context ?: run {
+            completionCallback?.invoke(null, Exception("Glide requires a view context for image loading"), 0, 0)
+            return
         }
 
-        // Build GlideUrl with headers if provided
-        val glideUrl = if (headers != null && headers.isNotEmpty()) {
-            val headersBuilder = LazyHeaders.Builder()
-            headers.forEach { (key, value) ->
-                headersBuilder.addHeader(key, value)
-            }
-            GlideUrl(url, headersBuilder.build())
-        } else {
-            GlideUrl(url)
-        }
+        val glideUrl = buildGlideUrl(url, headers)
+        val requestBuilder = configureRequest(context, glideUrl, priority, cachePolicy, defaultSource)
+            .listener(createRequestListener(url, completionCallback))
 
-        val context = imageView?.context ?: return
+        requestBuilder.into(imageView)
+    }
 
-        // Build request
-        var requestBuilder = Glide.with(context)
-            .asBitmap()
-            .load(glideUrl)
+    private fun validateImageView(
+        into: View?,
+        scaleType: ImageView.ScaleType,
+        completionCallback: GraniteImageCompletionCallback?
+    ): ImageView? {
+        if (into == null) return 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 null
+        }
+        into.scaleType = scaleType
+        return into
+    }
 
-        // Apply priority
-        requestBuilder = when (priority) {
-            GraniteImagePriority.LOW -> requestBuilder.priority(GlidePriority.LOW)
-            GraniteImagePriority.NORMAL -> requestBuilder.priority(GlidePriority.NORMAL)
-            GraniteImagePriority.HIGH -> requestBuilder.priority(GlidePriority.HIGH)
+    private fun buildGlideUrl(url: String, headers: Map<String, String>?): GlideUrl {
+        if (headers.isNullOrEmpty()) return GlideUrl(url)
+        val headersBuilder = LazyHeaders.Builder()
+        headers.forEach { (key, value) -> headersBuilder.addHeader(key, value) }
+        return GlideUrl(url, headersBuilder.build())
+    }
+
+    private fun configureRequest(
+        context: Context,
+        glideUrl: GlideUrl,
+        priority: GraniteImagePriority,
+        cachePolicy: GraniteImageCachePolicy,
+        defaultSource: String?
+    ): com.bumptech.glide.RequestBuilder<Bitmap> {
+        var builder = Glide.with(context).asBitmap().load(glideUrl)
+
+        builder = when (priority) {
+            GraniteImagePriority.LOW -> builder.priority(GlidePriority.LOW)
+            GraniteImagePriority.NORMAL -> builder.priority(GlidePriority.NORMAL)
+            GraniteImagePriority.HIGH -> builder.priority(GlidePriority.HIGH)
         }
 
-        // Apply cache policy
-        requestBuilder = when (cachePolicy) {
-            GraniteImageCachePolicy.NONE -> requestBuilder.diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true)
-            GraniteImageCachePolicy.MEMORY -> requestBuilder.diskCacheStrategy(DiskCacheStrategy.NONE)
-            GraniteImageCachePolicy.DISK -> requestBuilder.diskCacheStrategy(DiskCacheStrategy.ALL)
+        builder = when (cachePolicy) {
+            GraniteImageCachePolicy.NONE -> builder.diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true)
+            GraniteImageCachePolicy.MEMORY -> builder.diskCacheStrategy(DiskCacheStrategy.NONE)
+            GraniteImageCachePolicy.DISK -> builder.diskCacheStrategy(DiskCacheStrategy.ALL)
         }
 
-        // Apply default source (placeholder)
         if (!defaultSource.isNullOrEmpty()) {
-            // Try to load as drawable resource first, then as URL
             val resourceId = context.resources.getIdentifier(defaultSource, "drawable", context.packageName)
-            if (resourceId != 0) {
-                requestBuilder = requestBuilder.placeholder(resourceId)
-            }
+            if (resourceId != 0) builder = builder.placeholder(resourceId)
         }
 
-        // Add listener for completion callback
-        requestBuilder = requestBuilder.listener(object : RequestListener<Bitmap> {
-            override fun onLoadFailed(
-                e: GlideException?,
-                model: Any?,
-                target: Target<Bitmap>,
-                isFirstResource: Boolean
-            ): Boolean {
-                Log.e(TAG, "Error loading image: ${e?.message}")
-                completionCallback?.invoke(null, e, 0, 0)
-                return false
-            }
+        return builder
+    }
 
-            override fun onResourceReady(
-                resource: Bitmap,
-                model: Any,
-                target: Target<Bitmap>?,
-                dataSource: DataSource,
-                isFirstResource: Boolean
-            ): Boolean {
-                val cacheTypeStr = when (dataSource) {
-                    DataSource.MEMORY_CACHE -> "Memory"
-                    DataSource.DATA_DISK_CACHE, DataSource.RESOURCE_DISK_CACHE -> "Disk"
-                    else -> "Network"
-                }
-                Log.d(TAG, "Loaded with Glide ($cacheTypeStr): $url")
-                completionCallback?.invoke(resource, null, resource.width, resource.height)
-                return false
-            }
-        })
+    private fun createRequestListener(
+        url: String,
+        completionCallback: GraniteImageCompletionCallback?
+    ): RequestListener<Bitmap> = object : RequestListener<Bitmap> {
+        override fun onLoadFailed(
+            e: GlideException?, model: Any?, target: Target<Bitmap>, isFirstResource: Boolean
+        ): Boolean {
+            Log.e(TAG, "Error loading image: ${e?.message}")
+            completionCallback?.invoke(null, e, 0, 0)
+            return false
+        }
 
-        requestBuilder.into(imageView)
+        override fun onResourceReady(
+            resource: Bitmap, model: Any, target: Target<Bitmap>?, dataSource: DataSource, isFirstResource: Boolean
+        ): Boolean {
+            val cacheType = when (dataSource) {
+                DataSource.MEMORY_CACHE -> "Memory"
+                DataSource.DATA_DISK_CACHE, DataSource.RESOURCE_DISK_CACHE -> "Disk"
+                else -> "Network"
+            }
+            Log.d(TAG, "Loaded with Glide ($cacheType): $url")
+            completionCallback?.invoke(resource, null, resource.width, resource.height)
+            return false
+        }
     }
 
     override fun cancelLoad(view: View) {
@@ -165,4 +160,32 @@ class GlideImageProvider : GraniteImageProvider {
         // This would need an Application context passed during initialization
         onCompletion?.invoke(false, 0, 0, "Preload not supported without context")
     }
+
+    override fun clearMemoryCache(context: Context) {
+        // Glide: clearMemory() must be called on the main thread
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            Glide.get(context).clearMemory()
+        } else {
+            Handler(Looper.getMainLooper()).post {
+                Glide.get(context).clearMemory()
+            }
+        }
+        Log.d(TAG, "Memory cache cleared (Glide)")
+    }
+
+    override fun clearDiskCache(context: Context) {
+        // Glide: clearDiskCache() must be called on a background thread
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            Glide.get(context).clearDiskCache()
+        } else {
+            Executors.newSingleThreadExecutor().execute {
+                Glide.get(context).clearDiskCache()
+            }
+        }
+        Log.d(TAG, "Disk cache cleared (Glide)")
+    }
+
+    companion object {
+        private const val TAG = "GlideImageProvider"
+    }
 }

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

@@ -1,6 +1,7 @@
 package run.granite.image
 
 import android.content.Context
+import android.graphics.Bitmap
 import android.graphics.Color
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffColorFilter
@@ -10,11 +11,9 @@ import android.view.View
 import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.TextView
-import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.uimanager.events.Event
 import org.json.JSONObject
 
 /**
@@ -22,9 +21,7 @@ import org.json.JSONObject
  * It delegates actual image loading to the registered GraniteImageProvider.
  */
 class GraniteImage(context: Context) : FrameLayout(context) {
-    companion object {
-        private const val TAG = "GraniteImage"
-    }
+    internal var providerResolver: () -> GraniteImageProvider? = { GraniteImageRegistry.provider }
 
     private var containerView: View? = null
     private var currentUri: String? = null
@@ -42,46 +39,25 @@ class GraniteImage(context: Context) : FrameLayout(context) {
         Log.d(TAG, "GraniteImage initialized")
     }
 
-    // Event dispatching methods using modern EventDispatcher
-    private fun getEventDispatcher(): EventDispatcher? {
-        val reactContext = context as? ReactContext ?: return null
-        return UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    private fun dispatchEvent(event: Event<*>) {
+        val reactContext = context as? ReactContext ?: return
+        UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)?.dispatchEvent(event)
     }
 
-    private fun emitLoadStart() {
-        Log.d(TAG, "emitLoadStart")
-        getEventDispatcher()?.dispatchEvent(
-            GraniteImageLoadStartEvent(UIManagerHelper.getSurfaceId(this), id)
-        )
-    }
+    private fun emitLoadStart() =
+        dispatchEvent(GraniteImageLoadStartEvent(UIManagerHelper.getSurfaceId(this), id))
 
-    private fun emitProgress(loaded: Int, total: Int) {
-        Log.d(TAG, "emitProgress: $loaded / $total")
-        getEventDispatcher()?.dispatchEvent(
-            GraniteImageProgressEvent(UIManagerHelper.getSurfaceId(this), id, loaded, total)
-        )
-    }
+    private fun emitProgress(loaded: Int, total: Int) =
+        dispatchEvent(GraniteImageProgressEvent(UIManagerHelper.getSurfaceId(this), id, loaded, total))
 
-    private fun emitLoad(width: Int, height: Int) {
-        Log.d(TAG, "emitLoad: ${width}x${height}")
-        getEventDispatcher()?.dispatchEvent(
-            GraniteImageLoadEvent(UIManagerHelper.getSurfaceId(this), id, width, height)
-        )
-    }
+    private fun emitLoad(width: Int, height: Int) =
+        dispatchEvent(GraniteImageLoadEvent(UIManagerHelper.getSurfaceId(this), id, width, height))
 
-    private fun emitError(error: String) {
-        Log.d(TAG, "emitError: $error")
-        getEventDispatcher()?.dispatchEvent(
-            GraniteImageErrorEvent(UIManagerHelper.getSurfaceId(this), id, error)
-        )
-    }
+    private fun emitError(error: String) =
+        dispatchEvent(GraniteImageErrorEvent(UIManagerHelper.getSurfaceId(this), id, error))
 
-    private fun emitLoadEnd() {
-        Log.d(TAG, "emitLoadEnd")
-        getEventDispatcher()?.dispatchEvent(
-            GraniteImageLoadEndEvent(UIManagerHelper.getSurfaceId(this), id)
-        )
-    }
+    private fun emitLoadEnd() =
+        dispatchEvent(GraniteImageLoadEndEvent(UIManagerHelper.getSurfaceId(this), id))
 
     fun setUri(uri: String?) {
         if (uri != currentUri) {
@@ -123,14 +99,11 @@ class GraniteImage(context: Context) : FrameLayout(context) {
     }
 
     fun setPriority(priority: String?) {
-        currentPriority = when (priority) {
-            "low" -> GraniteImagePriority.LOW
-            "high" -> GraniteImagePriority.HIGH
-            else -> GraniteImagePriority.NORMAL
-        }
+        currentPriority = GraniteImagePriority.fromString(priority)
     }
 
     fun setCachePolicy(cachePolicy: String?) {
+        // View-side API uses canonical names: "memory", "none", "disk" (default)
         currentCachePolicy = when (cachePolicy) {
             "memory" -> GraniteImageCachePolicy.MEMORY
             "none" -> GraniteImageCachePolicy.NONE
@@ -163,7 +136,7 @@ class GraniteImage(context: Context) : FrameLayout(context) {
             containerView = null
         }
 
-        val provider = GraniteImageRegistry.provider
+        val provider = providerResolver()
 
         if (provider == null) {
             showErrorView("No GraniteImageProvider registered")
@@ -206,37 +179,48 @@ class GraniteImage(context: Context) : FrameLayout(context) {
             },
             completionCallback = { bitmap, error, width, height ->
                 post {
-                    if (error != null) {
-                        emitError(error.message ?: "Unknown error")
-
-                        // Load fallback image if available
-                        currentFallbackSource?.let { fallback ->
-                            provider.loadImage(
-                                url = fallback,
-                                into = imageView,
-                                scaleType = currentScaleType,
-                                headers = null,
-                                priority = GraniteImagePriority.HIGH,
-                                cachePolicy = GraniteImageCachePolicy.DISK,
-                                defaultSource = null,
-                                progressCallback = null,
-                                completionCallback = null
-                            )
-                        }
-                    } else {
-                        emitLoad(width, height)
-
-                        // Apply tint color if set
-                        currentTintColor?.let { color ->
-                            provider.applyTintColor(color, imageView)
-                        }
-                    }
-                    emitLoadEnd()
+                    handleLoadCompletion(bitmap, error, width, height, imageView, provider)
                 }
             }
         )
     }
 
+    private fun handleLoadCompletion(
+        bitmap: Bitmap?,
+        error: Exception?,
+        width: Int,
+        height: Int,
+        imageView: View,
+        provider: GraniteImageProvider
+    ) {
+        if (error != null) {
+            emitError(error.message ?: "Unknown error")
+
+            // Load fallback image if available
+            currentFallbackSource?.let { fallback ->
+                provider.loadImage(
+                    url = fallback,
+                    into = imageView,
+                    scaleType = currentScaleType,
+                    headers = null,
+                    priority = GraniteImagePriority.HIGH,
+                    cachePolicy = GraniteImageCachePolicy.DISK,
+                    defaultSource = null,
+                    progressCallback = null,
+                    completionCallback = null
+                )
+            }
+        } else {
+            emitLoad(width, height)
+
+            // Apply tint color if set
+            currentTintColor?.let { color ->
+                provider.applyTintColor(color, imageView)
+            }
+        }
+        emitLoadEnd()
+    }
+
     private fun showErrorView(message: String) {
         Log.e(TAG, message)
 
@@ -266,7 +250,7 @@ class GraniteImage(context: Context) : FrameLayout(context) {
     }
 
     fun cleanup() {
-        val provider = GraniteImageRegistry.provider
+        val provider = providerResolver()
         containerView?.let {
             provider?.cancelLoad(it)
             removeView(it)
@@ -274,4 +258,8 @@ class GraniteImage(context: Context) : FrameLayout(context) {
         containerView = null
         currentUri = null
     }
+
+    companion object {
+        private const val TAG = "GraniteImage"
+    }
 }

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

@@ -1,14 +1,12 @@
 package run.granite.image
 
 import android.util.Log
-import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.ViewManagerDelegate
 import com.facebook.react.uimanager.annotations.ReactProp
-import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.viewmanagers.GraniteImageManagerDelegate
 import com.facebook.react.viewmanagers.GraniteImageManagerInterface
 
@@ -18,11 +16,6 @@ import com.facebook.react.viewmanagers.GraniteImageManagerInterface
  */
 @ReactModule(name = GraniteImageManager.NAME)
 class GraniteImageManager : SimpleViewManager<GraniteImage>(), GraniteImageManagerInterface<GraniteImage> {
-    companion object {
-        const val NAME = "GraniteImage"
-        private const val TAG = "GraniteImageManager"
-    }
-
     private val delegate: ViewManagerDelegate<GraniteImage> = GraniteImageManagerDelegate(this)
 
     override fun getName(): String = NAME
@@ -97,4 +90,9 @@ class GraniteImageManager : SimpleViewManager<GraniteImage>(), GraniteImageManag
             .put("onGraniteLoadEnd", MapBuilder.of("registrationName", "onGraniteLoadEnd"))
             .build()
     }
+
+    companion object {
+        const val NAME = "GraniteImage"
+        private const val TAG = "GraniteImageManager"
+    }
 }

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

@@ -8,18 +8,23 @@ 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.ExecutorService
 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)
+class GraniteImageModule(
+    reactContext: ReactApplicationContext,
+    private val providerResolver: () -> GraniteImageProvider? = { GraniteImageRegistry.provider },
+    private val executor: ExecutorService = Executors.newFixedThreadPool(4)
+) : ReactContextBaseJavaModule(reactContext) {
+
+    private data class PreloadSource(
+        val uri: String,
+        val headers: Map<String, String>?,
+        val priority: GraniteImagePriority,
+        val cachePolicy: GraniteImageCachePolicy
+    )
 
     override fun getName(): String = NAME
 
@@ -27,7 +32,7 @@ class GraniteImageModule(reactContext: ReactApplicationContext) : ReactContextBa
     fun preload(sourcesJson: String, promise: Promise) {
         Log.d(TAG, "preload called with: $sourcesJson")
 
-        val provider = GraniteImageRegistry.provider
+        val provider = providerResolver()
         if (provider == null) {
             Log.w(TAG, "No provider registered, cannot preload")
             promise.reject("NO_PROVIDER", "No provider registered, cannot preload")
@@ -38,75 +43,19 @@ class GraniteImageModule(reactContext: ReactApplicationContext) : ReactContextBa
             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)
-                            }
-                        }
-                    )
+                val completedCount = AtomicInteger(0)
+                val successCount = AtomicInteger(0)
+                val failCount = AtomicInteger(0)
+
+                for (i in 0 until totalCount) {
+                    val preloadSource = parsePreloadSource(sources.getJSONObject(i))
+                    preloadSingle(provider, preloadSource, completedCount, successCount, failCount, totalCount, promise)
                 }
             } catch (e: Exception) {
                 Log.e(TAG, "Failed to parse sources JSON: ${e.message}")
@@ -115,17 +64,112 @@ class GraniteImageModule(reactContext: ReactApplicationContext) : ReactContextBa
         }
     }
 
+    private fun preloadSingle(
+        provider: GraniteImageProvider,
+        source: PreloadSource,
+        completedCount: AtomicInteger,
+        successCount: AtomicInteger,
+        failCount: AtomicInteger,
+        totalCount: Int,
+        promise: Promise
+    ) {
+        if (source.uri.isEmpty()) {
+            checkPreloadCompletion(completedCount, successCount, failCount, totalCount, promise)
+            return
+        }
+
+        Log.d(TAG, "Preloading: ${source.uri}")
+        provider.loadImage(
+            url = source.uri,
+            imageView = null,
+            contentMode = "cover",
+            headers = source.headers,
+            priority = source.priority,
+            cachePolicy = source.cachePolicy,
+            onProgress = null,
+            onCompletion = { success, width, height, error ->
+                if (success) {
+                    Log.d(TAG, "Preloaded successfully: ${source.uri} (${width}x${height})")
+                    successCount.incrementAndGet()
+                } else {
+                    Log.d(TAG, "Preload failed for ${source.uri}: $error")
+                    failCount.incrementAndGet()
+                }
+                checkPreloadCompletion(completedCount, successCount, failCount, totalCount, promise)
+            }
+        )
+    }
+
+    private fun checkPreloadCompletion(
+        completedCount: AtomicInteger,
+        successCount: AtomicInteger,
+        failCount: AtomicInteger,
+        totalCount: Int,
+        promise: Promise
+    ) {
+        if (completedCount.incrementAndGet() == totalCount) {
+            Log.d(TAG, "Preload completed: ${successCount.get()} succeeded, ${failCount.get()} failed")
+            promise.resolve(null)
+        }
+    }
+
+    private fun parsePreloadSource(source: JSONObject): PreloadSource {
+        val uri = source.optString("uri", "")
+
+        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 = GraniteImagePriority.fromString(priorityStr)
+
+        // Module-side API uses FastImage-compatible names: "cacheOnly", "web"
+        // (intentionally different from View-side API which uses "memory", "none")
+        val cacheStr = source.optString("cache", "")
+        val cachePolicy = when (cacheStr) {
+            "cacheOnly" -> GraniteImageCachePolicy.DISK
+            "web" -> GraniteImageCachePolicy.NONE
+            else -> GraniteImageCachePolicy.DISK
+        }
+
+        return PreloadSource(
+            uri = uri,
+            headers = headers.ifEmpty { null },
+            priority = priority,
+            cachePolicy = cachePolicy
+        )
+    }
+
     @ReactMethod
     fun clearMemoryCache(promise: Promise) {
         Log.d(TAG, "clearMemoryCache called")
-        // Memory cache clearing depends on provider implementation
+        val provider = providerResolver()
+        val context = reactApplicationContext
+        if (provider != null) {
+            provider.clearMemoryCache(context)
+        }
         promise.resolve(null)
     }
 
     @ReactMethod
     fun clearDiskCache(promise: Promise) {
         Log.d(TAG, "clearDiskCache called")
-        // Disk cache clearing depends on provider implementation
+        val provider = providerResolver()
+        val context = reactApplicationContext
+        if (provider != null) {
+            provider.clearDiskCache(context)
+        }
         promise.resolve(null)
     }
+
+    companion object {
+        const val NAME = "GraniteImageModule"
+        private const val TAG = "GraniteImageModule"
+    }
 }

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

@@ -10,15 +10,21 @@ import com.facebook.react.uimanager.ViewManager
  * React Native Package that registers the GraniteImage component and GraniteImageModule.
  */
 class GraniteImagePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        ensureProviderRegistered()
+        return listOf(GraniteImageModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        ensureProviderRegistered()
+        return listOf(GraniteImageManager())
+    }
+
     companion object {
         private const val TAG = "GraniteImagePackage"
         private var providerRegistered = false
 
-        init {
-            registerDefaultProvider()
-        }
-
-        private fun registerDefaultProvider() {
+        internal fun ensureProviderRegistered() {
             if (providerRegistered) return
 
             // Try to auto-register a provider based on available implementations
@@ -48,12 +54,4 @@ class GraniteImagePackage : ReactPackage {
             }
         }
     }
-
-    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

@@ -2,6 +2,7 @@ package run.granite.image
 
 import android.content.Context
 import android.graphics.Bitmap
+import android.graphics.Color
 import android.view.View
 import android.widget.ImageView
 
@@ -9,9 +10,18 @@ import android.widget.ImageView
  * Priority levels for image loading
  */
 enum class GraniteImagePriority {
-    LOW, NORMAL, HIGH
+    LOW, NORMAL, HIGH;
+
+    companion object {
+        fun fromString(value: String?): GraniteImagePriority = when (value) {
+            "low" -> LOW
+            "high" -> HIGH
+            else -> NORMAL
+        }
+    }
 }
 
+
 /**
  * Cache policy for image loading
  */
@@ -37,8 +47,13 @@ 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).
+     * Default implementation creates an ImageView with a light gray background.
      */
-    fun createImageView(context: Context): View
+    fun createImageView(context: Context): View {
+        return ImageView(context).apply {
+            setBackgroundColor(Color.LTGRAY)
+        }
+    }
 
     /**
      * Loads an image from the given URL into the provided view.
@@ -102,4 +117,20 @@ interface GraniteImageProvider {
     fun applyTintColor(color: Int, view: View) {
         // Default implementation - do nothing
     }
+
+    /**
+     * Clears the memory cache.
+     * Default implementation is no-op. Override in provider implementations to clear actual cache.
+     */
+    fun clearMemoryCache(context: Context) {
+        // default: no-op
+    }
+
+    /**
+     * Clears the disk cache.
+     * Default implementation is no-op. Override in provider implementations to clear actual cache.
+     */
+    fun clearDiskCache(context: Context) {
+        // default: no-op
+    }
 }

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

@@ -1,6 +1,5 @@
 package run.granite.image.providers
 
-import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.PorterDuff
@@ -21,8 +20,9 @@ import okhttp3.CacheControl
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import okhttp3.Response
+import java.io.ByteArrayOutputStream
 import java.io.IOException
-import java.util.WeakHashMap
+import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.TimeUnit
 
 /**
@@ -30,23 +30,13 @@ import java.util.concurrent.TimeUnit
  * 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 activeCalls = ConcurrentHashMap<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)
     }
@@ -85,24 +75,7 @@ class OkHttpImageProvider : GraniteImageProvider {
             }
         }
 
-        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 request = buildRequest(url, headers, cachePolicy)
         val call = client.newCall(request)
         if (into != null) {
             activeCalls[into] = call
@@ -120,73 +93,102 @@ class OkHttpImageProvider : GraniteImageProvider {
             }
 
             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)
+                response.use {
+                    if (into != null) {
+                        activeCalls.remove(into)
                     }
-                    return
+                    handleResponse(response, imageView, url, progressCallback, completionCallback)
                 }
+            }
+        })
+    }
 
-                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
-                }
+    private fun buildRequest(
+        url: String,
+        headers: Map<String, String>?,
+        cachePolicy: GraniteImageCachePolicy
+    ): Request {
+        val requestBuilder = Request.Builder().url(url)
 
-                // 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
-                    }
+        // Add headers
+        headers?.forEach { (key, value) ->
+            requestBuilder.addHeader(key, value)
+        }
 
-                    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)
-                    }
-                }
+        // Apply cache policy
+        when (cachePolicy) {
+            GraniteImageCachePolicy.NONE -> {
+                requestBuilder.cacheControl(CacheControl.FORCE_NETWORK)
             }
-        })
+            GraniteImageCachePolicy.MEMORY, GraniteImageCachePolicy.DISK -> {
+                // Use default caching
+            }
+        }
+
+        return requestBuilder.build()
+    }
+
+    private fun handleResponse(
+        response: Response,
+        imageView: ImageView?,
+        url: String,
+        progressCallback: GraniteImageProgressCallback?,
+        completionCallback: GraniteImageCompletionCallback?
+    ) {
+        if (!response.isSuccessful) {
+            postError(Exception("HTTP error: ${response.code}"), completionCallback)
+            return
+        }
+
+        val body = response.body
+        if (body == null) {
+            postError(Exception("No data received"), completionCallback)
+            return
+        }
+
+        try {
+            val imageBytes = readResponseBytes(body, progressCallback)
+            val bitmap = decodeBitmap(imageBytes)
+            if (bitmap == null) {
+                postError(Exception("Failed to decode image data"), completionCallback)
+                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) }
+        }
+    }
+
+    private fun readResponseBytes(
+        body: okhttp3.ResponseBody,
+        progressCallback: GraniteImageProgressCallback?
+    ): ByteArray {
+        val contentLength = body.contentLength()
+        val inputStream = body.byteStream()
+        val outputStream = ByteArrayOutputStream()
+        val buffer = ByteArray(8192)
+        var totalBytesRead = 0L
+        var bytesRead: Int
+        while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+            outputStream.write(buffer, 0, bytesRead)
+            totalBytesRead += bytesRead
+            if (contentLength > 0) progressCallback?.invoke(totalBytesRead, contentLength)
+        }
+        return outputStream.toByteArray()
+    }
+
+    private fun decodeBitmap(imageBytes: ByteArray): Bitmap? {
+        return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.size)
+    }
+
+    private fun postError(error: Exception, completionCallback: GraniteImageCompletionCallback?) {
+        Log.e(TAG, error.message ?: "Unknown error")
+        mainHandler.post { completionCallback?.invoke(null, error, 0, 0) }
     }
 
     override fun cancelLoad(view: View) {
@@ -225,4 +227,23 @@ class OkHttpImageProvider : GraniteImageProvider {
             }
         )
     }
+
+    override fun clearMemoryCache(context: Context) {
+        // OkHttp: no built-in memory cache — no-op
+        Log.d(TAG, "Memory cache clear not supported (OkHttp)")
+    }
+
+    override fun clearDiskCache(context: Context) {
+        // OkHttp: evict all if client.cache is configured
+        try {
+            client.cache?.evictAll()
+            Log.d(TAG, "Disk cache cleared (OkHttp)")
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to clear disk cache: ${e.message}")
+        }
+    }
+
+    companion object {
+        private const val TAG = "OkHttpImageProvider"
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@granite-js/image",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "A pluggable React Native image component that lets you use your existing native image loading infrastructure",
   "type": "module",
   "main": "./dist/module/index.js",