react-native-fast-image 8.31.0 → 8.31.2

package/README.md

@@ -5,6 +5,7 @@ Performant React Native image component.
 [![Version][version-badge]][package]
 [![Downloads][downloads-badge]][npmtrends]
 [![Build Status][build-badge]][build]
+[![Docs][docs-badge]][docs]
 
 React Native's `Image` component handles image caching like browsers for the most part. If the server is returning proper cache control headers for images you'll generally get the sort of built in caching behavior you'd have in a browser. Even so, many people have noticed:
 
@@ -137,7 +138,7 @@ When `source` changes, the image that's showing stays until the new one has load
 
 Remote url to load the image from. e.g. `'https://example.com/image.jpg'`.
 
-Also loads local files (`file://`, and on Android `content://`), photo library images on iOS (`ph://`, see [Photo library images](#photo-library-images-ios)) and SVG images (see [SVG images](docs/formats.md#svg-images)).
+Also loads local files (`file://`, and on Android `content://`), images in the app by name (e.g. `'my_image'`: in its asset catalog on iOS, a drawable on Android), photo library images on iOS (`ph://`, see [Photo library images](#photo-library-images-ios)) and SVG images (see [SVG images](docs/formats.md#svg-images)).
 
 ---
 
@@ -622,7 +623,7 @@ await FastImage.configureCache({ maxDiskSize: 500 * 1024 * 1024 })
 const { maxDiskSize, diskSize } = await FastImage.configureCache()
 ```
 
-On Android, if your app has its own `AppGlideModule` (see [using FastImage with an AppGlideModule](docs/android-build-settings.md#if-your-app-has-its-own-appglidemodule)), set the disk cache size there instead: `maxDiskSize` isn't applied or reported.
+On Android, if your app has its own `AppGlideModule` (see [using FastImage with an AppGlideModule](docs/android-build-settings.md#if-your-app-has-its-own-appglidemodule)), set the disk cache size there instead: `maxDiskSize` isn't applied or reported. Likewise in an app with [expo-image](docs/android-build-settings.md#with-expo-image), whose Glide setup sets the disk cache.
 
 Images with `cache: 'web'` are kept in their own HTTP cache instead, up to 50 MB on each platform, which these limits don't change.
 
@@ -658,7 +659,7 @@ How fresh an image must be: see [`source.cache`](#sourcecache).
 
 ### `CacheState`
 
-`configureCache`'s result: the limits in effect (0 for no limit), and the bytes the disk cache uses now. Android only has `maxDiskSize` and `diskSize`, and neither if the app has its own `AppGlideModule`.
+`configureCache`'s result: the limits in effect (0 for no limit), and the bytes the disk cache uses now. Android only has `maxDiskSize` and `diskSize`, and neither if the app has its own `AppGlideModule` (or expo-image, which has one).
 
 - `maxDiskSize?` (`number`)
 - `maxDiskAge?` (`number`)
@@ -799,7 +800,7 @@ In `android/app/src/main/AndroidManifest.xml`, inside `<application>`:
 <meta-data android:name="fastimage.MAX_DISK_SIZE" android:value="209715200" />
 ```
 
-If your app has its own `AppGlideModule` (see [using FastImage with an AppGlideModule](docs/android-build-settings.md#if-your-app-has-its-own-appglidemodule)), set the disk cache size there instead.
+If your app has its own `AppGlideModule` (see [using FastImage with an AppGlideModule](docs/android-build-settings.md#if-your-app-has-its-own-appglidemodule)), set the disk cache size there instead. In an app with [expo-image](docs/android-build-settings.md#with-expo-image), expo-image's Glide setup sets it.
 
 [^glide-memory]: Glide's default, which FastImage keeps: room for two screenfuls of decoded images (2 × the screen's width × height × 4 bytes, about 20 MB on a 1080 × 2400 screen), plus a pool of bitmaps to reuse (one screenful on Android 8 and later, four before). Together they're limited to 40% of the memory Android gives the app (33% on low-memory devices), and both shrink to fit.
 
@@ -846,6 +847,8 @@ Thanks to [@mobinni](https://github.com/mobinni) for helping with the conceptual
 
 [build-badge]: https://github.com/DylanVann/react-native-fast-image/actions/workflows/ci.yml/badge.svg
 [build]: https://github.com/DylanVann/react-native-fast-image/actions/workflows/ci.yml
+[docs-badge]: https://img.shields.io/badge/docs-website-blue.svg
+[docs]: https://react-native-fast-image.dylanvann.workers.dev
 [downloads-badge]: https://img.shields.io/npm/dm/react-native-fast-image.svg
 [npmtrends]: http://www.npmtrends.com/react-native-fast-image
 [package]: https://www.npmjs.com/package/react-native-fast-image

package/android/build.gradle

@@ -19,6 +19,18 @@ buildscript {
 
 apply plugin: 'com.android.library'
 
+// Whether the app has expo-image (in a node_modules folder above the app's
+// android folder, as Node finds it), which ships its own AppGlideModule.
+def appHasExpoImage = {
+    for (def dir = rootProject.projectDir; dir != null; dir = dir.parentFile) {
+        if (new File(dir, "node_modules/expo-image/package.json").isFile()) return true
+    }
+    return false
+}
+// An app has one AppGlideModule: with expo-image, FastImage's is left out,
+// and FastImage registers its Glide components itself (FastImageGlide).
+def excludeAppGlideModule = safeExtGet('excludeAppGlideModule', appHasExpoImage())
+
 // When changing the default, revisit the Glide rules in consumer-rules.pro.
 // 4.15+ animates animated WebP (Android 9+) and AVIF (Android 12+).
 def glideVersion = safeExtGet('glideVersion', '4.16.0')
@@ -56,7 +68,7 @@ android {
             }
             java {
                 srcDir glideHasAnimatedDecoder ? "src/glide-4.15/java" : "src/glide-older/java"
-                if (safeExtGet('excludeAppGlideModule', false)) {
+                if (excludeAppGlideModule) {
                     srcDir "src"
                     exclude "**/FastImageGlideModule.java"
                     // Only the one chosen above.

package/android/src/glide-4.15/java/com/dylanvann/fastimage/FastImageAnimated.java

@@ -194,7 +194,7 @@ final class FastImageAnimated {
 
         @Override
         public boolean handles(@NonNull ByteBuffer source, @NonNull Options options) throws IOException {
-            return glide.handles(source, options);
+            return FastImageGlide.isRequest(options) && glide.handles(source, options);
         }
 
         @Nullable
@@ -229,7 +229,7 @@ final class FastImageAnimated {
 
         @Override
         public boolean handles(@NonNull InputStream source, @NonNull Options options) throws IOException {
-            return glide.handles(source, options);
+            return FastImageGlide.isRequest(options) && glide.handles(source, options);
         }
 
         // Read whole, as Glide's own does.

package/android/src/main/java/com/dylanvann/fastimage/FastImageApng.java

@@ -99,7 +99,7 @@ final class FastImageApng {
     private static final class BufferDecoder implements ResourceDecoder<ByteBuffer, Drawable> {
         @Override
         public boolean handles(@NonNull ByteBuffer source, @NonNull Options options) {
-            return animates(options) && plays(source) >= 0;
+            return FastImageGlide.isRequest(options) && animates(options) && plays(source) >= 0;
         }
 
         @Nullable
@@ -113,7 +113,7 @@ final class FastImageApng {
     private static final class StreamDecoder implements ResourceDecoder<InputStream, Drawable> {
         @Override
         public boolean handles(@NonNull InputStream source, @NonNull Options options) throws IOException {
-            if (!animates(options)) return false;
+            if (!FastImageGlide.isRequest(options) || !animates(options)) return false;
             byte[] head = new byte[HEAD_LENGTH];
             source.mark(HEAD_LENGTH);
             int read = 0;

package/android/src/main/java/com/dylanvann/fastimage/FastImageGif.java

@@ -40,7 +40,7 @@ final class FastImageGif {
         ByteBuffer data = gif.getBuffer();
         GifHeader header = new GifHeaderParser().setData(data).parseHeader();
         if (header.getNumFrames() <= 0 || header.getStatus() != GifDecoder.STATUS_OK) return null;
-        Glide glide = Glide.get(context);
+        Glide glide = FastImageGlide.get(context);
         BitmapPool bitmapPool = glide.getBitmapPool();
         GifDecoder decoder = new StandardGifDecoder(
                 new GifBitmapProvider(bitmapPool, glide.getArrayPool()),

package/android/src/main/java/com/dylanvann/fastimage/FastImageGlide.java

@@ -0,0 +1,76 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.Registry;
+import com.bumptech.glide.load.Option;
+import com.bumptech.glide.load.Options;
+
+// FastImage's use of Glide, which the app may share with other libraries.
+final class FastImageGlide {
+    private FastImageGlide() {}
+
+    // Set on FastImage's requests, so its decoders (animated WebP and AVIF,
+    // APNG, SVG) only take its own images: another library's images (e.g.
+    // expo-image's) keep that library's decoders.
+    static final Option<Boolean> REQUEST = Option.memory("com.dylanvann.fastimage.Request", false);
+
+    static boolean isRequest(@NonNull Options options) {
+        return Boolean.TRUE.equals(options.get(REQUEST));
+    }
+
+    // The Glide instance FastImage's components (FastImageOkHttpProgressGlideModule)
+    // were registered with.
+    private static volatile Glide registered;
+
+    // Whether Glide started with FastImage's AppGlideModule (as the app's).
+    private static volatile boolean appModule;
+
+    static void appModuleStarted() {
+        appModule = true;
+    }
+
+    static void registered(@NonNull Glide glide) {
+        registered = glide;
+    }
+
+    // Glide, with FastImage's components. Glide registers them if the app's
+    // generated Glide module lists FastImage's module, as FastImage's
+    // AppGlideModule's does. Another library's (e.g. expo-image's, which ships
+    // one) only lists the modules it was built with, so then they're
+    // registered here, before FastImage's first request.
+    @NonNull
+    static Glide get(@NonNull Context context) {
+        Glide glide = Glide.get(context);
+        // Glide registers them itself, when its registry is first used (in
+        // the background, by the first load: Glide 4.15+ builds it lazily).
+        if (appModule) return glide;
+        // Builds the registry, which registers them if the app's module lists
+        // FastImage's.
+        Registry registry = glide.getRegistry();
+        if (registered != glide) {
+            synchronized (FastImageGlide.class) {
+                if (registered != glide) {
+                    new FastImageOkHttpProgressGlideModule()
+                            .registerComponents(context.getApplicationContext(), glide, registry);
+                }
+            }
+        }
+        return glide;
+    }
+
+    // Glide, with FastImage's components registered now, for callers in the
+    // background that use them directly rather than through a load (the HTTP
+    // cache of `cache: 'web'` images, which registering them sets up): with
+    // FastImage's AppGlideModule, Glide registers them only when its registry
+    // is first used, e.g. by FastImage's first load.
+    @NonNull
+    static Glide getRegistered(@NonNull Context context) {
+        Glide glide = get(context);
+        glide.getRegistry();
+        return glide;
+    }
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageGlideModule.java

@@ -16,6 +16,7 @@ public final class FastImageGlideModule extends AppGlideModule {
     // FastImageCacheLimits), in Glide's default folder.
     @Override
     public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
+        FastImageGlide.appModuleStarted();
         long maxDiskSize = FastImageCacheLimits.maxDiskSize(context);
         builder.setDiskCache(new InternalCacheDiskCacheFactory(context, maxDiskSize == 0 ? Long.MAX_VALUE : maxDiskSize));
         FastImageCacheLimits.startedMaxDiskSize = maxDiskSize;

package/android/src/main/java/com/dylanvann/fastimage/FastImageOkHttpProgressGlideModule.java

@@ -119,11 +119,6 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             builder.cookieJar(new JavaNetCookieJar(new FastImageCookieHandler(context)));
         }
         OkHttpClient client = builder.build();
-        registry.replace(GlideUrl.class, InputStream.class, new UrlLoaderFactory(client));
-        FastImageSvg.register(registry, glide.getBitmapPool());
-        FastImageAnimated.register(context, glide, registry);
-        FastImageApng.register(registry);
-
         // `cache: 'web'` skips Glide's caches and relies on HTTP caching, so
         // those urls get a client with an HTTP cache (#280): one of their own,
         // not the app's (if it gave React Native's shared client one), so
@@ -132,70 +127,49 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         // store them twice).
         webCache = new Cache(new File(context.getCacheDir(), "fast-image-http-cache"), WEB_CACHE_SIZE);
         webClient = client.newBuilder().cache(webCache).build();
-        registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
+        registry.prepend(FastImageUrl.class, InputStream.class, new UrlLoaderFactory(client, webClient));
+        FastImageSvg.register(registry, glide.getBitmapPool());
+        FastImageAnimated.register(context, glide, registry);
+        FastImageApng.register(registry);
 
         // writeToCache: local files stored under a source's key.
         registry.prepend(FastImageCacheWrite.class, InputStream.class,
                 new FastImageCacheWrite.LoaderFactory(context.getApplicationContext()));
+        FastImageGlide.registered(glide);
     }
 
-    // Loads GlideUrls with the given client, except `web` ones
-    // (FastImageWebGlideUrls): Glide gives a model to the loaders of its
-    // superclasses too, and tries the next one when a load fails, so a `web`
-    // image that failed (e.g. a 404) was requested again with this client,
-    // without the HTTP cache, which also hid the failure.
-    private static class UrlLoaderFactory implements ModelLoaderFactory<GlideUrl, InputStream> {
+    // Loads FastImage's remote images (FastImageUrls): `web` ones
+    // (FastImageWebGlideUrls) with the client with the HTTP cache, others with
+    // the other client, where a view loading an image that's being preloaded
+    // waits for the preload's download. FastImageUrl isn't a GlideUrl, so
+    // Glide doesn't also give these to other GlideUrl loaders, which it would
+    // try after a failed load (e.g. a 404, requested again).
+    private static class UrlLoaderFactory implements ModelLoaderFactory<FastImageUrl, InputStream> {
         private final OkHttpClient client;
+        private final OkHttpClient webClient;
 
-        UrlLoaderFactory(OkHttpClient client) {
+        UrlLoaderFactory(OkHttpClient client, OkHttpClient webClient) {
             this.client = client;
+            this.webClient = webClient;
         }
 
         @NonNull
         @Override
-        public ModelLoader<GlideUrl, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
+        public ModelLoader<FastImageUrl, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
             final OkHttpUrlLoader loader = new OkHttpUrlLoader(client);
-            return new ModelLoader<GlideUrl, InputStream>() {
+            final OkHttpUrlLoader webLoader = new OkHttpUrlLoader(webClient);
+            return new ModelLoader<FastImageUrl, InputStream>() {
                 @Override
-                public LoadData<InputStream> buildLoadData(@NonNull GlideUrl model, int width, int height, @NonNull Options options) {
-                    LoadData<InputStream> data = loader.buildLoadData(model, width, height, options);
-                    // A view loading an image that's being preloaded waits
-                    // for the preload's download.
-                    return data == null ? null : FastImageSharedDownloads.share(data, model, options);
-                }
-
-                @Override
-                public boolean handles(@NonNull GlideUrl model) {
-                    return !(model instanceof FastImageWebGlideUrl);
-                }
-            };
-        }
-
-        @Override
-        public void teardown() {
-        }
-    }
-
-    // Loads FastImageWebGlideUrls with the given client.
-    private static class WebUrlLoaderFactory implements ModelLoaderFactory<FastImageWebGlideUrl, InputStream> {
-        private final OkHttpClient client;
-
-        WebUrlLoaderFactory(OkHttpClient client) {
-            this.client = client;
-        }
-
-        @NonNull
-        @Override
-        public ModelLoader<FastImageWebGlideUrl, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
-            final OkHttpUrlLoader loader = new OkHttpUrlLoader(client);
-            return new ModelLoader<FastImageWebGlideUrl, InputStream>() {
-                @Override
-                public LoadData<InputStream> buildLoadData(@NonNull FastImageWebGlideUrl model, int width, int height, @NonNull Options options) {
-                    return loader.buildLoadData(model, width, height, options);
+                public LoadData<InputStream> buildLoadData(@NonNull FastImageUrl model, int width, int height, @NonNull Options options) {
+                    if (model.url instanceof FastImageWebGlideUrl) {
+                        return webLoader.buildLoadData(model.url, width, height, options);
+                    }
+                    LoadData<InputStream> data = loader.buildLoadData(model.url, width, height, options);
+                    return data == null ? null : FastImageSharedDownloads.share(data, model.url, options);
                 }
 
                 @Override
-                public boolean handles(@NonNull FastImageWebGlideUrl model) {
+                public boolean handles(@NonNull FastImageUrl model) {
                     return true;
                 }
             };

package/android/src/main/java/com/dylanvann/fastimage/FastImageRequestListener.java

@@ -4,7 +4,6 @@ import android.graphics.drawable.Drawable;
 
 import com.bumptech.glide.load.DataSource;
 import com.bumptech.glide.load.engine.GlideException;
-import com.bumptech.glide.load.model.GlideUrl;
 import com.bumptech.glide.load.resource.gif.GifDrawable;
 import com.bumptech.glide.request.Request;
 import com.bumptech.glide.request.RequestListener;
@@ -83,7 +82,7 @@ public class FastImageRequestListener implements RequestListener<Drawable> {
             view.applyLoopCount((GifDrawable) resource);
         }
         if (!events) return false;
-        boolean local = !(model instanceof GlideUrl);
+        boolean local = !(model instanceof FastImageUrl);
         int[] size = FastImageSourceSize.get(resource, model, local,
                 dataSource == DataSource.RESOURCE_DISK_CACHE);
         if (size != null) {

package/android/src/main/java/com/dylanvann/fastimage/FastImageSource.java

@@ -122,7 +122,7 @@ public class FastImageSource extends ImageSource {
         if (isLocalFile()) {
             return getUri().toString();
         }
-        return getGlideUrl();
+        return new FastImageUrl(getGlideUrl());
     }
 
     @Override

package/android/src/main/java/com/dylanvann/fastimage/FastImageSourceSize.java

@@ -218,7 +218,7 @@ final class FastImageSourceSize {
             int orientation;
             stream = open(context, source);
             try {
-                Glide glide = Glide.get(context);
+                Glide glide = FastImageGlide.get(context);
                 orientation = ImageHeaderParserUtils.getOrientation(
                         glide.getRegistry().getImageHeaderParsers(), stream, glide.getArrayPool());
             } finally {

package/android/src/main/java/com/dylanvann/fastimage/FastImageSvg.java

@@ -118,6 +118,7 @@ final class FastImageSvg {
 
         @Override
         public boolean handles(@NonNull InputStream source, @NonNull Options options) throws IOException {
+            if (!FastImageGlide.isRequest(options)) return false;
             // Glide rewinds the stream before decoding.
             byte[] head = new byte[HEAD_LENGTH];
             int length = 0;
@@ -145,6 +146,7 @@ final class FastImageSvg {
 
         @Override
         public boolean handles(@NonNull ByteBuffer source, @NonNull Options options) {
+            if (!FastImageGlide.isRequest(options)) return false;
             ByteBuffer copy = source.duplicate();
             byte[] head = new byte[Math.min(HEAD_LENGTH, copy.remaining())];
             copy.get(head);

package/android/src/main/java/com/dylanvann/fastimage/FastImageUrl.java

@@ -0,0 +1,36 @@
+package com.dylanvann.fastimage;
+
+import androidx.annotation.NonNull;
+
+import com.bumptech.glide.load.model.GlideUrl;
+
+// What FastImage loads a remote image with: its GlideUrl (url, headers, and
+// cache key: the disk cache key stays the GlideUrl's), loaded by FastImage's
+// own loader (FastImageOkHttpProgressGlideModule). Not a GlideUrl itself: the
+// app's Glide may have other GlideUrl loaders (Glide's, another library's,
+// e.g. expo-image's), which Glide would also try after a failed load, and
+// FastImage leaves them as they are for the app's other loads.
+final class FastImageUrl {
+    final GlideUrl url;
+
+    FastImageUrl(@NonNull GlideUrl url) {
+        this.url = url;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof FastImageUrl && url.equals(((FastImageUrl) other).url);
+    }
+
+    @Override
+    public int hashCode() {
+        return url.hashCode();
+    }
+
+    // The GlideUrl's (its cache key), which FastImageSourceSize keys sizes by.
+    @NonNull
+    @Override
+    public String toString() {
+        return url.toString();
+    }
+}

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewConverter.java

@@ -122,7 +122,8 @@ class FastImageViewConverter {
                 // memoryCache false: only kept on disk.
                 .skipMemoryCache(skipMemoryCache || (imageSource != null && !imageSource.isMemoryCache()))
                 .priority(priority)
-                .placeholder(TRANSPARENT_DRAWABLE);
+                .placeholder(TRANSPARENT_DRAWABLE)
+                .set(FastImageGlide.REQUEST, true);
 
         // imageSource is null when only a defaultSource is shown.
         if (imageSource != null && imageSource.isResource()) {

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewManager.java

@@ -53,6 +53,7 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         // shared by all views kept the last view's Activity alive after it was
         // destroyed, and gave views another Activity's manager (#492).
         RequestManager requestManager = null;
+        FastImageGlide.get(reactContext);
         if (isValidContextForGlide(reactContext)) {
             requestManager = Glide.with(reactContext);
         } else if (getActivityFromContext(reactContext) == null) {

package/android/src/main/java/com/dylanvann/fastimage/FastImageViewModule.java

@@ -87,7 +87,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         BitmapFactory.decodeFile(file.getPath(), bounds);
         if (bounds.outWidth <= 0 || bounds.outHeight <= 0) return null;
         int orientation = ImageHeaderParser.UNKNOWN_ORIENTATION;
-        Glide glide = Glide.get(context);
+        Glide glide = FastImageGlide.get(context);
         try (InputStream stream = new FileInputStream(file)) {
             orientation = ImageHeaderParserUtils.getOrientation(
                     glide.getRegistry().getImageHeaderParsers(), stream, glide.getArrayPool());
@@ -119,6 +119,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         UiThreadUtil.runOnUiThread(new Runnable() {
             @Override
             public void run() {
+                FastImageGlide.get(context);
                 final int count = sources.size();
                 final WritableMap[] results = new WritableMap[count];
                 // Sources of this call still to finish. It starts at the
@@ -270,7 +271,8 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
     // thread. For a preload (`shared`), views that load the image meanwhile
     // wait for the download and read its file (FastImageSharedDownloads).
     private static void loadFile(Context context, Object model, RequestOptions options, boolean shared, final FileCallback callback) {
-        final String key = shared && model instanceof GlideUrl ? ((GlideUrl) model).getCacheKey() : null;
+        final String key = shared && model instanceof FastImageUrl ? ((FastImageUrl) model).url.getCacheKey() : null;
+        FastImageGlide.get(context);
         Glide.with(context)
                 .asFile()
                 .load(model)
@@ -298,6 +300,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
     @Nullable
     private static File cachedFile(Context context, Object model, RequestOptions options) {
         try {
+            FastImageGlide.get(context);
             return Glide.with(context)
                     .asFile()
                     .load(model)
@@ -348,7 +351,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
             cachePathExecutor.execute(new Runnable() {
                 @Override
                 public void run() {
-                    File file = cachedFile(context, FastImageKeyedGlideUrl.forKey(cacheKey), new RequestOptions());
+                    File file = cachedFile(context, new FastImageUrl(FastImageKeyedGlideUrl.forKey(cacheKey)), new RequestOptions());
                     promise.resolve(file != null ? pathResult(file) : failure("Not in the disk cache"));
                 }
             });
@@ -376,8 +379,8 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
             public void run() {
                 // On disk already: in Glide's cache (not for `web` images,
                 // which it doesn't cache), or in the HTTP cache of `web`
-                // images (set up by Glide, which is started first).
-                Glide.get(context);
+                // images (set up when FastImage's components are registered).
+                FastImageGlide.getRegistered(context);
                 File file = imageSource.isWebCache() ? null : cachedFile(context, imageSource.getSourceForLoad(), options);
                 if (file == null) file = FastImageOkHttpProgressGlideModule.webCacheFile(imageSource.getUri().toString());
                 if (file != null) {
@@ -486,7 +489,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         final GlideUrl key = imageSource != null && imageSource.isRemote()
                 ? imageSource.getGlideUrl()
                 : FastImageKeyedGlideUrl.forKey(cacheKey);
-        final Object lookUp = imageSource != null && imageSource.isRemote() ? imageSource.getSourceForLoad() : key;
+        final Object lookUp = imageSource != null && imageSource.isRemote() ? imageSource.getSourceForLoad() : new FastImageUrl(key);
         // A file:// or content:// uri, or a path.
         Uri parsed = Uri.parse(file);
         final Uri fileUri = parsed.getScheme() == null ? Uri.fromFile(new File(file)) : parsed;
@@ -551,7 +554,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         cachePathExecutor.execute(new Runnable() {
             @Override
             public void run() {
-                Glide.get(context);
+                FastImageGlide.get(context);
                 WritableMap result = Arguments.createMap();
                 long maxDiskSize = FastImageCacheLimits.startedMaxDiskSize;
                 if (maxDiskSize >= 0) {
@@ -574,7 +577,7 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         activity.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                Glide.get(activity.getApplicationContext()).clearMemory();
+                FastImageGlide.get(activity.getApplicationContext()).clearMemory();
                 promise.resolve(null);
             }
         });
@@ -588,9 +591,9 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
             return;
         }
 
-        Glide.get(activity.getApplicationContext()).clearDiskCache();
+        FastImageGlide.getRegistered(activity.getApplicationContext()).clearDiskCache();
         // And the HTTP cache of `cache: 'web'` images, which Glide doesn't
-        // cache.
+        // cache (set up when FastImage's components are registered).
         try {
             FastImageOkHttpProgressGlideModule.clearWebCache();
         } catch (IOException e) {

package/android/src/main/java/com/dylanvann/fastimage/FastImageWebGlideUrl.java

@@ -6,6 +6,7 @@ import com.bumptech.glide.load.model.Headers;
 // A url loaded with `cache: 'web'`. Glide doesn't cache these, so they load
 // through an OkHttp client with an HTTP cache (see
 // FastImageOkHttpProgressGlideModule) to follow the server's caching headers.
+// Loaded as a FastImageUrl, like FastImage's other urls.
 class FastImageWebGlideUrl extends GlideUrl {
     FastImageWebGlideUrl(String url, Headers headers) {
         super(url, headers);

package/dist/index.d.ts

@@ -13,8 +13,9 @@ export type Source = {
     /**
      * Remote url to load the image from. e.g. `'https://example.com/image.jpg'`.
      *
-     * Also loads local files (`file://`, and on Android `content://`), photo
-     * library images on iOS (`ph://`, see
+     * Also loads local files (`file://`, and on Android `content://`), images
+     * in the app by name (e.g. `'my_image'`: in its asset catalog on iOS, a
+     * drawable on Android), photo library images on iOS (`ph://`, see
      * [Photo library images](#photo-library-images-ios)) and SVG images (see
      * [SVG images](docs/formats.md#svg-images)).
      */
@@ -187,7 +188,8 @@ export interface CacheLimits {
 /**
  * `configureCache`'s result: the limits in effect (0 for no limit), and the
  * bytes the disk cache uses now. Android only has `maxDiskSize` and
- * `diskSize`, and neither if the app has its own `AppGlideModule`.
+ * `diskSize`, and neither if the app has its own `AppGlideModule` (or
+ * expo-image, which has one).
  */
 export interface CacheState {
     maxDiskSize?: number;

package/ios/FastImage/FFFastImageSource.m

@@ -62,6 +62,75 @@ static CGSize FFFPhotoPixelSize(NSURL *url)
     return size;
 }
 
+// An image in the app by its name (`uri: 'my_image'`), such as one in the
+// app's asset catalog, as React Native's Image takes: RCTConvert makes a uri
+// without a scheme a file in the app's resources, where such an image isn't a
+// file. The name, or nil if the url is a file that exists or isn't in the
+// app's resources.
+static NSString *FFFBundleAssetName(NSURL *url)
+{
+    if (!url.isFileURL) {
+        return nil;
+    }
+    NSString *resources = [NSBundle.mainBundle.resourcePath stringByAppendingString:@"/"];
+    NSString *path = url.path;
+    if (![path hasPrefix:resources] || path.length == resources.length ||
+        [NSFileManager.defaultManager fileExistsAtPath:path]) {
+        return nil;
+    }
+    return [path substringFromIndex:resources.length];
+}
+
+// Loads images in the app by name (FFFBundleAssetName) with UIImage
+// imageNamed:, which finds them in the asset catalog (and image files in the
+// app's resources, e.g. with @2x and @3x versions), as React Native's Image
+// does.
+@interface FFFBundleAssetLoader : NSObject <SDImageLoader>
+@end
+
+@implementation FFFBundleAssetLoader
+
++ (FFFBundleAssetLoader *)sharedLoader
+{
+    static FFFBundleAssetLoader *loader;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+        loader = [FFFBundleAssetLoader new];
+    });
+    return loader;
+}
+
+- (BOOL)canRequestImageForURL:(NSURL *)url
+{
+    return YES;
+}
+
+- (id<SDWebImageOperation>)requestImageWithURL:(NSURL *)url
+                                        options:(SDWebImageOptions)options
+                                        context:(SDWebImageContext *)context
+                                       progress:(SDImageLoaderProgressBlock)progressBlock
+                                      completed:(SDImageLoaderCompletedBlock)completedBlock
+{
+    NSString *name = FFFBundleAssetName(url);
+    UIImage *image = name ? [UIImage imageNamed:name] : nil;
+    if (completedBlock) {
+        if (image) {
+            completedBlock(image, nil, nil, YES);
+        } else {
+            NSString *message = [NSString stringWithFormat:@"No image named %@ in the app", name ?: url.path];
+            completedBlock(nil, nil, [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey: message}], YES);
+        }
+    }
+    return nil;
+}
+
+- (BOOL)shouldBlockFailedURLWithURL:(NSURL *)url error:(NSError *)error
+{
+    return NO;
+}
+
+@end
+
 // Loads photo library images (ph://<localIdentifier>) with
 // SDWebImagePhotosPlugin's loader: a dependency on iOS (the podspec), found
 // at runtime so that tvOS builds without it (an app can add it there). Its
@@ -368,6 +437,9 @@ static id<SDImageCoder> FFFSVGCoder;
     if ([_url.scheme isEqualToString:@"assets-library"]) {
         return [FFFPhotosLoader assetsLibraryLoader];
     }
+    if (FFFBundleAssetName(_url)) {
+        return [FFFBundleAssetLoader sharedLoader];
+    }
     if (_cacheControl != FFFCacheControlWeb) {
         return nil;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-fast-image",
-    "version": "8.31.0",
+    "version": "8.31.2",
     "description": "FastImage, performant React Native image component.",
     "keywords": [
         "cache",