react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/Binding.h

@@ -10,16 +10,20 @@
 #include <fbjni/fbjni.h>
 #include <react/jni/JMessageQueueThread.h>
 #include <react/jni/JRuntimeExecutor.h>
+#include <react/jni/JRuntimeScheduler.h>
 #include <react/jni/ReadableNativeMap.h>
 #include <react/renderer/animations/LayoutAnimationDriver.h>
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/scheduler/SchedulerDelegate.h>
 #include <react/renderer/uimanager/LayoutAnimationStatusDelegate.h>
+
 #include <memory>
 #include <mutex>
 #include "ComponentFactory.h"
 #include "EventBeatManager.h"
+#include "EventEmitterWrapper.h"
 #include "JBackgroundExecutor.h"
+#include "SurfaceHandlerBinding.h"
 
 namespace facebook {
 namespace react {
@@ -75,6 +79,9 @@ class Binding : public jni::HybridClass<Binding>,
   constexpr static auto UIManagerJavaDescriptor =
       "com/facebook/react/fabric/FabricUIManager";
 
+  constexpr static auto ReactFeatureFlagsJavaDescriptor =
+      "com/facebook/react/config/ReactFeatureFlags";
+
   static void registerNatives();
 
  private:
@@ -92,10 +99,14 @@ class Binding : public jni::HybridClass<Binding>,
       jboolean isRTL,
       jboolean doLeftAndRightSwapInRTL);
 
+  jni::local_ref<ReadableNativeMap::jhybridobject> getInspectorDataForInstance(
+      jni::alias_ref<EventEmitterWrapper::javaobject> eventEmitterWrapper);
+
   static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jclass>);
 
   void installFabricUIManager(
       jni::alias_ref<JRuntimeExecutor::javaobject> runtimeExecutorHolder,
+      jni::alias_ref<JRuntimeScheduler::javaobject> runtimeSchedulerHolder,
       jni::alias_ref<jobject> javaUIManager,
       EventBeatManager *eventBeatManager,
       jni::alias_ref<JavaMessageQueueThread::javaobject> jsMessageQueueThread,
@@ -124,12 +135,25 @@ class Binding : public jni::HybridClass<Binding>,
 
   void stopSurface(jint surfaceId);
 
+  void registerSurface(SurfaceHandlerBinding *surfaceHandler);
+
+  void unregisterSurface(SurfaceHandlerBinding *surfaceHandler);
+
   void schedulerDidFinishTransaction(
       MountingCoordinator::Shared const &mountingCoordinator) override;
 
+  void preallocateShadowView(
+      const SurfaceId surfaceId,
+      const ShadowView &shadowView);
+
   void schedulerDidRequestPreliminaryViewAllocation(
       const SurfaceId surfaceId,
-      const ShadowView &shadowView) override;
+      const ShadowNode &shadowNode) override;
+
+  void schedulerDidCloneShadowNode(
+      SurfaceId surfaceId,
+      const ShadowNode &oldShadowNode,
+      const ShadowNode &newShadowNode) override;
 
   void schedulerDidDispatchCommand(
       const ShadowView &shadowView,
@@ -140,14 +164,11 @@ class Binding : public jni::HybridClass<Binding>,
       const ShadowView &shadowView,
       std::string const &eventType) override;
 
-  void schedulerDidSetJSResponder(
-      SurfaceId surfaceId,
-      const ShadowView &shadowView,
-      const ShadowView &initialShadowView,
+  void schedulerDidSetIsJSResponder(
+      ShadowView const &shadowView,
+      bool isJSResponder,
       bool blockNativeResponder) override;
 
-  void schedulerDidClearJSResponder() override;
-
   void setPixelDensity(float pointScaleFactor);
 
   void driveCxxAnimations();
@@ -168,14 +189,18 @@ class Binding : public jni::HybridClass<Binding>,
   std::shared_ptr<Scheduler> scheduler_;
   std::mutex schedulerMutex_;
 
+  better::map<SurfaceId, SurfaceHandler> surfaceHandlerRegistry_{};
+  better::shared_mutex
+      surfaceHandlerRegistryMutex_; // Protects `surfaceHandlerRegistry_`.
+
   std::recursive_mutex commitMutex_;
 
   float pointScaleFactor_ = 1;
 
   std::shared_ptr<const ReactNativeConfig> reactNativeConfig_{nullptr};
   bool disablePreallocateViews_{false};
-  bool disableVirtualNodePreallocation_{false};
   bool enableFabricLogs_{false};
+  bool enableEarlyEventEmitterUpdate_{false};
 };
 
 } // namespace react

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/CoreComponentsRegistry.cpp

