react-native 0.0.0-17be3a003 → 0.0.0-18697adec

package/ReactCommon/react/nativemodule/core/platform/ios/RCTTurboModuleManager.mm

@@ -18,6 +18,7 @@
 #import <React/RCTBridge+Private.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTCxxModule.h>
+#import <React/RCTInitializing.h>
 #import <React/RCTLog.h>
 #import <React/RCTModuleData.h>
 #import <React/RCTPerformanceLogger.h>
@@ -173,8 +174,8 @@ static Class getFallbackClassFromName(const char *name)
   std::mutex _turboModuleHoldersMutex;
   std::atomic<bool> _invalidating;
 
-  RCTModuleRegistry *_moduleRegistry;
-  RCTViewRegistry *_viewRegistry_DEPRECATED;
+  RCTRetainJSCallback _retainJSCallback;
+  std::shared_ptr<LongLivedObjectCollection> _longLivedObjectCollection;
 }
 
 - (instancetype)initWithBridge:(RCTBridge *)bridge
@@ -186,12 +187,6 @@ static Class getFallbackClassFromName(const char *name)
     _delegate = delegate;
     _bridge = bridge;
     _invalidating = false;
-    _moduleRegistry = [RCTModuleRegistry new];
-    [_moduleRegistry setBridge:bridge];
-    [_moduleRegistry setTurboModuleRegistry:self];
-
-    _viewRegistry_DEPRECATED = [RCTViewRegistry new];
-    [_viewRegistry_DEPRECATED setBridge:bridge];
 
     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(bridgeWillInvalidateModules:)
@@ -201,15 +196,27 @@ static Class getFallbackClassFromName(const char *name)
                                              selector:@selector(bridgeDidInvalidateModules:)
                                                  name:RCTBridgeDidInvalidateModulesNotification
                                                object:_bridge.parentBridge];
+
+    if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScope) {
+      // Use LongLivedObjectCollection singleton regularly
+      _retainJSCallback = nil;
+    } else if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScopeUsingRetainJSCallback) {
+      // Use LongLivedObjectCollection singleton via the _retainJSCallback
+      _retainJSCallback = ^(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker2) {
+        return CallbackWrapper::createWeak(std::move(callback), runtime, jsInvoker2);
+      };
+    } else if (RCTGetTurboModuleCleanupMode() == kRCTTurboModuleManagerScope) {
+      // Use a LongLivedObjectCollection scoped to the TurboModuleManager
+      _longLivedObjectCollection = std::make_shared<LongLivedObjectCollection>();
+      __block std::shared_ptr<LongLivedObjectCollection> longLivedObjectCollection = _longLivedObjectCollection;
+      _retainJSCallback = ^(jsi::Function &&callback, jsi::Runtime &runtime, std::shared_ptr<CallInvoker> jsInvoker2) {
+        return CallbackWrapper::createWeak(longLivedObjectCollection, std::move(callback), runtime, jsInvoker2);
+      };
+    }
   }
   return self;
 }
 
-- (void)setBridgelessComponentViewProvider:(RCTBridgelessComponentViewProvider)viewProvider
-{
-  [_viewRegistry_DEPRECATED setBridgelessComponentViewProvider:viewProvider];
-}
-
 - (void)notifyAboutTurboModuleSetup:(const char *)name
 {
   NSString *moduleName = [[NSString alloc] initWithUTF8String:name];
@@ -277,6 +284,9 @@ static Class getFallbackClassFromName(const char *name)
   Class moduleClass = [module class];
 
   dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);
