react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/ReactAndroid/src/main/jni/react/jni/ReadableNativeMap.h

@@ -11,10 +11,9 @@
 #include <folly/dynamic.h>
 #include <folly/json.h>
 #include <optional>
+#include <vector>
 
-#include "NativeCommon.h"
 #include "NativeMap.h"
-#include "ReadableNativeArray.h"
 
 namespace facebook::react {
 
@@ -24,7 +23,7 @@ struct ReadableMap : jni::JavaClass<ReadableMap> {
   static auto constexpr kJavaDescriptor = "Lcom/facebook/react/bridge/ReadableMap;";
 };
 
-void addDynamicToJArray(jni::local_ref<jni::JArrayClass<jobject>> jarray, jint index, const folly::dynamic &dyn);
+void addDynamicToJArray(jni::alias_ref<jni::JArrayClass<jobject>> jarray, jint index, const folly::dynamic &dyn);
 
 struct ReadableNativeMap : jni::HybridClass<ReadableNativeMap, NativeMap> {
   static auto constexpr kJavaDescriptor = "Lcom/facebook/react/bridge/ReadableNativeMap;";
@@ -32,7 +31,6 @@ struct ReadableNativeMap : jni::HybridClass<ReadableNativeMap, NativeMap> {
   jni::local_ref<jni::JArrayClass<jstring>> importKeys();
   jni::local_ref<jni::JArrayClass<jobject>> importValues();
   jni::local_ref<jni::JArrayClass<jobject>> importTypes();
-  std::optional<folly::dynamic> keys_;
   static jni::local_ref<jhybridobject> createWithContents(folly::dynamic &&map);
 
   static void mapException(std::exception_ptr ex);
@@ -41,6 +39,14 @@ struct ReadableNativeMap : jni::HybridClass<ReadableNativeMap, NativeMap> {
   using HybridBase::HybridBase;
   friend HybridBase;
   friend struct WritableNativeMap;
+
+ private:
+  void throwIfKeysNotImported() const;
+
+  // folly::dynamic stores object entries in an F14NodeMap, so these pointers
+  // remain valid across the insertions and replacements exposed by
+  // WritableNativeMap.
+  std::optional<std::vector<const folly::dynamic *>> values_;
 };
 
 } // namespace facebook::react

package/ReactAndroid/src/main/jni/react/jni/test/JArrayBufferTest.cpp

@@ -0,0 +1,164 @@
+/*
+ * 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 <react/jni/JArrayBuffer.h>
+#include <react/jni/JByteBufferMutableBuffer.h>
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+namespace facebook::react {
+
+namespace {
+
+class TestBuffer final : public jsi::MutableBuffer {
+ public:
+  explicit TestBuffer(std::vector<uint8_t> bytes) noexcept
+      : bytes_(std::move(bytes)) {}
+
+  size_t size() const override {
+    return bytes_.size();
+  }
+
+  uint8_t* data() override {
+    return bytes_.data();
+  }
+
+ private:
+  std::vector<uint8_t> bytes_;
+};
+
+} // namespace
+
+/*
+ * The static factories and toJSBuffer all need a live JavaVM, so the coverage
+ * available host-side is the ownership state machine itself: which buffers
+ * invalidate() may revoke, and whether mutableBuffer() reports a revoked borrow
+ * instead of handing out a dangling pointer. The JNI section at the bottom of
+ * this file covers the direct-ByteBuffer adapter on device.
+ */
+
+TEST(JArrayBufferTest, owningBufferExposesItsBytes) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  JArrayBuffer arrayBuffer{buffer, true};
+
+  EXPECT_TRUE(arrayBuffer.isOwningBytes());
+  EXPECT_EQ(arrayBuffer.mutableBuffer(), buffer);
+}
+
+TEST(JArrayBufferTest, borrowedBufferExposesItsBytesBeforeInvalidation) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  JArrayBuffer arrayBuffer{buffer, false};
+
+  EXPECT_FALSE(arrayBuffer.isOwningBytes());
+  EXPECT_EQ(arrayBuffer.mutableBuffer(), buffer);
+}
+
+/*
+ * Bug this catches: without the revocation, a module that stored a non-owning
+ * ArrayBuffer keeps a direct ByteBuffer over JS-heap bytes that the call frame
+ * no longer keeps alive, and every later read silently returns whatever now
+ * occupies that memory.
+ */
+TEST(JArrayBufferTest, invalidateRevokesABorrow) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  JArrayBuffer arrayBuffer{buffer, false};
+
+  arrayBuffer.invalidate();
+
+  EXPECT_THROW(arrayBuffer.mutableBuffer(), std::runtime_error);
+}
+
+TEST(JArrayBufferTest, invalidateLeavesAnOwningBufferUsable) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  JArrayBuffer arrayBuffer{buffer, true};
+
+  arrayBuffer.invalidate();
+
+  EXPECT_EQ(arrayBuffer.mutableBuffer(), buffer);
+}
+
+TEST(JArrayBufferTest, invalidateIsIdempotent) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  JArrayBuffer arrayBuffer{buffer, false};
+
+  arrayBuffer.invalidate();
+  arrayBuffer.invalidate();
+
+  EXPECT_THROW(arrayBuffer.mutableBuffer(), std::runtime_error);
+}
+
+// Revoking a borrow must drop the last reference this object holds, so an
+// aliasing adapter (and the JNI global ref inside it) is torn down with the
+// call frame rather than at the whim of the Java GC.
+TEST(JArrayBufferTest, invalidateReleasesTheBorrowedBuffer) {
+  auto buffer = std::make_shared<TestBuffer>(std::vector<uint8_t>{1, 2, 3});
+  std::weak_ptr<jsi::MutableBuffer> weakBuffer = buffer;
+  JArrayBuffer arrayBuffer{std::move(buffer), false};
+
+  arrayBuffer.invalidate();
+
+  EXPECT_TRUE(weakBuffer.expired());
+}
+
+#ifdef __ANDROID__
+
+/*
+ * JByteBufferMutableBuffer is the adapter every ArrayBuffer is built on, and it
+ * is pure JNI: size() and data() read a direct java.nio.ByteBuffer. That needs
+ * a live JavaVM, so it is only reachable in the on-device variant of this
+ * target.
+ *
+ * The Kotlin peer itself is not testable here — this APK carries no RN Java
+ * classes — so ArrayBuffer.kt stays covered by the Robolectric test.
+ */
+
+TEST(JByteBufferMutableBufferTest, exposesTheAddressAndSizeOfADirectBuffer) {
+  auto byteBuffer = jni::JByteBuffer::allocateDirect(4);
+  auto* bytes = byteBuffer->getDirectBytes();
+  const uint8_t expected[] = {1, 2, 3, 4};
+  std::memcpy(bytes, expected, sizeof(expected));
+
+  JByteBufferMutableBuffer buffer{byteBuffer};
+
+  EXPECT_EQ(buffer.size(), sizeof(expected));
+  EXPECT_EQ(buffer.data(), bytes);
+  EXPECT_EQ(std::memcmp(buffer.data(), expected, sizeof(expected)), 0);
+}
+
+TEST(JByteBufferMutableBufferTest, aliasesWrappedBytesWithoutCopying) {
+  uint8_t bytes[] = {1, 2, 3, 4};
+  auto byteBuffer = jni::JByteBuffer::wrapBytes(bytes, sizeof(bytes));
+
+  JByteBufferMutableBuffer buffer{byteBuffer};
+
+  EXPECT_EQ(buffer.data(), bytes);
+  EXPECT_EQ(buffer.size(), sizeof(bytes));
+}
+
+/*
+ * Bug this catches: GetDirectBufferAddress reports null for a zero-capacity
+ * direct buffer, and getDirectBytes turns that into a JNI exception. Without
+ * the short-circuit in data(), a zero-length ArrayBuffer — which JS can hand a
+ * TurboModule at any time — throws out of a path that has no business failing.
+ */
+TEST(JByteBufferMutableBufferTest, reportsNoDataForAnEmptyBuffer) {
+  auto byteBuffer = jni::JByteBuffer::allocateDirect(0);
+
+  JByteBufferMutableBuffer buffer{byteBuffer};
+
+  EXPECT_EQ(buffer.size(), 0u);
+  EXPECT_EQ(buffer.data(), nullptr);
+}
+
+#endif // __ANDROID__
+
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/jni/test/ModuleRegistryBuilderTest.cpp

