@amazon-devices/expo-image 2.0.9000000000 → 2.0.9000000002

package/CMakeLists.txt

@@ -11,81 +11,107 @@
 # IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
 #
-set(PACKAGE_NAME "expo-image")
-set(AUTO_LINK_PACKAGE_NAME "${PACKAGE_NAME}-${KEPLER_REACT_NATIVE_MAJOR_VERSION}")
-set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/kepler)
-set(SOURCES_KEPLER 
-  kepler/ExpoImage.cpp
-  kepler/ExpoImageCacheHandler.cpp
-  kepler/ExpoImageComponent.cpp
-
-  kepler/utils/PlaceholderImageLoaderDelegate.cpp
-  kepler/utils/PrefetchImageLoaderDelegate.cpp
-  kepler/utils/SourceImageLoaderDelegate.cpp
-  kepler/utils/SourceImageLoaderDelegateEmitter.cpp
 
-  kepler/contentposition/ImageContentPosition.cpp
+cmake_minimum_required(VERSION 3.22)
 
-  kepler/blurhash/decode.cpp
+set(EXPO_IMAGE_MAJOR_VERSION 2)
+set(EXPO_IMAGE_MINOR_VERSION 0)
+set(EXPO_IMAGE_VERSION "${EXPO_IMAGE_MAJOR_VERSION}.${EXPO_IMAGE_MINOR_VERSION}")
 
-  kepler/thumbhash/decode.cpp
+set(PACKAGE_NAME expo-image)
+set(AUTO_LINK_PACKAGE_NAME ${PACKAGE_NAME}-${EXPO_IMAGE_MAJOR_VERSION})
 
-  kepler/ImageWrapper/BlurhashImageWrapper.cpp
-  kepler/ImageWrapper/CacheImageWrapper.cpp
-  kepler/ImageWrapper/HashImageWrapper.cpp
-  kepler/ImageWrapper/ImageWrapper.cpp
-  kepler/ImageWrapper/LocalImageWrapper.cpp
-  kepler/ImageWrapper/ThumbhashImageWrapper.cpp
+find_package(Apmf REQUIRED)
+find_package(Kepler REQUIRED)
+find_package(turbomoduleAPI CONFIG REQUIRED)
 
-  kepler/managers/ExpoImageManager.cpp
+kepler_add_idl_import_library(
+  expo_image_idl
+  PACKAGES
+  com.amazon.kepler.uitoolkit.view
+  com.amazon.kepler.uitoolkit.react
+  com.amazon.kepler.uitoolkit.graphics
 )
 
-set(KEPLER_INIT kepler/KeplerInit.cpp)
+set(SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/kepler)
 
-find_library (MBED_CRYPTO NAMES mbedcrypto REQUIRED)
+set(HEADERS
+    ${SRC_DIR}/Constants.h
+    ${SRC_DIR}/ImageSourceInfo.h
+    ${SRC_DIR}/enums/ImageContentFit.h
+    ${SRC_DIR}/enums/ImagePriority.h
+    ${SRC_DIR}/contentposition/ImageContentPosition.h
+    ${SRC_DIR}/utils/ColorUtils.h
+    ${SRC_DIR}/utils/SourceSelection.h
+    ${SRC_DIR}/ExpoImage/ExpoImageTurboModule.h
+    ${SRC_DIR}/ExpoImage/PrefetchListener.h
+    ${SRC_DIR}/ExpoImageComponent/ExpoImageComponentViewManager.h
+    ${SRC_DIR}/ExpoImageComponent/ExpoImageView.h
+    ${SRC_DIR}/ExpoImageComponent/ExpoImageStore.h
+    ${SRC_DIR}/ExpoImageComponent/HashImageDecoder.h
+    ${SRC_DIR}/ExpoImageComponent/ImageLoadListeners.h
+    ${SRC_DIR}/ExpoImageComponent/TransitionAnimator.h
+    ${SRC_DIR}/ExpoImageComponent/AccessibilityDelegate.h
+    ${SRC_DIR}/ViewManagerFactory.h
+)
 
-add_library(${PACKAGE_NAME} STATIC ${SOURCES_KEPLER})
+set(SOURCES
+    ${SRC_DIR}/AutoLinkInit.cpp
+    ${SRC_DIR}/ViewManagerFactory.cpp
+    ${SRC_DIR}/contentposition/ImageContentPosition.cpp
+    ${SRC_DIR}/ExpoImage/ExpoImageTurboModule.cpp
+    ${SRC_DIR}/ExpoImage/PrefetchListener.cpp
+    ${SRC_DIR}/ExpoImageComponent/ExpoImageComponentViewManager.cpp
+    ${SRC_DIR}/ExpoImageComponent/ExpoImageView.cpp
+    ${SRC_DIR}/ExpoImageComponent/HashImageDecoder.cpp
+    ${SRC_DIR}/ExpoImageComponent/ImageLoadListeners.cpp
+    ${SRC_DIR}/ExpoImageComponent/TransitionAnimator.cpp
+    ${SRC_DIR}/ExpoImageComponent/AccessibilityDelegate.cpp
+    ${SRC_DIR}/utils/SourceSelection.cpp
+    ${SRC_DIR}/blurhash/decode.cpp
+    ${SRC_DIR}/thumbhash/decode.cpp
+)
 
+find_library(MBED_CRYPTO NAMES mbedcrypto REQUIRED)
 
-target_include_directories(
-  ${PACKAGE_NAME}
-  PUBLIC
-  ${SRC_DIR}
+set(LIBRARIES
+    turbomoduleAPI::turbomoduleAPI
+    ${MBED_CRYPTO}
 )
 
-target_link_libraries(
-  ${PACKAGE_NAME}
-  PUBLIC
-  keplerui::keplerscript-${KEPLER_REACT_NATIVE_MAJOR_VERSION}
-  ${MBED_CRYPTO}
-)
 
-target_compile_options(
-  ${PACKAGE_NAME}  
-  PRIVATE
-  -fpermissive
-)
+kepler_add_library(${AUTO_LINK_PACKAGE_NAME} SHARED ${HEADERS} ${SOURCES})
 
-add_library(${AUTO_LINK_PACKAGE_NAME} SHARED ${KEPLER_INIT} ${SOURCES_KEPLER})
+set_target_properties(${AUTO_LINK_PACKAGE_NAME} PROPERTIES
+    SOVERSION ${EXPO_IMAGE_MAJOR_VERSION}.${EXPO_IMAGE_MINOR_VERSION})
 
-set_target_properties(${AUTO_LINK_PACKAGE_NAME} PROPERTIES SOVERSION ${KEPLER_REACT_NATIVE_MAJOR_VERSION}.${KEPLER_REACT_NATIVE_MINOR_VERSION})
+target_include_directories(${AUTO_LINK_PACKAGE_NAME} PRIVATE ${SRC_DIR})
 
-target_link_libraries(
-  ${AUTO_LINK_PACKAGE_NAME}
-  PRIVATE
-  ${PACKAGE_NAME}  
-)
+target_link_libraries(${AUTO_LINK_PACKAGE_NAME} PRIVATE expo_image_idl ${LIBRARIES})
 
-# Helps in checking undefined references
-add_executable(${AUTO_LINK_PACKAGE_NAME}_exe ${KEPLER_INIT} ${SOURCES_KEPLER})
-target_link_libraries(${AUTO_LINK_PACKAGE_NAME}_exe
-  PRIVATE
-  ${AUTO_LINK_PACKAGE_NAME}
-  keplerui::keplerscript-${KEPLER_REACT_NATIVE_MAJOR_VERSION}
-  ${MBED_CRYPTO}
+kepler_install_components(${AUTO_LINK_PACKAGE_NAME} IN_PROCESS "/com.amazon.kepler.uitoolkit.react.expoimage")
+
+set(component_name "com.amazon.kepler.uitoolkit.react.expoimage.so")
+add_custom_command(
+  TARGET ${AUTO_LINK_PACKAGE_NAME}
+  POST_BUILD
+  COMMAND ${CMAKE_COMMAND}
+  ARGS -E copy $<TARGET_FILE:${AUTO_LINK_PACKAGE_NAME}> ${CMAKE_INSTALL_LIBDIR}/${component_name}
 )
-target_include_directories(${AUTO_LINK_PACKAGE_NAME}_exe PRIVATE ${SRC_DIR})
 
-install(TARGETS ${AUTO_LINK_PACKAGE_NAME}
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+install(TARGETS ${AUTO_LINK_PACKAGE_NAME} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+# Create a dummy main for link-time symbol checking
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/main_stub.cpp "int main() { return 0; }")
+
+# Helps in checking undefined references at build time
+add_executable(${AUTO_LINK_PACKAGE_NAME}_exe
+    ${CMAKE_CURRENT_BINARY_DIR}/main_stub.cpp
+    ${SOURCES}
 )
+target_include_directories(${AUTO_LINK_PACKAGE_NAME}_exe PRIVATE ${SRC_DIR})
+target_link_libraries(${AUTO_LINK_PACKAGE_NAME}_exe
+    PRIVATE
+    expo_image_idl
+    ${LIBRARIES}
+)

package/README.kepler.md

@@ -121,3 +121,4 @@ Check out the dedicated documentation page for info about this library, API refe
 | Package version  | Based on | @amazon-devices/react-native-kepler version |
 | ---------------- | -------- | --------------------------------- |
 | 2.0.x    | expo-image v1.6.0   | 2.0.x            |
+| 2.0.x    | expo-image v1.6.0   | 4.0.x+rn0.83.0   |

package/kepler/AutoLinkInit.cpp

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <Kepler/turbomodule/KeplerTurboModuleRegistration.h>
+
+#include "ExpoImage/ExpoImageTurboModule.h"
+
+extern "C" {
+__attribute__((visibility("default"))) void autoLinkKeplerTurboModulesV1() noexcept {
+    KEPLER_REGISTER_TURBO_MODULE_WITH_NAME("ExpoImage", expoimage, ExpoImageTurboModule);
+}
+}

package/kepler/Constants.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#pragma once
+
+#include <string_view>
+
+namespace expoimage {
+
+constexpr std::string_view kUri{"uri"};
+constexpr std::string_view kWidth{"width"};
+constexpr std::string_view kHeight{"height"};
+constexpr std::string_view kPriority{"priority"};
+constexpr std::string_view kCache{"cache"};
+
+}  // namespace expoimage

package/kepler/ExpoImage/ExpoImageTurboModule.cpp

@@ -0,0 +1,148 @@
+#include "ExpoImageTurboModule.h"
+#include "PrefetchListener.h"
+#include "../ExpoImageComponent/ExpoImageStore.h"
+
+#include <apmf/fn.h>
+#include <apmf/iface/com/amazon/apmf/InvalidArgumentError.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/IGraphicsModule.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/ITask.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/CacheType.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageOptionsBuilder.h>
+#include <apmf/log.h>
+#include <apmf/process.h>
+
+namespace expoimage {
+
+using apmf::iface::com::amazon::kepler::uitoolkit::graphics::IGraphicsModule;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::CacheType;
+
+APMF_DEFINE_LOGGER(ExpoImageTMLogger, "com.amazon.kepler.uitoolkit.react.expoimage.tm");
+using namespace apmf::log_levels;
+
+ExpoImageTurboModule::ExpoImageTurboModule() : KeplerTurboModule("ExpoImage") {
+    viewModule_ = apmf::GetProcessObject()
+                       ->getComponent("/com.amazon.kepler.uitoolkit.view")
+                       .TryQueryInterface<IViewModule>();
+    if (!viewModule_) {
+        throw apmf::InvalidArgumentError("ExpoImage: failed to acquire IViewModule");
+    }
+    cacheManager_ = viewModule_->getImageCacheManager();
+    imageLoader_ = viewModule_->makeImageLoader();
+    if (!imageLoader_) {
+        APMF_LOG(ExpoImageTMLogger, WARNING)
+                << "ExpoImage: IViewModule::makeImageLoader() returned null; "
+                   "prefetch will resolve(false)";
+    }
+    if (!cacheManager_) {
+        APMF_LOG(ExpoImageTMLogger, WARNING)
+                << "ExpoImage: IViewModule::getImageCacheManager() returned null; "
+                   "clearMemoryCache / clearDiskCache will resolve(false)";
+    }
+
+    auto graphicsComponent = apmf::GetProcessObject()
+                                     ->getComponent("/com.amazon.kepler.uitoolkit.graphics");
+    if (graphicsComponent) {
+        auto graphicsModule = graphicsComponent.TryQueryInterface<IGraphicsModule>();
+        if (graphicsModule) {
+            uiRunLoop_ = graphicsModule->tryGetUIRunLoop();
+            if (!uiRunLoop_) {
+                APMF_LOG(ExpoImageTMLogger, WARNING)
+                        << "ExpoImage: IGraphicsModule::tryGetUIRunLoop() returned null; "
+                           "clearMemoryCache / clearDiskCache will resolve(false)";
+            }
+        } else {
+            APMF_LOG(ExpoImageTMLogger, WARNING)
+                    << "ExpoImage: failed to query IGraphicsModule from "
+                       "/com.amazon.kepler.uitoolkit.graphics; clearMemoryCache / "
+                       "clearDiskCache will resolve(false)";
+        }
+    } else {
+        APMF_LOG(ExpoImageTMLogger, WARNING)
+                << "ExpoImage: /com.amazon.kepler.uitoolkit.graphics component is not "
+                   "available; clearMemoryCache / clearDiskCache will resolve(false)";
+    }
+}
+
+void ExpoImageTurboModule::aggregateMethods(
+        MethodAggregator<KeplerTurboModule>& methodAggregator) const noexcept {
+    methodAggregator.addMethod("prefetch", 1, &ExpoImageTurboModule::prefetch);
+    methodAggregator.addMethod("clearMemoryCache", 0, &ExpoImageTurboModule::clearMemoryCache);
+    methodAggregator.addMethod("clearDiskCache", 0, &ExpoImageTurboModule::clearDiskCache);
+}
+
+Promise ExpoImageTurboModule::prefetch(std::vector<std::string> urls) {
+    APMF_LOG(ExpoImageTMLogger, DEBUG)
+            << "ExpoImageTurboModule::prefetch: count=" << urls.size();
+    return Promise([vm = viewModule_, loader = imageLoader_, urls = std::move(urls)](std::shared_ptr<Promise> promise) {
+        if (urls.empty()) {
+            promise->resolve(true);
+            return;
+        }
+        if (!loader) {
+            promise->resolve(false);
+            return;
+        }
+        auto listener = Ptr<PrefetchListener>::Make(urls.size(), [promise](bool success) {
+            promise->resolve(success);
+        });
+        auto options = vm->makeImageOptionsBuilder()->build();
+        for (const auto& url : urls) {
+            APMF_LOG(ExpoImageTMLogger, DEBUG)
+                    << "ExpoImageTurboModule::prefetch: url=" << url;
+            loader->prefetch(url, listener, options);
+        }
+    });
+}
+
+Promise ExpoImageTurboModule::clearMemoryCache() {
+    APMF_LOG(ExpoImageTMLogger, DEBUG) << "ExpoImageTurboModule::clearMemoryCache";
+    return Promise([cm = cacheManager_, runLoop = uiRunLoop_](std::shared_ptr<Promise> promise) {
+        if (!runLoop || !cm) {
+            APMF_LOG(ExpoImageTMLogger, WARNING)
+                    << "ExpoImageTurboModule::clearMemoryCache: "
+                    << (!runLoop ? "uiRunLoop_" : "cacheManager_")
+                    << " is null (graphics module / view module unavailable at init); "
+                       "resolving false";
+            promise->resolve(false);
+            return;
+        }
+        runLoop->scheduleTask(
+                apmf::Fn([cm, promise](apmf::method::execute) {
+                    cm->clear(CacheType::MEMORY);
+                    // also drop the expo-image decoded-image cache
+                    // (the process-wide ExpoImageStore), which the framework
+                    // IImageCacheManager does not know about. Safe here: this task
+                    // runs on uiRunLoop_ and the store is UI-thread-owned.
+                    expoimage::sharedExpoImageStore()->clear();
+                    promise->resolve(true);
+                }),
+                nullptr,
+                nullptr,
+                false);
+    });
+}
+
+Promise ExpoImageTurboModule::clearDiskCache() {
+    APMF_LOG(ExpoImageTMLogger, DEBUG) << "ExpoImageTurboModule::clearDiskCache";
+    return Promise([cm = cacheManager_, runLoop = uiRunLoop_](std::shared_ptr<Promise> promise) {
+        if (!runLoop || !cm) {
+            APMF_LOG(ExpoImageTMLogger, WARNING)
+                    << "ExpoImageTurboModule::clearDiskCache: "
+                    << (!runLoop ? "uiRunLoop_" : "cacheManager_")
+                    << " is null (graphics module / view module unavailable at init); "
+                       "resolving false";
+            promise->resolve(false);
+            return;
+        }
+        runLoop->scheduleTask(
+                apmf::Fn([cm, promise](apmf::method::execute) {
+                    cm->clear(CacheType::PERSISTENT);
+                    promise->resolve(true);
+                }),
+                nullptr,
+                nullptr,
+                false);
+    });
+}
+
+}  // namespace expoimage

package/kepler/ExpoImage/ExpoImageTurboModule.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <apmf/iface/com/amazon/kepler/uitoolkit/graphics/IRunLoop.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageCacheManager.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageLoader.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IViewModule.h>
+#include <apmf/ptr.h>
+#include <Kepler/turbomodule/JSValue.h>
+#include <Kepler/turbomodule/KeplerTurboModule.h>
+#include <Kepler/turbomodule/Promise.h>
+
+namespace expoimage {
+
+using apmf::Ptr;
+using com::amazon::kepler::turbomodule::JSArray;
+using com::amazon::kepler::turbomodule::JSObject;
+using com::amazon::kepler::turbomodule::KeplerTurboModule;
+using com::amazon::kepler::turbomodule::MethodAggregator;
+using com::amazon::kepler::turbomodule::Promise;
+using apmf::iface::com::amazon::kepler::uitoolkit::graphics::IRunLoop;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageCacheManager;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageLoader;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IViewModule;
+
+class ExpoImageTurboModule : public KeplerTurboModule {
+public:
+    ExpoImageTurboModule();
+    void aggregateMethods(MethodAggregator<KeplerTurboModule>& methodAggregator) const noexcept override;
+
+    Promise prefetch(std::vector<std::string> urls);
+    Promise clearMemoryCache();
+    Promise clearDiskCache();
+
+private:
+    Ptr<IViewModule> viewModule_;
+    Ptr<IImageCacheManager> cacheManager_;
+    Ptr<IImageLoader> imageLoader_;
+    Ptr<IRunLoop> uiRunLoop_;
+};
+
+}  // namespace expoimage

package/kepler/ExpoImage/PrefetchListener.cpp

@@ -0,0 +1,45 @@
+#include "PrefetchListener.h"
+
+#include <apmf/log.h>
+
+namespace expoimage {
+
+APMF_DEFINE_LOGGER(PrefetchListenerLogger,
+                   "com.amazon.kepler.uitoolkit.react.expoimage.prefetch");
+using namespace apmf::log_levels;
+
+PrefetchListener::PrefetchListener(size_t total, std::function<void(bool)> onFinish)
+    : total_(total), onFinish_(std::move(onFinish)) {}
+
+void PrefetchListener::onStart(View<IImageLoadRequest>) {}
+void PrefetchListener::onProgress(View<IImageLoadRequest>, float) {}
+
+void PrefetchListener::onSuccess(View<IImageLoadRequest>, View<IImage>) {
+    // No counting — onPrefetchComplete handles prefetch completion.
+    // Both may fire for a single prefetch; counting here would double-count.
+}
+
+void PrefetchListener::onFailure(View<IImageLoadRequest>, ImageLoadError const& error) {
+    APMF_LOG(PrefetchListenerLogger, WARNING)
+            << "PrefetchListener::onFailure: prefetch failed; resolving false";
+    if (!resolved_.exchange(true)) {
+        onFinish_(false);
+    }
+}
+
+void PrefetchListener::onCanceled(View<IImageLoadRequest>) {
+    APMF_LOG(PrefetchListenerLogger, DEBUG)
+            << "PrefetchListener::onCanceled: prefetch canceled; resolving false";
+    if (!resolved_.exchange(true)) {
+        onFinish_(false);
+    }
+}
+
+void PrefetchListener::onPrefetchComplete(View<IImageLoadRequest>) {
+    APMF_LOG(PrefetchListenerLogger, DEBUG) << "PrefetchListener::onPrefetchComplete";
+    if (++loaded_ == total_ && !resolved_.exchange(true)) {
+        onFinish_(true);
+    }
+}
+
+}  // namespace expoimage

package/kepler/ExpoImage/PrefetchListener.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <apmf/apmf_base.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImage.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageLoadListener.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IImageLoadRequest.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/ImageLoadError.h>
+#include <apmf/log.h>
+#include <apmf/ptr.h>
+
+#include <atomic>
+#include <functional>
+
+namespace expoimage {
+
+using apmf::ApmfBase;
+using apmf::View;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImage;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageLoadListener;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::IImageLoadRequest;
+using apmf::iface::com::amazon::kepler::uitoolkit::view::ImageLoadError;
+
+struct PrefetchListener : ApmfBase<PrefetchListener, IImageLoadListener> {
+public:
+    PrefetchListener(size_t total, std::function<void(bool)> onFinish);
+    void onStart(View<IImageLoadRequest> request);
+    void onProgress(View<IImageLoadRequest> request, float progress);
+    void onSuccess(View<IImageLoadRequest> request, View<IImage> image);
+    void onFailure(View<IImageLoadRequest> request, ImageLoadError const& error);
+    void onCanceled(View<IImageLoadRequest> request);
+    void onPrefetchComplete(View<IImageLoadRequest> request);
+
+private:
+    std::atomic<size_t> loaded_{0};
+    size_t total_;
+    std::atomic<bool> resolved_{false};
+    std::function<void(bool)> onFinish_;
+};
+
+}  // namespace expoimage

package/kepler/ExpoImageComponent/AccessibilityDelegate.cpp

@@ -0,0 +1,33 @@
+#include "AccessibilityDelegate.h"
+
+#include <apmf/iface/com/amazon/kepler/ucc/v1_0/common/Role.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IHiddenTraitBuilder.h>
+
+namespace expoimage {
+
+namespace ucc = apmf::iface::com::amazon::kepler::ucc::v1_0::common;
+
+void ExpoImageAccessibilityDelegate::build(
+        apmf::View<uiview::IAccessibilityContext> context,
+        apmf::View<uiview::IAccessibilityDelegate> defaultDelegate) {
+    if (!accessible_) {
+        context->setTrait(context->makeHiddenTraitBuilder()->build());
+        return;
+    }
+
+    if (defaultDelegate) defaultDelegate->build(context, nullptr);
+
+    context->setRole(ucc::Role::IMAGE);
+
+    if (!description_.empty()) {
+        context->setDescription(description_);
+    }
+}
+
+void ExpoImageAccessibilityDelegate::clear(
+        apmf::View<uiview::IAccessibilityContext> context,
+        apmf::View<uiview::IAccessibilityDelegate> defaultDelegate) {
+    if (defaultDelegate) defaultDelegate->clear(context, nullptr);
+}
+
+}  // namespace expoimage

package/kepler/ExpoImageComponent/AccessibilityDelegate.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <apmf/apmf_base.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IAccessibilityContext.h>
+#include <apmf/iface/com/amazon/kepler/uitoolkit/view/IAccessibilityDelegate.h>
+#include <apmf/ptr.h>
+
+#include <string>
+
+namespace expoimage {
+
+using apmf::ApmfBase;
+namespace uiview = apmf::iface::com::amazon::kepler::uitoolkit::view;
+
+struct ExpoImageAccessibilityDelegate
+        : ApmfBase<ExpoImageAccessibilityDelegate, uiview::IAccessibilityDelegate> {
+    void build(apmf::View<uiview::IAccessibilityContext> context,
+               apmf::View<uiview::IAccessibilityDelegate> defaultDelegate);
+    void clear(apmf::View<uiview::IAccessibilityContext> context,
+               apmf::View<uiview::IAccessibilityDelegate> defaultDelegate);
+
+    void setDescription(const std::string& text) { description_ = text; }
+    void setAccessible(bool accessible) { accessible_ = accessible; }
+
+private:
+    std::string description_;
+    bool accessible_{true};
+};
+
+}  // namespace expoimage