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

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

@@ -0,0 +1,237 @@
+package com.dylanvann.fastimage;
+
+import android.content.Context;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Base64;
+import android.util.LruCache;
+import android.widget.ImageView;
+
+import androidx.annotation.Nullable;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.load.ImageHeaderParserUtils;
+import com.bumptech.glide.load.resource.bitmap.DownsampleStrategy;
+import com.bumptech.glide.load.resource.gif.GifDrawable;
+import com.bumptech.glide.request.RequestOptions;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.ByteBuffer;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+// Works out an image's own size for onLoad, as iOS reports it (#608). Glide
+// decodes images to fit the view, so the loaded drawable is usually smaller
+// than the image.
+final class FastImageSourceSize {
+    // Sizes of recently decoded images, for loads from the memory cache, which
+    // don't decode.
+    private static final LruCache<String, int[]> SIZES = new LruCache<>(500);
+    private static final Executor EXECUTOR = Executors.newSingleThreadExecutor();
+    private static final Handler MAIN = new Handler(Looper.getMainLooper());
+
+    private FastImageSourceSize() {
+    }
+
+    // Wraps the downsample strategy Glide would use, to record the image's
+    // size (after EXIF rotation) when Glide decodes it. Views loading the same
+    // image at the same size share one decode, which uses the first view's
+    // options, so the size is recorded by image rather than by request.
+    static final class Capture extends DownsampleStrategy {
+        private final DownsampleStrategy strategy;
+        private final String key;
+        private boolean recorded;
+
+        Capture(DownsampleStrategy strategy, String key) {
+            this.strategy = strategy;
+            this.key = key;
+        }
+
+        @Override
+        public float getScaleFactor(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            // Called again with the sampled size; the first call has the image's.
+            if (!recorded) {
+                recorded = true;
+                SIZES.put(key, new int[]{sourceWidth, sourceHeight});
+            }
+            return strategy.getScaleFactor(sourceWidth, sourceHeight, requestedWidth, requestedHeight);
+        }
+
+        @Override
+        public SampleSizeRounding getSampleSizeRounding(int sourceWidth, int sourceHeight, int requestedWidth, int requestedHeight) {
+            return strategy.getSampleSizeRounding(sourceWidth, sourceHeight, requestedWidth, requestedHeight);
+        }
+
+        // Glide's memory cache keys include the strategy, so match the wrapped
+        // one to keep sharing cached images between views.
+        @Override
+        public boolean equals(Object o) {
+            return o instanceof Capture && ((Capture) o).strategy.equals(strategy);
+        }
+
+        @Override
+        public int hashCode() {
+            return strategy.hashCode();
+        }
+    }
+
+    // What RequestBuilder.into(ImageView) applies for the view's scale type
+    // (it leaves a transformation that's already set alone), with the
+    // downsample strategy it implies wrapped by capture.
+    static RequestOptions scaleTypeOptions(@Nullable ImageView.ScaleType scaleType, Capture capture) {
+        RequestOptions options = new RequestOptions();
+        if (scaleType != null) {
+            switch (scaleType) {
+                case CENTER_CROP:
+                    options = options.optionalCenterCrop();
+                    break;
+                case CENTER_INSIDE:
+                case FIT_XY:
+                    options = options.optionalCenterInside();
+                    break;
+                case FIT_CENTER:
+                case FIT_START:
+                case FIT_END:
+                    options = options.optionalFitCenter();
+                    break;
+                default:
+                    break;
+            }
+        }
+        return options.downsample(capture);
+    }
+
+    static Capture capture(@Nullable ImageView.ScaleType scaleType, Object model) {
+        return new Capture(strategy(scaleType), String.valueOf(model));
+    }
+
+    private static DownsampleStrategy strategy(@Nullable ImageView.ScaleType scaleType) {
+        if (scaleType == null) return DownsampleStrategy.DEFAULT;
+        switch (scaleType) {
+            case CENTER_CROP:
+                return DownsampleStrategy.CENTER_OUTSIDE;
+            case CENTER_INSIDE:
+            case FIT_XY:
+                return DownsampleStrategy.CENTER_INSIDE;
+            case FIT_CENTER:
+            case FIT_START:
+            case FIT_END:
+                return DownsampleStrategy.FIT_CENTER;
+            default:
+                return DownsampleStrategy.DEFAULT;
+        }
+    }
+
+    // The image's size, or null when it has to be read from a local image's
+    // header first (see readLocal).
+    @Nullable
+    static int[] get(Drawable resource, Object model, boolean local, boolean fromResourceCache) {
+        String key = String.valueOf(model);
+        if (resource instanceof GifDrawable) {
+            // Glide decodes GIFs itself (sampled to fit the view), without the
+            // downsample strategy; their header has the size.
+            int[] size = gifSize((GifDrawable) resource);
+            if (size != null) return size;
+        } else if (fromResourceCache) {
+            // Glide caches local images already resized for the view, and the
+            // decode from there recorded the resized size.
+            SIZES.remove(key);
+            return null;
+        } else {
+            int[] size = SIZES.get(key);
+            if (size != null) return size;
+            if (local) return null;
+        }
+        return new int[]{resource.getIntrinsicWidth(), resource.getIntrinsicHeight()};
+    }
+
+    @Nullable
+    private static int[] gifSize(GifDrawable gif) {
+        ByteBuffer buffer = gif.getBuffer();
+        if (buffer == null || buffer.limit() < 10) return null;
+        // The logical screen width and height (little-endian) follow the
+        // 6-byte signature.
+        int width = (buffer.get(6) & 0xff) | (buffer.get(7) & 0xff) << 8;
+        int height = (buffer.get(8) & 0xff) | (buffer.get(9) & 0xff) << 8;
+        return new int[]{width, height};
+    }
+
+    interface Callback {
+        void onSize(int[] size);
+    }
+
+    // Reads a local image's size from its header, off the main thread.
+    static void readLocal(Context context, final FastImageSource source, final Drawable resource, final Object model, final Callback callback) {
+        final Context appContext = context.getApplicationContext();
+        EXECUTOR.execute(new Runnable() {
+            @Override
+            public void run() {
+                int[] size = readBounds(appContext, source);
+                if (size != null) {
+                    SIZES.put(String.valueOf(model), size);
+                } else {
+                    size = new int[]{resource.getIntrinsicWidth(), resource.getIntrinsicHeight()};
+                }
+                final int[] result = size;
+                MAIN.post(new Runnable() {
+                    @Override
+                    public void run() {
+                        callback.onSize(result);
+                    }
+                });
+            }
+        });
+    }
+
+    @Nullable
+    private static int[] readBounds(Context context, FastImageSource source) {
+        try {
+            BitmapFactory.Options options = new BitmapFactory.Options();
+            options.inJustDecodeBounds = true;
+            InputStream stream = open(context, source);
+            try {
+                BitmapFactory.decodeStream(stream, null, options);
+            } finally {
+                stream.close();
+            }
+            if (options.outWidth <= 0 || options.outHeight <= 0) return null;
+            int orientation;
+            stream = open(context, source);
+            try {
+                Glide glide = Glide.get(context);
+                orientation = ImageHeaderParserUtils.getOrientation(
+                        glide.getRegistry().getImageHeaderParsers(), stream, glide.getArrayPool());
+            } finally {
+                stream.close();
+            }
+            // EXIF orientations 5 to 8 rotate by 90 or 270 degrees.
+            boolean rotated = orientation >= 5 && orientation <= 8;
+            return rotated
+                    ? new int[]{options.outHeight, options.outWidth}
+                    : new int[]{options.outWidth, options.outHeight};
+        } catch (IOException | RuntimeException e) {
+            return null;
+        }
+    }
+
+    private static InputStream open(Context context, FastImageSource source) throws IOException {
+        if (source.isBase64Resource()) {
+            String data = source.getSource();
+            byte[] bytes = Base64.decode(data.substring(data.indexOf(',') + 1), Base64.DEFAULT);
+            return new ByteArrayInputStream(bytes);
+        }
+        Uri uri = source.getUri();
+        String path = uri.getPath();
+        if ("file".equals(uri.getScheme()) && path != null && path.startsWith("/android_asset/")) {
+            return context.getAssets().open(path.substring("/android_asset/".length()));
+        }
+        InputStream stream = context.getContentResolver().openInputStream(uri);
+        if (stream == null) throw new IOException("Can't open " + uri);
+        return stream;
+    }
+}

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

