react-native-fast-image 9.0.3 → 9.2.0

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

@@ -8,6 +8,7 @@ import android.app.Activity;
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.graphics.PorterDuff;
+import android.util.Log;
 
 import androidx.annotation.NonNull;
 
@@ -21,25 +22,53 @@ import com.facebook.react.common.MapBuilder;
 import com.facebook.react.uimanager.LayoutShadowNode;
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.PointerEvents;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.WeakHashMap;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
 
 import javax.annotation.Nullable;
 
-class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> implements FastImageProgressListener {
+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";
-    private static final Map<String, List<FastImageViewWithUrl>> VIEWS_FOR_URLS = new WeakHashMap<>();
+    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
+    // download reported, until the UI thread sends it. The UI thread adds and
+    // removes views, and downloads report steps on their own threads: only
+    // used under its lock.
+    private static final Map<String, Progress> PROGRESS = new HashMap<>();
+    // Numbers the steps downloads report, so a view can tell those reported
+    // before its load started (see FastImageViewWithUrl.takesProgress).
+    private static final AtomicLong REPORTED_STEPS = new AtomicLong();
+    // Whether any view gets progress (set under PROGRESS's lock), so downloads
+    // can skip reporting without taking any lock.
+    private static volatile boolean tracking = false;
+
+    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.
+        boolean posted;
+        long loaded;
+        long total;
+        long step;
+    }
 
     @NonNull
     @Override
@@ -143,10 +172,10 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         view.setPaused(paused);
     }
 
-    // Set when the image has an onProgress (see onProgress).
+    // Set when the image has an onProgress (see onDownloadProgress).
     @ReactProp(name = "trackProgress")
     public void setTrackProgress(FastImageViewWithUrl view, boolean trackProgress) {
-        view.trackProgress = trackProgress;
+        view.setTrackProgress(trackProgress);
     }
 
     @ReactProp(name = "resizeMode")
@@ -160,12 +189,9 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
 
     @Override
     public void onDropViewInstance(@NonNull FastImageViewWithUrl view) {
-        // This will cancel existing requests.
-        view.clearView(view.requestManager);
-
-        // Same key as when the view was tracked (toStringUrl, not toString,
-        // which differ for urls that need escaping).
-        view.untrackUrl(VIEWS_FOR_URLS);
+        // Cancels its request, and nothing loads or tracks progress for it
+        // any more (the progress map doesn't keep it, or its Activity).
+        view.drop();
 
         super.onDropViewInstance(view);
     }
@@ -181,26 +207,100 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
                 .build();
     }
 
