react-native-tvos 0.85.3-0 → 0.86.0-0

package/ReactAndroid/src/main/jni/react/fabric/EventEmitterWrapper.cpp

@@ -7,6 +7,7 @@
 
 #include "EventEmitterWrapper.h"
 #include <fbjni/fbjni.h>
+#include <react/timing/primitives.h>
 
 #include <utility>
 
@@ -14,10 +15,24 @@ using namespace facebook::jni;
 
 namespace facebook::react {
 
+namespace {
+
+/*
+ * Converts a Java timestamp (milliseconds since boot from
+ * SystemClock.uptimeMillis()) to a HighResTimeStamp.
+ */
+HighResTimeStamp highResTimeStampFromMillis(jlong millis) {
+  return HighResTimeStamp::fromChronoSteadyClockTimePoint(
+      std::chrono::steady_clock::time_point(std::chrono::milliseconds(millis)));
+}
+
+} // namespace
+
 void EventEmitterWrapper::dispatchEvent(
     std::string eventName,
     NativeMap* payload,
-    int category) {
+    int category,
+    jlong eventTimestamp) {
   // It is marginal, but possible for this to be constructed without a valid
   // EventEmitter. In those cases, make sure we noop/blackhole events instead of
   // crashing.
@@ -25,13 +40,15 @@ void EventEmitterWrapper::dispatchEvent(
     eventEmitter->dispatchEvent(
         std::move(eventName),
         (payload != nullptr) ? payload->consume() : folly::dynamic::object(),
-        static_cast<RawEvent::Category>(category));
+        static_cast<RawEvent::Category>(category),
+        highResTimeStampFromMillis(eventTimestamp));
   }
 }
 
 void EventEmitterWrapper::dispatchEventSynchronously(
     std::string eventName,
-    NativeMap* params) {
+    NativeMap* params,
+    jlong eventTimestamp) {
   // It is marginal, but possible for this to be constructed without a valid
   // EventEmitter. In those cases, make sure we noop/blackhole events instead of
   // crashing.
@@ -40,21 +57,24 @@ void EventEmitterWrapper::dispatchEventSynchronously(
       eventEmitter->dispatchEvent(
           std::move(eventName),
           (params != nullptr) ? params->consume() : folly::dynamic::object(),
-          RawEvent::Category::Discrete);
+          RawEvent::Category::Discrete,
+          highResTimeStampFromMillis(eventTimestamp));
     });
   }
 }
 
 void EventEmitterWrapper::dispatchUniqueEvent(
     std::string eventName,
-    NativeMap* payload) {
+    NativeMap* payload,
+    jlong eventTimestamp) {
   // It is marginal, but possible for this to be constructed without a valid
   // EventEmitter. In those cases, make sure we noop/blackhole events instead of
   // crashing.
   if (eventEmitter != nullptr) {
     eventEmitter->dispatchUniqueEvent(
         std::move(eventName),
-        (payload != nullptr) ? payload->consume() : folly::dynamic::object());
+        (payload != nullptr) ? payload->consume() : folly::dynamic::object(),
+        highResTimeStampFromMillis(eventTimestamp));
   }
 }
 

package/ReactAndroid/src/main/jni/react/fabric/EventEmitterWrapper.h

@@ -25,9 +25,9 @@ class EventEmitterWrapper : public jni::HybridClass<EventEmitterWrapper> {
 
   SharedEventEmitter eventEmitter;
 
-  void dispatchEvent(std::string eventName, NativeMap *payload, int category);
-  void dispatchEventSynchronously(std::string eventName, NativeMap *params);
-  void dispatchUniqueEvent(std::string eventName, NativeMap *payload);
+  void dispatchEvent(std::string eventName, NativeMap *payload, int category, jlong eventTimestamp);
+  void dispatchEventSynchronously(std::string eventName, NativeMap *params, jlong eventTimestamp);
+  void dispatchUniqueEvent(std::string eventName, NativeMap *payload, jlong eventTimestamp);
 };
 
 } // namespace facebook::react

package/ReactAndroid/src/main/jni/react/fabric/FabricMountingManager.cpp

@@ -52,6 +52,15 @@ void FabricMountingManager::onSurfaceStop(SurfaceId surfaceId) {
   allocatedViewRegistry_.erase(surfaceId);
 }
 