@@ -12,8 +12,6 @@
 #include <fbjni/fbjni.h>
 
 #include <react/renderer/componentregistry/ComponentDescriptorRegistry.h>
-#include <react/renderer/components/androidpicker/AndroidDialogPickerComponentDescriptor.h>
-#include <react/renderer/components/androidpicker/AndroidDropdownPickerComponentDescriptor.h>
 #include <react/renderer/components/androidswitch/AndroidSwitchComponentDescriptor.h>
 #include <react/renderer/components/androidtextinput/AndroidTextInputComponentDescriptor.h>
 #include <react/renderer/components/image/ImageComponentDescriptor.h>
@@ -64,14 +62,13 @@ CoreComponentsRegistry::sharedProviderRegistry() {
         concreteComponentDescriptorProvider<SliderComponentDescriptor>());
     providerRegistry->add(
         concreteComponentDescriptorProvider<ScrollViewComponentDescriptor>());
+    providerRegistry->add(
+        concreteComponentDescriptorProvider<
+            AndroidHorizontalScrollContentViewComponentDescriptor>());
     providerRegistry->add(
         concreteComponentDescriptorProvider<ParagraphComponentDescriptor>());
     providerRegistry->add(concreteComponentDescriptorProvider<
                           AndroidDrawerLayoutComponentDescriptor>());
-    providerRegistry->add(concreteComponentDescriptorProvider<
-                          AndroidDialogPickerComponentDescriptor>());
-    providerRegistry->add(concreteComponentDescriptorProvider<
-                          AndroidDropdownPickerComponentDescriptor>());
 
     return providerRegistry;
   }();

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/EventEmitterWrapper.cpp

@@ -21,14 +21,34 @@ EventEmitterWrapper::initHybrid(jni::alias_ref<jclass>) {
 void EventEmitterWrapper::invokeEvent(
     std::string eventName,
     NativeMap *payload) {
-  eventEmitter->dispatchEvent(
-      eventName, payload->consume(), EventPriority::AsynchronousBatched);
+  // 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->dispatchEvent(
+        eventName, payload->consume(), EventPriority::AsynchronousBatched);
+  }
+}
+
+void EventEmitterWrapper::invokeUniqueEvent(
+    std::string eventName,
+    NativeMap *payload,
+    int customCoalesceKey) {
+  // TODO: customCoalesceKey currently unused
+  // 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(eventName, payload->consume());
+  }
 }
 
 void EventEmitterWrapper::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", EventEmitterWrapper::initHybrid),
       makeNativeMethod("invokeEvent", EventEmitterWrapper::invokeEvent),
+      makeNativeMethod(
+          "invokeUniqueEvent", EventEmitterWrapper::invokeUniqueEvent),
   });
 }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/EventEmitterWrapper.h

@@ -26,6 +26,10 @@ class EventEmitterWrapper : public jni::HybridClass<EventEmitterWrapper> {
   SharedEventEmitter eventEmitter;
 
   void invokeEvent(std::string eventName, NativeMap *params);
+  void invokeUniqueEvent(
+      std::string eventName,
+      NativeMap *params,
+      int customCoalesceKey);
 
  private:
   static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jclass>);

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/OnLoad.cpp

@@ -13,6 +13,7 @@
 #include "EventBeatManager.h"
 #include "EventEmitterWrapper.h"
 #include "StateWrapperImpl.h"
+#include "SurfaceHandlerBinding.h"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
   return facebook::jni::initialize(vm, [] {
@@ -22,5 +23,6 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
     facebook::react::StateWrapperImpl::registerNatives();
     facebook::react::ComponentFactory::registerNatives();
     facebook::react::CoreComponentsRegistry::registerNatives();
+    facebook::react::SurfaceHandlerBinding::registerNatives();
   });
 }

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/StateWrapperImpl.cpp

@@ -8,6 +8,8 @@
 #include "StateWrapperImpl.h"
 #include <fbjni/fbjni.h>
 #include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
 
 using namespace facebook::jni;
 
@@ -22,13 +24,22 @@ jni::local_ref<StateWrapperImpl::jhybriddata> StateWrapperImpl::initHybrid(
   return makeCxxInstance();
 }
 
