react-native-tvos 0.77.1-0 → 0.78.0-0

package/ReactAndroid/src/main/java/com/facebook/react/modules/websocket/WebSocketModule.kt

@@ -0,0 +1,397 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.facebook.react.modules.websocket
+
+import com.facebook.common.logging.FLog
+import com.facebook.fbreact.specs.NativeWebSocketModuleSpec
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.network.CustomClientBuilder
+import com.facebook.react.modules.network.ForwardingCookieHandler
+import java.io.IOException
+import java.net.URI
+import java.net.URISyntaxException
+import java.util.HashMap
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import okio.ByteString
+
+@ReactModule(name = WebSocketModule.NAME)
+public class WebSocketModule(context: ReactApplicationContext) :
+    NativeWebSocketModuleSpec(context) {
+
+  public interface ContentHandler {
+    public fun onMessage(text: String, params: WritableMap)
+
+    public fun onMessage(byteString: ByteString, params: WritableMap)
+  }
+
+  private val webSocketConnections: MutableMap<Int, WebSocket> = ConcurrentHashMap()
+  private val contentHandlers: MutableMap<Int, ContentHandler> = ConcurrentHashMap()
+  private val cookieHandler: ForwardingCookieHandler = ForwardingCookieHandler()
+
+  override fun invalidate() {
+    for (socket in webSocketConnections.values) {
+      socket.close(1_001 /* endpoint is going away */, null)
+    }
+    webSocketConnections.clear()
+    contentHandlers.clear()
+  }
+
+  private fun sendEvent(eventName: String, params: WritableMap) {
+    val reactAppContext = reactApplicationContext
+    if (reactAppContext.hasActiveReactInstance()) {
+      reactAppContext.emitDeviceEvent(eventName, params)
+    }
+  }
+
+  public fun setContentHandler(id: Int, contentHandler: ContentHandler?): Unit {
+    if (contentHandler != null) {
+      contentHandlers[id] = contentHandler
+    } else {
+      contentHandlers.remove(id)
+    }
+  }
+
+  override fun connect(
+      url: String,
+      protocols: ReadableArray?,
+      options: ReadableMap?,
+      socketID: Double
+  ) {
+    val id = socketID.toInt()
+    val okHttpBuilder =
+        OkHttpClient.Builder()
+            .connectTimeout(10, TimeUnit.SECONDS)
+            .writeTimeout(10, TimeUnit.SECONDS)
+            .readTimeout(0, TimeUnit.MINUTES) // Disable timeouts for read
+
+    applyCustomBuilder(okHttpBuilder)
+
+    val client = okHttpBuilder.build()
+
+    val builder = Request.Builder().tag(id).url(url)
+
+    val cookie = this.getCookie(url)
+    if (cookie != null) {
+      builder.addHeader("Cookie", cookie)
+    }
+
+    var hasOriginHeader = false
+
+    if (options?.hasKey("headers") == true && options.getType("headers") == ReadableType.Map) {
+      val headers = checkNotNull(options.getMap("headers"))
+      val iterator = headers.keySetIterator()
+
+      while (iterator.hasNextKey()) {
+        val key = iterator.nextKey()
+        if (ReadableType.String == headers.getType(key)) {
+          if (key.equals("origin", ignoreCase = true)) {
+            hasOriginHeader = true
+          }
+          builder.addHeader(
+              key,
+              checkNotNull(headers.getString(key)) { "value for name $key == null" },
+          )
+        } else {
+          FLog.w(ReactConstants.TAG, "Ignoring: requested $key, value not a string")
+        }
+      }
+    }
+
+    if (!hasOriginHeader) {
+      builder.addHeader("origin", getDefaultOrigin(url))
+    }
+
+    if (protocols != null && protocols.size() > 0) {
+      val protocolsValue = StringBuilder("")
+      for (i in 0..<protocols.size()) {
+        val v = protocols.getString(i)?.trim()
+        if (!v.isNullOrEmpty() && !v.contains(",")) {
+          protocolsValue.append(v)
+          protocolsValue.append(",")
+        }
+      }
+      if (protocolsValue.length > 0) {
+        protocolsValue.replace(protocolsValue.length - 1, protocolsValue.length, "")
+        builder.addHeader("Sec-WebSocket-Protocol", protocolsValue.toString())
+      }
+    }
+
+    client.newWebSocket(
+        builder.build(),
+        object : WebSocketListener() {
+          override fun onOpen(webSocket: WebSocket, response: Response) {
+            webSocketConnections[id] = webSocket
+            val params = Arguments.createMap()
+            params.putInt("id", id)
+            params.putString("protocol", response.header("Sec-WebSocket-Protocol", ""))
+            sendEvent("websocketOpen", params)
+          }
+
+          override fun onClosing(websocket: WebSocket, code: Int, reason: String) {
+            websocket.close(code, reason)
+          }
+
+          override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+            val params = Arguments.createMap()
+            params.putInt("id", id)
+            params.putInt("code", code)
+            params.putString("reason", reason)
+            sendEvent("websocketClosed", params)
+          }
+
+          override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+            notifyWebSocketFailed(id, t.message)
+          }
+
+          override fun onMessage(webSocket: WebSocket, text: String) {
+            val params = Arguments.createMap()
+            params.putInt("id", id)
+            params.putString("type", "text")
+
+            val contentHandler = contentHandlers[id]
+            if (contentHandler != null) {
+              contentHandler.onMessage(text, params)
+            } else {
+              params.putString("data", text)
+            }
+            sendEvent("websocketMessage", params)
+          }
+
+          override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+            val params = Arguments.createMap()
+            params.putInt("id", id)
+            params.putString("type", "binary")
+
+            val contentHandler = contentHandlers[id]
+            if (contentHandler != null) {
+              contentHandler.onMessage(bytes, params)
+            } else {
+              val text = bytes.base64()
+
+              params.putString("data", text)
+            }
+
+            sendEvent("websocketMessage", params)
+          }
+        })
+
+    // Trigger shutdown of the dispatcher's executor so this process can exit cleanly
+    client.dispatcher().executorService().shutdown()
+  }
+
+  override fun close(code: Double, reason: String?, socketID: Double) {
+    val id = socketID.toInt()
+    val client = webSocketConnections[id]
+    if (client == null) {
+      // WebSocket is already closed
+      // Don't do anything, mirror the behavior on web
+      return
+    }
+    try {
+      client.close(code.toInt(), reason)
+      webSocketConnections.remove(id)
+      contentHandlers.remove(id)
+    } catch (e: Exception) {
+      FLog.e(ReactConstants.TAG, "Could not close WebSocket connection for id $id", e)
+    }
+  }
+
+  override fun send(message: String, socketID: Double) {
+    val id = socketID.toInt()
+    val client = webSocketConnections[id]
+    if (client == null) {
+      // This is a programmer error -- display development warning
+      var params: WritableMap = Arguments.createMap()
+      params.putInt("id", id)
+      params.putString("message", "client is null")
+      sendEvent("websocketFailed", params)
+      params = Arguments.createMap()
+      params.putInt("id", id)
+      params.putInt("code", 0)
+      params.putString("reason", "client is null")
+      sendEvent("websocketClosed", params)
+      webSocketConnections.remove(id)
+      contentHandlers.remove(id)
+      return
+    }
+    try {
+      client.send(message)
+    } catch (e: Exception) {
+      notifyWebSocketFailed(id, e.message)
+    }
+  }
+
+  override fun sendBinary(base64String: String, socketID: Double) {
+    val id = socketID.toInt()
+    val client = webSocketConnections[id]
+    if (client == null) {
+      // This is a programmer error -- display development warning
+      var params: WritableMap = Arguments.createMap()
+      params.putInt("id", id)
+      params.putString("message", "client is null")
+      sendEvent("websocketFailed", params)
+      params = Arguments.createMap()
+      params.putInt("id", id)
+      params.putInt("code", 0)
+      params.putString("reason", "client is null")
+      sendEvent("websocketClosed", params)
+      webSocketConnections.remove(id)
+      contentHandlers.remove(id)
+      return
+    }
+    try {
+      val decodedString = checkNotNull(ByteString.decodeBase64(base64String)) { "bytes == null" }
+      client.send(decodedString)
+    } catch (e: Exception) {
+      notifyWebSocketFailed(id, e.message)
+    }
+  }
+
+  public fun sendBinary(byteString: ByteString, id: Int): Unit {
+    val client = webSocketConnections[id]
+    if (client == null) {
+      // This is a programmer error -- display development warning
+      var params: WritableMap = Arguments.createMap()
+      params.putInt("id", id)
+      params.putString("message", "client is null")
+      sendEvent("websocketFailed", params)
+      params = Arguments.createMap()
+      params.putInt("id", id)
+      params.putInt("code", 0)
+      params.putString("reason", "client is null")
+      sendEvent("websocketClosed", params)
+      webSocketConnections.remove(id)
+      contentHandlers.remove(id)
+      return
+    }
+    try {
+      client.send(byteString)
+    } catch (e: Exception) {
+      notifyWebSocketFailed(id, e.message)
+    }
+  }
+
+  override fun ping(socketID: Double) {
+    val id = socketID.toInt()
+    val client = webSocketConnections[id]
+    if (client == null) {
+      // This is a programmer error -- display development warning
+      var params: WritableMap = Arguments.createMap()
+      params.putInt("id", id)
+      params.putString("message", "client is null")
+      sendEvent("websocketFailed", params)
+      params = Arguments.createMap()
+      params.putInt("id", id)
+      params.putInt("code", 0)
+      params.putString("reason", "client is null")
+      sendEvent("websocketClosed", params)
+      webSocketConnections.remove(id)
+      contentHandlers.remove(id)
+      return
+    }
+    try {
+      client.send(ByteString.EMPTY)
+    } catch (e: Exception) {
+      notifyWebSocketFailed(id, e.message)
+    }
+  }
+
+  private fun notifyWebSocketFailed(id: Int, message: String?) {
+    val params = Arguments.createMap()
+    params.putInt("id", id)
+    params.putString("message", message)
+    sendEvent("websocketFailed", params)
+  }
+
+  /**
+   * Get the cookie for a specific domain
+   *
+   * @param uri
+   * @return The cookie header or null if none is set
+   */
+  private fun getCookie(uri: String): String? {
+    try {
+      val origin = URI(getDefaultOrigin(uri))
+      val cookieMap = cookieHandler.get(origin, HashMap<String, List<String>>())
+      val cookieList = cookieMap["Cookie"]
+      if (cookieList.isNullOrEmpty()) {
+        return null
+      }
+      return cookieList[0]
+    } catch (e: URISyntaxException) {
+      throw IllegalArgumentException("Unable to get cookie from $uri")
+    } catch (e: IOException) {
+      throw IllegalArgumentException("Unable to get cookie from $uri")
+    }
+  }
+
+  override fun addListener(eventName: String): Unit = Unit
+
+  override fun removeListeners(count: Double): Unit = Unit
+
+  public companion object {
+    public const val NAME: String = NativeWebSocketModuleSpec.NAME
+
+    private var customClientBuilder: CustomClientBuilder? = null
+
+    @JvmStatic
+    public fun setCustomClientBuilder(ccb: CustomClientBuilder?): Unit {
+      customClientBuilder = ccb
+    }
+
+    private fun applyCustomBuilder(builder: OkHttpClient.Builder) {
+      customClientBuilder?.apply(builder)
+    }
+
+    /**
+     * Get the default HTTP(S) origin for a specific WebSocket URI
+     *
+     * @param uri
+     * @return A string of the endpoint converted to HTTP protocol (http[s]://host[:port])
+     */
+    private fun getDefaultOrigin(uri: String): String {
+      try {
+        val requestURI = URI(uri)
+        val scheme =
+            when (requestURI.scheme) {
+              "wss" -> "https"
+              "ws" -> "http"
+              "http",
+              "https" -> requestURI.scheme
+              else -> ""
+            }
+
+        val defaultOrigin =
+            if (requestURI.port != -1) {
+              String.format("%s://%s:%s", scheme, requestURI.host, requestURI.port)
+            } else {
+              String.format("%s://%s", scheme, requestURI.host)
+            }
+
+        return defaultOrigin
+      } catch (e: URISyntaxException) {
+        throw IllegalArgumentException("Unable to set $uri as default origin header")
+      }
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostDelegate.kt

@@ -12,7 +12,6 @@ import com.facebook.react.ReactPackage
 import com.facebook.react.ReactPackageTurboModuleManagerDelegate
 import com.facebook.react.bridge.JSBundleLoader
 import com.facebook.react.common.annotations.UnstableReactNativeAPI
-import com.facebook.react.fabric.ReactNativeConfig
 
 /**
  * [ReactHostDelegate] is an interface that defines parameters required to initialize React Native.
@@ -54,13 +53,4 @@ public interface ReactHostDelegate {
    * the internals of React Native.
    */
   public fun handleInstanceException(error: Exception)
-
-  /**
-   * ReactNative Configuration that allows to customize the behavior of key/value pairs used by the
-   * framework to enable/disable experimental capabilities
-   *
-   * [moduleProvider] is a function that returns the Native Module with the name received as a
-   * parameter.
-   */
-  public fun getReactNativeConfig(): ReactNativeConfig
 }

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactHostImpl.java

@@ -194,7 +194,7 @@ public class ReactHostImpl implements ReactHost {
     mUIExecutor = uiExecutor;
     mMemoryPressureRouter = new MemoryPressureRouter(context);
     mAllowPackagerServerAccess = allowPackagerServerAccess;
-    mUseDevSupport = useDevSupport || ReactBuildConfig.UNSTABLE_ENABLE_FUSEBOX_RELEASE;
+    mUseDevSupport = useDevSupport;
     if (devSupportManagerFactory == null) {
       devSupportManagerFactory = new DefaultDevSupportManagerFactory();
     }

package/ReactAndroid/src/main/java/com/facebook/react/runtime/ReactInstance.java

@@ -17,6 +17,7 @@ import com.facebook.infer.annotation.ThreadConfined;
 import com.facebook.infer.annotation.ThreadSafe;
 import com.facebook.jni.HybridData;
 import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.BuildConfig;
 import com.facebook.react.DebugCorePackage;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.ViewManagerOnDemandReactPackage;
@@ -130,9 +131,7 @@ final class ReactInstance {
         mQueueConfiguration.getNativeModulesQueueThread();
 
     ReactChoreographer.initialize(AndroidChoreographerProvider.getInstance());
-    if (useDevSupport) {
-      devSupportManager.startInspector();
-    }
+    devSupportManager.startInspector();
 
     JSTimerExecutor jsTimerExecutor = createJSTimerExecutor();
     mJavaTimerManager =
@@ -146,7 +145,9 @@ final class ReactInstance {
     BindingsInstaller bindingsInstaller = delegate.getBindingsInstaller();
     // Notify JS if profiling is enabled
     boolean isProfiling =
-        Systrace.isTracing(Systrace.TRACE_TAG_REACT_APPS | Systrace.TRACE_TAG_REACT_JS_VM_CALLS);
+        BuildConfig.ENABLE_PERFETTO
+            || Systrace.isTracing(
+                Systrace.TRACE_TAG_REACT_APPS | Systrace.TRACE_TAG_REACT_JS_VM_CALLS);
 
     mHybridData =
         initHybrid(
@@ -277,8 +278,7 @@ final class ReactInstance {
         getRuntimeScheduler(),
         mFabricUIManager,
         eventBeatManager,
-        componentFactory,
-        delegate.getReactNativeConfig());
+        componentFactory);
 
     // Initialize the FabricUIManager
     mFabricUIManager.initialize();
@@ -324,8 +324,8 @@ final class ReactInstance {
     }
 
     @Override
-    public void reportJsException(ParsedError error) {
-      JavaOnlyMap data = StackTraceHelper.convertParsedError(error);
+    public void reportJsException(ProcessedError error) {
+      JavaOnlyMap data = StackTraceHelper.convertProcessedError(error);
 
       try {
         NativeExceptionsManagerSpec exceptionsManager =

package/ReactAndroid/src/main/java/com/facebook/react/runtime/hermes/HermesInstance.kt

@@ -9,24 +9,18 @@ package com.facebook.react.runtime.hermes
 
 import com.facebook.jni.HybridData
 import com.facebook.jni.annotations.DoNotStrip
-import com.facebook.react.fabric.ReactNativeConfig
 import com.facebook.react.runtime.JSRuntimeFactory
 import com.facebook.soloader.SoLoader
 
-public class HermesInstance(
-    reactNativeConfig: ReactNativeConfig?,
-    allocInOldGenBeforeTTI: Boolean
-) : JSRuntimeFactory(initHybrid(reactNativeConfig as Any?, allocInOldGenBeforeTTI)) {
+public class HermesInstance(allocInOldGenBeforeTTI: Boolean) :
+    JSRuntimeFactory(initHybrid(allocInOldGenBeforeTTI)) {
 
-  public constructor() : this(null, false)
+  public constructor() : this(false)
 
   public companion object {
     @JvmStatic
     @DoNotStrip
-    protected external fun initHybrid(
-        reactNativeConfig: Any?,
-        allocInOldGenBeforeTTI: Boolean
-    ): HybridData
+    protected external fun initHybrid(allocInOldGenBeforeTTI: Boolean): HybridData
 
     init {
       SoLoader.loadLibrary("hermesinstancejni")

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BackgroundStyleApplicator.kt

@@ -298,6 +298,10 @@ public object BackgroundStyleApplicator {
     val borderInsets = compositeBackgroundDrawable.borderInsets
     val borderRadius = compositeBackgroundDrawable.borderRadius
 
+    /**
+     * z-ordering of user-provided shadow-list is opposite direction of LayerDrawable z-ordering
+     * https://drafts.csswg.org/css-backgrounds/#shadow-layers
+     */
     for (boxShadow in shadows.asReversed()) {
       val offsetX = boxShadow.offsetX
       val offsetY = boxShadow.offsetY

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManager.java

@@ -84,6 +84,7 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
     view.setTag(R.id.accessibility_actions, null);
     view.setTag(R.id.accessibility_value, null);
     view.setTag(R.id.accessibility_state_expanded, null);
+    view.setTag(R.id.view_clipped, null);
 
     // This indirectly calls (and resets):
     // setTranslationX
@@ -813,62 +814,62 @@ public abstract class BaseViewManager<T extends View, C extends LayoutShadowNode
   }
 
   /* Experimental W3C Pointer events start */
-  @ReactProp(name = "onPointerEnter")
+  @ReactProp(name = ViewProps.ON_POINTER_ENTER)
   public void setPointerEnter(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.ENTER, value);
   }
 
-  @ReactProp(name = "onPointerEnterCapture")
+  @ReactProp(name = ViewProps.ON_POINTER_ENTER_CAPTURE)
   public void setPointerEnterCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.ENTER_CAPTURE, value);
   }
 
-  @ReactProp(name = "onPointerOver")
+  @ReactProp(name = ViewProps.ON_POINTER_OVER)
   public void setPointerOver(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.OVER, value);
   }
 
-  @ReactProp(name = "onPointerOverCapture")
+  @ReactProp(name = ViewProps.ON_POINTER_OVER_CAPTURE)
   public void setPointerOverCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.OVER_CAPTURE, value);
   }
 
-  @ReactProp(name = "onPointerOut")
+  @ReactProp(name = ViewProps.ON_POINTER_OUT)
   public void setPointerOut(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.OUT, value);
   }
 
-  @ReactProp(name = "onPointerOutCapture")
+  @ReactProp(name = ViewProps.ON_POINTER_OUT_CAPTURE)
   public void setPointerOutCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.OUT_CAPTURE, value);
   }
 
-  @ReactProp(name = "onPointerLeave")
+  @ReactProp(name = ViewProps.ON_POINTER_LEAVE)
   public void setPointerLeave(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.LEAVE, value);
   }
 
-  @ReactProp(name = "onPointerLeaveCapture")
+  @ReactProp(name = ViewProps.ON_POINTER_LEAVE_CAPTURE)
   public void setPointerLeaveCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.LEAVE_CAPTURE, value);
   }
 