+bool FabricMountingManager::isViewAllocated(SurfaceId surfaceId, Tag tag) {
+  std::lock_guard lock(allocatedViewsMutex_);
+  auto it = allocatedViewRegistry_.find(surfaceId);
+  if (it == allocatedViewRegistry_.end()) {
+    return false;
+  }
+  return it->second.count(tag) > 0;
+}
+
 namespace {
 
 #ifdef REACT_NATIVE_DEBUG
@@ -1026,6 +1035,20 @@ void FabricMountingManager::destroyUnmountedShadowNode(
   auto tag = family.getTag();
   auto surfaceId = family.getSurfaceId();
 
+  // Remove from allocatedViewRegistry so that executeMount does not skip
+  // the Create mount item for this tag. Without this, if the view was
+  // preallocated and then destroyed (e.g. due to a superseded concurrent
+  // render), executeMount would skip the Create because allocatedViewTags
+  // still contains the tag, but the Java side no longer has the view in
+  // tagToViewState (it was deleted by destroyUnmountedView below).
+  {
+    std::lock_guard allocatedViewsLock(allocatedViewsMutex_);
+    auto allocatedViewsIterator = allocatedViewRegistry_.find(surfaceId);
+    if (allocatedViewsIterator != allocatedViewRegistry_.end()) {
+      allocatedViewsIterator->second.erase(tag);
+    }
+  }
+
   // ThreadScope::WithClassLoader is necessary because
   // destroyUnmountedShadowNode is being called from a destructor thread
   jni::ThreadScope::WithClassLoader([&]() {
@@ -1206,6 +1229,30 @@ void FabricMountingManager::synchronouslyUpdateViewOnUIThread(
   synchronouslyUpdateViewOnUIThreadJNI(javaUIManager_, viewTag, propsMap);
 }
 
+void FabricMountingManager::captureViewSnapshot(Tag tag, SurfaceId surfaceId) {
+  static auto captureViewSnapshotJNI =
+      JFabricUIManager::javaClassStatic()->getMethod<void(jint, jint)>(
+          "captureViewSnapshot");
+  captureViewSnapshotJNI(javaUIManager_, tag, surfaceId);
+}
+
+void FabricMountingManager::setViewSnapshot(
+    Tag sourceTag,
+    Tag targetTag,
+    SurfaceId surfaceId) {
+  static auto setViewSnapshotJNI =
+      JFabricUIManager::javaClassStatic()->getMethod<void(jint, jint, jint)>(
+          "setViewSnapshot");
+  setViewSnapshotJNI(javaUIManager_, sourceTag, targetTag, surfaceId);
+}
+
+void FabricMountingManager::clearPendingSnapshots() {
+  static auto clearPendingSnapshotsJNI =
+      JFabricUIManager::javaClassStatic()->getMethod<void()>(
+          "clearPendingSnapshots");
+  clearPendingSnapshotsJNI(javaUIManager_);
+}
+
 void FabricMountingManager::scheduleReactRevisionMerge(SurfaceId surfaceId) {
   static const auto scheduleReactRevisionMerge =
       JFabricUIManager::javaClassStatic()->getMethod<void(int32_t)>(

package/ReactAndroid/src/main/jni/react/fabric/FabricMountingManager.h

@@ -40,6 +40,20 @@ class FabricMountingManager final {
    */
   void drainPreallocateViewsQueue();
 
+  /*
+   * Preallocates a view on the Java side and registers the tag in
+   * allocatedViewRegistry_ so that executeMount skips the redundant Create
+   * mount item for this tag.
+   */
+  void preallocateShadowView(const ShadowView &shadowView);
+
+  /*
+   * Returns true if the given tag is registered in allocatedViewRegistry_
+   * for the given surface. A registered tag means executeMount will skip
+   * the Create mount item (the view was already preallocated).
+   */
+  bool isViewAllocated(SurfaceId surfaceId, Tag tag);
+
   void executeMount(const MountingTransaction &transaction);
 
   void dispatchCommand(const ShadowView &shadowView, const std::string &commandName, const folly::dynamic &args);
@@ -54,6 +68,12 @@ class FabricMountingManager final {
 
   void synchronouslyUpdateViewOnUIThread(Tag viewTag, const folly::dynamic &props);
 
+  void captureViewSnapshot(Tag tag, SurfaceId surfaceId);
+
+  void setViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId);
+
+  void clearPendingSnapshots();
+
   void scheduleReactRevisionMerge(SurfaceId surfaceId);
 
  private:
@@ -75,12 +95,6 @@ class FabricMountingManager final {
 
   std::unordered_map<SurfaceId, std::unordered_set<Tag>> allocatedViewRegistry_{};
   std::recursive_mutex allocatedViewsMutex_;
-
-  /*
-   * Calls FabricUIManager.preallocateView() on the Java side if view needs to
-   * be preallocated.
-   */
-  void preallocateShadowView(const ShadowView &shadowView);
 };
 
 } // namespace facebook::react

package/ReactAndroid/src/main/jni/react/fabric/FabricUIManagerBinding.cpp

@@ -659,7 +659,7 @@ void FabricUIManagerBinding::schedulerShouldRenderTransactions(
     return;
   }
 
-  if (ReactNativeFeatureFlags::enableImagePrefetchingJNIBatchingAndroid()) {
+  if (ReactNativeFeatureFlags::enableImagePrefetchingAndroid()) {
     auto weakImageFetcher =
         scheduler_->getContextContainer()->find<std::weak_ptr<ImageFetcher>>(
             ImageFetcherKey);
@@ -797,6 +797,29 @@ void FabricUIManagerBinding::schedulerDidUpdateShadowTree(
   // no-op
 }
 
+void FabricUIManagerBinding::schedulerDidCaptureViewSnapshot(
+    Tag tag,
+    SurfaceId surfaceId) {
+  if (mountingManager_) {
+    mountingManager_->captureViewSnapshot(tag, surfaceId);
+  }
+}
+
+void FabricUIManagerBinding::schedulerDidSetViewSnapshot(
+    Tag sourceTag,
+    Tag targetTag,
+    SurfaceId surfaceId) {
+  if (mountingManager_) {
+    mountingManager_->setViewSnapshot(sourceTag, targetTag, surfaceId);
+  }
+}
+
+void FabricUIManagerBinding::schedulerDidClearPendingSnapshots() {
+  if (mountingManager_) {
+    mountingManager_->clearPendingSnapshots();
+  }
+}
+
 void FabricUIManagerBinding::onAnimationStarted() {
   auto mountingManager = getMountingManager("onAnimationStarted");
   if (!mountingManager) {

package/ReactAndroid/src/main/jni/react/fabric/FabricUIManagerBinding.h

@@ -117,6 +117,12 @@ class FabricUIManagerBinding : public jni::HybridClass<FabricUIManagerBinding>,
 
   void schedulerDidUpdateShadowTree(const std::unordered_map<Tag, folly::dynamic> &tagToProps) override;
 
+  void schedulerDidCaptureViewSnapshot(Tag tag, SurfaceId surfaceId) override;
+
+  void schedulerDidSetViewSnapshot(Tag sourceTag, Tag targetTag, SurfaceId surfaceId) override;
+
+  void schedulerDidClearPendingSnapshots() override;
+
   void setPixelDensity(float pointScaleFactor);
 
   void driveCxxAnimations();

package/ReactAndroid/src/main/jni/react/fabric/FocusOrderingHelper.cpp

@@ -6,7 +6,6 @@
  */
 
 #include "FocusOrderingHelper.h"
-#include <android/log.h>
 #include <react/renderer/uimanager/UIManager.h>
 
 namespace facebook::react {

package/ReactAndroid/src/main/jni/react/fabric/SurfaceHandlerBinding.cpp

@@ -60,6 +60,7 @@ void SurfaceHandlerBinding::setLayoutConstraints(
   context.swapLeftAndRightInRTL = (doLeftAndRightSwapInRTL != 0u);
   context.pointScaleFactor = pixelDensity;
   context.viewportOffset = {.x = offsetX, .y = offsetY};
+  context.viewportSize = {.width = maxWidth, .height = maxHeight};
   context.fontSizeMultiplier = fontScale;
 
   surfaceHandler_.constraintLayout(constraints, context);

package/ReactAndroid/src/main/jni/react/fabric/test_helper/FabricMountingManagerTestHelper.cpp

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "FabricMountingManagerTestHelper.h"
+
+#include <react/renderer/components/view/ViewComponentDescriptor.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/ComponentDescriptor.h>
+#include <react/renderer/mounting/ShadowView.h>
+
+namespace facebook::react {
+
+FabricMountingManagerTestHelper::FabricMountingManagerTestHelper(
+    jni::alias_ref<JFabricUIManager::javaobject> jFabricUIManager)
+    : javaUIManager_(jni::make_global(jFabricUIManager)) {
+  mountingManager_ = std::make_shared<FabricMountingManager>(javaUIManager_);
+
+  auto params = ComponentDescriptorParameters{
+      .eventDispatcher = EventDispatcher::Shared{},
+      .contextContainer = std::make_shared<ContextContainer>(),
+      .flavor = nullptr};
+  viewComponentDescriptor_ = std::make_unique<ViewComponentDescriptor>(params);
+}
+
+void FabricMountingManagerTestHelper::initHybrid(
+    jni::alias_ref<jhybridobject> jobj,
+    jni::alias_ref<JFabricUIManager::javaobject> jFabricUIManager) {
+  setCxxInstance(jobj, jFabricUIManager);
+}
+
+void FabricMountingManagerTestHelper::startSurface(jint surfaceId) {
+  mountingManager_->onSurfaceStart(surfaceId);
+}
+
+void FabricMountingManagerTestHelper::stopSurface(jint surfaceId) {
+  mountingManager_->onSurfaceStop(surfaceId);
+}
+
+void FabricMountingManagerTestHelper::preallocateView(
+    jint surfaceId,
+    jint tag) {
+  ShadowView sv{};
+  sv.componentName = "View";
+  sv.surfaceId = surfaceId;
+  sv.tag = tag;
+  sv.props = std::make_shared<const ViewProps>();
+  sv.layoutMetrics.frame.size = {.width = 100, .height = 100};
+  mountingManager_->preallocateShadowView(sv);
+}
+
+void FabricMountingManagerTestHelper::destroyUnmountedView(
+    jint surfaceId,
+    jint tag) {
+  auto family = viewComponentDescriptor_->createFamily(
+      {.tag = tag, .surfaceId = surfaceId, .instanceHandle = nullptr});
+  mountingManager_->destroyUnmountedShadowNode(*family);
+}
+
+bool FabricMountingManagerTestHelper::isTagAllocated(jint surfaceId, jint tag) {
+  return mountingManager_->isViewAllocated(surfaceId, tag);
+}
+
+void FabricMountingManagerTestHelper::registerNatives() {
+  registerHybrid({
+      makeNativeMethod(
+          "initHybrid", FabricMountingManagerTestHelper::initHybrid),
+      makeNativeMethod(
+          "startSurface", FabricMountingManagerTestHelper::startSurface),
+      makeNativeMethod(
+          "stopSurface", FabricMountingManagerTestHelper::stopSurface),
+      makeNativeMethod(
+          "preallocateView", FabricMountingManagerTestHelper::preallocateView),
+      makeNativeMethod(
+          "destroyUnmountedView",
+          FabricMountingManagerTestHelper::destroyUnmountedView),
+      makeNativeMethod(
+          "isTagAllocated", FabricMountingManagerTestHelper::isTagAllocated),
+  });
+}
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/fabric/test_helper/FabricMountingManagerTestHelper.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <react/renderer/components/view/ViewComponentDescriptor.h>
+
+#include <react/fabric/FabricMountingManager.h>
+
+namespace facebook::react {
+
+/**
+ * JNI test helper that wraps a real FabricMountingManager
+ */
+class FabricMountingManagerTestHelper : public jni::HybridClass<FabricMountingManagerTestHelper> {
+ public:
+  static constexpr auto kJavaDescriptor = "Lcom/facebook/react/fabric/FabricMountingManagerTestHelper;";
+
+  void startSurface(jint surfaceId);
+  void stopSurface(jint surfaceId);
+  void preallocateView(jint surfaceId, jint tag);
+  void destroyUnmountedView(jint surfaceId, jint tag);
+  bool isTagAllocated(jint surfaceId, jint tag);
+
+  static void registerNatives();
+
+ private:
+  friend HybridBase;
+
+  explicit FabricMountingManagerTestHelper(jni::alias_ref<JFabricUIManager::javaobject> jFabricUIManager);
+
+  static void initHybrid(
+      jni::alias_ref<jhybridobject> jobj,
+      jni::alias_ref<JFabricUIManager::javaobject> jFabricUIManager);
+
+  jni::global_ref<JFabricUIManager::javaobject> javaUIManager_;
+  std::shared_ptr<FabricMountingManager> mountingManager_;
+  std::unique_ptr<ViewComponentDescriptor> viewComponentDescriptor_;
+};
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/fabric/test_helper/OnLoad.cpp

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <fbjni/fbjni.h>
+
+#include "FabricMountingManagerTestHelper.h"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* /*unused*/) {
+  return facebook::jni::initialize(vm, [] {
+    facebook::react::FabricMountingManagerTestHelper::registerNatives();
+  });
+}