react-native-fast-image 9.0.2 → 9.1.0

package/README.md

@@ -539,15 +539,15 @@ await FastImage.preload(photos.map((uri) => ({ uri, memoryCache: false })))
 
 ### `clearMemoryCache()`
 
-**Returns:** `Promise<void>`
+**Returns:** `Promise<ClearCacheResult>`
 
-Removes every image from the memory cache, e.g. to free memory. They're decoded from the disk cache again when they're next shown.
+Removes every image from the memory cache, e.g. to free memory. They're decoded from the disk cache again when they're next shown. Resolves with `{ ok: true }` once it's done, or `{ ok: false, error }` if it couldn't (Android: Glide failed to start). Never rejects. On the web, it does nothing (the browser manages its cache) and resolves with an error.
 
 ### `clearDiskCache()`
 
-**Returns:** `Promise<void>`
+**Returns:** `Promise<ClearCacheResult>`
 
-Removes every image from the disk cache, including the HTTP cache of `cache: 'web'` images, e.g. when a user logs out. They're downloaded again when they're next shown. There's no way to remove a single image: to load one again after it changed, change its [`cacheKey`](#sourcecachekey).
+Removes every image from the disk cache, including the HTTP cache of `cache: 'web'` images, e.g. when a user logs out. They're downloaded again when they're next shown. There's no way to remove a single image: to load one again after it changed, change its [`cacheKey`](#sourcecachekey). Resolves like `clearMemoryCache`.
 
 ### `getCachePath(source)`
 
@@ -668,6 +668,14 @@ How fresh an image must be: see [`source.cache`](#sourcecache).
 
 ---
 
+### `ClearCacheResult`
+
+**Type:** `{ ok: true } | { ok: false; error: string }`
+
+`clearMemoryCache`'s and `clearDiskCache`'s result: `ok` once the cache is cleared, or not `ok` with the error.
+
+---
+
 ### `LoadResult`
 
 **Type:** `{ ok: true; width: number; height: number } | { ok: false; error: string }`

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

@@ -37,6 +37,13 @@ final class FastImageGlide {
         registered = glide;
     }
 
+    // Whether Glide has started with FastImage's AppGlideModule or has
+    // FastImage's components: until then, none of FastImage's images are in
+    // its memory cache.
+    static boolean used() {
+        return appModule || registered != null;
+    }
+
     // 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

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

@@ -23,10 +23,12 @@ import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.bridge.ReactContext;
 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.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.WeakHashMap;
 
@@ -82,6 +84,16 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
                         .getResourceDrawable(view.getContext(), source));
     }
 