@@ -50,12 +50,20 @@ class FastImageViewConverter {
                 put("center", ScaleType.CENTER_INSIDE);
             }};
 
+    // Whether the source has a uri to load (not null, missing or blank).
+    static boolean hasUri(@Nullable ReadableMap source) {
+        if (source == null || !source.hasKey("uri") || source.isNull("uri")) return false;
+        String uri = source.getString("uri");
+        return uri != null && !uri.trim().isEmpty();
+    }
+
     // Resolve the source uri to a file path that android understands.
     static @Nullable
     FastImageSource getImageSource(Context context, @Nullable ReadableMap source) {
-        return source == null
-                ? null
-                : new FastImageSource(context, source.getString("uri"), getHeaders(source));
+        if (source == null) return null;
+        FastImageSource imageSource = new FastImageSource(context, source.getString("uri"), getHeaders(source));
+        imageSource.setWebCache(getCacheControl(source) == FastImageCacheControl.WEB);
+        return imageSource;
     }
 
     static Headers getHeaders(ReadableMap source) {
@@ -79,7 +87,7 @@ class FastImageViewConverter {
         return headers;
     }
 
-    static RequestOptions getOptions(Context context, FastImageSource imageSource, ReadableMap source) {
+    static RequestOptions getOptions(Context context, @Nullable FastImageSource imageSource, @Nullable ReadableMap source) {
         // Get priority.
         final Priority priority = FastImageViewConverter.getPriority(source);
         // Get cache control method.
@@ -108,7 +116,8 @@ class FastImageViewConverter {
                 .priority(priority)
                 .placeholder(TRANSPARENT_DRAWABLE);
 
-        if (imageSource.isResource()) {
+        // imageSource is null when only a defaultSource is shown.
+        if (imageSource != null && imageSource.isResource()) {
             // Every local resource (drawable) in Android has its own unique numeric id, which are
             // generated at build time. Although these ids are unique, they are not guaranteed unique
             // across builds. The underlying glide implementation caches these resources. To make

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

@@ -18,10 +18,11 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 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.uimanager.ThemedReactContext;
 import com.facebook.react.uimanager.annotations.ReactProp;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
 import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper;
 
 import java.util.List;
@@ -37,9 +38,6 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
     static final String REACT_ON_PROGRESS_EVENT = "onFastImageProgress";
     private static final Map<String, List<FastImageViewWithUrl>> VIEWS_FOR_URLS = new WeakHashMap<>();
 
-    @Nullable
-    private RequestManager requestManager = null;
-
     @NonNull
     @Override
     public String getName() {
@@ -49,11 +47,20 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
     @NonNull
     @Override
     protected FastImageViewWithUrl createViewInstance(@NonNull ThemedReactContext reactContext) {
+        // Each view keeps the RequestManager for its own Activity. A single one
+        // 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;
         if (isValidContextForGlide(reactContext)) {
             requestManager = Glide.with(reactContext);
+        } else if (getActivityFromContext(reactContext) == null) {
+            // Not in an Activity (e.g. a root view created with the application
+            // context): load with the application context, instead of leaving
+            // requestManager null and never loading (#520).
+            requestManager = Glide.with(reactContext.getApplicationContext());
         }
 
-        return new FastImageViewWithUrl(reactContext);
+        return new FastImageViewWithUrl(reactContext, requestManager);
     }
 
     @ReactProp(name = "source")
@@ -77,26 +84,40 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         }
     }
 
+    @ReactProp(name = "recyclingKey")
+    public void setRecyclingKey(FastImageViewWithUrl view, @Nullable String recyclingKey) {
+        view.setRecyclingKey(recyclingKey);
+    }
+
+    @ReactProp(name = "loopCount", defaultInt = -1)
+    public void setLoopCount(FastImageViewWithUrl view, int loopCount) {
+        view.setLoopCount(loopCount);
+    }
+
+    @ReactProp(name = "imageRendering")
+    public void setImageRendering(FastImageViewWithUrl view, @Nullable String imageRendering) {
+        view.setImageRendering(imageRendering);
+    }
+
+    @ReactProp(name = "paused")
+    public void setPaused(FastImageViewWithUrl view, boolean paused) {
+        view.setPaused(paused);
+    }
+
     @ReactProp(name = "resizeMode")
     public void setResizeMode(FastImageViewWithUrl view, String resizeMode) {
         final FastImageViewWithUrl.ScaleType scaleType = FastImageViewConverter.getScaleType(resizeMode);
-        view.setScaleType(scaleType);
+        view.setResizeMode(scaleType);
     }
 
     @Override
     public void onDropViewInstance(@NonNull FastImageViewWithUrl view) {
         // This will cancel existing requests.
-        view.clearView(requestManager);
-
-        if (view.glideUrl != null) {
-            final String key = view.glideUrl.toString();
-            FastImageOkHttpProgressGlideModule.forget(key);
-            List<FastImageViewWithUrl> viewsForKey = VIEWS_FOR_URLS.get(key);
-            if (viewsForKey != null) {
-                viewsForKey.remove(view);
-                if (viewsForKey.size() == 0) VIEWS_FOR_URLS.remove(key);
-            }
-        }
+        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);
 
         super.onDropViewInstance(view);
     }
@@ -120,10 +141,7 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
                 WritableMap event = new WritableNativeMap();
                 event.putInt("loaded", (int) bytesRead);
                 event.putInt("total", (int) expectedLength);
-                ThemedReactContext context = (ThemedReactContext) view.getContext();
-                RCTEventEmitter eventEmitter = context.getJSModule(RCTEventEmitter.class);
-                int viewId = view.getId();
-                eventEmitter.receiveEvent(viewId, REACT_ON_PROGRESS_EVENT, event);
+                FastImageEvents.send(view, REACT_ON_PROGRESS_EVENT, event);
             }
         }
     }
@@ -143,6 +161,20 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
         return !isActivityDestroyed(activity);
     }
 
