@amazon-devices/expo-image 2.0.9000000000 → 3.0.0

package/kepler/ExpoImageComponent/ExpoImageComponentViewManager.cpp

@@ -0,0 +1,132 @@
+#include "ExpoImageComponentViewManager.h"
+
+#include <apmf/fn.h>
+#include <apmf/iface/com/amazon/apmf/ISubscription.h>
+#include <apmf/iface/com/amazon/apmf/InvalidArgumentError.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IJsObjectBuilder.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageView3.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IView2.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IViewLifecycleListener.h>
+#include <apmf/log.h>
+
+#include <limits>
+
+namespace expoimage {
+
+using namespace apmf::log_levels;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageView3;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IView2;
+
+APMF_DEFINE_LOGGER(ExpoImageVMLogger, "com.amazon.kepler.uitoolkit.react.expoimage.vm");
+
+ExpoImageComponentViewManager::ExpoImageComponentViewManager(View<IViewModule> viewModule) {
+    viewModule_ = viewModule;
+    // use the single process-wide store (shared loader +
+    // decoded-image cache) so every view manager AND the ExpoImage TurboModule's
+    // clearMemoryCache() operate on the same cache. The shared loader is created
+    // lazily here on first construction.
+    store_ = sharedExpoImageStore();
+    if (viewModule_ && !store_->loader) {
+        store_->loader = viewModule_->makeImageLoader();
+    }
+}
+
+Ptr<IView> ExpoImageComponentViewManager::createEntry(Ptr<IView> containerPtr) {
+    // Hierarchy: containerPtr → clipView (clips descendants) → imageView.
+    // clipView is sized to the cell bounds and clips the imageView when it is
+    // sized to the image's natural dimensions (Fit::NONE / ScaleDown-small).
+    auto clipView = viewModule_->makeView();
+    if (!clipView) {
+        throw apmf::InvalidArgumentError("ExpoImage: viewModule->makeView() returned null for clipView");
+    }
+    auto clipView2 = clipView.TryQueryInterface<IView2>();
+    if (clipView2) clipView2->setContentClipping(true);
+
+    auto imageViewBase = viewModule_->makeImageView();
+    if (!imageViewBase) {
+        throw apmf::InvalidArgumentError("ExpoImage: viewModule->makeImageView() returned null");
+    }
+
+    auto imageView = imageViewBase.TryQueryInterface<IImageView3>();
+    if (!imageView) {
+        throw apmf::InvalidArgumentError("ExpoImage: IImageView3 query returned null");
+    }
+
+    clipView->addChild(imageViewBase);
+    containerPtr->addChild(clipView);
+
+    void* key = containerPtr.get();
+    views_[key] = std::make_unique<ExpoImageView>(viewModule_, containerPtr, clipView, imageView, store_);
+
+    // erase the per-view entry when the IView detaches.
+    //
+    // The log proved cells are genuinely RECREATED on every navigation step
+    // (createEntry fires per step; liveEntries climbs monotonically), so an
+    // earlier "never erase" experiment leaked an ExpoImageView (+ detached
+    // clip/image render objects) per step (102 -> 196+ and growing). Erasing is
+    // now both correct AND flicker-free, because the decoded image is persisted
+    // by the shared ExpoImageStore cache (not by the view) -- a recreated cell
+    // re-paints synchronously from the cache in loadSource(). An in-flight load
+    // also survives this erase: it runs on the shared loader and its listener
+    // owns the captures, so it still completes and warms the cache.
+    auto sub = containerPtr->addLifecycleListener(apmf::Fn(
+            [](apmf::method::onMount, View<IView>) {},
+            [this, key](apmf::method::onUnmount, View<IView>) {
+                auto it = views_.find(key);
+                if (it == views_.end()) return;
+                // Move the entry out first so ~ExpoImageView runs only AFTER the
+                // map is consistent and this callback has returned.
+                auto doomed = std::move(it->second);
+                views_.erase(it);
+            }));
+    views_[key]->lifecycleSub_ = std::move(sub);
+    return containerPtr;
+}
+
+Ptr<IView> ExpoImageComponentViewManager::makeView() {
+    return createEntry(viewModule_->makeView());
+}
+
+ExpoImageView& ExpoImageComponentViewManager::ensureEntry(View<IView> view) {
+    void* key = view.get();
+    auto it = views_.find(key);
+    if (it == views_.end()) {
+        createEntry(Ptr<IView>(view));
+        it = views_.find(key);
+    }
+    return *it->second;
+}
+
+Ptr<IPropsRegistry> ExpoImageComponentViewManager::registerProps(View<IPropsRegistryBuilder> builder) {
+    auto emptyObj = context_->makeJsObjectBuilder()->build();
+    builder->stringPropWithDefault("contentFit", "cover");
+    builder->stringPropWithDefault("placeholderContentFit", "scale-down");
+    builder->boolPropWithDefault("allowDownscaling", true);
+    builder->objectPropWithDefault("contentPosition", emptyObj);
+    builder->intPropWithDefault("tintColor", std::numeric_limits<int>::max());
+    builder->intPropWithDefault("overlayColor", std::numeric_limits<int>::max());
+    builder->doublePropWithDefault("blurRadius", 0.0);
+    builder->arrayProp("placeholder");
+    builder->arrayProp("source");
+    builder->stringPropWithDefault("priority", "normal");
+    builder->objectPropWithDefault("transition", emptyObj);
+    builder->stringPropWithDefault("recyclingKey", "");
+    builder->stringPropWithDefault("accessibilityLabel", "");
+    builder->stringPropWithDefault("alt", "");
+    builder->boolPropWithDefault("accessible", true);
+    return builder->build();
+}
+
+void ExpoImageComponentViewManager::updateContext(View<IContext> context) {
+    context_ = context;
+}
+
+void ExpoImageComponentViewManager::updateProps(View<IView> view, View<IJsObject> newProps) {
+    ensureEntry(view).updateProps(newProps, context_);
+}
+
+void ExpoImageComponentViewManager::updateLayout(View<IView> view, View<ILayout> newLayout) {
+    ensureEntry(view).updateLayout(newLayout);
+}
+
+}  // namespace expoimage