@@ -0,0 +1,74 @@
+/*
+ * 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 <react/jni/ModuleRegistryBuilder.h>
+
+#include <fbjni/fbjni.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#ifndef RCT_REMOVE_LEGACY_ARCH
+
+namespace facebook::react {
+
+/**
+ * Pure-C++ unit tests for the JNI-free slice of `ModuleRegistryBuilder.cpp`.
+ *
+ * The bulk of this translation unit is JNI-coupled: `ModuleHolder::getName`
+ * and `ModuleHolder::getProvider` both call into a live JavaVM (via
+ * `getClass()` / `jni::make_global(self())`), so their behaviour is
+ * exercised by the Robolectric / instrumentation tests that run against a
+ * real JVM.
+ *
+ * The one branch that can be validated without calling into Java at all
+ * is `buildNativeModuleList`'s null-collection guard: when the incoming
+ * `alias_ref<JCollection<...>>` is a null reference, the function must
+ * short-circuit and return an empty vector rather than dereferencing the
+ * null collection. `alias_ref` is default-constructible to a null state
+ * whose `operator bool()` returns false, which is exactly what
+ * `buildNativeModuleList`'s `if (javaModules)` check tests against, so we
+ * can drive that path without touching JNI.
+ */
+
+/*
+ * Verifies the null-input contract of `buildNativeModuleList`: when the
+ * `javaModules` collection is a null `alias_ref`, no `JavaNativeModule`
+ * instances are constructed and the returned vector is empty.
+ *
+ * Bug this catches: if the `if (javaModules)` guard is ever removed or
+ * inverted, the subsequent `for (const auto& jm : *javaModules)` would
+ * dereference a null JNI reference and crash the process on every startup
+ * path that leaves `javaModules` unset (for example, new-architecture
+ * bring-up paths that legitimately pass no legacy Java modules). Because
+ * the crash would only surface once the process actually reaches this
+ * code with a null collection, catching it here — instead of relying on
+ * an app-level smoke test — is the earliest signal available.
+ *
+ * The `Instance` weak_ptr and `MessageQueueThread` shared_ptr are supplied
+ * as empty on purpose: the guard runs before either is dereferenced, so
+ * their state must not affect the null-collection contract.
+ */
+TEST(
+    ModuleRegistryBuilderTest,
+    buildNativeModuleListReturnsEmptyForNullCollection) {
+  std::weak_ptr<Instance> noInstance;
+  std::shared_ptr<MessageQueueThread> noQueue;
+  jni::alias_ref<jni::JCollection<JavaModuleWrapper::javaobject>::javaobject>
+      nullCollection;
+  ASSERT_FALSE(static_cast<bool>(nullCollection))
+      << "Precondition: default-constructed alias_ref must be null so that "
+         "the guard under test is actually exercised.";
+
+  auto modules = buildNativeModuleList(noInstance, nullCollection, noQueue);
+
+  EXPECT_TRUE(modules.empty());
+}
+
+} // namespace facebook::react
+
+#endif