+  if (methodQueue == nil) {
+    RCTLogError(@"TurboModule \"%@\" was not associated with a method queue.", moduleClass);
+  }
 
   /**
    * Step 2c: Create and native CallInvoker from the TurboModule's method queue.
@@ -309,6 +319,7 @@ static Class getFallbackClassFromName(const char *name)
       .jsInvoker = _jsInvoker,
       .nativeInvoker = nativeInvoker,
       .isSyncModule = methodQueue == RCTJSThread,
+      .retainJSCallback = _retainJSCallback,
   };
 
   /**
@@ -411,9 +422,12 @@ static Class getFallbackClassFromName(const char *name)
      */
 
     if ([_delegate respondsToSelector:@selector(getModuleClassFromName:)]) {
-      std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
-
-      moduleClass = [_delegate getModuleClassFromName:moduleName];
+      if (RCTTurboModuleManagerDelegateLockingDisabled()) {
+        moduleClass = [_delegate getModuleClassFromName:moduleName];
+      } else {
+        std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
+        moduleClass = [_delegate getModuleClassFromName:moduleName];
+      }
     }
 
     if (!moduleClass) {
@@ -495,9 +509,12 @@ static Class getFallbackClassFromName(const char *name)
 
   TurboModulePerfLogger::moduleCreateConstructStart(moduleName, moduleId);
   if ([_delegate respondsToSelector:@selector(getModuleInstanceFromClass:)]) {
-    std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
-
-    module = [_delegate getModuleInstanceFromClass:moduleClass];
+    if (RCTTurboModuleManagerDelegateLockingDisabled()) {
+      module = [_delegate getModuleInstanceFromClass:moduleClass];
+    } else {
+      std::lock_guard<std::mutex> delegateGuard(_turboModuleManagerDelegateMutex);
+      module = [_delegate getModuleInstanceFromClass:moduleClass];
+    }
   } else {
     module = [moduleClass new];
   }
@@ -505,10 +522,6 @@ static Class getFallbackClassFromName(const char *name)
 
   TurboModulePerfLogger::moduleCreateSetUpStart(moduleName, moduleId);
 
-  if ([module respondsToSelector:@selector(setTurboModuleRegistry:)]) {
-    [module setTurboModuleRegistry:self];
-  }
-
   /**
    * It is reasonable for NativeModules to not want/need the bridge.
    * In such cases, they won't have `@synthesize bridge = _bridge` in their
@@ -545,44 +558,6 @@ static Class getFallbackClassFromName(const char *name)
     }
   }
 
-  /**
-   * Attach the RCTModuleRegistry to this TurboModule, which allows this TurboModule
-   * To load other NativeModules & TurboModules.
-   *
-   * Usage: In the NativeModule @implementation, include:
-   *   `@synthesize moduleRegistry = _moduleRegistry`
-   */
-  if ([module respondsToSelector:@selector(moduleRegistry)] && _moduleRegistry) {
-    @try {
-      [(id)module setValue:_moduleRegistry forKey:@"moduleRegistry"];
-    } @catch (NSException *exception) {
-      RCTLogError(
-          @"%@ has no setter or ivar for its module registry, which is not "
-           "permitted. You must either @synthesize the moduleRegistry property, "
-           "or provide your own setter method.",
-          RCTBridgeModuleNameForClass([module class]));
-    }
-  }
-
-  /**
-   * Attach the RCTViewRegistry to this TurboModule, which allows this TurboModule
-   * To query a React component's UIView, given its reactTag.
-   *
-   * Usage: In the NativeModule @implementation, include:
-   *   `@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED`
-   */
-  if ([module respondsToSelector:@selector(viewRegistry_DEPRECATED)] && _viewRegistry_DEPRECATED) {
-    @try {
-      [(id)module setValue:_viewRegistry_DEPRECATED forKey:@"viewRegistry_DEPRECATED"];
-    } @catch (NSException *exception) {
-      RCTLogError(
-          @"%@ has no setter or ivar for its module registry, which is not "
-           "permitted. You must either @synthesize the viewRegistry_DEPRECATED property, "
-           "or provide your own setter method.",
-          RCTBridgeModuleNameForClass([module class]));
-    }
-  }
-
   /**
    * Some modules need their own queues, but don't provide any, so we need to create it for them.
    * These modules typically have the following:
@@ -620,13 +595,27 @@ static Class getFallbackClassFromName(const char *name)
       } @catch (NSException *exception) {
         RCTLogError(
             @"%@ has no setter or ivar for its methodQueue, which is not "
-             "permitted. You must either @synthesize the bridge property, "
+             "permitted. You must either @synthesize the methodQueue property, "
              "or provide your own setter method.",
             RCTBridgeModuleNameForClass([module class]));
       }
     }
   }
 
+  /**
+   * Decorate TurboModules with bridgeless-compatible APIs that call into the bridge.
+   */
+  if (_bridge) {
+    [_bridge attachBridgeAPIsToTurboModule:module];
+  }
+
+  /**
+   * If the TurboModule conforms to RCTInitializing, invoke its initialize method.
+   */
+  if ([module respondsToSelector:@selector(initialize)]) {
+    [(id<RCTInitializing>)module initialize];
+  }
+
   /**
    * Attach method queue to id<RCTTurboModule> object.
    * This is necessary because the id<RCTTurboModule> object can be eagerly created/initialized before the method
@@ -645,8 +634,10 @@ static Class getFallbackClassFromName(const char *name)
   if (_bridge) {
     RCTModuleData *data = [[RCTModuleData alloc] initWithModuleInstance:(id<RCTBridgeModule>)module
                                                                  bridge:_bridge
-                                                         moduleRegistry:_moduleRegistry
-                                                viewRegistry_DEPRECATED:_viewRegistry_DEPRECATED];
+                                                         moduleRegistry:_bridge.moduleRegistry
+                                                viewRegistry_DEPRECATED:nil
+                                                          bundleManager:nil
+                                                      callableJSModules:nil];
     [_bridge registerModuleForFrameUpdates:(id<RCTBridgeModule>)module withModuleData:data];
   }
 
@@ -767,9 +758,17 @@ static Class getFallbackClassFromName(const char *name)
     return turboModule;
   };
 
-  runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider)](jsi::Runtime &runtime) {
-    react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider));
-  });
+  if (RCTGetTurboModuleCleanupMode() == kRCTGlobalScope ||
+      RCTGetTurboModuleCleanupMode() == kRCTGlobalScopeUsingRetainJSCallback) {
+    runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider)](jsi::Runtime &runtime) {
+      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider));
+    });
+  } else if (RCTGetTurboModuleCleanupMode() == kRCTTurboModuleManagerScope) {
+    runtimeExecutor([turboModuleProvider = std::move(turboModuleProvider),
+                     longLivedObjectCollection = _longLivedObjectCollection](jsi::Runtime &runtime) {
+      react::TurboModuleBinding::install(runtime, std::move(turboModuleProvider), longLivedObjectCollection);
+    });
+  }
 }
 
 #pragma mark RCTTurboModuleRegistry
@@ -834,6 +833,27 @@ static Class getFallbackClassFromName(const char *name)
     return;
   }
 
+  [self _enterInvalidatingState];
+}
+
+- (void)bridgeDidInvalidateModules:(NSNotification *)notification
+{
+  RCTBridge *bridge = notification.userInfo[@"bridge"];
+  if (bridge != _bridge) {
+    return;
+  }
+
+  [self _invalidateModules];
+}
+
+- (void)invalidate
+{
+  [self _enterInvalidatingState];
+  [self _invalidateModules];
+}
+
+- (void)_enterInvalidatingState
+{
   // This should halt all insertions into _turboModuleHolders
   if (RCTTurboModuleSharedMutexInitEnabled()) {
     std::unique_lock<std::shared_timed_mutex> guard(_turboModuleHoldersSharedMutex);
@@ -844,13 +864,8 @@ static Class getFallbackClassFromName(const char *name)
   }
 }
 
-- (void)bridgeDidInvalidateModules:(NSNotification *)notification
+- (void)_invalidateModules
 {
-  RCTBridge *bridge = notification.userInfo[@"bridge"];
-  if (bridge != _bridge) {
-    return;
-  }
-
   // Backward-compatibility: RCTInvalidating handling.
   dispatch_group_t moduleInvalidationGroup = dispatch_group_create();
 
@@ -868,20 +883,31 @@ static Class getFallbackClassFromName(const char *name)
                                                shouldPerfLog:NO];
 
     if ([module respondsToSelector:@selector(invalidate)]) {
-      if ([module respondsToSelector:@selector(methodQueue)]) {
-        dispatch_queue_t methodQueue = [module performSelector:@selector(methodQueue)];
-        if (methodQueue) {
-          dispatch_group_enter(moduleInvalidationGroup);
-          [bridge
-              dispatchBlock:^{
-                [((id<RCTInvalidating>)module) invalidate];
-                dispatch_group_leave(moduleInvalidationGroup);
-              }
-                      queue:methodQueue];
-          continue;
+      dispatch_queue_t methodQueue = (dispatch_queue_t)objc_getAssociatedObject(module, &kAssociatedMethodQueueKey);
+
+      if (methodQueue == nil) {
+        RCTLogError(
+            @"TurboModuleManager: Couldn't invalidate TurboModule \"%@\", because its method queue is nil.",
+            [module class]);
+        continue;
+      }
+
+      dispatch_group_enter(moduleInvalidationGroup);
+      dispatch_block_t invalidateModule = ^{
+        [((id<RCTInvalidating>)module) invalidate];
+        dispatch_group_leave(moduleInvalidationGroup);
+      };
+
+      if (_bridge) {
+        [_bridge dispatchBlock:invalidateModule queue:methodQueue];
+      } else {
+        // Bridgeless mode
+        if (methodQueue == RCTJSThread) {
+          invalidateModule();
+        } else {
+          dispatch_async(methodQueue, invalidateModule);
         }
       }
-      [((id<RCTInvalidating>)module) invalidate];
     }
   }
 
@@ -893,26 +919,4 @@ static Class getFallbackClassFromName(const char *name)
   _turboModuleCache.clear();
 }
 
-- (void)invalidate
-{
-  if (RCTTurboModuleSharedMutexInitEnabled()) {
-    std::unique_lock<std::shared_timed_mutex> guard(_turboModuleHoldersSharedMutex);
-    _invalidating = true;
-  } else {
-    std::lock_guard<std::mutex> guard(_turboModuleHoldersMutex);
-    _invalidating = true;
-  }
-
-  // Backward-compatibility: RCTInvalidating handling, but not adhering to desired methodQueue.
-  for (const auto &p : _turboModuleHolders) {
-    id<RCTTurboModule> module = p.second.getModule();
-    if ([module respondsToSelector:@selector(invalidate)]) {
-      [((id<RCTInvalidating>)module) invalidate];
-    }
-  }
-
-  _turboModuleHolders.clear();
-  _turboModuleCache.clear();
-}
-
 @end

package/ReactCommon/react/nativemodule/samples/BUCK

@@ -42,10 +42,10 @@ rn_xplat_cxx_library(
     force_static = True,
     ios_deps = [
         "//xplat/FBBaseLite:FBBaseLite",
-        "//xplat/js:RCTLinking",
-        "//xplat/js:RCTPushNotification",
         "//xplat/js/react-native-github:RCTCxxBridge",
         "//xplat/js/react-native-github:RCTCxxModule",
+        "//xplat/js/react-native-github:RCTLinking",
+        "//xplat/js/react-native-github:RCTPushNotification",
         "//xplat/js/react-native-github:ReactInternal",
     ],
     ios_exported_headers = subdir_glob(

package/ReactCommon/react/nativemodule/samples/platform/android/Android.mk

@@ -10,7 +10,7 @@ LOCAL_MODULE := sampleturbomodule
 LOCAL_C_INCLUDES := $(LOCAL_PATH)
 LOCAL_SRC_FILES := $(wildcard $(LOCAL_PATH)/ReactCommon/*.cpp)
 LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)
-LOCAL_SHARED_LIBRARIES := libfbjni libreact_nativemodule_core
+LOCAL_SHARED_LIBRARIES := libfbjni libreact_nativemodule_core libjsi
 LOCAL_CFLAGS := \
   -DLOG_TAG=\"ReactNative\"
 LOCAL_CFLAGS += -fexceptions -frtti -std=c++17 -Wall

package/ReactCommon/react/nativemodule/samples/platform/ios/RCTSampleTurboModule.mm

@@ -17,8 +17,6 @@ using namespace facebook::react;
 // Backward-compatible export
 RCT_EXPORT_MODULE()
 
-@synthesize turboModuleRegistry = _turboModuleRegistry;
-
 // Backward-compatible queue configuration
 + (BOOL)requiresMainQueueSetup
 {

package/ReactCommon/react/renderer/animations/BUCK

@@ -62,6 +62,7 @@ rn_xplat_cxx_library(
         react_native_xplat_target("react/debug:debug"),
         react_native_xplat_target("react/renderer/componentregistry:componentregistry"),
         react_native_xplat_target("react/renderer/components/view:view"),
+        react_native_xplat_target("react/renderer/components/image:image"),
         react_native_xplat_target("react/renderer/core:core"),
         react_native_xplat_target("react/renderer/debug:debug"),
         react_native_xplat_target("react/renderer/mounting:mounting"),
@@ -91,6 +92,7 @@ fb_xplat_cxx_test(
         react_native_xplat_target("react/renderer/components/root:root"),
         react_native_xplat_target("react/renderer/components/scrollview:scrollview"),
         react_native_xplat_target("react/renderer/components/view:view"),
+        react_native_xplat_target("react/test_utils:test_utils"),
         "//xplat/js/react-native-github:generated_components-rncore",
     ],
 )

package/ReactCommon/react/renderer/animations/LayoutAnimationCallbackWrapper.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <jsi/jsi.h>
+#include <memory>
+
+namespace facebook {
+namespace react {
+
+class LayoutAnimationCallbackWrapper {
+ public:
+  LayoutAnimationCallbackWrapper(jsi::Function &&callback)
+      : callback_(std::make_shared<jsi::Function>(std::move(callback))) {}
+  LayoutAnimationCallbackWrapper() : callback_(nullptr) {}
+
+  void call(jsi::Runtime &runtime) const {
+    if (callback_) {
+      callback_->call(runtime);
+      callback_.reset();
+    }
+  }
+
+ private:
+  mutable std::shared_ptr<jsi::Function> callback_;
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/animations/LayoutAnimationDriver.cpp

@@ -7,25 +7,10 @@
 
 #include "LayoutAnimationDriver.h"
 
-#include <algorithm>
-#include <chrono>
-
-#include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
-#include <react/renderer/components/root/RootShadowNode.h>
-#include <react/renderer/components/view/ViewProps.h>
-#include <react/renderer/core/ComponentDescriptor.h>
-#include <react/renderer/core/LayoutMetrics.h>
-#include <react/renderer/core/LayoutableShadowNode.h>
-#include <react/renderer/core/Props.h>
-#include <react/renderer/mounting/MountingCoordinator.h>
-
-#include <react/renderer/mounting/Differentiator.h>
-#include <react/renderer/mounting/ShadowTreeRevision.h>
-#include <react/renderer/mounting/ShadowView.h>
-#include <react/renderer/mounting/ShadowViewMutation.h>
-
 #include <glog/logging.h>
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/animations/utils.h>
+#include <algorithm>
 
 namespace facebook {
 namespace react {
@@ -71,19 +56,12 @@ void LayoutAnimationDriver::animationMutationsForFrame(
           animationInterpolationFactor, baselineShadowView, finalShadowView);
 
       // Create the mutation instruction
-      auto updateMutation = ShadowViewMutation::UpdateMutation(
-          keyframe.viewPrev, mutatedShadowView);
-
-      // All generated Update mutations must have an "old" and "new"
-      // ShadowView. Checking for nonzero tag doesn't guarantee that the views
-      // are valid/correct, just that something is there.
-      react_native_assert(updateMutation.oldChildShadowView.tag > 0);
-      react_native_assert(updateMutation.newChildShadowView.tag > 0);
+      mutationsList.emplace_back(ShadowViewMutation::UpdateMutation(
+          keyframe.viewPrev, mutatedShadowView));
 
-      mutationsList.push_back(updateMutation);
       PrintMutationInstruction("Animation Progress:", updateMutation);
 
-      keyframe.viewPrev = mutatedShadowView;
+      keyframe.viewPrev = std::move(mutatedShadowView);
 
       if (animationTimeProgressLinear < 1) {
         incompleteAnimations++;

package/ReactCommon/react/renderer/animations/LayoutAnimationDriver.h

@@ -7,17 +7,9 @@
 
 #pragma once
 
-#include <react/renderer/core/EventTarget.h>
-#include <react/renderer/debug/flags.h>
-#include <react/renderer/mounting/Differentiator.h>
-#include <react/renderer/mounting/MountingCoordinator.h>
-#include <react/renderer/mounting/MountingOverrideDelegate.h>
-#include <react/renderer/mounting/MountingTransaction.h>
-#include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
-
-#include <folly/dynamic.h>
-
-#include "LayoutAnimationKeyFrameManager.h"
+#include <react/renderer/animations/LayoutAnimationKeyFrameManager.h>
+#include <react/renderer/core/ReactPrimitives.h>
+#include <react/renderer/mounting/ShadowViewMutation.h>
 
 namespace facebook {
 namespace react {
@@ -26,10 +18,12 @@ class LayoutAnimationDriver : public LayoutAnimationKeyFrameManager {
  public:
   LayoutAnimationDriver(
       RuntimeExecutor runtimeExecutor,
+      ContextContainer::Shared &contextContainer,
       LayoutAnimationStatusDelegate *delegate)
-      : LayoutAnimationKeyFrameManager(runtimeExecutor, delegate) {}
-
-  virtual ~LayoutAnimationDriver() {}
+      : LayoutAnimationKeyFrameManager(
+            runtimeExecutor,
+            contextContainer,
+            delegate) {}
 
  protected:
   virtual void animationMutationsForFrame(