-    // Sends the progress to the views loading the url that have an onProgress:
-    // the others would send an event to JS for every chunk, for nothing (and
-    // on the New Architecture each would log an unhandled event).
-    @Override
-    public void onProgress(String key, long bytesRead, long expectedLength) {
-        List<FastImageViewWithUrl> viewsForKey = VIEWS_FOR_URLS.get(key);
-        if (viewsForKey != null) {
-            for (FastImageViewWithUrl view : viewsForKey) {
-                if (!view.trackProgress) continue;
-                WritableMap event = new WritableNativeMap();
-                event.putInt("loaded", (int) bytesRead);
-                event.putInt("total", (int) expectedLength);
-                FastImageEvents.send(view, REACT_ON_PROGRESS_EVENT, event);
+    // On the UI thread (FastImageViewWithUrl's updateProgressTracking).
+    static void trackProgress(String key, FastImageViewWithUrl view) {
+        synchronized (PROGRESS) {
+            Progress progress = PROGRESS.get(key);
+            if (progress == null) {
+                progress = new Progress();
+                PROGRESS.put(key, progress);
             }
+            progress.views.add(view);
+            tracking = true;
         }
     }
 
-    @Override
-    public float getGranularityPercentage() {
-        return 0.5f;
+    // On the UI thread. A key's entry goes once it has no views.
+    static void untrackProgress(String key, FastImageViewWithUrl view) {
+        synchronized (PROGRESS) {
+            Progress progress = PROGRESS.get(key);
+            if (progress == null) return;
+            progress.views.remove(view);
+            if (progress.views.isEmpty()) PROGRESS.remove(key);
+            tracking = !PROGRESS.isEmpty();
+        }
+    }
+
+    // Whether any view gets progress now (a hint: a view can start loading
+    // just after).
+    static boolean wantsProgress() {
+        return tracking;
+    }
+
+    // The latest step downloads reported (for a load that starts now).
+    static long progressStep() {
+        return REPORTED_STEPS.get();
+    }
+
+    // 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.
+    static void onDownloadProgress(final String key, long loaded, long total) {
+        synchronized (PROGRESS) {
+            Progress progress = PROGRESS.get(key);
+            if (progress == null) return;
+            // While a post is waiting, it keeps the furthest step: another
+            // download of the key may report one behind it meanwhile. A step
+            // kept keeps its number, so a load that started after it (e.g. a
+            // reload, whose download reports behind it) doesn't take it.
+            if (!progress.posted || (double) loaded / total >= (double) progress.loaded / progress.total) {
+                progress.loaded = loaded;
+                progress.total = total;
+                progress.step = REPORTED_STEPS.incrementAndGet();
+            }
+            if (progress.posted) return;
+            progress.posted = true;
+        }
+        UiThreadUtil.runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                sendProgress(key);
+            }
+        });
+    }
+
+    private static void sendProgress(String key) {
+        List<FastImageViewWithUrl> views;
+        long loaded;
+        long total;
+        long step;
+        synchronized (PROGRESS) {
+            Progress progress = PROGRESS.get(key);
+            // Sent already, or no view wants it any more.
+            if (progress == null || !progress.posted) return;
+            progress.posted = false;
+            loaded = progress.loaded;
+            total = progress.total;
+            step = progress.step;
+            views = new ArrayList<>(progress.views);
+        }
+        for (FastImageViewWithUrl view : views) {
+            if (!view.takesProgress(step, loaded, total)) continue;
+            WritableMap event = new WritableNativeMap();
+            event.putInt("loaded", (int) loaded);
+            event.putInt("total", (int) 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);
+            }
+        }
     }
 
     private static boolean isValidContextForGlide(final Context context) {
@@ -269,6 +369,6 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
     @Override
     protected void onAfterUpdateTransaction(@NonNull FastImageViewWithUrl view) {
         super.onAfterUpdateTransaction(view);
-        view.onAfterUpdate(this, view.requestManager, VIEWS_FOR_URLS);
+        view.onAfterUpdate(this, view.requestManager);
     }
 }

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

@@ -1,6 +1,5 @@
 package com.dylanvann.fastimage;
 
-import android.app.Activity;
 import android.content.Context;
 import android.graphics.BitmapFactory;
 import android.graphics.drawable.Drawable;
@@ -226,8 +225,9 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
                         }
                     };
                     // A remote image is downloaded to the disk cache first,
