react-native-fast-image 10.8.1 → 10.8.3

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

@@ -1,5 +1,8 @@
 package com.fastimage;
 
+import android.os.Handler;
+import android.os.Looper;
+
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.WritableMap;
@@ -15,6 +18,8 @@ final class FastImageEvents {
     static final int ERROR = 1 << 3;
     static final int LOAD_END = 1 << 4;
 
+    private static final Handler MAIN = new Handler(Looper.getMainLooper());
+
     private FastImageEvents() {
     }
 
@@ -57,8 +62,21 @@ final class FastImageEvents {
         send(view, FastImageRequestListener.REACT_ON_LOAD_END_EVENT, event);
     }
 
-    // Only the events JS has a handler for: most images have none.
+    // Only the events JS has a handler for: most images have none. Posted to
+    // the main thread rather than dispatched here: this is called from Glide's
+    // onResourceReady and onLoadFailed, and EventDispatcher calls its listeners
+    // inline. Reanimated's listener flushes pending mount items, which can
+    // drop this view, and the drop clears the request inside its own
+    // callback, which Glide doesn't allow (it throws). Every event goes through
+    // here, so they keep their order: e.g. a view's onProgress comes after its
+    // onLoadStart, even from progress the UI thread had waiting before the
+    // load started.
     static void send(FastImageViewWithUrl view, String name, WritableMap data) {
+        if (!view.handles(bit(name))) return;
+        MAIN.post(() -> dispatch(view, name, data));
+    }
+
+    private static void dispatch(FastImageViewWithUrl view, String name, WritableMap data) {
         if (!view.handles(bit(name))) return;
         ReactContext context = FastImageViewManager.getReactContext(view.getContext());
         if (context == null) return;

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

@@ -9,7 +9,6 @@ import android.content.Context;
 import android.content.ContextWrapper;
 import android.graphics.Bitmap;
 import android.graphics.PorterDuff;
-import android.util.Log;
 import android.graphics.Rect;
 import android.graphics.drawable.BitmapDrawable;
 import android.util.DisplayMetrics;
@@ -64,7 +63,6 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl>
     static final String REACT_CLASS = "FastImageView";
     static final String REACT_ON_LOAD_START_EVENT = "onFastImageLoadStart";
     static final String REACT_ON_PROGRESS_EVENT = "onFastImageProgress";
-    static final String LOG_TAG = "FastImage";
     // Download progress, by the key downloads are shared by
     // (FastImageSharedDownloads.key): the views that get it, those with an onProgress from
     // their load's onLoadStart to its onLoad or onError, and the latest step a
@@ -82,7 +80,7 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl>
     private static final class Progress {
         final Set<FastImageViewWithUrl> views = new LinkedHashSet<>();
         // A step waits to be sent: later ones replace it meanwhile, so a url
-        // has at most one post to the UI thread at a time.
+        // has at most one step waiting at a time.
         boolean posted;
         long loaded;
         long total;
@@ -504,10 +502,12 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl>
 
     // A download's progress (FastImageSharedDownloads), on its thread, which
     // only notes it if a view wants it (so downloads of images without an
-    // onProgress post nothing). It's sent from the UI thread, where
-    // views start and end their loads: a view only gets it during its own load,
-    // not after its onLoad or once it loads again, and progress posted during
-    // a download comes before the onLoad Glide posts after it.
+    // onProgress post nothing). The UI thread, where views start and end their
+    // loads, picks the views that take it, and posts it behind their other
+    // events (FastImageEvents.send): a view only gets it during its own load,
+    // after its onLoadStart, not after its onLoad or once it loads again, and
+    // progress posted during a download comes before the onLoad Glide posts
+    // after it.
     static void onDownloadProgress(final String key, long loaded, long total) {
         synchronized (PROGRESS) {
             Progress progress = PROGRESS.get(key);
@@ -554,14 +554,8 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl>
             event.putInt("total", (int) total);
             // Downloads only report a known length (see FastImageSharedDownloads).
             event.putDouble("progress", Math.min(1.0, Math.max(0.0, (double) loaded / total)));
-            try {
-                FastImageEvents.send(view, REACT_ON_PROGRESS_EVENT, event);
-            } catch (RuntimeException e) {
-                // E.g. the view's React instance is gone: progress isn't worth
-                // crashing the app for.
-                // (Not the key: it has the request's headers.)
-                Log.w(LOG_TAG, "Couldn't send onProgress", e);
-            }
+            // Posted after the view's onLoadStart, which may still be waiting.
+            FastImageEvents.send(view, REACT_ON_PROGRESS_EVENT, event);
         }
     }
 

package/package.json

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