package/ReactAndroid/src/main/jni/react/reactnativeblob/test/BlobCollectorTest.cpp

@@ -0,0 +1,151 @@
+/*
+ * 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 "BlobCollector.h"
+
+#include <fbjni/fbjni.h>
+#include <gtest/gtest.h>
+
+#include <array>
+#include <memory>
+#include <string>
+
+namespace facebook::react {
+namespace {
+
+class JContext : public jni::JavaClass<JContext> {
+ public:
+  static constexpr auto kJavaDescriptor = "Landroid/content/Context;";
+};
+
+class JInstrumentation : public jni::JavaClass<JInstrumentation> {
+ public:
+  static constexpr auto kJavaDescriptor = "Landroid/app/Instrumentation;";
+
+  jni::local_ref<JContext> getTargetContext() {
+    static const auto method =
+        javaClassStatic()->getMethod<JContext::javaobject()>(
+            "getTargetContext");
+    return method(self());
+  }
+};
+
+class JInstrumentationRegistry
+    : public jni::JavaClass<JInstrumentationRegistry> {
+ public:
+  static constexpr auto kJavaDescriptor =
+      "Landroidx/test/platform/app/InstrumentationRegistry;";
+
+  static jni::local_ref<JInstrumentation> getInstrumentation() {
+    static const auto method =
+        javaClassStatic()->getStaticMethod<JInstrumentation::javaobject()>(
+            "getInstrumentation");
+    return method(javaClassStatic());
+  }
+};
+
+class JReactApplicationContext
+    : public jni::JavaClass<JReactApplicationContext> {
+ public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/facebook/react/bridge/ReactApplicationContext;";
+};
+
+class JBridgeReactContext
+    : public jni::JavaClass<JBridgeReactContext, JReactApplicationContext> {
+ public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/facebook/react/bridge/BridgeReactContext;";
+
+  static jni::local_ref<JReactApplicationContext> create(
+      jni::alias_ref<JContext> context) {
+    static const auto constructor =
+        javaClassStatic()
+            ->getConstructor<JBridgeReactContext::javaobject(
+                JContext::javaobject)>();
+    return jni::static_ref_cast<JReactApplicationContext>(
+        javaClassStatic()->newObject(constructor, context.get()));
+  }
+};
+
+class JBlobModule : public jni::JavaClass<JBlobModule> {
+ public:
+  static constexpr auto kJavaDescriptor =
+      "Lcom/facebook/react/modules/blob/BlobModule;";
+
+  static jni::local_ref<JBlobModule> create(
+      jni::alias_ref<JReactApplicationContext> reactContext) {
+    static const auto constructor =
+        javaClassStatic()
+            ->getConstructor<JBlobModule::javaobject(
+                JReactApplicationContext::javaobject)>();
+    return javaClassStatic()->newObject(constructor, reactContext.get());
+  }
+
+  void store(jni::alias_ref<jni::JArrayByte> data, const std::string& blobId) {
+    static const auto method =
+        javaClassStatic()->getMethod<void(jbyteArray, jstring)>("store");
+    method(self(), data.get(), jni::make_jstring(blobId).get());
+  }
+
+  jlong getLengthOfBlob(const std::string& blobId) {
+    static const auto method =
+        javaClassStatic()->getMethod<jlong(jstring)>("getLengthOfBlob");
+    return method(self(), jni::make_jstring(blobId).get());
+  }
+};
+
+jni::local_ref<jni::JArrayByte> makeByteArray(const jbyte* bytes, jsize size) {
+  auto javaBytes = jni::JArrayByte::newArray(size);
+  javaBytes->setRegion(0, size, bytes);
+  return javaBytes;
+}
+
+class BlobCollectorTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    jni::ThreadScope::WithClassLoader([&] {
+      auto instrumentation = JInstrumentationRegistry::getInstrumentation();
+      auto context =
+          JBridgeReactContext::create(instrumentation->getTargetContext());
+      blobModule_ = jni::make_global(JBlobModule::create(context));
+    });
+  }
+
+  jni::global_ref<JBlobModule> blobModule_;
+};
+
+/*
+ * Bug this catches: the collector must ask Java for the blob's actual byte
+ * length and must release the same blob id when the JS host object is
+ * collected. A mismatch in method names, descriptor, object lifetime, or blob
+ * id plumbing would either report the wrong external-memory pressure to Hermes
+ * or leak blob storage after GC.
+ */
+TEST_F(
+    BlobCollectorTest,
+    testBlobCollectorReportsStoredLengthAndRemovesBlobOnDestruction) {
+  const std::string blobId{"native-collector-test"};
+  constexpr jsize blobLength = 7;
+  const std::array<jbyte, blobLength> bytes{0, 1, 1, 2, 3, 5, 8};
+
+  jni::ThreadScope::WithClassLoader([&] {
+    blobModule_->store(makeByteArray(bytes.data(), blobLength), blobId);
+    ASSERT_EQ(blobModule_->getLengthOfBlob(blobId), blobLength);
+
+    {
+      BlobCollector collector{blobModule_, blobId};
+
+      EXPECT_EQ(collector.getBlobLength(), blobLength);
+    }
+
+    EXPECT_EQ(blobModule_->getLengthOfBlob(blobId), 0);
+  });
+}
+
+} // namespace
+} // namespace facebook::react

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactExceptionManager.cpp