+    // A view's context is the ThemedReactContext it was created with, but below
+    // Android 5 (API 21) AppCompatImageView wraps it in a TintContextWrapper, so
+    // it can't be cast directly (#840). Unwrap until the ReactContext.
+    @Nullable
+    static ReactContext getReactContext(Context context) {
+        while (context instanceof ContextWrapper) {
+            if (context instanceof ReactContext) {
+                return (ReactContext) context;
+            }
+            context = ((ContextWrapper) context).getBaseContext();
+        }
+        return null;
+    }
+
     private static Activity getActivityFromContext(final Context context) {
         if (context instanceof Activity) {
             return (Activity) context;
@@ -175,9 +207,21 @@ class FastImageViewManager extends SimpleViewManager<FastImageViewWithUrl> imple
 
     }
 
+    // Legacy architecture only; the New Architecture doesn't use shadow nodes.
+    @NonNull
+    @Override
+    public LayoutShadowNode createShadowNodeInstance() {
+        return new FastImageShadowNode();
+    }
+
+    @Override
+    public void updateExtraData(@NonNull FastImageViewWithUrl view, Object extraData) {
+        if (extraData == FastImageShadowNode.ZERO_LAYOUT) view.onZeroLayout();
+    }
+
     @Override
     protected void onAfterUpdateTransaction(@NonNull FastImageViewWithUrl view) {
         super.onAfterUpdateTransaction(view);
-        view.onAfterUpdate(this, requestManager, VIEWS_FOR_URLS);
+        view.onAfterUpdate(this, view.requestManager, VIEWS_FOR_URLS);
     }
 }

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

