@amazon-devices/expo-image 2.0.1758683737

package/kepler/ExpoImageComponent.h

@@ -0,0 +1,199 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+#include <KeplerScript/utils/image/KeplerScriptImageCacheHandler.h>
+#include <Volta/animation/Animated.h>
+#include <Volta/animation/Animation.h>
+#include <Volta/animation/Animator.h>
+#include <Volta/animation/Driver.h>
+#include <Volta/animation/Transform.h>
+#include <Volta/ui/presentation/EventController.h>
+#include <Volta/utils/Image.h>
+#include <graphics/ClipRRectLayer.h>
+#include <graphics/ImageFilterLayer.h>
+
+#include "ImageWrapper/ImageWrapper.h"
+#include "KeplerImageViewComponent.h"
+#include "KeplerScript/utils/KeplerUIManager.h"
+#include "contentposition/ImageContentPosition.h"
+#include "enums/ImageContentFit.h"
+#include "enums/ImagePriority.h"
+#include "react/renderer/components/image/ImageShadowNode.h"
+
+struct ImageTransition {
+    float duration;
+    std::string timing;
+};
+
+class ExpoImageDrawableLayer : public volta::graphics::DrawableLayer {
+public:
+    ExpoImageDrawableLayer();
+    void onDraw(volta::graphics::Canvas& canvas) override;
+    void setSize(const volta::graphics::Size&);
+
+private:
+#ifdef UNIT_TEST
+public:
+#endif
+    /**
+     * KeplerImageViewComponent is marked as friend class to access all private members
+     * instead of exposing individual setters. The members will be set when the props are modified
+     */
+    friend class ExpoImageComponent;
+    volta::react::BorderCalculatedMetrics borderCalculatedMetrics_;
+    volta::graphics::Size size_;
+    std::shared_ptr<ImageWrapper> imageWrapper_;
+    std::shared_ptr<ImageWrapper> oldImageWrapper_;
+    std::shared_ptr<ImageWrapper> placeholderWrapper_;
+    ImageContentFit imageContentFit_;
+    ImageContentFit imagePlaceholderContentFit_;
+    bool imageAllowDownscaling_;
+    ImageContentPosition imageContentPosition_;
+    volta::graphics::Color overlayColor_;
+    volta::graphics::Color tintColor_;
+    double blurRadius_ = 0.0;
+    uint8_t opacity_ = 255;
+    std::function<void()> onAnimationInit_;
+    bool shouldInitializeAnimation_{false};
+
+    void paintImageWithContentFit(
+            const volta::graphics::Image& image,
+            volta::graphics::Canvas& canvas,
+            const volta::graphics::Paint& paint,
+            ImageContentFit imageContentFit,
+            bool isPlaceholderUsed);
+};
+
+class ExpoImageComponent final : public volta::react::KeplerViewComponent {
+public:
+    ExpoImageComponent(const std::shared_ptr<volta::react::KeplerScriptImageCacheHandler>&);
+
+    /**
+     * @brief Set the overlay color
+     * @details When the image has rounded corners, specifying an overlayColor will cause the
+     * remaining space in the corners to be filled with a solid color.
+     * @param newValue
+     */
+    void setOverlayColor(const int& newValue);
+
+    /**
+     * @brief Set the tint color
+     * @details Changes the color of all the non-transparent pixels to the tintColor.
+     * @param newValue
+     */
+    void setTintColor(const int& newValue);
+
+    /**
+     * @brief Set the Blur Radius
+     * @details Changes the pixels for the Image.
+     * @param newValue
+     */
+    void setBlurRadius(const double& newValue);
+
+    /**
+     * @brief Set the content fit ('cover', 'contain', 'fill', 'none', 'scale-down')
+     * @param newValue
+     */
+    void setContentFit(const std::string& newValue);
+
+    /**
+     * @brief Set the placeholder content fit ('cover', 'contain', 'fill', 'none', 'scale-down')
+     * @param newValue
+     */
+    void setPlaceholderContentFit(const std::string& newValue);
+
+    /**
+     * @brief Set the allow downscaling prop (true/false)
+     * @param newValue
+     */
+    void setAllowDownscaling(const bool& newValue);
+
+    /**
+     * @brief Set the local default image source uri
+     * @param newValue JsonContainer with ImageSource data
+     */
+    void setPlaceholder(const utils::json::JsonContainer& newValue);
+
+    /**
+     * @brief Set the local default image source uri
+     * @param newValue JsonContainer with ImageSource data
+     */
+    void setSource(const utils::json::JsonContainer& newValue);
+
+    /**
+     * @brief Set the priority for completing image load ('low', 'normal', 'high').
+     * @param newValue
+     */
+    void setPriority(const std::string& newValue);
+
+    /**
+     * @brief Set the content position
+     * @param newValue JsonContainer with ImageContentPosition data
+     */
+    void setContentPosition(const utils::json::JsonContainer& newValue);
+
+    /**
+     * @brief Set the image transition
+     * @param newValue JsonContainer with ImageTransition data
+     */
+    void setTransition(const utils::json::JsonContainer& newValue);
+
+    /**
+     * @brief Set the recycling key
+     * @param newValue
+     */
+    void setRecyclingKey(const std::string& newValue);
+
+    // void buildAccessibilityInfo(AccessibilityContext& accessibilityContext) override;
+
+    virtual void event(volta::EventContext&) override;
+
+    void init();
+
+protected:
+    void updateLayoutMetrics(
+            const std::shared_ptr<volta::react::KeplerViewComponentLayoutMetrics>& oldLayoutMetrics,
+            const std::shared_ptr<volta::react::KeplerViewComponentLayoutMetrics>& newLayoutMetrics) override;
+
+    void updateState(const std::shared_ptr<const void>& oldState, const std::shared_ptr<const void>& newState) override;
+
+private:
+#ifdef UNIT_TEST
+public:
+#endif
+    mutable ExpoImageDrawableLayer imageDrawableLayer_;
+    volta::graphics::Color overlayColor_;
+    volta::graphics::Color tintColor_;
+    std::string contentFit_;
+    std::string placeholderContentFit_;
+    std::string recyclingKey_;
+    bool shouldClearOnSourceChange_ = false;
+    std::vector<facebook::react::ImageSource> sources_;
+    std::vector<facebook::react::ImageSource> placeholders_;
+    std::shared_ptr<ImageWrapper> currentSource_;
+    std::shared_ptr<ImageWrapper> oldSource_;
+    std::shared_ptr<ImageWrapper> currentPlaceholder_;
+    std::shared_ptr<volta::react::KeplerScriptImageCacheHandler> cacheHandler_;
+    ImagePriority priority_;
+    volta::Animator animator_;
+    volta::Animation<float> animation_;
+    bool shouldAnimateOnSrcChange_{false};
+    ImageTransition imageTransition;
+    const float opacityTargetValue_{255.0f};
+
+    std::optional<facebook::react::ImageSource> getBestSource(const std::vector<facebook::react::ImageSource>&);
+    std::shared_ptr<volta::IImageLoaderDelegate> createSourceLoaderDelegate(std::function<void()> onLoad);
+    std::shared_ptr<volta::IImageLoaderDelegate> createPlaceholderLoaderDelegate(std::function<void()> onLoad);
+    void createCurrentSource(facebook::react::ImageSource);
+    void rerenderIfNeeded();
+    void loadLocalImage(const utils::json::JsonContainer& imageSourceJsonContainer);
+    void startImageAnimation();
+    void animateImage();
+    void createImageAnimation(ImageTransition& imageTransition);
+};