-jni::local_ref<ReadableNativeMap::jhybridobject> StateWrapperImpl::getState() {
+jni::local_ref<ReadableNativeMap::jhybridobject>
+StateWrapperImpl::getStateDataImpl() {
   folly::dynamic map = state_->getDynamic();
   local_ref<ReadableNativeMap::jhybridobject> readableNativeMap =
       ReadableNativeMap::newObjectCxxArgs(map);
   return readableNativeMap;
 }
 
+jni::local_ref<ReadableMapBuffer::jhybridobject>
+StateWrapperImpl::getStateMapBufferDataImpl() {
+  MapBuffer map = state_->getMapBuffer();
+  auto ReadableMapBuffer =
+      ReadableMapBuffer::createWithContents(std::move(map));
+  return ReadableMapBuffer;
+}
+
 void StateWrapperImpl::updateStateImpl(NativeMap *map) {
   // Get folly::dynamic from map
   auto dynamicMap = map->consume();
@@ -39,8 +50,11 @@ void StateWrapperImpl::updateStateImpl(NativeMap *map) {
 void StateWrapperImpl::registerNatives() {
   registerHybrid({
       makeNativeMethod("initHybrid", StateWrapperImpl::initHybrid),
-      makeNativeMethod("getState", StateWrapperImpl::getState),
+      makeNativeMethod("getStateDataImpl", StateWrapperImpl::getStateDataImpl),
       makeNativeMethod("updateStateImpl", StateWrapperImpl::updateStateImpl),
+      makeNativeMethod(
+          "getStateMapBufferDataImpl",
+          StateWrapperImpl::getStateMapBufferDataImpl),
   });
 }
 

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/StateWrapperImpl.h

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
+#include <react/common/mapbuffer/ReadableMapBuffer.h>
 #include <react/jni/ReadableNativeMap.h>
 #include <react/renderer/core/State.h>
 
@@ -25,7 +26,8 @@ class StateWrapperImpl : public jni::HybridClass<StateWrapperImpl> {
 
   static void registerNatives();
 
-  jni::local_ref<ReadableNativeMap::jhybridobject> getState();
+  jni::local_ref<ReadableMapBuffer::jhybridobject> getStateMapBufferDataImpl();
+  jni::local_ref<ReadableNativeMap::jhybridobject> getStateDataImpl();
   void updateStateImpl(NativeMap *map);
   void updateStateWithFailureCallbackImpl(
       NativeMap *map,

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/SurfaceHandlerBinding.cpp

@@ -0,0 +1,122 @@
+/*
+ * 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.
+ */
+
+#include "SurfaceHandlerBinding.h"
+#include <react/renderer/scheduler/Scheduler.h>
+
+namespace facebook {
+namespace react {
+
+SurfaceHandlerBinding::SurfaceHandlerBinding(
+    SurfaceId surfaceId,
+    std::string const &moduleName)
+    : surfaceHandler_(moduleName, surfaceId) {}
+
+void SurfaceHandlerBinding::setDisplayMode(jint mode) {
+  surfaceHandler_.setDisplayMode(static_cast<DisplayMode>(mode));
+}
+
+void SurfaceHandlerBinding::start() {
+  std::unique_lock<better::shared_mutex> lock(lifecycleMutex_);
+
+  if (surfaceHandler_.getStatus() != SurfaceHandler::Status::Running) {
+    surfaceHandler_.start();
+  }
+}
+
+void SurfaceHandlerBinding::stop() {
+  std::unique_lock<better::shared_mutex> lock(lifecycleMutex_);
+
+  if (surfaceHandler_.getStatus() == SurfaceHandler::Status::Running) {
+    surfaceHandler_.stop();
+  }
+}
+
+jint SurfaceHandlerBinding::getSurfaceId() {
+  return surfaceHandler_.getSurfaceId();
+}
+
+void SurfaceHandlerBinding::setSurfaceId(jint surfaceId) {
+  surfaceHandler_.setSurfaceId(surfaceId);
+}
+
+jboolean SurfaceHandlerBinding::isRunning() {
+  return surfaceHandler_.getStatus() == SurfaceHandler::Status::Running;
+}
+
+jni::local_ref<jstring> SurfaceHandlerBinding::getModuleName() {
+  return jni::make_jstring(surfaceHandler_.getModuleName());
+}
+
+jni::local_ref<SurfaceHandlerBinding::jhybriddata>
+SurfaceHandlerBinding::initHybrid(
+    jni::alias_ref<jclass>,
+    jint surfaceId,
+    jni::alias_ref<jstring> moduleName) {
+  auto env = jni::Environment::current();
+  const char *moduleNameValue =
+      env->GetStringUTFChars(moduleName.get(), JNI_FALSE);
+  env->ReleaseStringUTFChars(moduleName.get(), moduleNameValue);
+
+  return makeCxxInstance(surfaceId, moduleNameValue);
+}
+
+void SurfaceHandlerBinding::setLayoutConstraints(
+    jfloat minWidth,
+    jfloat maxWidth,
+    jfloat minHeight,
+    jfloat maxHeight,
+    jfloat offsetX,
+    jfloat offsetY,
+    jboolean doLeftAndRightSwapInRTL,
+    jboolean isRTL,
+    jfloat pixelDensity) {
+  LayoutConstraints constraints = {};
+  constraints.minimumSize = {minWidth, minHeight};
+  constraints.maximumSize = {maxWidth, maxHeight};
+  constraints.layoutDirection =
+      isRTL ? LayoutDirection::RightToLeft : LayoutDirection::LeftToRight;
+
+  LayoutContext context = {};
+  context.swapLeftAndRightInRTL = doLeftAndRightSwapInRTL;
+  context.pointScaleFactor = pixelDensity;
+  context.viewportOffset = {offsetX, offsetY};
+
+  surfaceHandler_.constraintLayout(constraints, context);
+}
+
+void SurfaceHandlerBinding::setProps(NativeMap *props) {
+  surfaceHandler_.setProps(props->consume());
+}
+
+SurfaceHandler const &SurfaceHandlerBinding::getSurfaceHandler() {
+  return surfaceHandler_;
+}
+
+void SurfaceHandlerBinding::registerNatives() {
+  registerHybrid({
+      makeNativeMethod("initHybrid", SurfaceHandlerBinding::initHybrid),
+      makeNativeMethod(
+          "getSurfaceIdNative", SurfaceHandlerBinding::getSurfaceId),
+      makeNativeMethod(
+          "setSurfaceIdNative", SurfaceHandlerBinding::setSurfaceId),
+      makeNativeMethod("isRunningNative", SurfaceHandlerBinding::isRunning),
+      makeNativeMethod(
+          "getModuleNameNative", SurfaceHandlerBinding::getModuleName),
+      makeNativeMethod("startNative", SurfaceHandlerBinding::start),
+      makeNativeMethod("stopNative", SurfaceHandlerBinding::stop),
+      makeNativeMethod(
+          "setLayoutConstraintsNative",
+          SurfaceHandlerBinding::setLayoutConstraints),
+      makeNativeMethod("setPropsNative", SurfaceHandlerBinding::setProps),
+      makeNativeMethod(
+          "setDisplayModeNative", SurfaceHandlerBinding::setDisplayMode),
+  });
+}
+
+} // namespace react
+} // namespace facebook

package/ReactAndroid/src/main/java/com/facebook/react/fabric/jni/SurfaceHandlerBinding.h

@@ -0,0 +1,68 @@
+/*
+ * 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 <fbjni/fbjni.h>
+#include <react/jni/ReadableNativeMap.h>
+#include <react/renderer/scheduler/SurfaceHandler.h>
+
+namespace facebook {
+namespace react {
+
+class SurfaceHandlerBinding : public jni::HybridClass<SurfaceHandlerBinding> {
+ public:
+  constexpr static const char *const kJavaDescriptor =
+      "Lcom/facebook/react/fabric/SurfaceHandlerBinding;";
+
+  static void registerNatives();
+
+  SurfaceHandlerBinding(SurfaceId surfaceId, std::string const &moduleName);
+
+  void start();
+  void stop();
+
+  void setDisplayMode(jint mode);
+
+  void registerScheduler(std::shared_ptr<Scheduler> scheduler);
+  void unregisterScheduler(std::shared_ptr<Scheduler> scheduler);
+
+  jint getSurfaceId();
+  void setSurfaceId(jint surfaceId);
+  jni::local_ref<jstring> getModuleName();
+
+  jboolean isRunning();
+
+  void setLayoutConstraints(
+      jfloat minWidth,
+      jfloat maxWidth,
+      jfloat minHeight,
+      jfloat maxHeight,
+      jfloat offsetX,
+      jfloat offsetY,
+      jboolean doLeftAndRightSwapInRTL,
+      jboolean isRTL,
+      jfloat pixelDensity);
+
+  void setProps(NativeMap *props);
+
+  SurfaceHandler const &getSurfaceHandler();
+
+ private:
+  mutable better::shared_mutex lifecycleMutex_;
+  const SurfaceHandler surfaceHandler_;
+
+  jni::alias_ref<SurfaceHandlerBinding::jhybriddata> jhybridobject_;
+
+  static jni::local_ref<jhybriddata> initHybrid(
+      jni::alias_ref<jclass>,
+      jint surfaceId,
+      jni::alias_ref<jstring> moduleName);
+};
+
+} // namespace react
+} // namespace facebook