@@ -53,11 +53,37 @@ class ProcessedErrorImpl
       stack->add(ProcessedErrorStackFrameImpl::create(frame));
     }
 
-    auto extraDataDynamic =
-        jsi::dynamicFromValue(runtime, jsi::Value(runtime, error.extraData));
+    // Marshalling `extraData` out of the runtime can throw (e.g. a
+    // jsi::JSIException when the runtime is in a bad state during a fatal
+    // error). This runs inside the `noexcept` onJsError callback, so an
+    // escaping exception aborts the whole process; contain it and report the
+    // error without its extra data instead. `extraData` may end up null (here,
+    // or when the JS value is null/undefined); the Java field is nullable.
+    jni::local_ref<ReadableNativeMap::jhybridobject> extraData;
 
-    auto extraData =
-        ReadableNativeMap::createWithContents(std::move(extraDataDynamic));
+    auto reportWithoutExtraData = [&](const char* reason) {
+      LOG(ERROR)
+          << "JReactExceptionManager: failed to marshal JS error extraData; reporting the error without it: "
+          << reason;
+      try {
+        extraData = ReadableNativeMap::createWithContents(
+            folly::dynamic::object("extraDataMarshallingError", reason));
+      } catch (...) {
+        // The fallback allocation can itself throw; leave extraData null.
+        extraData = nullptr;
+      }
+    };
+
+    try {
+      auto extraDataDynamic =
+          jsi::dynamicFromValue(runtime, jsi::Value(runtime, error.extraData));
+      extraData =
+          ReadableNativeMap::createWithContents(std::move(extraDataDynamic));
+    } catch (const std::exception& e) {
+      reportWithoutExtraData(e.what());
+    } catch (...) {
+      reportWithoutExtraData("unknown exception");
+    }
 
     return newInstance(
         error.message,

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.cpp

@@ -251,6 +251,7 @@ void JReactHostInspectorTarget::recordFrameTimings(
       frameTimingSequence->getBeginTimestamp(),
       frameTimingSequence->getEndTimestamp(),
       frameTimingSequence->getScreenshot(),
+      frameTimingSequence->getVsyncInterval(),
   });
 }
 

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactHostInspectorTarget.h