-  @ReactProp(name = "onPointerMove")
+  @ReactProp(name = ViewProps.ON_POINTER_MOVE)
   public void setPointerMove(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.MOVE, value);
   }
 
-  @ReactProp(name = "onPointerMoveCapture")
+  @ReactProp(name = ViewProps.ON_POINTER_MOVE_CAPTURE)
   public void setPointerMoveCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.MOVE_CAPTURE, value);
   }
 
-  @ReactProp(name = "onClick")
+  @ReactProp(name = ViewProps.ON_CLICK)
   public void setClick(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.CLICK, value);
   }
 
-  @ReactProp(name = "onClickCapture")
+  @ReactProp(name = ViewProps.ON_CLICK_CAPTURE)
   public void setClickCapture(@NonNull T view, boolean value) {
     setPointerEventsFlag(view, PointerEventHelper.EVENT.CLICK_CAPTURE, value);
   }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/BaseViewManagerDelegate.kt

@@ -126,20 +126,23 @@ public abstract class BaseViewManagerDelegate<
       ViewProps.Z_INDEX -> mViewManager.setZIndex(view, (value as Double?)?.toFloat() ?: 0.0f)
 
       // Experimental pointer events
-      "onPointerEnter" -> mViewManager.setPointerEnter(view, value as Boolean? ?: false)
-      "onPointerEnterCapture" ->
+      ViewProps.ON_POINTER_ENTER -> mViewManager.setPointerEnter(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_ENTER_CAPTURE ->
           mViewManager.setPointerEnterCapture(view, value as Boolean? ?: false)
-      "onPointerOver" -> mViewManager.setPointerOver(view, value as Boolean? ?: false)
-      "onPointerOverCapture" -> mViewManager.setPointerOverCapture(view, value as Boolean? ?: false)
-      "onPointerOut" -> mViewManager.setPointerOut(view, value as Boolean? ?: false)
-      "onPointerOutCapture" -> mViewManager.setPointerOutCapture(view, value as Boolean? ?: false)
-      "onPointerLeave" -> mViewManager.setPointerLeave(view, value as Boolean? ?: false)
-      "onPointerLeaveCapture" ->
+      ViewProps.ON_POINTER_OVER -> mViewManager.setPointerOver(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_OVER_CAPTURE ->
+          mViewManager.setPointerOverCapture(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_OUT -> mViewManager.setPointerOut(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_OUT_CAPTURE ->
+          mViewManager.setPointerOutCapture(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_LEAVE -> mViewManager.setPointerLeave(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_LEAVE_CAPTURE ->
           mViewManager.setPointerLeaveCapture(view, value as Boolean? ?: false)
-      "onPointerMove" -> mViewManager.setPointerMove(view, value as Boolean? ?: false)
-      "onPointerMoveCapture" -> mViewManager.setPointerMoveCapture(view, value as Boolean? ?: false)
-      "onClick" -> mViewManager.setClick(view, value as Boolean? ?: false)
-      "onClickCapture" -> mViewManager.setClickCapture(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_MOVE -> mViewManager.setPointerMove(view, value as Boolean? ?: false)
+      ViewProps.ON_POINTER_MOVE_CAPTURE ->
+          mViewManager.setPointerMoveCapture(view, value as Boolean? ?: false)
+      ViewProps.ON_CLICK -> mViewManager.setClick(view, value as Boolean? ?: false)
+      ViewProps.ON_CLICK_CAPTURE -> mViewManager.setClickCapture(view, value as Boolean? ?: false)
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/{ComponentNameResolver.java → ComponentNameResolver.kt}

@@ -5,13 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.uimanager;
+package com.facebook.react.uimanager
 
-import com.facebook.proguard.annotations.DoNotStripAny;
+import com.facebook.proguard.annotations.DoNotStripAny
 
 @DoNotStripAny
-public interface ComponentNameResolver {
-
+internal interface ComponentNameResolver {
   /* returns a list of all the component names that are registered in React Native. */
-  String[] getComponentNames();
+  public val componentNames: Array<String>?
 }

package/ReactAndroid/src/main/java/com/facebook/react/uimanager/GuardedFrameCallback.kt

@@ -8,6 +8,7 @@
 package com.facebook.react.uimanager
 
 import android.view.Choreographer
+import com.facebook.react.bridge.JSExceptionHandler
 import com.facebook.react.bridge.ReactContext
 
 /**
@@ -15,13 +16,15 @@ import com.facebook.react.bridge.ReactContext
  * handled by the [JSExceptionHandler] registered if the app is in dev mode.
  */
 public abstract class GuardedFrameCallback
-protected constructor(private val reactContext: ReactContext) : Choreographer.FrameCallback {
+protected constructor(private val exceptionHandler: JSExceptionHandler) :
+    Choreographer.FrameCallback {
+  protected constructor(reactContext: ReactContext) : this(reactContext.exceptionHandler)
 
   override public fun doFrame(frameTimeNanos: Long) {
     try {
       doFrameGuarded(frameTimeNanos)
     } catch (e: RuntimeException) {
-      reactContext.handleException(e)
+      exceptionHandler.handleException(e)
     }
   }