package/kepler/ExpoImageComponent/ExpoImageComponentViewManager.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <apmf/apmf_base.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IContext.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IContextDelegate.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IJsObject.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/ILayout.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/ILayoutDelegate.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IPropsDelegate.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IPropsRegistry.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IPropsRegistryBuilder.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IViewManager.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IView.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IViewModule.h>
+#include <apmf/ptr.h>
+
+#include "ExpoImageView.h"
+
+#include <memory>
+#include <unordered_map>
+
+namespace expoimage {
+
+using apmf::ApmfBase;
+using apmf::Ptr;
+using apmf::View;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IContext;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IContextDelegate;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IJsObject;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::ILayout;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::ILayoutDelegate;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IPropsDelegate;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IPropsRegistry;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IPropsRegistryBuilder;
+using apmf::iface::com::amazon::kepler::uitoolkit::react::IViewManager;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IView;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IViewModule;
+
+/**
+ * Singleton ViewManager — thin dispatcher that delegates to per-view ExpoImageView instances.
+ */
+struct ExpoImageComponentViewManager
+        : ApmfBase<ExpoImageComponentViewManager, IViewManager, IContextDelegate, IPropsDelegate, ILayoutDelegate> {
+public:
+    explicit ExpoImageComponentViewManager(View<IViewModule> viewModule);
+
+    Ptr<IView> makeView();
+    Ptr<IPropsRegistry> registerProps(View<IPropsRegistryBuilder> builder);
+    void updateContext(View<IContext> context);
+    void updateProps(View<IView> view, View<IJsObject> newProps);
+    void updateLayout(View<IView> view, View<ILayout> newLayout);
+
+private:
+    ExpoImageView& ensureEntry(View<IView> view);
+    Ptr<IView> createEntry(Ptr<IView> containerPtr);
+
+    Ptr<IViewModule> viewModule_;
+    Ptr<IContext> context_;
+    std::unordered_map<void*, std::unique_ptr<ExpoImageView>> views_;
+    // shared loader + decoded-image cache, lives for the whole
+    // process (this view manager is a singleton). Shared by every ExpoImageView so
+    // loads survive cell recreation and repeat posters paint synchronously.
+    std::shared_ptr<ExpoImageStore> store_;
+};
+
+}  // namespace expoimage

