react-native-windows 0.70.8 → 0.71.0-preview.1

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -5,29 +5,23 @@
 #include <DynamicReader.h>
 #include <DynamicWriter.h>
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/CompositionUIService.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/Composition/TextInput/WindowsTextInputComponentDescriptor.h>
 #include <Fabric/FabricUIManagerModule.h>
 #include <Fabric/ReactNativeConfigProperties.h>
-#ifndef CORE_ABI
-#include <Fabric/ViewComponentView.h>
-#endif // CORE_ABI
+#include <ICompositionRootView.h>
 #include <IReactContext.h>
 #include <IReactRootView.h>
-#ifndef CORE_ABI
-#include <IXamlRootView.h>
-#endif // CORE_ABI
 #include <JSI/jsi.h>
 #include <SchedulerSettings.h>
 #include <UI.Xaml.Controls.h>
 #include <react/components/rnwcore/ComponentDescriptors.h>
 #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
 #include <react/renderer/components/image/ImageComponentDescriptor.h>
-#ifndef CORE_ABI
-#include <react/renderer/components/slider/SliderComponentDescriptor.h>
-#endif // CORE_ABI
 #include <react/renderer/components/text/ParagraphComponentDescriptor.h>
 #include <react/renderer/components/text/RawTextComponentDescriptor.h>
 #include <react/renderer/components/text/TextComponentDescriptor.h>
-#include <react/renderer/components/textinput/iostextinput/TextInputComponentDescriptor.h>
 #include <react/renderer/components/view/ViewComponentDescriptor.h>
 #include <react/renderer/core/EventBeat.h>
 #include <react/renderer/scheduler/Scheduler.h>
@@ -35,9 +29,7 @@
 #include <react/utils/ContextContainer.h>
 #include <runtimeexecutor/ReactCommon/RuntimeExecutor.h>
 #include <winrt/Windows.Graphics.Display.h>
-#ifndef CORE_ABI
-#include "TextInput/WindowsTextInputComponentDescriptor.h"
-#endif // CORE_ABI
+#include <winrt/Windows.UI.Composition.Desktop.h>
 #include "Unicode.h"
 
 #pragma warning(push)
@@ -65,80 +57,53 @@ FabricUIManager::FabricUIManager() {}
 
 FabricUIManager::~FabricUIManager() {}
 