@@ -113,6 +113,12 @@ struct JFrameTimingSequence : public jni::JavaClass<JFrameTimingSequence> {
     }
     return std::nullopt;
   }
+
+  HighResDuration getVsyncInterval() const
+  {
+    auto field = javaClassStatic()->getField<jlong>("vsyncIntervalNanos");
+    return HighResDuration::fromNanoseconds(static_cast<int64_t>(getFieldValue(field)));
+  }
 };
 
 struct JReactHostImpl : public jni::JavaClass<JReactHostImpl> {

package/ReactAndroid/src/main/jni/react/runtime/jni/JReactInstance.cpp

@@ -15,7 +15,6 @@
 #include <jsi/jsi.h>
 #include <react/jni/JRuntimeExecutor.h>
 #include <react/jni/JSLogging.h>
-#include <react/renderer/runtimescheduler/RuntimeSchedulerCallInvoker.h>
 #include <react/runtime/BridgelessNativeMethodCallInvoker.h>
 #include <react/runtime/JSRuntimeBindings.h>
 
@@ -89,10 +88,11 @@ JReactInstance::JReactInstance(
 
   auto unbufferedRuntimeExecutor = instance_->getUnbufferedRuntimeExecutor();
   // Set up the JS and native modules call invokers (for TurboModules)
-  auto jsInvoker = std::make_unique<RuntimeSchedulerCallInvoker>(
-      instance_->getRuntimeScheduler());
+  // Shares the instance's BufferedRuntimeExecutor so async calls from native
+  // are ordered against callFunctionOnModule and cannot run before the bundle
+  // has evaluated. invokeSync still goes straight to the scheduler.
   jsCallInvokerHolder_ = jni::make_global(
-      CallInvokerHolder::newObjectCxxArgs(std::move(jsInvoker)));
+      CallInvokerHolder::newObjectCxxArgs(instance_->createJSCallInvoker()));
   auto nativeMethodCallInvoker =
       std::make_unique<BridgelessNativeMethodCallInvoker>(
           sharedNativeMessageQueueThread);

package/ReactAndroid/src/main/res/views/uimanager/values-pt-rPT/strings.xml

@@ -9,7 +9,7 @@
     <string name="header_description" gender="unknown">Título</string>
     <string name="alert_description" gender="unknown">Aviso</string>
     <string name="combobox_description" gender="unknown">Caixa de combinação</string>
-    <string name="menubar_description" gender="unknown">Barra do menu</string>
+    <string name="menubar_description" gender="unknown">Barra de menus</string>
     <string name="menuitem_description" gender="unknown">Item do menu</string>
     <string name="progressbar_description" gender="unknown">Barra de progresso</string>
     <string name="radiogroup_description" gender="unknown">Grupo de opções</string>

package/ReactAndroid/src/main/res/views/uimanager/values-zu/strings.xml

@@ -3,7 +3,16 @@
 <!-- @generated -->
 <!-- FB Locale: zu_ZA -->
 <resources exclude-from-buck-resource-map="true">
+    <string name="image_description" gender="unknown">Isithombe</string>
+    <string name="imagebutton_description" gender="unknown">Inkinobho, Isithombe</string>
+    <string name="alert_description" gender="unknown">Isexwayiso</string>
     <string name="menu_description" gender="unknown">Imenyu</string>
+    <string name="menuitem_description" gender="unknown">Into Yemenyu</string>
+    <string name="scrollbar_description" gender="unknown">Ibha Lokuskrola</string>
     <string name="rn_tab_description" gender="unknown">Ithebhu</string>
+    <string name="timer_description" gender="unknown">Isibali-sikhathi</string>
+    <string name="state_expanded_description" gender="unknown">kwandisiwe</string>
+    <string name="state_collapsed_description" gender="unknown">ihlukanisiwe</string>
+    <string name="state_unselected_description" gender="unknown">okungakhethwanga</string>
     <string name="state_off_description" gender="unknown">kuvaliwe</string>
 </resources>

package/ReactApple/Libraries/RCTFoundation/RCTDeprecation/RCTDeprecation.podspec

@@ -22,4 +22,6 @@ Pod::Spec.new do |s|
       "CLANG_CXX_LANGUAGE_STANDARD" => rct_cxx_language_standard()
     }
     s.compiler_flags         = "-Wnullable-to-nonnull-conversion -Wnullability-completeness"