+    // React Native's View manager handles pointerEvents; a SimpleViewManager
+    // doesn't. Parsed here: PointerEvents.parsePointerEvents isn't in every
+    // supported React Native version.
+    @ReactProp(name = "pointerEvents")
+    public void setPointerEvents(FastImageViewWithUrl view, @Nullable String pointerEvents) {
+        view.setPointerEvents(pointerEvents == null
+                ? PointerEvents.AUTO
+                : PointerEvents.valueOf(pointerEvents.toUpperCase(Locale.US).replace('-', '_')));
+    }
+
     @ReactProp(name = "tintColor", customType = "Color")
     public void setTintColor(FastImageViewWithUrl view, @Nullable Integer color) {
         if (color == null) {

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;
@@ -566,32 +565,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 +604,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

@@ -43,6 +43,8 @@ import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 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;
@@ -51,7 +53,7 @@ import java.util.Map;
 
 import javax.annotation.Nonnull;
 
-class FastImageViewWithUrl extends AppCompatImageView {
+class FastImageViewWithUrl extends AppCompatImageView implements ReactPointerEventsView {
     private boolean mNeedsReload = false;
     private ReadableMap mSource = null;
     private Drawable mDefaultSource = null;
@@ -66,6 +68,20 @@ class FastImageViewWithUrl extends AppCompatImageView {
         this.requestManager = requestManager;
     }
 
+    // FastImage sends "none" when it has pointerEvents="box-none" (the image
+    // is part of the box, which doesn't take touches). React Native's touch
+    // handling only reads pointerEvents from a ReactPointerEventsView.
+    private PointerEvents mPointerEvents = PointerEvents.AUTO;
+
+    @Override
+    public PointerEvents getPointerEvents() {
+        return mPointerEvents;
+    }
+
+    void setPointerEvents(PointerEvents pointerEvents) {
+        mPointerEvents = pointerEvents;
+    }
+
     public void setSource(@Nullable ReadableMap source) {
         mNeedsReload = true;
         mPropSource = source;

package/dist/index.cjs.js

@@ -111,13 +111,31 @@ function withoutCache(source) {
 	const { cache: _cache, ...rest } = source || {};
 	return rest;
 }
-function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgress, onLoad, onError, onLoadEnd, style, fallback, children, resizeMode = "cover", loop, transition, forwardedRef, onLayout, pointerEvents, ...viewProps }) {
+function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgress, onLoad, onError, onLoadEnd, style, fallback, children, resizeMode = "cover", loop, transition, forwardedRef, onLayout, pointerEvents, hitSlop, onStartShouldSetResponder, onStartShouldSetResponderCapture, onMoveShouldSetResponder, onMoveShouldSetResponderCapture, onResponderGrant, onResponderReject, onResponderStart, onResponderMove, onResponderEnd, onResponderRelease, onResponderTerminationRequest, onResponderTerminate, onTouchStart, onTouchMove, onTouchEnd, onTouchCancel, onTouchEndCapture, ...viewProps }) {
 	const { onClick, ...props } = viewProps;
 	const fallbackResult = (0, react.useRef)(void 0);
 	const wrapperProps = {
 		onLayout,
 		onClick,
-		pointerEvents
+		pointerEvents,
+		hitSlop,
+		onStartShouldSetResponder,
+		onStartShouldSetResponderCapture,
+		onMoveShouldSetResponder,
+		onMoveShouldSetResponderCapture,
+		onResponderGrant,
+		onResponderReject,
+		onResponderStart,
+		onResponderMove,
+		onResponderEnd,
+		onResponderRelease,
+		onResponderTerminationRequest,
+		onResponderTerminate,
+		onTouchStart,
+		onTouchMove,
+		onTouchEnd,
+		onTouchCancel,
+		onTouchEndCapture
 	};
 	const imageProps = {
 		...props,
@@ -227,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);

package/dist/index.cjs.web.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.d.ts

@@ -208,6 +208,16 @@ export type CachePathResult = {
     ok: false;
     error: string;
 };
+/**
+ * `clearMemoryCache`'s and `clearDiskCache`'s result: `ok` once the cache is
+ * cleared, or not `ok` with the error.
+ */
+export type ClearCacheResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
 /**
  * `onProgress`'s event: `nativeEvent` has the bytes `loaded` and the `total`,
  * and `progress`, `loaded / total` from 0 to 1.
@@ -529,8 +539,18 @@ export interface FastImageStaticProperties {
     priority: typeof priority;
     cacheControl: typeof cacheControl;
     preload: (sources: Source[]) => Promise<PreloadResult[]>;
-    clearMemoryCache: () => Promise<void>;
-    clearDiskCache: () => Promise<void>;
+    /**
+     * Removes every image from the memory cache. Resolves once it's done, or
+     * not `ok` with the error if it couldn't (Android: Glide failed to
+     * start). Never rejects.
+     */
+    clearMemoryCache: () => Promise<ClearCacheResult>;
+    /**
+     * Removes every image from the disk cache, and the HTTP cache of
+     * `cache: 'web'` images. Resolves once it's done, or not `ok` with the
+     * error if it couldn't (Android: Glide failed to start). Never rejects.
+     */
+    clearDiskCache: () => Promise<ClearCacheResult>;
     /**
      * The path of the source's downloaded file in the disk cache, downloading
      * it first if it isn't there (without decoding it). With
@@ -550,10 +570,14 @@ export interface FastImageStaticProperties {
     /**
      * Changes the cache's limits at runtime (only those given; 0 for no
      * limit, null to go back to the app's native config) and saves them, then
-     * resolves with the limits in effect and the disk cache's size. Without
-     * limits, only resolves. iOS applies changes at once. Android only has
-     * `maxDiskSize`, applied when Glide starts: at once if no image has
-     * loaded yet, otherwise from the next launch.
+     * resolves with the limits in effect and the disk cache's size; without
+     * limits, it only resolves with them. iOS applies changes at once.
+     * Android only has `maxDiskSize`, applied when Glide starts: at once if
+     * it hasn't started yet in this launch, otherwise from the next launch.
+     * FastImage starts it when its first view is created (before the view has
+     * a source), and for `preload`, `getCachePath`, `writeToCache`,
+     * `clearDiskCache` and `configureCache` itself, even without limits (e.g.
+     * to read the disk cache's size).
      */
     configureCache: (limits?: CacheLimits) => Promise<CacheState>;
 }

package/dist/index.js

@@ -84,13 +84,31 @@ function withoutCache(source) {
 	const { cache: _cache, ...rest } = source || {};
 	return rest;
 }
-function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgress, onLoad, onError, onLoadEnd, style, fallback, children, resizeMode = "cover", loop, transition, forwardedRef, onLayout, pointerEvents, ...viewProps }) {
+function FastImageBase({ source, defaultSource, tintColor, onLoadStart, onProgress, onLoad, onError, onLoadEnd, style, fallback, children, resizeMode = "cover", loop, transition, forwardedRef, onLayout, pointerEvents, hitSlop, onStartShouldSetResponder, onStartShouldSetResponderCapture, onMoveShouldSetResponder, onMoveShouldSetResponderCapture, onResponderGrant, onResponderReject, onResponderStart, onResponderMove, onResponderEnd, onResponderRelease, onResponderTerminationRequest, onResponderTerminate, onTouchStart, onTouchMove, onTouchEnd, onTouchCancel, onTouchEndCapture, ...viewProps }) {
 	const { onClick, ...props } = viewProps;
 	const fallbackResult = useRef(void 0);
 	const wrapperProps = {
 		onLayout,
 		onClick,
-		pointerEvents
+		pointerEvents,
+		hitSlop,
+		onStartShouldSetResponder,
+		onStartShouldSetResponderCapture,
+		onMoveShouldSetResponder,
+		onMoveShouldSetResponderCapture,
+		onResponderGrant,
+		onResponderReject,
+		onResponderStart,
+		onResponderMove,
+		onResponderEnd,
+		onResponderRelease,
+		onResponderTerminationRequest,
+		onResponderTerminate,
+		onTouchStart,
+		onTouchMove,
+		onTouchEnd,
+		onTouchCancel,
+		onTouchEndCapture
 	};
 	const imageProps = {
 		...props,
@@ -200,8 +218,8 @@ FastImage.preload = (sources) => Promise.resolve(NativeModules.FastImageView.pre
 		uri
 	};
 }));
