@depup/react-native-fast-image 8.6.3-depup.0 → 8.13.1-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/react-native-fast-image
 
 | Field | Value |
 |-------|-------|
-| Original | [react-native-fast-image](https://www.npmjs.com/package/react-native-fast-image) @ 8.6.3 |
-| Processed | 2026-03-18 |
+| Original | [react-native-fast-image](https://www.npmjs.com/package/react-native-fast-image) @ 8.13.1 |
+| Processed | 2026-09-27 |
 | Smoke test | failed |
 | Deps updated | 0 |
 

package/RNFastImage.podspec

@@ -16,6 +16,9 @@ Pod::Spec.new do |s|
   s.source_files  = "ios/**/*.{h,m}"
 
   s.dependency 'React-Core'
-  s.dependency 'SDWebImage', '~> 5.11.1'
-  s.dependency 'SDWebImageWebPCoder', '~> 0.8.4'
+  # Any 5.x from 5.11.1, so apps can use newer versions (and share them with
+  # other libraries) without having to update. 5.18.7+ has the privacy
+  # manifest Apple requires.
+  s.dependency 'SDWebImage', '>= 5.11.1', '< 6.0'
+  s.dependency 'SDWebImageWebPCoder', '>= 0.8.4', '< 1.0'
 end

package/android/build.gradle

@@ -19,7 +19,15 @@ buildscript {
 
 apply plugin: 'com.android.library'
 
+// Newer versions of the Android Gradle plugin (7.3+) take the namespace from
+// build.gradle and warn about the package attribute in AndroidManifest.xml;
+// older versions need that attribute.
+def supportsNamespace = project.android.hasProperty("namespace")
+
 android {
+    if (supportsNamespace) {
+        namespace "com.dylanvann.fastimage"
+    }
     compileSdkVersion safeExtGet('compileSdkVersion', 28)
     buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
     defaultConfig {
@@ -30,6 +38,9 @@ android {
     }
     sourceSets {
         main {
+            if (supportsNamespace) {
+                manifest.srcFile "src/main/AndroidManifestNew.xml"
+            }
             java {
                 if (safeExtGet('excludeAppGlideModule', false)) {
                     srcDir "src"
@@ -63,6 +74,8 @@ dependencies {
     //noinspection GradleDynamicVersion
     implementation 'com.facebook.react:react-native:+'  // From node_modules
     implementation "com.github.bumptech.glide:glide:${glideVersion}"
+    // FastImageGlideModule and FastImageOkHttpProgressGlideModule use @GlideModule.
+    implementation "com.github.bumptech.glide:annotations:${glideVersion}"
     implementation "com.github.bumptech.glide:okhttp3-integration:${glideVersion}"
     annotationProcessor "com.github.bumptech.glide:compiler:${glideVersion}"
 }

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,3 @@
+<!-- Used instead of AndroidManifest.xml when the namespace is set in build.gradle. -->
+<manifest>
+</manifest>

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

@@ -0,0 +1,84 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.os.Build;
+import android.text.TextUtils;
+import android.webkit.CookieManager;
+import android.webkit.CookieSyncManager;
+
+import androidx.annotation.Nullable;
+
+import java.net.CookieHandler;
+import java.net.URI;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+// Reads and stores cookies in Android's cookie store (the WebView's
+// CookieManager), which React Native's networking (fetch) and its Image
+// component use. Image requests then send the cookies the app's other requests
+// got, as on iOS. Does what React Native's ForwardingCookieHandler does,
+// without the ReactContext that one needs (up to at least 0.77). Used through
+// OkHttp's JavaNetCookieJar, which parses the cookies.
+final class FastImageCookieHandler extends CookieHandler {
+    private final Context context;
+    @Nullable
+    private CookieManager cookieManager;
+
+    FastImageCookieHandler(Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public Map<String, List<String>> get(URI uri, Map<String, List<String>> requestHeaders) {
+        CookieManager cookieManager = cookieManager();
+        if (cookieManager == null) return Collections.emptyMap();
+        String cookies = cookieManager.getCookie(uri.toString());
+        if (TextUtils.isEmpty(cookies)) return Collections.emptyMap();
+        return Collections.singletonMap("Cookie", Collections.singletonList(cookies));
+    }
+
+    @Override
+    public void put(URI uri, Map<String, List<String>> responseHeaders) {
+        CookieManager cookieManager = cookieManager();
+        if (cookieManager == null) return;
+        String url = uri.toString();
+        boolean added = false;
+        for (Map.Entry<String, List<String>> header : responseHeaders.entrySet()) {
+            String name = header.getKey();
+            if (!"Set-Cookie".equalsIgnoreCase(name) && !"Set-Cookie2".equalsIgnoreCase(name)) continue;
+            for (String cookie : header.getValue()) {
+                cookieManager.setCookie(url, cookie);
+                added = true;
+            }
+        }
+        if (added) flush(cookieManager);
+    }
+
+    @SuppressWarnings("deprecation")
+    private static void flush(CookieManager cookieManager) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            cookieManager.flush();
+        } else {
+            CookieSyncManager.getInstance().sync();
+        }
+    }
+
+    // null while the WebView isn't available (not installed, or being
+    // updated): requests go without cookies then, instead of failing.
+    @Nullable
+    @SuppressWarnings("deprecation")
+    private synchronized CookieManager cookieManager() {
+        if (cookieManager == null) {
+            try {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+                    CookieSyncManager.createInstance(context);
+                }
+                cookieManager = CookieManager.getInstance();
+            } catch (Exception e) {
+                return null;
+            }
+        }
+        return cookieManager;
+    }
+}

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

@@ -0,0 +1,45 @@
+package com.dylanvann.fastimage;
+
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.events.Event;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+// An event for a FastImage view, sent with the EventDispatcher (see
+// FastImageEvents) instead of the RCTEventEmitter JS module, which the New
+// Architecture warns about on every event.
+class FastImageEvent extends Event<FastImageEvent> {
+    private final String name;
+    private final WritableMap data;
+
+    // Event(viewTag) works back to React Native 0.60. Without a surface id,
+    // Fabric finds the view by its tag.
+    @SuppressWarnings("deprecation")
+    FastImageEvent(int viewTag, String name, WritableMap data) {
+        super(viewTag);
+        this.name = name;
+        this.data = data;
+    }
+
+    @Override
+    public String getEventName() {
+        return name;
+    }
+
+    // Every event reaches JS, e.g. each progress update, as before.
+    @Override
+    public boolean canCoalesce() {
+        return false;
+    }
+
+    // Overrides Event.getEventData on React Native 0.65+ (not on older ones,
+    // hence no @Override).
+    protected WritableMap getEventData() {
+        return data;
+    }
+
+    @Override
+    @SuppressWarnings("deprecation")
+    public void dispatch(RCTEventEmitter rctEventEmitter) {
+        rctEventEmitter.receiveEvent(getViewTag(), name, data);
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.dylanvann.fastimage;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.EventDispatcher;
+
+import java.lang.reflect.Method;
+
+// Sends FastImage view events through React Native's EventDispatcher.
+final class FastImageEvents {
+    // UIManagerHelper.getEventDispatcherForReactTag (React Native 0.63+, also
+    // bridgeless). Looked up by reflection so older versions still compile.
+    @Nullable
+    private static final Method GET_EVENT_DISPATCHER = findGetEventDispatcher();
+
+    private FastImageEvents() {
+    }
+
+    static void send(View view, String name) {
+        send(view, name, Arguments.createMap());
+    }
+
+    static void send(View view, String name, WritableMap data) {
+        ReactContext context = FastImageViewManager.getReactContext(view.getContext());
+        if (context == null) return;
+        EventDispatcher dispatcher = eventDispatcher(context, view.getId());
+        if (dispatcher != null) {
+            dispatcher.dispatchEvent(new FastImageEvent(view.getId(), name, data));
+        }
+    }
+
+    @Nullable
+    private static EventDispatcher eventDispatcher(ReactContext context, int viewTag) {
+        if (GET_EVENT_DISPATCHER != null) {
+            try {
+                return (EventDispatcher) GET_EVENT_DISPATCHER.invoke(null, context, viewTag);
+            } catch (Exception ignored) {
+                // Fall back to the UIManagerModule's.
+            }
+        }
+        UIManagerModule uiManager = context.getNativeModule(UIManagerModule.class);
+        return uiManager == null ? null : uiManager.getEventDispatcher();
+    }
+
+    @Nullable
+    private static Method findGetEventDispatcher() {
+        try {
+            return Class.forName("com.facebook.react.uimanager.UIManagerHelper")
+                    .getMethod("getEventDispatcherForReactTag", ReactContext.class, int.class);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,110 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.gifdecoder.GifDecoder;
+import com.bumptech.glide.gifdecoder.GifHeader;
+import com.bumptech.glide.gifdecoder.GifHeaderParser;
+import com.bumptech.glide.gifdecoder.StandardGifDecoder;
+import com.bumptech.glide.load.Transformation;
+import com.bumptech.glide.load.engine.Resource;
+import com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool;
+import com.bumptech.glide.load.resource.UnitTransformation;
+import com.bumptech.glide.load.resource.bitmap.BitmapResource;
+import com.bumptech.glide.load.resource.gif.GifBitmapProvider;
+import com.bumptech.glide.load.resource.gif.GifDrawable;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+
+// Gives a view its own animation of a GIF. Glide gives every view that shows
+// the same GIF (same url and size) a GifDrawable over one frame loader (it's
+// in the cached drawable's constant state), so they animate as one: a view
+// whose GIF stopped (the `loop` prop) keeps drawing another view's frames, and
+// restarting one throws while another view plays it. A copy has its own
+// decoder and frame loader over the same data, so each view animates on its
+// own, as with React Native's Image and on iOS. Decoded like Glide's
+// ByteBufferGifDecoder does, at the size the image was loaded at, and cropped
+// or fitted with the same transformation.
+final class FastImageGif {
+    private FastImageGif() {}
+
+    // Null if the GIF can't be decoded again (then the view shows Glide's).
+    @Nullable
+    static GifDrawable copy(Context context, GifDrawable gif, int width, int height) {
+        if (width <= 0 || height <= 0) return null;
+        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);
+        BitmapPool bitmapPool = glide.getBitmapPool();
+        GifDecoder decoder = new StandardGifDecoder(
+                new GifBitmapProvider(bitmapPool, glide.getArrayPool()),
+                header, gif.getBuffer(), sampleSize(header, width, height));
+        decoder.setDefaultBitmapConfig(Bitmap.Config.ARGB_8888);
+        decoder.advance();
+        Bitmap firstFrame = decoder.getNextFrame();
+        if (firstFrame == null) {
+            decoder.clear();
+            return null;
+        }
+        GifDrawable copy = new GifDrawable(
+                context, decoder, UnitTransformation.<Bitmap>get(), width, height, firstFrame);
+        Transformation<Bitmap> transformation = gif.getFrameTransformation();
+        if (transformation != null && !(transformation instanceof UnitTransformation)) {
+            // As GifDrawableTransformation does.
+            Resource<Bitmap> frame = new BitmapResource(firstFrame, bitmapPool);
+            Resource<Bitmap> transformed = transformation.transform(context, frame, width, height);
+            if (!frame.equals(transformed)) frame.recycle();
+            copy.setFrameTransformation(transformation, transformed.get());
+        }
+        return copy;
+    }
+
+    // GifDrawable.start() also starts counting plays again, so a paused GIF
+    // would play its whole loop count again when resumed; iOS continues it.
+    // The count isn't public: keep it across start() by reflection. A GIF
+    // that already finished its plays starts over, as on iOS. Without the
+    // fields (another Glide version), it counts again, as start() does.
+    @Nullable
+    private static final Field LOOP_COUNT = field("loopCount");
+    @Nullable
+    private static final Field MAX_LOOP_COUNT = field("maxLoopCount");
+
+    static void resume(GifDrawable gif) {
+        if (LOOP_COUNT == null || MAX_LOOP_COUNT == null) {
+            gif.start();
+            return;
+        }
+        try {
+            int played = LOOP_COUNT.getInt(gif);
+            int max = MAX_LOOP_COUNT.getInt(gif);
+            gif.start();
+            if (max == GifDrawable.LOOP_FOREVER || played < max) LOOP_COUNT.setInt(gif, played);
+        } catch (IllegalAccessException e) {
+            gif.start();
+        }
+    }
+
+    @Nullable
+    private static Field field(String name) {
+        try {
+            Field field = GifDrawable.class.getDeclaredField(name);
+            field.setAccessible(true);
+            return field.getType() == int.class ? field : null;
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    // ByteBufferGifDecoder's.
+    private static int sampleSize(GifHeader header, int width, int height) {
+        int exact = Math.min(header.getHeight() / height, header.getWidth() / width);
+        int powerOfTwo = exact == 0 ? 0 : Integer.highestOneBit(exact);
+        return Math.max(1, powerOfTwo);
+    }
+}

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

@@ -7,17 +7,25 @@ import com.bumptech.glide.Glide;
 import com.bumptech.glide.Registry;
 import com.bumptech.glide.annotation.GlideModule;
 import com.bumptech.glide.integration.okhttp3.OkHttpUrlLoader;
+import com.bumptech.glide.load.Options;
 import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.load.model.ModelLoader;
+import com.bumptech.glide.load.model.ModelLoaderFactory;
+import com.bumptech.glide.load.model.MultiModelLoaderFactory;
 import com.bumptech.glide.module.LibraryGlideModule;
+import com.facebook.react.modules.network.CookieJarContainer;
 import com.facebook.react.modules.network.OkHttpClientProvider;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
 
+import okhttp3.Cache;
 import okhttp3.Interceptor;
+import okhttp3.JavaNetCookieJar;
 import okhttp3.MediaType;
 import okhttp3.OkHttpClient;
 import okhttp3.Request;
@@ -33,6 +41,7 @@ import okio.Source;
 public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
 
     private static final DispatchingProgressListener progressListener = new DispatchingProgressListener();
+    private static final long WEB_CACHE_SIZE = 50 * 1024 * 1024;
 
     @Override
     public void registerComponents(
@@ -40,13 +49,61 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
             @NonNull Glide glide,
             @NonNull Registry registry
     ) {
-        OkHttpClient client = OkHttpClientProvider
-                .getOkHttpClient()
+        OkHttpClient sharedClient = OkHttpClientProvider.getOkHttpClient();
+        OkHttpClient.Builder builder = sharedClient
                 .newBuilder()
-                .addInterceptor(createInterceptor(progressListener))
-                .build();
+                .addInterceptor(createInterceptor(progressListener));
+        // React Native's shared client comes with an empty cookie jar (React
+        // Native only fills it in for its networking and Image clients), so
+        // images were loaded without the app's cookies, unlike on iOS. Use the
+        // same cookie store. A cookie jar the app set up itself is kept.
+        if (sharedClient.cookieJar() instanceof CookieJarContainer) {
+            builder.cookieJar(new JavaNetCookieJar(new FastImageCookieHandler(context)));
+        }
+        OkHttpClient client = builder.build();
         OkHttpUrlLoader.Factory factory = new OkHttpUrlLoader.Factory(client);
         registry.replace(GlideUrl.class, InputStream.class, factory);
+
+        // `cache: 'web'` skips Glide's caches and relies on HTTP caching, but
+        // React Native's shared client has no HTTP cache (unless the app gave
+        // it one), so those urls get a client with one (#280). Other urls are
+        // cached by Glide, so they don't use it (that would store them twice).
+        OkHttpClient webClient = client.cache() != null
+                ? client
+                : client.newBuilder()
+                        .cache(new Cache(new File(context.getCacheDir(), "fast-image-http-cache"), WEB_CACHE_SIZE))
+                        .build();
+        registry.prepend(FastImageWebGlideUrl.class, InputStream.class, new WebUrlLoaderFactory(webClient));
+    }
+
+    // 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);
+                }
+
+                @Override
+                public boolean handles(@NonNull FastImageWebGlideUrl model) {
+                    return true;
+                }
+            };
+        }
+
+        @Override
+        public void teardown() {
+        }
     }
 
     private static Interceptor createInterceptor(final ResponseProgressListener listener) {
@@ -92,7 +149,10 @@ public class FastImageOkHttpProgressGlideModule extends LibraryGlideModule {
         @Override
         public void update(final String key, final long bytesRead, final long contentLength) {
             final FastImageProgressListener listener = LISTENERS.get(key);
-            if (listener == null) {
+            // Without a Content-Length the total is unknown (-1), and a
+            // percentage can't be worked out from it, so don't send those. (It
+            // also looked like the last update, which stopped all updates.)
+            if (listener == null || contentLength <= 0) {
                 return;
             }
             if (contentLength <= bytesRead) {

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

@@ -4,57 +4,100 @@ 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;
 import com.bumptech.glide.request.target.ImageViewTarget;
 import com.bumptech.glide.request.target.Target;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
-import com.facebook.react.uimanager.ThemedReactContext;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
 
 public class FastImageRequestListener implements RequestListener<Drawable> {
     static final String REACT_ON_ERROR_EVENT = "onFastImageError";
     static final String REACT_ON_LOAD_EVENT = "onFastImageLoad";
     static final String REACT_ON_LOAD_END_EVENT = "onFastImageLoadEnd";
     private final String key;
+    private final FastImageSource source;
+    // Whether the request shows the previous image as a thumbnail meanwhile.
+    private final boolean thumbnail;
+    // False when loading the image that's showing again at a new size: the
+    // view shows it at its old size if that fails.
+    private final boolean events;
 
-    FastImageRequestListener(String key) {
+    FastImageRequestListener(String key, FastImageSource source, boolean thumbnail, boolean events) {
         this.key = key;
-    }
-
-    private static WritableMap mapFromResource(Drawable resource) {
-        WritableMap resourceData = new WritableNativeMap();
-        resourceData.putInt("width", resource.getIntrinsicWidth());
-        resourceData.putInt("height", resource.getIntrinsicHeight());
-        return resourceData;
+        this.source = source;
+        this.thumbnail = thumbnail;
+        this.events = events;
     }
 
     @Override
     public boolean onLoadFailed(@androidx.annotation.Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+        if (!events) return false;
         FastImageOkHttpProgressGlideModule.forget(key);
         if (!(target instanceof ImageViewTarget)) {
             return false;
         }
         FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
-        ThemedReactContext context = (ThemedReactContext) view.getContext();
-        RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
-        int viewId = view.getId();
-        eventEmitter.receiveEvent(viewId, REACT_ON_ERROR_EVENT, new WritableNativeMap());
-        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_END_EVENT, new WritableNativeMap());
+        view.onImageFailed(thumbnail);
+        WritableMap event = new WritableNativeMap();
+        event.putString("error", errorMessage(e));
+        FastImageEvents.send(view, REACT_ON_ERROR_EVENT, event);
+        FastImageEvents.send(view, REACT_ON_LOAD_END_EVENT);
         return false;
     }
 
+    // The first root cause's message, e.g. "Not Found, status code: 404".
+    // The first root cause's message, e.g. "Not Found, status code: 404" (also
+    // for preload results).
+    static String errorMessage(@androidx.annotation.Nullable GlideException e) {
+        if (e != null) {
+            for (Throwable cause : e.getRootCauses()) {
+                if (cause.getMessage() != null) return cause.getMessage();
+            }
+            if (e.getMessage() != null) return e.getMessage();
+        }
+        return "Failed to load the image";
+    }
+
     @Override
-    public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
+    public boolean onResourceReady(Drawable resource, Object model, final Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
         if (!(target instanceof ImageViewTarget)) {
             return false;
         }
-        FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
-        ThemedReactContext context = (ThemedReactContext) view.getContext();
-        RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
-        int viewId = view.getId();
-        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_EVENT, mapFromResource(resource));
-        eventEmitter.receiveEvent(viewId, REACT_ON_LOAD_END_EVENT, new WritableNativeMap());
+        final FastImageViewWithUrl view = (FastImageViewWithUrl) ((ImageViewTarget) target).getView();
+        view.onImageLoaded();
+        if (resource instanceof GifDrawable) {
+            // The `loop` prop, or the file's own loop count as on iOS. Glide
+            // loops every GIF forever by default (#651).
+            view.applyLoopCount((GifDrawable) resource);
+        }
+        if (!events) return false;
+        boolean local = !(model instanceof GlideUrl);
+        int[] size = FastImageSourceSize.get(resource, model, local,
+                dataSource == DataSource.RESOURCE_DISK_CACHE);
+        if (size != null) {
+            sendLoad(view, size);
+            return false;
+        }
+        // A local image whose size isn't known: read it from the image first,
+        // unless the view starts another load meanwhile.
+        final Request request = target.getRequest();
+        FastImageSourceSize.readLocal(view.getContext(), source, resource, model, new FastImageSourceSize.Callback() {
+            @Override
+            public void onSize(int[] size) {
+                if (target.getRequest() == request) sendLoad(view, size);
+            }
+        });
         return false;
     }
+
+    private static void sendLoad(FastImageViewWithUrl view, int[] size) {
+        WritableMap event = new WritableNativeMap();
+        event.putInt("width", size[0]);
+        event.putInt("height", size[1]);
+        FastImageEvents.send(view, REACT_ON_LOAD_EVENT, event);
+        FastImageEvents.send(view, REACT_ON_LOAD_END_EVENT);
+    }
 }

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

@@ -0,0 +1,21 @@
+package com.dylanvann.fastimage;
+
+import com.facebook.react.uimanager.LayoutShadowNode;
+import com.facebook.react.uimanager.UIViewOperationQueue;
+
+// Legacy architecture only. React Native only lays out a view when its frame
+// changes, so a view that stays 0×0 at its parent's origin is never laid out,
+// and Glide waits for its size forever (#865). When the computed size is zero,
+// tell the view, so it can lay itself out and load as it does on the New
+// Architecture. Remove with legacy architecture support.
+public class FastImageShadowNode extends LayoutShadowNode {
+    static final Object ZERO_LAYOUT = new Object();
+
+    @Override
+    public void onCollectExtraUpdates(UIViewOperationQueue uiViewOperationQueue) {
+        super.onCollectExtraUpdates(uiViewOperationQueue);
+        if (Math.round(getLayoutWidth()) == 0 && Math.round(getLayoutHeight()) == 0) {
+            uiViewOperationQueue.enqueueUpdateExtraData(getReactTag(), ZERO_LAYOUT);
+        }
+    }
+}

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

@@ -17,6 +17,7 @@ public class FastImageSource extends ImageSource {
     private static final String ANDROID_RESOURCE_SCHEME = "android.resource";
     private static final String ANDROID_CONTENT_SCHEME = "content";
     private static final String LOCAL_FILE_SCHEME = "file";
+    private static final String ASSET_SCHEME = "asset";
     private final Headers mHeaders;
     private Uri mUri;
 
@@ -40,6 +41,10 @@ public class FastImageSource extends ImageSource {
         return LOCAL_FILE_SCHEME.equals(uri.getScheme());
     }
 
+    public static boolean isAssetUri(Uri uri) {
+        return ASSET_SCHEME.equals(uri.getScheme());
+    }
+
     public FastImageSource(Context context, String source) {
         this(context, source, null);
     }
@@ -62,6 +67,12 @@ public class FastImageSource extends ImageSource {
             // glide can understand the uri.
             mUri = Uri.parse(mUri.toString().replace("res:/", ANDROID_RESOURCE_SCHEME + "://" + context.getPackageName() + "/"));
         }
+
+        if (isAssetUri(mUri) && mUri.getPath() != null) {
+            // Convert asset:/ (a file in the app's assets, as React Native's
+            // Image supports) to file:///android_asset/, which Glide loads.
+            mUri = Uri.parse(LOCAL_FILE_SCHEME + ":///android_asset" + mUri.getPath());
+        }
     }
 
 
@@ -106,7 +117,16 @@ public class FastImageSource extends ImageSource {
         return mHeaders;
     }
 
+    // Set for `cache: 'web'`.
+    private boolean mWebCache = false;
+
+    void setWebCache(boolean webCache) {
+        mWebCache = webCache;
+    }
+
     public GlideUrl getGlideUrl() {
-        return new GlideUrl(getUri().toString(), getHeaders());
+        return mWebCache
+                ? new FastImageWebGlideUrl(getUri().toString(), getHeaders())
+                : new GlideUrl(getUri().toString(), getHeaders());
     }
 }