-// Equiv of AsyncEventBeat (ReactAndroid\src\main\java\com\facebook\react\fabric\jni\AsyncEventBeat.h)
-class AsyncEventBeat final : public facebook::react::EventBeat { //, public facebook::react::EventBeatManagerObserver {
+class AsyncEventBeat final : public facebook::react::EventBeat {
  public:
   AsyncEventBeat(
       facebook::react::EventBeat::SharedOwnerBox const &ownerBox,
-      // EventBeatManager *eventBeatManager,
       const winrt::Microsoft::ReactNative::ReactContext &context,
-      facebook::react::RuntimeExecutor runtimeExecutor,
-      std::weak_ptr<FabricUIManager> uiManager)
-      : EventBeat(ownerBox),
-        m_context(context),
-        // eventBeatManager_(eventBeatManager),
-        runtimeExecutor_(runtimeExecutor),
-        uiManager_(uiManager) {
-    m_context.UIDispatcher().Post([this, uiManager, ownerBox = ownerBox_]() {
-      auto owner = ownerBox->owner.lock();
-      if (!owner) {
-        return;
-      }
-
-#ifndef CORE_ABI
-      // TODO: should use something other than CompositionTarget::Rendering ... not sure where to plug this in yet
-      // Getting the beat running to unblock basic events
-      m_rendering = xaml::Media::CompositionTarget::Rendering(
-          winrt::auto_revoke, [this, ownerBox](const winrt::IInspectable &, const winrt::IInspectable & /*args*/) {
-            auto owner = ownerBox->owner.lock();
-            if (!owner) {
-              return;
-            }
+      facebook::react::RuntimeExecutor runtimeExecutor)
+      : EventBeat(ownerBox), m_context(context), m_runtimeExecutor(runtimeExecutor) {}
 
-            tick();
-          });
-#endif // CORE_ABI
-    });
-
-    // eventBeatManager->addObserver(*this);
-  }
-
-  ~AsyncEventBeat() {
-    // eventBeatManager_->removeObserver(*this);
-  }
+  void induce() const override {
+    if (!isRequested_ || m_isBeatCallbackScheduled) {
+      isRequested_ = false;
+      return;
+    }
+    isRequested_ = false;
+    m_isBeatCallbackScheduled = true;
 
-  void tick() const /* override */ {
-    runtimeExecutor_([this, ownerBox = ownerBox_](facebook::jsi::Runtime &runtime) {
+    m_runtimeExecutor([this, ownerBox = ownerBox_](jsi::Runtime &runtime) {
       auto owner = ownerBox->owner.lock();
       if (!owner) {
         return;
       }
 
-      this->beat(runtime);
+      m_isBeatCallbackScheduled = false;
+      if (beatCallback_) {
+        beatCallback_(runtime);
+      }
     });
   }
 
-  void induce() const override {
-    tick();
-  }
-
   void request() const override {
     bool alreadyRequested = isRequested_;
     EventBeat::request();
     if (!alreadyRequested) {
-      if (auto uiManager = uiManager_.lock()) {
-        // Notifies that an event will be dispatched (e.g. LayoutEvent)
-        // uiManager->onRequestEventBeat();
-      }
+      m_context.UIDispatcher().Post([this, ownerBox = ownerBox_]() {
+        auto owner = ownerBox->owner.lock();
+        if (!owner) {
+          return;
+        }
+        induce();
+      });
     }
   }
 
  private:
-  // EventBeatManager *eventBeatManager_;
-  xaml::Media::CompositionTarget::Rendering_revoker m_rendering;
+  mutable std::atomic<bool> m_isBeatCallbackScheduled{false};
   winrt::Microsoft::ReactNative::ReactContext m_context;
-  facebook::react::RuntimeExecutor runtimeExecutor_;
-  std::weak_ptr<FabricUIManager> uiManager_;
+  facebook::react::RuntimeExecutor m_runtimeExecutor;
 };
 
 std::shared_ptr<facebook::react::ComponentDescriptorProviderRegistry const> sharedProviderRegistry() {
@@ -154,20 +119,14 @@ std::shared_ptr<facebook::react::ComponentDescriptorProviderRegistry const> shar
         facebook::react::concreteComponentDescriptorProvider<facebook::react::RawTextComponentDescriptor>());
     providerRegistry->add(
         facebook::react::concreteComponentDescriptorProvider<facebook::react::ScrollViewComponentDescriptor>());
-#ifndef CORE_ABI
-    providerRegistry->add(
-        facebook::react::concreteComponentDescriptorProvider<facebook::react::SliderComponentDescriptor>());
-#endif // CORE_ABI
     providerRegistry->add(
         facebook::react::concreteComponentDescriptorProvider<facebook::react::SwitchComponentDescriptor>());
     providerRegistry->add(
         facebook::react::concreteComponentDescriptorProvider<facebook::react::TextComponentDescriptor>());
     providerRegistry->add(
         facebook::react::concreteComponentDescriptorProvider<facebook::react::ViewComponentDescriptor>());
-#ifndef CORE_ABI
     providerRegistry->add(
         facebook::react::concreteComponentDescriptorProvider<facebook::react::WindowsTextInputComponentDescriptor>());
-#endif // CORE_ABI
     return providerRegistry;
   }();
 
@@ -187,19 +146,14 @@ void FabricUIManager::installFabricUIManager() noexcept {
 
   auto runtimeExecutor = SchedulerSettings::GetRuntimeExecutor(m_context.Properties());
 
-  // TODO: T31905686 Create synchronous Event Beat
   facebook::react::EventBeat::Factory synchronousBeatFactory =
-      [/*eventBeatManager,*/ runtimeExecutor, localUIManager = weak_from_this(), context = m_context](
-          facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, /* eventBeatManager, */ context, runtimeExecutor, localUIManager);
+      [runtimeExecutor, context = m_context](facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
+        return std::make_unique<AsyncEventBeat>(ownerBox, context, runtimeExecutor);
       };
 
   facebook::react::EventBeat::Factory asynchronousBeatFactory =
-      [/*eventBeatManager,*/ runtimeExecutor, localUIManager = weak_from_this(), context = m_context](
-          facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
-        return std::make_unique<AsyncEventBeat>(
-            ownerBox, /* eventBeatManager, */ context, runtimeExecutor, localUIManager);
+      [runtimeExecutor, context = m_context](facebook::react::EventBeat::SharedOwnerBox const &ownerBox) {
+        return std::make_unique<AsyncEventBeat>(ownerBox, context, runtimeExecutor);
       };
 
   contextContainer->insert("ReactNativeConfig", config);
@@ -210,15 +164,10 @@ void FabricUIManager::installFabricUIManager() noexcept {
                                         facebook::react::ContextContainer::Shared const &contextContainer)
       -> facebook::react::ComponentDescriptorRegistry::Shared {
     auto registry = sharedProviderRegistry()->createComponentDescriptorRegistry({eventDispatcher, contextContainer});
-    // Enabling the fallback component will require us to run the view component codegen to generate
-    // UnimplementedNativeViewComponentDescriptor
-    /*
     auto mutableRegistry = std::const_pointer_cast<facebook::react::ComponentDescriptorRegistry>(registry);
     mutableRegistry->setFallbackComponentDescriptor(
         std::make_shared<facebook::react::UnimplementedNativeViewComponentDescriptor>(
-            facebook::react::ComponentDescriptorParameters{
-                eventDispatcher, contextContainer, nullptr}));
-    */
+            facebook::react::ComponentDescriptorParameters{eventDispatcher, contextContainer, nullptr}));
     return registry;
   };
   toolbox.runtimeExecutor = runtimeExecutor;
@@ -239,7 +188,7 @@ void FabricUIManager::installFabricUIManager() noexcept {
   m_surfaceManager = std::make_shared<facebook::react::SurfaceManager>(*m_scheduler);
 }
 
-const ComponentViewRegistry &FabricUIManager::GetViewRegistry() const noexcept {
+const IComponentViewRegistry &FabricUIManager::GetViewRegistry() const noexcept {
   return m_registry;
 }
 
@@ -248,33 +197,26 @@ void FabricUIManager::startSurface(
     facebook::react::SurfaceId surfaceId,
     const std::string &moduleName,
     const folly::dynamic &initialProps) noexcept {
-#ifndef CORE_ABI
-  auto xamlRootView = static_cast<IXamlRootView *>(rootview);
-  auto rootFE = xamlRootView->GetXamlView().as<xaml::FrameworkElement>();
-
-  m_surfaceRegistry.insert({surfaceId, xamlRootView->GetXamlView()});
-#endif // CORE_ABI
+  auto CompositionRootView = static_cast<ICompositionRootView *>(rootview);
+  m_surfaceRegistry.insert({surfaceId, {CompositionRootView->GetVisual()}});
 
   m_context.UIDispatcher().Post([self = shared_from_this(), surfaceId]() {
-    self->m_registry.dequeueComponentViewWithComponentHandle(facebook::react::RootShadowNode::Handle(), surfaceId);
+    auto &rootComponentViewDescriptor = self->m_registry.dequeueComponentViewWithComponentHandle(
+        facebook::react::RootShadowNode::Handle(), surfaceId, self->m_compContext);
+
+    self->m_surfaceRegistry.at(surfaceId).rootVisual.InsertAt(
+        static_cast<const CompositionBaseComponentView &>(*rootComponentViewDescriptor.view).Visual(), 0);
   });
 
   facebook::react::LayoutContext context;
-
-  // TODO: This call wont work with winUI
-  context.pointScaleFactor = static_cast<facebook::react::Float>(
-      winrt::Windows::Graphics::Display::DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel());
-
   facebook::react::LayoutConstraints constraints;
-#ifndef CORE_ABI
-  constraints.minimumSize.height = static_cast<facebook::react::Float>(rootFE.ActualHeight());
-  constraints.minimumSize.width = static_cast<facebook::react::Float>(rootFE.ActualWidth());
-  constraints.maximumSize.height = static_cast<facebook::react::Float>(rootFE.ActualHeight());
-  constraints.maximumSize.width = static_cast<facebook::react::Float>(rootFE.ActualWidth());
-  constraints.layoutDirection = rootFE.FlowDirection() == xaml::FlowDirection::LeftToRight
-      ? facebook::react::LayoutDirection::LeftToRight
-      : facebook::react::LayoutDirection::RightToLeft;
-#endif // CORE_ABI
+  context.pointScaleFactor = static_cast<float>(CompositionRootView->ScaleFactor());
+  context.fontSizeMultiplier = static_cast<float>(CompositionRootView->ScaleFactor());
+  constraints.minimumSize.height = static_cast<float>(CompositionRootView->GetActualHeight());
+  constraints.minimumSize.width = static_cast<float>(CompositionRootView->GetActualWidth());
+  constraints.maximumSize.height = static_cast<float>(CompositionRootView->GetActualHeight());
+  constraints.maximumSize.width = static_cast<float>(CompositionRootView->GetActualWidth());
+  constraints.layoutDirection = facebook::react::LayoutDirection::LeftToRight;
 
   m_surfaceManager->startSurface(
       surfaceId,
@@ -303,17 +245,7 @@ void FabricUIManager::constraintSurfaceLayout(
   m_surfaceManager->constraintSurfaceLayout(surfaceId, layoutConstraints, layoutContext);
 }
 
-void FabricUIManager::didMountComponentsWithRootTag(facebook::react::SurfaceId surfaceId) noexcept {
-  auto rootComponentViewDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);
-#ifndef CORE_ABI
-  auto children = m_surfaceRegistry.at(surfaceId).as<xaml::Controls::Panel>().Children();
-
-  uint32_t index;
-  if (!children.IndexOf(static_cast<ViewComponentView &>(*rootComponentViewDescriptor.view).Element(), index)) {
-    children.Append(static_cast<ViewComponentView &>(*rootComponentViewDescriptor.view).Element());
-  }
-#endif // CORE_ABI
-}
+void FabricUIManager::didMountComponentsWithRootTag(facebook::react::SurfaceId surfaceId) noexcept {}
 
 struct RemoveDeleteMetadata {
   facebook::react::Tag tag;
@@ -333,7 +265,7 @@ void FabricUIManager::RCTPerformMountInstructions(
       case facebook::react::ShadowViewMutation::Create: {
         auto &newChildShadowView = mutation.newChildShadowView;
         auto &newChildViewDescriptor = m_registry.dequeueComponentViewWithComponentHandle(
-            newChildShadowView.componentHandle, newChildShadowView.tag);
+            newChildShadowView.componentHandle, newChildShadowView.tag, m_compContext);
         // observerCoordinator.registerViewComponentDescriptor(newChildViewDescriptor, surfaceId);
         break;
       }
@@ -465,46 +397,18 @@ void FabricUIManager::schedulerDidFinishTransaction(
 void FabricUIManager::schedulerDidRequestPreliminaryViewAllocation(
     facebook::react::SurfaceId surfaceId,
     const facebook::react::ShadowNode &shadowView) {
-  /*
-    if (m_context.UIDispatcher().HasThreadAccess()) {
-    m_registry.dequeueComponentViewWithComponentHandle(shadowView.componentHandle, surfaceId);
+  // iOS does not do this optimization, but Android does.  It maybe that android's allocations are more expensive due to
+  // the Java boundary.
+  // TODO: We should do some perf tests to see if this is worth doing.
+
+  if (m_context.UIDispatcher().HasThreadAccess()) {
+    m_registry.dequeueComponentViewWithComponentHandle(shadowView.getComponentHandle(), surfaceId, m_compContext);
   } else {
-      m_context.UIDispatcher().Post(
-        [componentHandle = shadowView.componentHandle, surfaceId, self = shared_from_this()]() {
-          self->m_registry.dequeueComponentViewWithComponentHandle(componentHandle, surfaceId);
-          });
+    m_context.UIDispatcher().Post(
+        [componentHandle = shadowView.getComponentHandle(), surfaceId, self = shared_from_this()]() {
+          self->m_registry.dequeueComponentViewWithComponentHandle(componentHandle, surfaceId, self->m_compContext);
+        });
   }
-  */
-
-  // Not needed on iOS.. so maybe not needed in windows?
-  /*
-  bool isLayoutableShadowNode = shadowView.layoutMetrics != facebook::react::EmptyLayoutMetrics;
-
-  shadowView.props
-
-  local_ref<ReadableMap::javaobject> props =
-      castReadableMap(ReadableNativeMap::newObjectCxxArgs(shadowView.props->rawProps));
-  auto component = getPlatformComponentName(shadowView);
-
-  preallocateView(
-      localJavaUIManager,
-      surfaceId,
-      shadowView.tag,
-      component.get(),
-      props.get(),
-      (javaStateWrapper != nullptr ? javaStateWrapper.get() : nullptr),
-      isLayoutableShadowNode);
-
-  assert(false);
-
-  */
-}
-
-void FabricUIManager::schedulerDidCloneShadowNode(
-    facebook::react::SurfaceId /*surfaceId*/,
-    const facebook::react::ShadowNode & /*oldShadowNode*/,
-    const facebook::react::ShadowNode & /*newShadowNode*/) {
-  // currently unused
 }
 
 void FabricUIManager::schedulerDidDispatchCommand(
@@ -541,6 +445,10 @@ void FabricUIManager::schedulerDidSendAccessibilityEvent(
 void FabricUIManager::Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
   m_context = reactContext;
 
+  m_compContext =
+      winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+          reactContext.Properties().Handle());
+
   m_registry.Initialize(reactContext);
 
   m_context.Properties().Set(FabicUIManagerProperty(), shared_from_this());

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.h

@@ -2,11 +2,13 @@
 // Licensed under the MIT License.
 #pragma once
 
+#include <Fabric/Composition/CompositionHelpers.h>
 #include <NativeModules.h>
 #include <React.h>
 #include <react/renderer/scheduler/SchedulerDelegate.h>
 #include <react/renderer/scheduler/SurfaceManager.h>
-#include "ComponentViewRegistry.h"
+#include <winrt/Windows.UI.Composition.h>
+#include "Composition/ComponentViewRegistry.h"
 
 namespace facebook::react {
 class Scheduler;
@@ -44,7 +46,7 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
       const facebook::react::LayoutConstraints &layoutConstraints,
       const facebook::react::LayoutContext &layoutContext) const noexcept;
 
-  const ComponentViewRegistry &GetViewRegistry() const noexcept;
+  const IComponentViewRegistry &GetViewRegistry() const noexcept;
 
  private:
   void installFabricUIManager() noexcept;
@@ -58,6 +60,7 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   void didMountComponentsWithRootTag(facebook::react::SurfaceId surfaceId) noexcept;
 
   winrt::Microsoft::ReactNative::ReactContext m_context;
+  winrt::Microsoft::ReactNative::Composition::ICompositionContext m_compContext;
   std::shared_ptr<facebook::react::Scheduler> m_scheduler;
   std::shared_ptr<facebook::react::SurfaceManager> m_surfaceManager;
   std::mutex m_schedulerMutex; // Protect m_scheduler
@@ -65,9 +68,11 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   bool m_followUpTransactionRequired{false};
 
   ComponentViewRegistry m_registry;
-#ifndef CORE_ABI
-  std::unordered_map<facebook::react::SurfaceId, XamlView> m_surfaceRegistry;
-#endif // CORE_ABI
+  struct SurfaceInfo {
+    winrt::Microsoft::ReactNative::Composition::IVisual rootVisual{nullptr};
+  };
+
+  std::unordered_map<facebook::react::SurfaceId, SurfaceInfo> m_surfaceRegistry;
 
   // Inherited via SchedulerDelegate
   virtual void schedulerDidFinishTransaction(
@@ -75,10 +80,6 @@ struct FabricUIManager final : public std::enable_shared_from_this<FabricUIManag
   virtual void schedulerDidRequestPreliminaryViewAllocation(
       facebook::react::SurfaceId surfaceId,
       const facebook::react::ShadowNode &shadowView) override;
-  virtual void schedulerDidCloneShadowNode(
-      facebook::react::SurfaceId surfaceId,
-      const facebook::react::ShadowNode &oldShadowNode,
-      const facebook::react::ShadowNode &newShadowNode) override;
   virtual void schedulerDidDispatchCommand(
       facebook::react::ShadowView const &shadowView,
       std::string const &commandName,

package/Microsoft.ReactNative/Fabric/IComponentViewRegistry.h

@@ -0,0 +1,34 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ComponentView.h"
+
+#include <Fabric/Composition/CompositionHelpers.h>
+#include <Microsoft.ReactNative.Cxx/ReactContext.h>
+
+namespace Microsoft::ReactNative {
+
+struct ComponentViewDescriptor final {
+  std::shared_ptr<IComponentView> view{nullptr};
+};
+
+struct IComponentViewRegistry {
+ public:
+  virtual void Initialize(winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept = 0;
+
+  virtual ComponentViewDescriptor const &dequeueComponentViewWithComponentHandle(
+      facebook::react::ComponentHandle componentHandle,
+      facebook::react::Tag tag,
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext) noexcept = 0;
+  virtual ComponentViewDescriptor const &componentViewDescriptorWithTag(facebook::react::Tag tag) const noexcept = 0;
+  virtual std::shared_ptr<IComponentView> findComponentViewWithTag(facebook::react::Tag tag) const noexcept = 0;
+  virtual void enqueueComponentViewWithComponentHandle(
+      facebook::react::ComponentHandle componentHandle,
+      facebook::react::Tag tag,
+      ComponentViewDescriptor componentViewDescriptor) noexcept = 0;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/ImageManager.cpp

@@ -4,23 +4,21 @@
 #include "pch.h"
 
 #include <react/renderer/imagemanager/ImageManager.h>
+#include "WindowsImageManager.h"
 
 namespace facebook {
 namespace react {
 
-ImageManager::ImageManager(ContextContainer::Shared const &contextContainer) {
-  // Silence unused-private-field warning.
-  (void)self_;
-  // Not implemented.
+ImageManager::ImageManager(ContextContainer::Shared const &) {
+  self_ = new Microsoft::ReactNative::WindowsImageManager();
 }
 
 ImageManager::~ImageManager() {
-  // Not implemented.
+  delete (Microsoft::ReactNative::WindowsImageManager *)self_;
 }
 
 ImageRequest ImageManager::requestImage(const ImageSource &imageSource, SurfaceId surfaceId) const {
-  // Not implemented.
-  return ImageRequest(imageSource, nullptr);
+  return ((Microsoft::ReactNative::WindowsImageManager *)self_)->requestImage(imageSource, surfaceId);
 }
 
 } // namespace react

package/Microsoft.ReactNative/Fabric/ImageRequest.cpp

@@ -9,29 +9,44 @@ namespace facebook {
 namespace react {
 
 ImageRequest::ImageRequest(ImageSource imageSource, std::shared_ptr<const ImageTelemetry> telemetry)
-    : imageSource_(std::move(imageSource)), telemetry_(telemetry) {
-  // Not implemented.
+    : imageSource_(std::move(imageSource)), telemetry_(std::move(telemetry)) {
+  coordinator_ = std::make_shared<ImageResponseObserverCoordinator>();
 }
 
 ImageRequest::ImageRequest(ImageRequest &&other) noexcept
     : imageSource_(std::move(other.imageSource_)),
       telemetry_(std::move(other.telemetry_)),
       coordinator_(std::move(other.coordinator_)) {
-  // Not implemented.
+  other.coordinator_ = nullptr;
+  other.cancelRequest_ = nullptr;
+  other.telemetry_ = nullptr;
+  other.imageSource_ = {};
 }
 
 ImageRequest::~ImageRequest() {
-  // Not implemented.
+  if (cancelRequest_) {
+    cancelRequest_();
+  }
+}
+
+void ImageRequest::setCancelationFunction(std::function<void(void)> cancelationFunction) {
+  cancelRequest_ = cancelationFunction;
+}
+
+const ImageSource &ImageRequest::getImageSource() const {
+  return imageSource_;
+}
+
+const std::shared_ptr<const ImageTelemetry> &ImageRequest::getSharedTelemetry() const {
+  return telemetry_;
 }
 
 const ImageResponseObserverCoordinator &ImageRequest::getObserverCoordinator() const {
-  // Not implemented
-  abort();
+  return *coordinator_;
 }
 
 const std::shared_ptr<const ImageResponseObserverCoordinator> &ImageRequest::getSharedObserverCoordinator() const {
-  // Not implemented
-  abort();
+  return coordinator_;
 }
 
 } // namespace react

package/Microsoft.ReactNative/Fabric/ReactTaggedView.h

@@ -0,0 +1,35 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "ComponentView.h"
+
+namespace Microsoft::ReactNative {
+
+/**
+ * Lightweight wrapper class around a ComponentView with a react tag which registers a
+ * constant react tag at initialization time for a stable hash and provides the
+ * underlying view to a caller if that underlying view's react tag has not
+ * changed from the one provided at initalization time (i.e. recycled).
+ */
+struct ReactTaggedView {
+  ReactTaggedView(std::shared_ptr<IComponentView> componentView) {
+    m_view = std::move(componentView);
+    m_tag = m_view->tag();
+  }
+
+  std::shared_ptr<IComponentView> &view() noexcept {
+    if (m_view && m_view->tag() != m_tag) {
+      m_view = nullptr;
+    }
+    return m_view;
+  }
+
+ private:
+  facebook::react::Tag m_tag;
+  std::shared_ptr<IComponentView> m_view;
+};
+
+} // namespace Microsoft::ReactNative