-FastImage.clearMemoryCache = () => NativeModules.FastImageView.clearMemoryCache();
-FastImage.clearDiskCache = () => NativeModules.FastImageView.clearDiskCache();
+FastImage.clearMemoryCache = () => Promise.resolve(NativeModules.FastImageView.clearMemoryCache());
+FastImage.clearDiskCache = () => Promise.resolve(NativeModules.FastImageView.clearDiskCache());
 FastImage.configureCache = (limits = {}) => Promise.resolve(NativeModules.FastImageView.configureCache(limits));
 FastImage.writeToCache = (source, file) => Array.isArray(source) ? Promise.resolve({
 	ok: false,

package/dist/index.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.web.js

@@ -212,8 +212,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);

package/dist/index.web.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/ios/FastImage/FFFastImageViewManager.m

@@ -467,7 +467,7 @@ RCT_EXPORT_METHOD(configureCache:(NSDictionary *)limits
 RCT_EXPORT_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
 {
     [SDImageCache.sharedImageCache clearMemory];
-    resolve(NULL);
+    resolve(@{@"ok": @YES});
 }
 
 RCT_EXPORT_METHOD(clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject)
@@ -475,7 +475,7 @@ RCT_EXPORT_METHOD(clearDiskCache:(RCTPromiseResolveBlock)resolve reject:(RCTProm
     // And the HTTP cache of `cache: 'web'` images.
     [FFFastImageSource.webURLCache removeAllCachedResponses];
     [SDImageCache.sharedImageCache clearDiskOnCompletion:^(){
-        resolve(NULL);
+        resolve(@{@"ok": @YES});
     }];
 }
 

package/package.json

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