package/kepler/ExpoImageComponent/ExpoImageStore.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImage.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageLoader.h>
+#include <apmf/ptr.h>
+
+#include <list>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace expoimage {
+
+using apmf::Ptr;
+namespace vi = apmf::iface::com::amazon::kepler::uitoolkit::view;
+
+/**
+ * process-wide store shared by ALL expo-image cells, owned as a
+ * single process-wide instance (sharedExpoImageStore()). Two responsibilities:
+ *  - `loader`: a SINGLE IImageLoader shared by every cell. Because it outlives any
+ *    individual cell, an in-flight load is NOT canceled when a fast-navigated
+ *    recycling row tears the cell down -- the load completes and populates the
+ *    cache for next time.
+ *  - the cache: a bounded key -> decoded IImage map. A (re)created cell whose key
+ *    is already cached paints SYNCHRONOUSLY (setImage same frame) with no async
+ *    round-trip, mirroring the pre-migration cached behaviour.
+ *
+ * Threading: every member is touched only on the UI thread. The stable
+ * IImageLoader posts its onSuccess/onFailure callbacks back to the UI RunLoop
+ * (download/decode happen on worker threads, completion is dispatched to the UI
+ * thread), so get()/put()/clear() and the cell prop/layout updates all run on the
+ * same thread -- no synchronization is required. clearMemoryCache() schedules
+ * clear() onto the UI RunLoop for the same reason.
+ */
+struct ExpoImageStore {
+    Ptr<vi::IImageLoader> loader;
+
+    // Sized to comfortably hold a full row's worth of posters (plus a margin) so a
+    // second pass through a list stays fully cached with no eviction re-flicker.
+    // Decoded images are view-sized (see computePreferredSize), so each entry is
+    // small.
+    size_t maxEntries{128};
+
+    // Returns the cached image for `key`, promoting it to most-recently-used.
+    Ptr<vi::IImage> get(const std::string& key) {
+        auto it = cache_.find(key);
+        if (it == cache_.end()) {
+            return Ptr<vi::IImage>{};
+        }
+        lru_.splice(lru_.end(), lru_, it->second.lruIt);  // promote to MRU
+        return it->second.img;
+    }
+
+    // Inserts/updates `key`, evicting the least-recently-used entry at capacity.
+    void put(const std::string& key, Ptr<vi::IImage> img) {
+        if (key.empty() || !img) {
+            return;
+        }
+        auto it = cache_.find(key);
+        if (it != cache_.end()) {
+            it->second.img = img;
+            lru_.splice(lru_.end(), lru_, it->second.lruIt);  // promote to MRU
+            return;
+        }
+        while (cache_.size() >= maxEntries && !lru_.empty()) {
+            cache_.erase(lru_.front());
+            lru_.pop_front();
+        }
+        lru_.push_back(key);
+        cache_.emplace(key, Entry{img, std::prev(lru_.end())});
+    }
+
+    // Drops all cached decoded images (memory cache). The shared loader is kept.
+    void clear() {
+        cache_.clear();
+        lru_.clear();
+    }
+
+private:
+    struct Entry {
+        Ptr<vi::IImage> img;
+        std::list<std::string>::iterator lruIt;
+    };
+    std::list<std::string> lru_;                  // front = LRU, back = MRU
+    std::unordered_map<std::string, Entry> cache_;
+};
+
+// Single process-wide store, shared by every ExpoImageComponentViewManager and by
+// the ExpoImage TurboModule (so JS clearMemoryCache() can release it).
+inline std::shared_ptr<ExpoImageStore> sharedExpoImageStore() {
+    static std::shared_ptr<ExpoImageStore> instance = std::make_shared<ExpoImageStore>();
+    return instance;
+}
+
+}  // namespace expoimage