-                    // so views that load it meanwhile can wait for the file
-                    // (FastImageSharedDownloads), then decoded from there.
+                    // then decoded from there. Views that load it meanwhile
+                    // share the download (FastImageSharedDownloads), and those
+                    // that get to downloading just after it ended read its file.
                     final boolean download = !imageSource.isWebCache() && imageSource.isRemote();
                     pendingPreloads.add(!download ? decode : new Runnable() {
                         @Override
@@ -268,16 +268,18 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
 
     // Downloads the image into Glide's disk cache without decoding it (if it
     // isn't there), then calls back with its file or the error, on the UI
-    // thread. For a preload (`shared`), views that load the image meanwhile
-    // wait for the download and read its file (FastImageSharedDownloads).
+    // thread. Views that load the image meanwhile share its download
+    // (FastImageSharedDownloads); for a preload (`shared`), those whose
+    // request gets to downloading just after it finished read its file.
     private static void loadFile(Context context, Object model, RequestOptions options, boolean shared, final FileCallback callback) {
-        final String key = shared && model instanceof FastImageUrl ? ((FastImageUrl) model).url.getCacheKey() : null;
+        final String key = shared && model instanceof FastImageUrl
+                ? FastImageSharedDownloads.key(((FastImageUrl) model).url)
+                : null;
         FastImageGlide.get(context);
         Glide.with(context)
                 .asFile()
                 .load(model)
                 .apply(options)
-                .set(FastImageSharedDownloads.PRELOAD, shared)
                 .listener(new RequestListener<File>() {
                     @Override
                     public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<File> target, boolean isFirstResource) {
@@ -566,32 +568,38 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         });
     }
 
+    // The cache functions use the app's context, not the current Activity's:
+    // there may be no Activity while JS runs (e.g. after Android destroyed it
+    // in the background). Glide clears its memory cache on the main thread.
     @ReactMethod
     public void clearMemoryCache(final Promise promise) {
-        final Activity activity = getCurrentActivity();
-        if (activity == null) {
-            promise.resolve(null);
-            return;
-        }
-
-        activity.runOnUiThread(new Runnable() {
+        final ReactApplicationContext context = getReactApplicationContext();
+        UiThreadUtil.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                FastImageGlide.get(activity.getApplicationContext()).clearMemory();
-                promise.resolve(null);
+                try {
+                    // Not before FastImage has used Glide: there's nothing of
+                    // its in memory, and starting Glide here would set its
+                    // disk cache size before a configureCache could.
+                    if (FastImageGlide.used()) Glide.get(context).clearMemory();
+                    promise.resolve(cleared());
+                } catch (RuntimeException e) {
+                    promise.resolve(failure(e));
+                }
             }
         });
     }
 
+    // On the native modules' thread: Glide clears its disk cache off the main
+    // thread.
     @ReactMethod
     public void clearDiskCache(Promise promise) {
-        final Activity activity = getCurrentActivity();
-        if (activity == null) {
-            promise.resolve(null);
+        try {
+            FastImageGlide.getRegistered(getReactApplicationContext()).clearDiskCache();
+        } catch (RuntimeException e) {
+            promise.resolve(failure(e));
             return;
         }
-
-        FastImageGlide.getRegistered(activity.getApplicationContext()).clearDiskCache();
         // And the HTTP cache of `cache: 'web'` images, which Glide doesn't
         // cache (set up when FastImage's components are registered).
         try {
@@ -599,6 +607,20 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         } catch (IOException e) {
             // Cleared as far as it could.
         }
-        promise.resolve(null);
+        promise.resolve(cleared());
+    }
+
+    private static WritableMap cleared() {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("ok", true);
+        return result;
+    }
+
+    // Glide failing to start, e.g. when an app's Glide module calls
+    // Glide.get() from registerComponents (#962): resolved as an error, not
+    // thrown, which would crash the app (on the main thread) or leave the
+    // promise unsettled.
+    private static WritableMap failure(RuntimeException e) {
+        return failure(e.getMessage() != null ? e.getMessage() : e.toString());
     }
 }

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

@@ -46,11 +46,6 @@ import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.uimanager.PointerEvents;
 import com.facebook.react.uimanager.ReactPointerEventsView;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
 import javax.annotation.Nonnull;
 
 class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEventsView {
@@ -58,7 +53,6 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     private ReadableMap mSource = null;
     private Drawable mDefaultSource = null;
 
-    public GlideUrl glideUrl;
     // Null when the view was created in a destroyed Activity (nothing loads).
     @Nullable
     final RequestManager requestManager;
@@ -108,8 +102,6 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     // What the last update was called with, to load once the view has a size.
     @Nullable
     private FastImageViewManager mManager;
-    @Nullable
-    private Map<String, List<FastImageViewWithUrl>> mViewsForUrlsMap;
 
     public void setSources(@Nullable ReadableArray sources) {
         mNeedsReload = true;
@@ -163,7 +155,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
         post(new Runnable() {
             @Override
             public void run() {
-                if (mNeedsReload && mManager != null) onAfterUpdate(mManager, requestManager, mViewsForUrlsMap);
+                if (mNeedsReload && mManager != null) onAfterUpdate(mManager, requestManager);
             }
         });
         return true;
@@ -214,8 +206,64 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
 
     // Pauses GIFs on the frame they're showing (the view's own animation).
     private boolean mPaused = false;
-    // Whether to send progress events (the image has an onProgress).
-    boolean trackProgress = false;
+    // Progress (see FastImageViewManager.onDownloadProgress): whether the image
+    // has an onProgress, the url its current load downloads (null for a local
+    // image, and once the load has ended), the progress key the view gets
+    // progress for (the loading url's, while it has an onProgress), the last
+    // step downloads reported before the load started, and the fraction the
+    // load has had.
+    private boolean mTrackProgress = false;
+    @Nullable
+    private GlideUrl mLoadingUrl;
+    @Nullable
+    private String mTrackedKey;
+    private long mProgressSince;
+    private double mProgressFraction;
+    // Dropped by React (FastImageViewManager.onDropViewInstance): reloads it
+    // posted to itself don't load anything, or track progress, any more.
+    private boolean mDropped = false;
+
+    void setTrackProgress(boolean trackProgress) {
+        mTrackProgress = trackProgress;
+        updateProgressTracking();
+    }
+
+    // The load ended (onLoad or onError), or the view no longer loads its
+    // source: no more progress, and the progress map no longer keeps the view
+    // (and its Activity) alive (#384).
+    void endProgress() {
+        mLoadingUrl = null;
+        updateProgressTracking();
+    }
+
+    void drop() {
+        mDropped = true;
+        clearView(requestManager);
+        endProgress();
+    }
+
+    // Whether a step a download reported is for the current load, and doesn't
+    // go back: one reported before it started is for an earlier load, e.g. of
+    // the same url before resizeMode changed, posted while that load still
+    // ran, and one below what the load has had is from another download of
+    // the key (e.g. one that started after the first had ended).
+    boolean takesProgress(long step, long loaded, long total) {
+        if (step <= mProgressSince) return false;
+        double fraction = (double) loaded / total;
+        if (fraction < mProgressFraction) return false;
+        mProgressFraction = fraction;
+        return true;
+    }
+
+    private void updateProgressTracking() {
+        String key = mTrackProgress && mLoadingUrl != null && !mDropped
+                ? FastImageSharedDownloads.key(mLoadingUrl)
+                : null;
+        if (key == null ? mTrackedKey == null : key.equals(mTrackedKey)) return;
+        if (mTrackedKey != null) FastImageViewManager.untrackProgress(mTrackedKey, this);
+        mTrackedKey = key;
+        if (key != null) FastImageViewManager.trackProgress(key, this);
+    }
 
     // The `transition` prop (from the next load): how long a loaded image
     // takes to fade in, in milliseconds (0 for no fade), whether it also fades
@@ -695,6 +743,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     // The loading image loaded (FastImageRequestListener).
     void onImageLoaded() {
         mLoadEnded = true;
+        endProgress();
         mShownRequest = mLoadingRequest;
         mShownWidth = mLoadingWidth;
         mShownHeight = mLoadingHeight;
@@ -734,7 +783,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     private boolean isResized() {
         int width = getWidth() - getPaddingLeft() - getPaddingRight();
         int height = getHeight() - getPaddingTop() - getPaddingBottom();
-        return requestManager != null && !mNeedsReload
+        return requestManager != null && !mDropped && !mNeedsReload
                 && mShownRequest != null && mShownRequest == mLoadingRequest
                 && mShownWidth > 0 && mShownHeight > 0 && width > 0 && height > 0
                 && (width != mShownWidth || height != mShownHeight);
@@ -752,7 +801,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
         clearView(requestManager);
         RequestBuilder<Drawable> builder = shown.clone()
                 .error(current.clone())
-                .listener(new FastImageRequestListener(null, null, true, false));
+                .listener(new FastImageRequestListener(null, true, false));
         if (meanwhile == null) builder = builder.thumbnail(current);
         into(shown, builder, meanwhile);
     }
@@ -776,7 +825,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
             clearView(requestManager);
             RequestBuilder<Drawable> builder = request.clone()
                     .error(current.clone())
-                    .listener(new FastImageRequestListener(null, null, true, false));
+                    .listener(new FastImageRequestListener(null, true, false));
             if (meanwhile == null) builder = builder.thumbnail(current);
             into(request, builder, meanwhile);
         } else if (mLoadingRequest != null && !mLoadEnded) {
@@ -848,6 +897,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     // defaultSource then, but not over a thumbnail: show it here, as iOS does.
     void onImageFailed(boolean hadThumbnail) {
         mLoadEnded = true;
+        endProgress();
         mShownRequest = null;
         if (!hadThumbnail) return;
         final int load = mLoadCount;
@@ -863,10 +913,9 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
     @SuppressLint("CheckResult")
     public void onAfterUpdate(
             @Nonnull FastImageViewManager manager,
-            @Nullable RequestManager requestManager,
-            @Nonnull Map<String, List<FastImageViewWithUrl>> viewsForUrlsMap) {
+            @Nullable RequestManager requestManager) {
+        if (mDropped) return;
         mManager = manager;
-        mViewsForUrlsMap = viewsForUrlsMap;
         if (mBlurChanged && !mNeedsReload) {
             mBlurChanged = false;
             reblur();
@@ -887,7 +936,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
                         if (!mWaitsForSize) return;
                         mWaitsForSize = false;
                         mWaitedForSize = true;
-                        onAfterUpdate(manager, requestManager, viewsForUrlsMap);
+                        onAfterUpdate(manager, requestManager);
                     }
                 });
                 return;
@@ -917,7 +966,7 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
             // Cancel existing requests.
             clearView(requestManager);
 
-            untrackUrl(viewsForUrlsMap);
+            endProgress();
 
             // Clear the image.
             setImageDrawable(null);
@@ -942,38 +991,33 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
             // Cancel existing requests.
             clearView(requestManager);
 
-            untrackUrl(viewsForUrlsMap);
+            endProgress();
             setImageDrawable(mDefaultSource);
             return;
         }
 
-        // `imageSource` may be null and we still continue, if `defaultSource` is not null
-        final GlideUrl glideUrl = imageSource == null ? null : imageSource.getGlideUrl();
-
-        String key = glideUrl == null ? null : glideUrl.toStringUrl();
-
-        // Loading a different url: stop tracking the old one.
-        if (this.glideUrl != null && !this.glideUrl.toStringUrl().equals(key)) {
-            untrackUrl(viewsForUrlsMap);
-        }
+        // `imageSource` may be null and we still continue, if `defaultSource` is not null.
+        // What Glide loads: a FastImageUrl for a remote image.
+        Object model = imageSource == null ? null : imageSource.getSourceForLoad();
 
         // Before the view clears (see shownCopy).
         Drawable meanwhile = shownRequest != null && imageSource != null ? shownCopy(shownRequest) : null;
 
         // Cancel existing request.
-        this.glideUrl = glideUrl;
         clearView(requestManager);
 
-        if (glideUrl != null) {
-            FastImageOkHttpProgressGlideModule.expect(key, manager);
-            List<FastImageViewWithUrl> viewsForKey = viewsForUrlsMap.get(key);
-            if (viewsForKey != null && !viewsForKey.contains(this)) {
-                viewsForKey.add(this);
-            } else if (viewsForKey == null) {
-                List<FastImageViewWithUrl> newViewsForKeys = new ArrayList<>(Collections.singletonList(this));
-                viewsForUrlsMap.put(key, newViewsForKeys);
-            }
+        // The url this load downloads, for its progress: a remote image's
+        // (without Glide, in a destroyed Activity, nothing loads).
+        mLoadingUrl = requestManager != null && model instanceof FastImageUrl
+                ? ((FastImageUrl) model).url
+                : null;
+        // A restart (reblur) is the same load: its progress doesn't go back,
+        // and steps already on their way to it still count.
+        if (!restarting) {
+            mProgressSince = FastImageViewManager.progressStep();
+            mProgressFraction = 0;
         }
+        updateProgressTracking();
 
         if (imageSource != null && !restarting) {
             // This is an orphan even without a load/loadend when only loading a placeholder
@@ -982,7 +1026,6 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
 
         if (requestManager != null) {
             // Records the image's own size when Glide decodes it, for onLoad.
-            Object model = imageSource == null ? null : imageSource.getSourceForLoad();
             RequestBuilder<Drawable> base =
                     requestManager
                             // This will make this work for remote and local images. e.g.
@@ -1019,31 +1062,13 @@ class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEve
                 builder = builder.thumbnail(fromCache(shownRequest));
             }
 
-            if (key != null)
-                builder.listener(new FastImageRequestListener(key, imageSource, thumbnail, true));
+            if (imageSource != null)
+                builder.listener(new FastImageRequestListener(imageSource, thumbnail, true));
 
             into(request, builder, meanwhile);
         }
     }
 
-    // Removes this view from the list of views for its current url (used to send
-    // progress events), which otherwise kept it, and its Activity, alive after
-    // its source changed (#384). The url's progress listener is only forgotten
-    // when no other view uses it.
-    void untrackUrl(@Nonnull Map<String, List<FastImageViewWithUrl>> viewsForUrlsMap) {
-        if (glideUrl == null) return;
-        String key = glideUrl.toStringUrl();
-        List<FastImageViewWithUrl> viewsForKey = viewsForUrlsMap.get(key);
-        if (viewsForKey != null) {
-            viewsForKey.remove(this);
-            if (viewsForKey.isEmpty()) viewsForUrlsMap.remove(key);
-        }
-        if (viewsForKey == null || viewsForKey.isEmpty()) {
-            FastImageOkHttpProgressGlideModule.forget(key);
-        }
-        glideUrl = null;
-    }
-
     public void clearView(@Nullable RequestManager requestManager) {
         // Glide keeps the view's request under its own tag id, not getTag().
         // Without a request this does nothing.

package/dist/index.cjs.js

@@ -245,8 +245,8 @@ FastImage.preload = (sources) => Promise.resolve(react_native.NativeModules.Fast
 		uri
 	};
 }));
-FastImage.clearMemoryCache = () => react_native.NativeModules.FastImageView.clearMemoryCache();
-FastImage.clearDiskCache = () => react_native.NativeModules.FastImageView.clearDiskCache();
+FastImage.clearMemoryCache = () => Promise.resolve(react_native.NativeModules.FastImageView.clearMemoryCache());
+FastImage.clearDiskCache = () => Promise.resolve(react_native.NativeModules.FastImageView.clearDiskCache());
 FastImage.configureCache = (limits = {}) => Promise.resolve(react_native.NativeModules.FastImageView.configureCache(limits));
 FastImage.writeToCache = (source, file) => Array.isArray(source) ? Promise.resolve({
 	ok: false,

package/dist/index.cjs.js.flow

@@ -73,6 +73,8 @@ export type CachePathResult =
     | {| ok: true, path: string |}
     | {| ok: false, error: string |}
 
+export type ClearCacheResult = {| ok: true |} | {| ok: false, error: string |}
+
 export type Transition = $ReadOnly<{|
     duration?: ?number,
     betweenImages?: ?boolean,
@@ -147,8 +149,8 @@ declare export default class FastImage extends React$Component<FastImageProps> {
     static priority: Priority;
     static cacheControl: CacheControl;
     static preload: PreloadFn;
-    static clearMemoryCache: () => Promise<void>;
-    static clearDiskCache: () => Promise<void>;
+    static clearMemoryCache: () => Promise<ClearCacheResult>;
+    static clearDiskCache: () => Promise<ClearCacheResult>;
     static getCachePath: (source: FastImageSource) => Promise<CachePathResult>;
     static configureCache: (limits?: CacheLimits) => Promise<CacheState>;
     static writeToCache: (

package/dist/index.cjs.web.js

@@ -239,8 +239,8 @@ FastImage.preload = (sources) => Promise.all(sources.map((source) => {
 		uri
 	}));
 }));
-FastImage.clearMemoryCache = () => Promise.resolve();
-FastImage.clearDiskCache = () => Promise.resolve();
+FastImage.clearMemoryCache = () => Promise.resolve(notSupported);
+FastImage.clearDiskCache = () => Promise.resolve(notSupported);
 FastImage.configureCache = () => Promise.resolve({});
 FastImage.writeToCache = () => Promise.resolve(notSupported);
 FastImage.getCachePath = () => Promise.resolve(notSupported);