@amazon-devices/expo-image 2.0.9000000000 → 3.0.0

package/kepler/ExpoImageComponent/ExpoImageView.cpp

@@ -0,0 +1,556 @@
+#include "ExpoImageView.h"
+#include "HashImageDecoder.h"
+#include "ImageLoadListeners.h"
+#include "TransitionAnimator.h"
+#include "../Constants.h"
+#include "../utils/ColorUtils.h"
+#include "../utils/SourceSelection.h"
+
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/Color.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/Point.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IFrame.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/react/IJsObjectBuilder.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageOptionsBuilder.h>
+#include <apmf/log.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/AspectRatioMode.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageViewStyle.h>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+namespace expoimage {
+
+namespace gfx = apmf::iface::com::amazon::kepler::uitoolkit::graphics;
+
+using apmf::iface::com::amazon::kepler::uitoolkit::view::AspectRatioMode;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::Fit;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageViewStyle;
+
+APMF_DEFINE_LOGGER(ExpoImageViewLogger, "com.amazon.kepler.uitoolkit.react.expoimage.view");
+using namespace apmf::log_levels;
+
+namespace {
+
+void parseSourceArray(View<IJsArray> arr, std::vector<ImageSourceInfo>& out) {
+    out.clear();
+    if (!arr) return;
+    auto count = arr->getElementCount();
+    out.reserve(count);
+    for (int32_t i = 0; i < count; ++i) {
+        auto elem = arr->getObject(i);
+        if (elem) out.push_back(parseImageSource(elem));
+    }
+}
+
+}  // anonymous namespace
+
+ExpoImageView::ExpoImageView(
+        Ptr<IViewModule> viewModule,
+        Ptr<IView> container,
+        Ptr<IView> clipView,
+        Ptr<IImageView3> imageView,
+        std::shared_ptr<ExpoImageStore> store)
+    : viewModule_(viewModule),
+      view_(container),
+      clipView_(clipView),
+      imageView_(imageView),
+      store_(std::move(store)) {
+    // use the SHARED loader (owned by the singleton view manager)
+    // so an in-flight load survives this cell being torn down during navigation and
+    // can complete + populate the cache. Fall back to a per-cell loader only if the
+    // store is somehow absent.
+    if (store_ && store_->loader) {
+        imageLoader_ = store_->loader;
+    } else {
+        imageLoader_ = viewModule_->makeImageLoader();
+    }
+    accessibilityDelegate_ = Ptr<ExpoImageAccessibilityDelegate>::Make();
+    accessibilityService_ = viewModule_->makeAccessibilityService();
+    if (accessibilityService_) accessibilityService_->setDelegate(view_, accessibilityDelegate_);
+}
+
+void ExpoImageView::updateProps(View<IJsObject> newProps, View<IContext> context) {
+    context_ = context;
+    auto keys = newProps->getAllKeys();
+    bool sourceChanged = false;
+    bool placeholderChanged = false;
+    for (const auto& key : keys) {
+        if (key == "contentFit") setContentFit(newProps->getString("contentFit"));
+        else if (key == "placeholderContentFit") setPlaceholderContentFit(newProps->getString("placeholderContentFit"));
+        else if (key == "allowDownscaling") setAllowDownscaling(newProps->getBool("allowDownscaling"));
+        else if (key == "contentPosition") setContentPosition(newProps->getObject("contentPosition"));
+        else if (key == "tintColor") setTintColor(newProps->getInt("tintColor"));
+        else if (key == "overlayColor") setOverlayColor(newProps->getInt("overlayColor"));
+        else if (key == "blurRadius") setBlurRadius(newProps->getDouble("blurRadius"));
+        else if (key == "placeholder") {
+            auto arr = newProps->getArray("placeholder");
+            if (arr) { setPlaceholder(arr); placeholderChanged = true; }
+        }
+        else if (key == "source") {
+            auto arr = newProps->getArray("source");
+            if (arr) { setSource(arr); sourceChanged = true; }
+        }
+        else if (key == "priority") setPriority(newProps->getString("priority"));
+        else if (key == "transition") setTransition(newProps->getObject("transition"));
+        else if (key == "recyclingKey") setRecyclingKey(newProps->getString("recyclingKey"));
+        else if (key == "accessibilityLabel") setAccessibilityLabel(newProps->getString("accessibilityLabel"));
+        else if (key == "alt") setAlt(newProps->getString("alt"));
+        else if (key == "accessible") setAccessible(newProps->getBool("accessible"));
+    }
+    if (sourceChanged) loadSource(true);
+    if (placeholderChanged) loadPlaceholder();
+}
+
+void ExpoImageView::updateLayout(View<ILayout> newLayout) {
+    auto size = newLayout->getContentFrame()->getSize();
+    view_->setSize(size);
+    if (clipView_) clipView_->setSize(size);
+    bool sizeChanged = (viewSize_.width != size.width || viewSize_.height != size.height);
+    viewSize_ = size;
+    displayState_->viewSize = size;
+    if (sizeChanged) {
+        loadSource(false);
+        loadPlaceholder();
+        applyContentPositionOffset();
+    }
+}
+
+// --- Prop handlers ---
+
+void ExpoImageView::setContentFit(const std::string& v) {
+    contentFit_ = parseContentFit(v);
+    applyContentPositionOffset(contentFit_, allowDownscaling_);
+}
+
+void ExpoImageView::setPlaceholderContentFit(const std::string& v) {
+    placeholderContentFit_ = parseContentFit(v, ImageContentFit::ScaleDown);
+}
+
+void ExpoImageView::setAllowDownscaling(bool v) {
+    if (allowDownscaling_ == v) return;
+    allowDownscaling_ = v;
+    applyContentPositionOffset(contentFit_, allowDownscaling_);
+}
+
+void ExpoImageView::setTintColor(int v) {
+    tintColor_ = v;
+    if (!imageView_) return;
+    auto style = imageView_.TryQueryInterface<IImageViewStyle>();
+    if (v == std::numeric_limits<int>::max()) {
+        style->setTintColor(gfx::Color{0.0f, 0.0f, 0.0f, 0.0f});
+    } else {
+        style->setTintColor(intToColor(v));
+    }
+}
+
+void ExpoImageView::setOverlayColor(int v) {
+    overlayColor_ = v;
+    if (!imageView_) return;
+    auto style = imageView_.TryQueryInterface<IImageViewStyle>();
+    if (v == std::numeric_limits<int>::max()) {
+        style->setOverlayColor(gfx::Color{0.0f, 0.0f, 0.0f, 0.0f});
+    } else {
+        style->setOverlayColor(intToColor(v));
+    }
+}
+
+void ExpoImageView::setBlurRadius(double v) {
+    blurRadius_ = v;
+    if (imageView_) {
+        auto style = imageView_.TryQueryInterface<IImageViewStyle>();
+        if (style) style->setBlurRadius(static_cast<float>(v));
+    }
+}
+
+void ExpoImageView::setPriority(const std::string& v) { priority_ = parsePriority(v); }
+
+void ExpoImageView::setRecyclingKey(const std::string& v) {
+    shouldClearOnSourceChange_ = !recyclingKey_.empty() && recyclingKey_ != v;
+    recyclingKey_ = v;
+}
+
+void ExpoImageView::setAccessibilityLabel(const std::string& v) {
+    accessibilityLabel_ = v;
+    accessibilityDelegate_->setDescription(alt_.empty() ? accessibilityLabel_ : alt_);
+    if (accessibilityService_) accessibilityService_->invalidate(view_);
+}
+
+void ExpoImageView::setAlt(const std::string& v) {
+    alt_ = v;
+    accessibilityDelegate_->setDescription(alt_.empty() ? accessibilityLabel_ : alt_);
+    if (accessibilityService_) accessibilityService_->invalidate(view_);
+}
+
+void ExpoImageView::setAccessible(bool v) {
+    accessibilityDelegate_->setAccessible(v);
+    if (accessibilityService_) accessibilityService_->invalidate(view_);
+}
+
+void ExpoImageView::setContentPosition(View<IJsObject> posObj) {
+    if (!posObj) return;
+    contentPosition_ = ImageContentPosition(
+            parsePositionValue(posObj, "top"), parsePositionValue(posObj, "bottom"),
+            parsePositionValue(posObj, "right"), parsePositionValue(posObj, "left"));
+    displayState_->contentPosition = contentPosition_;
+    applyContentPositionOffset();
+}
+
+void ExpoImageView::applyContentPositionOffset() {
+    applyContentPositionOffset(displayState_->activeFit, displayState_->activeAllowDownscaling);
+}
+
+void ExpoImageView::applyContentPositionOffset(ImageContentFit fit, bool allowDownscaling) {
+    displayState_->activeFit = fit;
+    displayState_->activeAllowDownscaling = allowDownscaling;
+
+    if (!imageView_) return;
+    layoutImageView(imageView_, fit, allowDownscaling, displayState_->loadedImageSize, viewSize_, contentPosition_);
+}
+
+void ExpoImageView::layoutImageView(
+        Ptr<IImageView3> imageView,
+        ImageContentFit fit,
+        bool allowDownscaling,
+        gfx::Size imageSize,
+        gfx::Size viewSize,
+        const ImageContentPosition& contentPosition) {
+    if (!imageView) return;
+
+    const bool imageSizeKnown = (imageSize.width > 0 && imageSize.height > 0);
+    const bool imageFitsInView = imageSizeKnown &&
+            (imageSize.width <= viewSize.width && imageSize.height <= viewSize.height);
+
+    const bool rendersAtNaturalSize =
+            !allowDownscaling
+            || fit == ImageContentFit::None
+            || (fit == ImageContentFit::ScaleDown && imageFitsInView);
+
+    imageView->setFit(resolveNativeFit(fit, allowDownscaling, imageSize, viewSize));
+
+    if (!rendersAtNaturalSize || !imageSizeKnown) {
+        imageView->setOffset(gfx::Point{0.0f, 0.0f});
+        imageView->setSize(viewSize);
+        return;
+    }
+
+    imageView->setSize(imageSize);
+    float offsetX = contentPosition.offsetX(imageSize, viewSize);
+    float offsetY = contentPosition.offsetY(imageSize, viewSize);
+    imageView->setOffset(gfx::Point{offsetX, offsetY});
+}
+
+void ExpoImageView::setTransition(View<IJsObject> transObj) {
+    if (!transObj) return;
+    auto keys = transObj->getAllKeys();
+    if (hasKey(keys, "duration")) transitionDuration_ = static_cast<float>(transObj->getDouble("duration")) / 1000.0f;
+    if (hasKey(keys, "timing")) transitionTiming_ = transObj->getString("timing");
+    shouldAnimate_ = transitionDuration_ > 0.0f;
+}
+
+void ExpoImageView::setSource(View<IJsArray> sourceArr) {
+    parseSourceArray(sourceArr, sources_);
+    displayState_->sourceLoaded = false;
+    displayState_->loadedUri.clear();
+    displayState_->pendingUri.clear();
+    displayState_->loadedImageSize = gfx::Size{0, 0};
+}
+
+void ExpoImageView::setPlaceholder(View<IJsArray> phArr) {
+    parseSourceArray(phArr, placeholders_);
+}
+
+// --- Image loading ---
+
+void ExpoImageView::loadSource(bool animate) {
+    auto best = getBestSource(sources_, viewSize_);
+    if (!best || best->uri.empty()) return;
+    if (!imageView_) return;
+
+    if (best->uri == displayState_->loadedUri || best->uri == displayState_->pendingUri) return;
+    if (shouldDeferRemoteLoad(*best)) return;
+
+    if (best->width > 0 && best->height > 0) {
+        displayState_->loadedImageSize = gfx::Size{best->width, best->height};
+        applyContentPositionOffset(contentFit_, allowDownscaling_);
+    }
+
+    APMF_LOG(ExpoImageViewLogger, DEBUG) << "ExpoImageView::loadSource: uri=" << best->uri;
+
+    // Do NOT blank the view before the (asynchronous) load of
+    // the new source completes. clearImage() here empties the imageView for the
+    // entire decode/network window, which on a fast-navigated recycling row
+    // reads as a flicker. Keep the previously displayed frame and let the new
+    // image replace it atomically in applySourceImage() (onSuccess -> setImage).
+    // This mirrors the pre-migration behaviour, which held the old bitmap and
+    // cross-faded instead of clearing to empty.
+    shouldClearOnSourceChange_ = false;
+
+    if (isHashUri(best->uri)) {
+        loadHashSource(*best, animate);
+    } else {
+        loadRemoteSource(*best, animate);
+    }
+}
+
+bool ExpoImageView::shouldDeferRemoteLoad(const ImageSourceInfo& best) const {
+    bool needsViewSize = (best.width <= 0.0f && best.height <= 0.0f);
+    bool hasViewSize = (viewSize_.width > 0.0f && viewSize_.height > 0.0f);
+    return needsViewSize && !hasViewSize && !isHashUri(best.uri);
+}
+
+std::optional<gfx::Size> ExpoImageView::computePreferredSize(const ImageSourceInfo& best) const {
+    if (best.width > 0.0f && best.height > 0.0f) {
+        return gfx::Size{best.width, best.height};
+    }
+
+    // remote sources frequently arrive from JS
+    // with 0x0 dimensions. Fall back to the view size so the loader decodes at
+    // display resolution instead of full native resolution -- this keeps decodes
+    // fast (so they finish before the cell is recycled) and keeps the decoded-image
+    // cache small. Only when the view size is also unknown do we defer (caller's
+    // shouldDeferRemoteLoad waits for updateLayout).
+    if (viewSize_.width > 0.0f && viewSize_.height > 0.0f) {
+        return gfx::Size{viewSize_.width, viewSize_.height};
+    }
+
+    return std::nullopt;
+}
+
+void ExpoImageView::loadHashSource(const ImageSourceInfo& best, bool animate) {
+    auto emitter = context_ ? context_->getEventEmitter() : nullptr;
+    if (emitter) emitter->emit(view_, "loadStart");
+    bool decoded = loadHashImage(best.uri, best.width, best.height, animate);
+    applyContentPositionOffset(contentFit_, allowDownscaling_);
+    if (decoded) {
+        displayState_->sourceLoaded = true;
+        displayState_->loadedUri = best.uri;
+        if (emitter) {
+            emitter->emit(view_, "load");
+            emitter->emit(view_, "loadEnd");
+        }
+    } else {
+        if (emitter) {
+            emitter->emit(view_, "error");
+            emitter->emit(view_, "loadEnd");
+        }
+    }
+}
+
+void ExpoImageView::loadRemoteSource(const ImageSourceInfo& best, bool animate) {
+    if (!context_) return;
+
+    auto ob = viewModule_->makeImageOptionsBuilder();
+    ob->priority(static_cast<uint32_t>(priority_));
+
+    // Compute the decode-size hint once; it also feeds the cache key so two cells
+    // sharing a URI at different sizes don't serve each other's decode.
+    std::optional<gfx::Size> preferred;
+    if (allowDownscaling_ && contentFit_ != ImageContentFit::None) {
+        preferred = computePreferredSize(best);
+        if (preferred) {
+            ob->preferredSize(*preferred);
+            ob->aspectRatioMode(AspectRatioMode::KEEP_ASPECT_RATIO);
+        }
+    }
+    const std::string cacheKey = best.uri + "|" +
+            (preferred ? (std::to_string(static_cast<int>(preferred->width)) + "x" +
+                          std::to_string(static_cast<int>(preferred->height)))
+                       : std::string("natural"));
+
+    SourceLoadCaptures captures{
+            view_,
+            imageView_,
+            viewModule_,
+            displayState_,
+            contentFit_,
+            allowDownscaling_,
+            animate && shouldAnimate_,
+            transitionDuration_,
+            transitionTiming_,
+            store_,
+            best.uri,
+            cacheKey};
+
+    // synchronous cache hit -> paint THIS frame, no async gap.
+    // During fast navigation a recycling row re-creates cells faster than a network
+    // load completes; without this the cell never paints (flicker). The same handful
+    // of posters cycle repeatedly, so after the first load each re-created cell hits
+    // the cache and swaps in instantly -- matching the old volta cached behaviour.
+    if (store_) {
+        if (auto cached = store_->get(cacheKey)) {
+            // Instant cache hit: the image is available this frame, so never
+            // fade-in from blank (that would flash on every recycled cell).
+            captures.shouldAnimate = false;
+
+            // the async loader path emits the JS load
+            // lifecycle events via SourceImageLoadListener (loadStart on
+            // dispatch; load + loadEnd on success). The synchronous cache-hit
+            // path below bypasses that listener, so it MUST emit the same event
+            // sequence here -- otherwise JS consumers that drive UI state from
+            // onLoad / onLoadStart / onLoadEnd (loading spinners, analytics,
+            // the Expo demo Rest example counters) stop receiving callbacks for
+            // every remount after the first warm load. Mirrors loadHashSource,
+            // which already emits these events directly without the listener.
+            auto emitter = context_ ? context_->getEventEmitter() : nullptr;
+            if (emitter) emitter->emit(view_, "loadStart");
+            applySourceImage(captures, cached);
+            if (emitter) {
+                emitter->emit(view_, "load");
+                emitter->emit(view_, "loadEnd");
+            }
+            return;
+        }
+    }
+
+    // Mark this URI in-flight so updateLayout-driven reloads don't re-issue it;
+    // cleared on completion (success or failure) in applySourceImage.
+    displayState_->pendingUri = best.uri;
+
+    auto listener = Ptr<SourceImageLoadListener>::Make(
+            context_->getEventEmitter(), view_,
+            [captures = std::move(captures)](Ptr<vi::IImage> img) {
+                applySourceImage(captures, img);
+            });
+    imageLoader_->load(best.uri, listener, ob->build());
+}
+
+void ExpoImageView::applySourceImage(const SourceLoadCaptures& c, Ptr<vi::IImage> img) {
+    if (!c.state) return;
+
+    // clear the in-flight marker for this URI on BOTH success and
+    // failure, so a transiently failed load can be retried. (Previously the URI was
+    // marked loaded eagerly before the async result, so a failed load was never
+    // retried until the JS source prop was re-set.)
+    if (c.state->pendingUri == c.uri) c.state->pendingUri.clear();
+
+    if (!c.imageView) return;
+    if (!img) return;  // failure: pending cleared above -> retry allowed
+
+    // cache the decoded image (keyed by uri + decode size) so a
+    // re-created cell for the same key paints synchronously next time. Runs even if
+    // THIS cell was already torn down, because the shared loader / captures keep the
+    // image alive -- that is how the cache gets warmed during navigation churn.
+    if (c.store) c.store->put(c.cacheKey, img);
+
+    c.state->loadedUri = c.uri;
+
+    // remember whether this cell already showed an image
+    // BEFORE this swap. setImage() replaces the previous bitmap atomically, so
+    // we never need to blank first.
+    const bool hadImage = c.state->hasDisplayedImage;
+    c.state->sourceLoaded = true;
+    c.state->hasDisplayedImage = true;
+
+    c.imageView->setImage(img);
+
+    const auto effectiveFit = c.allowDownscaling ? c.contentFit : ImageContentFit::None;
+
+    c.state->loadedImageSize = gfx::Size{
+            static_cast<float>(img->getWidth()), static_cast<float>(img->getHeight())};
+    c.state->activeFit = effectiveFit;
+    c.state->activeAllowDownscaling = c.allowDownscaling;
+
+    layoutImageView(c.imageView, effectiveFit, c.allowDownscaling,
+                    c.state->loadedImageSize, c.state->viewSize, c.state->contentPosition);
+
+    // only run the fade-in (which starts at opacity 0 = a blank
+    // cell) for the FIRST image this view shows. On a recycled cell that already
+    // displays an image, fading from blank produces a visible flash on every
+    // navigation step; the setImage() above already swapped it cleanly.
+    if (c.shouldAnimate && c.duration > 0.0f && !hadImage) {
+        startFadeInTransition(c.viewModule, c.view, c.duration, c.timing);
+    }
+}
+
+void ExpoImageView::animateTransition() {
+    if (transitionDuration_ <= 0.0f) return;
+    startFadeInTransition(viewModule_, view_, transitionDuration_, transitionTiming_);
+}
+
+bool ExpoImageView::loadHashImage(
+        const std::string& uri, float width, float height, bool animate) {
+    APMF_LOG(ExpoImageViewLogger, DEBUG) << "ExpoImageView::loadHashImage: uri=" << uri;
+
+    auto gfxImage = decodeHashToImage(uri, width, height);
+    if (!gfxImage) return false;
+
+    if (imageView_) {
+        imageView_->setGraphicsImage(gfxImage);
+    }
+
+    // fade-in (opacity 0 -> 1) only on the first image this
+    // view shows; recycled cells swap atomically to avoid a blank-flash flicker.
+    if (animate && shouldAnimate_ && !displayState_->hasDisplayedImage) animateTransition();
+    displayState_->hasDisplayedImage = true;
+    return true;
+}
+
+void ExpoImageView::loadPlaceholder() {
+    if (displayState_->sourceLoaded) return;
+    // do not re-show a placeholder on a view that already
+    // displays an image. On a recycled cell, setSource() resets sourceLoaded to
+    // false while the previous (real) image is still on screen; without this
+    // guard loadPlaceholder() would overwrite that image with the (often hash)
+    // placeholder before the new source decodes -- a sharp->blur->sharp flicker
+    // on every navigation step -- and re-issue the placeholder load that floods
+    // the log with onFailure. The retained image stays until the new source
+    // swaps in atomically (applySourceImage).
+    if (displayState_->hasDisplayedImage) return;
+    auto best = getBestSource(placeholders_, viewSize_);
+    if (!best || best->uri.empty()) return;
+    if (!imageView_) return;
+
+    if (isHashUri(best->uri)) {
+        loadHashPlaceholder(*best);
+    } else if (!shouldDeferRemoteLoad(*best)) {
+        loadRemotePlaceholder(*best);
+    }
+}
+
+void ExpoImageView::loadHashPlaceholder(const ImageSourceInfo& best) {
+    displayState_->loadedImageSize = gfx::Size{best.width, best.height};
+    loadHashImage(best.uri, best.width, best.height, false);
+
+    applyContentPositionOffset(placeholderContentFit_, true);
+}
+
+void ExpoImageView::loadRemotePlaceholder(const ImageSourceInfo& best) {
+    if (best.width > 0 && best.height > 0) {
+        displayState_->loadedImageSize = gfx::Size{best.width, best.height};
+    }
+    applyContentPositionOffset(placeholderContentFit_, true);
+
+    auto ob = viewModule_->makeImageOptionsBuilder();
+
+    if (placeholderContentFit_ != ImageContentFit::None) {
+        if (auto preferred = computePreferredSize(best)) {
+            ob->preferredSize(*preferred);
+            ob->aspectRatioMode(AspectRatioMode::KEEP_ASPECT_RATIO);
+        }
+    }
+
+    auto capturedImageView = imageView_;
+    auto capturedPlaceholderFit = placeholderContentFit_;
+    auto capturedState = displayState_;
+
+    auto listener = Ptr<PlaceholderImageLoadListener>::Make(
+            [capturedImageView, capturedPlaceholderFit, capturedState](Ptr<vi::IImage> img) {
+                if (!capturedImageView || !capturedState || capturedState->sourceLoaded || !img) return;
+                capturedImageView->setImage(img);
+
+                auto imgSize = gfx::Size{
+                        static_cast<float>(img->getWidth()),
+                        static_cast<float>(img->getHeight())};
+
+                capturedState->loadedImageSize = imgSize;
+                capturedState->activeFit = capturedPlaceholderFit;
+                capturedState->activeAllowDownscaling = true;
+
+                layoutImageView(capturedImageView, capturedPlaceholderFit, true,
+                                imgSize, capturedState->viewSize, capturedState->contentPosition);
+            });
+    imageLoader_->load(best.uri, listener, ob->build());
+}
+
+}  // namespace expoimage