+
+    mark_as_react_native_build(s)
   end

package/ReactApple/RCTAnimatedModuleProvider/RCTAnimatedModuleProvider+Private.h

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+#import <RCTAnimatedModuleProvider/RCTAnimatedModuleProvider.h>
+
+@interface RCTAnimatedModuleProvider (Private)
+
+/**
+ * When true, animated frames are skipped while the application is inactive (between
+ * `UIApplicationWillEnterForeground` -> `UIApplicationDidBecomeActive`), default is false.
+ */
+- (instancetype)initWithSkipFramesDuringForegroundTransition:(BOOL)skipFramesDuringForegroundTransition;
+
+@end

package/ReactApple/RCTAnimatedModuleProvider/RCTAnimatedModuleProvider.mm

@@ -7,12 +7,15 @@
 
 #import "RCTAnimatedModuleProvider.h"
 
+#import "RCTAnimatedModuleProvider+Private.h"
+
 #import <functional>
 
 #if TARGET_OS_OSX
 #import <React/RCTPlatformDisplayLink.h>
 #else
 #import <QuartzCore/CADisplayLink.h>
+#import <UIKit/UIKit.h>
 #endif
 
 #import <react/featureflags/ReactNativeFeatureFlags.h>
@@ -28,6 +31,21 @@
   std::function<void()> _onRender;
 
   std::weak_ptr<facebook::react::NativeAnimatedNodesManagerProvider> _nativeAnimatedNodesManagerProvider;
+
+  BOOL _skipFramesDuringForegroundTransition;
+}
+
+- (instancetype)init
+{
+  return [self initWithSkipFramesDuringForegroundTransition:NO];
+}
+
+- (instancetype)initWithSkipFramesDuringForegroundTransition:(BOOL)skipFramesDuringForegroundTransition
+{
+  if (self = [super init]) {
+    _skipFramesDuringForegroundTransition = skipFramesDuringForegroundTransition;
+  }
+  return self;
 }
 
 - (void)dealloc
@@ -61,6 +79,15 @@
   // use-after-free during hot reload. The provider must remain alive for the
   // entire duration of _onRender() since it holds references to the animation
   // nodes manager and related data structures.
+#if !TARGET_OS_OSX
+  // See initWithSkipFramesDuringForegroundTransition: the frame is skipped,
+  // never the clock.
+  if (_skipFramesDuringForegroundTransition &&
+      UIApplication.sharedApplication.applicationState == UIApplicationStateInactive) {
+    return;
+  }
+#endif
+
   auto strongProvider = _nativeAnimatedNodesManagerProvider.lock();
   if (strongProvider != nullptr && _displayLink != nullptr && _onRender != nullptr) {
     _onRender();

package/ReactApple/RCTAnimatedModuleProvider/React-RCTAnimatedModuleProvider.podspec

@@ -60,4 +60,6 @@ Pod::Spec.new do |s|
   depend_on_js_engine(s)
   add_rn_third_party_dependencies(s)
   add_rncore_dependency(s)
+
+  mark_as_react_native_build(s)
 end

package/ReactApple/RCTSwiftUI/RCTSwiftUI.podspec

@@ -36,4 +36,5 @@ Pod::Spec.new do |s|
     "DEFINES_MODULE" => "YES",
   }
 
+  mark_as_react_native_build(s)
 end

package/ReactApple/RCTSwiftUIWrapper/RCTSwiftUIWrapper.podspec

@@ -34,4 +34,5 @@ Pod::Spec.new do |s|
     "SWIFT_VERSION" => "5.0",
   }
 
+  mark_as_react_native_build(s)
 end