package/kepler/ImageWrapper/BlurhashImageWrapper.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "BlurhashImageWrapper.h"
+
+#include <boost/algorithm/string.hpp>
+
+#include "blurhash/decode.h"
+
+BlurHashImageWrapper::BlurHashImageWrapper(
+        const facebook::react::ImageSource& source,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+        HashImageWrapper(source, loaderDelegate){};
+
+void BlurHashImageWrapper::load() {
+    loaderDelegate_->notifyImageLoadStart();
+    auto delimiter_pos = source_.uri.find("/");
+    if (delimiter_pos == std::string::npos) return;
+
+    auto uri = source_.uri.substr(delimiter_pos + 1);
+    const int channels = 4;
+    const int width = source_.size.width;
+    const int height = source_.size.height;
+
+    auto pixels = decodeBlurhash(uri.c_str(), width, height, 1, channels);
+    imagePtr_ = volta::graphics::Image::makeRasterImage(
+            volta::graphics::Size(width, height),
+            std::move(pixels),
+            width * channels);
+    isLoaded_ = true;
+    loaderDelegate_->notifyImageLoadSuccess(*imagePtr_.get());
+}

package/kepler/ImageWrapper/BlurhashImageWrapper.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include "HashImageWrapper.h"
+
+class BlurHashImageWrapper : public HashImageWrapper {
+public:
+    BlurHashImageWrapper(
+            const facebook::react::ImageSource& source,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate);
+
+    void load();
+
+private:
+    volta::graphics::Size size_;
+};

package/kepler/ImageWrapper/CacheImageWrapper.cpp

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "CacheImageWrapper.h"
+
+#include <KeplerScript/components/ImageSourceBuilder.h>
+#include <KeplerScript/logger/KPLog.h>
+
+#include "KeplerScript/utils/KeplerUIManager.h"
+
+CacheImageWrapper::CacheImageWrapper(
+        const facebook::react::ImageSource& source,
+        const std::shared_ptr<volta::react::KeplerScriptImageCacheHandler>& cacheHandler,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate,
+        const ImagePriority priority) :
+        ImageWrapper(source, loaderDelegate),
+        cacheHandler_(cacheHandler),
+        priority_(priority) {}
+
+void CacheImageWrapper::load() {
+    if (isLoading_) return;
+
+    if (!cacheHandler_) {
+        volta::react::KPLog.warn("{} :: Invalid KeplerScriptImageCacheHandler", __func__);
+        return;
+    }
+
+    volta::ImageOptions imageOptions;
+    if (source_.resizeMode != facebook::react::ImageResizeMode::Center &&
+        source_.resizeMode != facebook::react::ImageResizeMode::Repeat) {
+        // facebook::react::ImageResizeMode::Center and facebook::react::ImageResizeMode::Repeat requires that the
+        // image should not be subjected to a canvas based resize and has its original size intact. This checks
+        // ensures that the canvas resize occurs for only image fit configurations other than Center and Repeat.
+        imageOptions.preferredSize(volta::graphics::Size{source_.size.width, source_.size.height});
+        imageOptions.keepAspectRatio(true);
+    }
+
+    const volta::ImageSource imageSourceUrl = volta::react::buildImageSource(source_.uri);
+    volta::ImageDetails details(imageSourceUrl, imageOptions, static_cast<uint8_t>(priority_));
+    cacheHandler_->load(details, shared_from_this());
+    isLoading_ = true;
+}
+
+volta::graphics::Image* CacheImageWrapper::getImage() {
+    if (imageRef_ != nullptr) {
+        return imageRef_->getImage();
+    }
+    return nullptr;
+}
+
+void CacheImageWrapper::notifyImageLoadStart() {
+    loaderDelegate_->notifyImageLoadStart();
+};
+
+void CacheImageWrapper::notifyImageLoadProgress(float progress) {
+    loaderDelegate_->notifyImageLoadProgress(progress);
+}
+
+void CacheImageWrapper::notifyImageLoadSuccess(volta::graphics::Image) {
+    /* migrated to notifyImageLoadSuccess(volta::image::ImageRef) below */
+    volta::react::KPLog.warn(
+            "ExpoImage :: Deprecated CacheImageWrapper::notifyImageLoadSuccess(volta::graphics::Image) called");
+}
+
+void CacheImageWrapper::notifyImageLoadSuccess(volta::image::ImageRef imageRef) {
+    isLoaded_ = true;
+    imageRef_ = std::make_shared<volta::image::ImageRef>(std::move(imageRef));
+    loaderDelegate_->notifyImageLoadSuccess(imageRef);
+}
+
+void CacheImageWrapper::notifyImageLoadFailure(volta::ImageLoadError error) {
+    isLoaded_ = false;
+    imageRef_ = nullptr;
+    loaderDelegate_->notifyImageLoadFailure(error);
+}

package/kepler/ImageWrapper/CacheImageWrapper.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+#include <KeplerScript/utils/image/KeplerScriptImageCacheHandler.h>
+
+#include "ImageWrapper.h"
+#include <KeplerScript/utils/image/LocalAssetImageLoader.h>
+#include "enums/ImagePriority.h"
+
+class CacheImageWrapper
+        : public ImageWrapper
+        , public volta::IImageLoaderDelegate
+        , public std::enable_shared_from_this<CacheImageWrapper> {
+public:
+    CacheImageWrapper(
+            const facebook::react::ImageSource& source,
+            const std::shared_ptr<volta::react::KeplerScriptImageCacheHandler>& cacheHandler,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate,
+            const ImagePriority priority);
+
+    void load();
+    volta::graphics::Image* getImage();
+
+    void notifyImageLoadStart() override;
+    void notifyImageLoadProgress(float progress) override;
+    void notifyImageLoadSuccess(volta::graphics::Image) override;
+    void notifyImageLoadSuccess(volta::image::ImageRef imageRef) override;
+    void notifyImageLoadFailure(volta::ImageLoadError error) override;
+
+private:
+    std::shared_ptr<volta::image::ImageRef> imageRef_;
+    std::shared_ptr<volta::react::KeplerScriptImageCacheHandler> cacheHandler_;
+    bool isLoading_ = false;
+    ImagePriority priority_;
+};

package/kepler/ImageWrapper/HashImageWrapper.cpp

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "HashImageWrapper.h"
+
+HashImageWrapper::HashImageWrapper(
+        const facebook::react::ImageSource& source,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+        ImageWrapper(source, loaderDelegate){};
+
+volta::graphics::Image* HashImageWrapper::getImage() {
+    if (imagePtr_ != nullptr) {
+        return imagePtr_.get();
+    }
+    return nullptr;
+}

package/kepler/ImageWrapper/HashImageWrapper.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include "ImageWrapper.h"
+
+class HashImageWrapper : public ImageWrapper {
+public:
+    HashImageWrapper(
+            const facebook::react::ImageSource& source,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate);
+    volta::graphics::Image* getImage();
+
+protected:
+    std::unique_ptr<volta::graphics::Image> imagePtr_;
+};

package/kepler/ImageWrapper/ImageWrapper.cpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ImageWrapper.h"
+
+ImageWrapper::ImageWrapper(
+        const facebook::react::ImageSource& source,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+        source_(source),
+        isLoaded_(false),
+        loaderDelegate_(loaderDelegate){};
+
+bool ImageWrapper::isLoaded() {
+    return isLoaded_;
+}
+
+const facebook::react::ImageSource& ImageWrapper::getSource() const {
+    return source_;
+}

package/kepler/ImageWrapper/ImageWrapper.h

@@ -0,0 +1,33 @@
+
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <Volta/utils/Image.h>
+
+#ifndef KEPLER
+#define KEPLER
+#endif
+
+#include "react/renderer/components/image/ImageShadowNode.h"
+
+class ImageWrapper {
+public:
+    ImageWrapper(const facebook::react::ImageSource& source, const volta::IImageLoaderDelegate::Shared& loaderDelegate);
+    virtual ~ImageWrapper() = default;
+    virtual void load() = 0;
+    virtual bool isLoaded();
+    virtual volta::graphics::Image* getImage() = 0;
+    const facebook::react::ImageSource& getSource() const;
+
+protected:
+    bool isLoaded_;
+    facebook::react::ImageSource source_;
+    const volta::IImageLoaderDelegate::Shared loaderDelegate_;
+};

package/kepler/ImageWrapper/LocalImageWrapper.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "LocalImageWrapper.h"
+
+#include <KeplerScript/logger/KPLog.h>
+
+#include "KeplerScript/utils/KeplerUIManager.h"
+
+LocalImageWrapper::LocalImageWrapper(
+        const facebook::react::ImageSource& source,
+        const std::weak_ptr<volta::react::LocalAssetImageLoader>& localImageLoader,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+        ImageWrapper(source, loaderDelegate),
+        localImageLoader_(localImageLoader) {}
+
+void LocalImageWrapper::load() {
+    if (isLoading_) return;
+    auto localAssetImageLoader = localImageLoader_.lock();
+    if (!localAssetImageLoader) {
+        volta::react::KPLog.warn("{} :: Invalid local asset image loader", __func__);
+        return;
+    }
+
+    loaderDelegate_->notifyImageLoadStart();
+    volta::ImageOptions imageOptions;
+    if (source_.resizeMode != facebook::react::ImageResizeMode::Center &&
+        source_.resizeMode != facebook::react::ImageResizeMode::Repeat) {
+        // facebook::react::ImageResizeMode::Center and facebook::react::ImageResizeMode::Repeat requires that the
+        // image should not be subjected to a canvas based resize and has its original size intact. This checks
+        // ensures that the canvas resize occurs for only image fit configurations other than Center and Repeat.
+        imageOptions.preferredSize(volta::graphics::Size{source_.size.width, source_.size.height});
+        imageOptions.keepAspectRatio(true);
+    }
+    isLoading_ = true;
+    localAssetImageLoader->loadImage(
+            source_.uri,
+            imageOptions,
+            [weakSelf = weak_from_this()](std::shared_ptr<volta::image::ImageRef> imageRefPtr) {
+                volta::react::KeplerUIManager::getInstance().executeOnUIThread([weakSelf, imageRefPtr]() {
+                    if (auto self = weakSelf.lock()) {
+                        self->imageRef_ = imageRefPtr;
+                        self->isLoaded_ = true;
+                        self->loaderDelegate_->notifyImageLoadSuccess(*imageRefPtr.get());
+                    }
+                });
+                return;
+            });
+}
+
+volta::graphics::Image* LocalImageWrapper::getImage() {
+    if (imageRef_ != nullptr) {
+        return imageRef_->getImage();
+    }
+    return nullptr;
+}

package/kepler/ImageWrapper/LocalImageWrapper.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include "ImageWrapper.h"
+#include <KeplerScript/utils/image/LocalAssetImageLoader.h>
+
+class LocalImageWrapper
+        : public ImageWrapper
+        , public std::enable_shared_from_this<LocalImageWrapper> {
+public:
+    LocalImageWrapper(
+            const facebook::react::ImageSource& source,
+            const std::weak_ptr<volta::react::LocalAssetImageLoader>& localImageLoader,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate);
+
+    void load();
+    volta::graphics::Image* getImage();
+
+private:
+    std::shared_ptr<volta::image::ImageRef> imageRef_;
+    std::weak_ptr<volta::react::LocalAssetImageLoader> localImageLoader_;
+    bool isLoading_ = false;
+};

package/kepler/ImageWrapper/ThumbhashImageWrapper.cpp

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "ThumbhashImageWrapper.h"
+
+#include "thumbhash/decode.h"
+
+ThumbHashImageWrapper::ThumbHashImageWrapper(
+        const facebook::react::ImageSource& source,
+        const volta::IImageLoaderDelegate::Shared& loaderDelegate) :
+        HashImageWrapper(source, loaderDelegate){};
+
+void ThumbHashImageWrapper::load() {
+    loaderDelegate_->notifyImageLoadStart();
+    auto delimiter_pos = source_.uri.find("/");
+    if (delimiter_pos == std::string::npos) return;
+
+    auto uri = source_.uri.substr(delimiter_pos + 1);
+    const int channels = 4;
+    auto thumbResult = decodeThumbhash(uri);
+
+    imagePtr_ = volta::graphics::Image::makeRasterImage(
+            volta::graphics::Size(thumbResult.width, thumbResult.height),
+            std::move(thumbResult.pixelArray),
+            thumbResult.width * channels);
+    isLoaded_ = true;
+    loaderDelegate_->notifyImageLoadSuccess(*imagePtr_.get());
+}

package/kepler/ImageWrapper/ThumbhashImageWrapper.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include "HashImageWrapper.h"
+
+class ThumbHashImageWrapper : public HashImageWrapper {
+public:
+    ThumbHashImageWrapper(
+            const facebook::react::ImageSource& source,
+            const volta::IImageLoaderDelegate::Shared& loaderDelegate);
+
+    void load();
+};