@@ -1,18 +1,30 @@
 package com.dylanvann.fastimage;
 
 import android.app.Activity;
+import android.graphics.drawable.Drawable;
 
 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 
 import com.bumptech.glide.Glide;
-import com.bumptech.glide.load.model.GlideUrl;
+import com.bumptech.glide.Priority;
+import com.bumptech.glide.load.DataSource;
+import com.bumptech.glide.load.engine.GlideException;
+import com.bumptech.glide.request.RequestListener;
+import com.bumptech.glide.request.RequestOptions;
+import com.bumptech.glide.request.target.Target;
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
-import com.facebook.react.views.imagehelper.ImageSource;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.ArrayDeque;
 
 class FastImageViewModule extends ReactContextBaseJavaModule {
 
@@ -28,36 +40,130 @@ class FastImageViewModule extends ReactContextBaseJavaModule {
         return REACT_CLASS;
     }
 
+    // At most this many preloaded sources load at a time, across all preload
+    // calls (the same as SDWebImagePrefetcher's default on iOS), so a long
+    // list doesn't queue hundreds of requests ahead of the images the app is
+    // showing (Glide's executors run requests in order within a priority).
+    private static final int PRELOAD_LIMIT = 3;
+    // Preloads waiting to start, in the order they were added, and the number
+    // loading. Only used on the UI thread (Glide calls its listeners there).
+    private static final ArrayDeque<Runnable> pendingPreloads = new ArrayDeque<>();
+    private static int preloadsInFlight = 0;
+
+    // Starts pending preloads while there's room. A listener calls it again,
+    // sometimes from inside run() (Glide reports a memory-cached image
+    // synchronously from preload()). That's fine: the counters are shared and
+    // updated before each run(), so the inner call starts what fits, and the
+    // outer loop sees the updated counters when it checks again.
+    private static void startPendingPreloads() {
+        while (preloadsInFlight < PRELOAD_LIMIT && !pendingPreloads.isEmpty()) {
+            preloadsInFlight++;
+            pendingPreloads.poll().run();
+        }
+    }
+
+    // Resolves with a result per source, in order, once all have loaded or
+    // failed: { ok, width, height } or { ok: false, error }. Never rejects.
     @ReactMethod
-    public void preload(final ReadableArray sources) {
-        final Activity activity = getCurrentActivity();
-        if (activity == null) return;
-        activity.runOnUiThread(new Runnable() {
+    public void preload(final ReadableArray sources, final Promise promise) {
+        final ReactApplicationContext context = getReactApplicationContext();
+        UiThreadUtil.runOnUiThread(new Runnable() {
             @Override
             public void run() {
-                for (int i = 0; i < sources.size(); i++) {
-                    final ReadableMap source = sources.getMap(i);
-                    final FastImageSource imageSource = FastImageViewConverter.getImageSource(activity, source);
-
-                    Glide
-                            .with(activity.getApplicationContext())
-                            // This will make this work for remote and local images. e.g.
-                            //    - file:///
-                            //    - content://
-                            //    - res:/
-                            //    - android.resource://
-                            //    - data:image/png;base64
-                            .load(
-                                    imageSource.isBase64Resource() ? imageSource.getSource() :
-                                    imageSource.isResource() ? imageSource.getUri() : imageSource.getGlideUrl()
-                            )
-                            .apply(FastImageViewConverter.getOptions(activity, imageSource, source))
-                            .preload();
+                final int count = sources.size();
+                final WritableMap[] results = new WritableMap[count];
+                // Sources of this call still to finish. It starts at the
+                // number of sources, so the promise can't resolve before
+                // they've all been added.
+                final int[] remaining = {count};
+                final Runnable finishOne = new Runnable() {
+                    @Override
+                    public void run() {
+                        if (--remaining[0] > 0) return;
+                        WritableArray array = Arguments.createArray();
+                        for (WritableMap result : results) array.pushMap(result);
+                        promise.resolve(array);
+                    }
+                };
+                for (int i = 0; i < count; i++) {
+                    final int index = i;
+                    final ReadableMap source = sources.isNull(i) ? null : sources.getMap(i);
+                    // Glide throws on an empty url. Invalid sources fail
+                    // without taking a slot.
+                    if (!FastImageViewConverter.hasUri(source)) {
+                        results[i] = failure("Invalid source: no uri");
+                        finishOne.run();
+                        continue;
+                    }
+                    final FastImageSource imageSource = FastImageViewConverter.getImageSource(context, source);
+                    // A uri that can't be resolved (e.g. a relative path) resolves
+                    // to an empty one.
+                    if (imageSource.getUri().toString().isEmpty()) {
+                        results[i] = failure("Invalid source: can't resolve " + source.getString("uri"));
+                        finishOne.run();
+                        continue;
+                    }
+                    RequestOptions options = FastImageViewConverter.getOptions(context, imageSource, source);
+                    // Low priority unless the source sets one, as on iOS (the
+                    // prefetcher's options), so the images the app shows load
+                    // first.
+                    final RequestOptions preloadOptions = source.hasKey("priority") && !source.isNull("priority")
+                            ? options
+                            : options.priority(Priority.LOW);
+                    pendingPreloads.add(new Runnable() {
+                        @Override
+                        public void run() {
+                            Glide
+                                    .with(context)
+                                    // Load it the way the view does, so local images
+                                    // (file://, content://, asset:/) work too.
+                                    .load(imageSource.getSourceForLoad())
+                                    .apply(preloadOptions)
+                                    .listener(new RequestListener<Drawable>() {
+                                        @Override
+                                        public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
+                                            results[index] = failure(FastImageRequestListener.errorMessage(e));
+                                            preloadsInFlight--;
+                                            finishOne.run();
+                                            startPendingPreloads();
+                                            return false;
+                                        }
+
+                                        @Override
+                                        public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
+                                            // Preloaded at its original size, so this is
+                                            // the image's own size.
+                                            WritableMap result = Arguments.createMap();
+                                            result.putBoolean("ok", true);
+                                            result.putInt("width", resource.getIntrinsicWidth());
+                                            result.putInt("height", resource.getIntrinsicHeight());
+                                            results[index] = result;
+                                            preloadsInFlight--;
+                                            finishOne.run();
+                                            startPendingPreloads();
+                                            return false;
+                                        }
+                                    })
+                                    .preload();
+                        }
+                    });
+                }
+                if (count == 0) {
+                    promise.resolve(Arguments.createArray());
+                    return;
                 }
+                startPendingPreloads();
             }
         });
     }
 
+    private static WritableMap failure(String error) {
+        WritableMap result = Arguments.createMap();
+        result.putBoolean("ok", false);
+        result.putString("error", error);
+        return result;
+    }
+
     @ReactMethod
     public void clearMemoryCache(final Promise promise) {
         final Activity activity = getCurrentActivity();