react-native-tvos 0.76.6-0 → 0.77.0-0

package/ReactCommon/react/nativemodule/samples/platform/android/SampleLegacyModule.kt

@@ -0,0 +1,277 @@
+/*
+ * 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.
+ */
+
+package com.facebook.fbreact.specs
+
+import android.widget.Toast
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Dynamic
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = SampleLegacyModule.NAME)
+public class SampleLegacyModule(private val context: ReactApplicationContext) :
+    ReactContextBaseJavaModule(context) {
+  private var toast: Toast? = null
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getBool(arg: Boolean?): Boolean? {
+    log("getBool", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getEnum(arg: Double?): Double? {
+    log("getEnum", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getDouble(arg: Double?): Double? {
+    log("getDouble", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getInt(arg: Int?): Int? {
+    log("getInt", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getFloat(arg: Float?): Float? {
+    log("getFloat", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getObjectDouble(arg: Double?): Double? {
+    log("getObjectDouble", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getObjectInteger(arg: Int?): Int? {
+    log("getObjectInteger", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getObjectFloat(arg: Float?): Float? {
+    log("getObjectFloat", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getString(arg: String?): String? {
+    log("getString", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getRootTag(arg: Double?): Double? {
+    log("getRootTag", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod
+  public fun voidFunc() {
+    log("voidFunc", "<void>", "<void>")
+    return
+  }
+
+  // This function returns {@link WritableMap} instead of {@link Map} for backward compat with
+  // existing native modules that use this Writable* as return types or in events. {@link
+  // WritableMap} is modified in the Java side, and read (or consumed) on the C++ side.
+  // In the future, all native modules should ideally return an immutable Map
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getObject(arg: ReadableMap?): WritableMap {
+    val map = WritableNativeMap()
+    arg?.let { map.merge(it) }
+    log("getObject", arg, map)
+    return map
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getUnsafeObject(arg: ReadableMap?): WritableMap {
+    val map = WritableNativeMap()
+    arg?.let { map.merge(it) }
+    log("getUnsafeObject", arg, map)
+    return map
+  }
+
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getDynamic(dynamic: Dynamic?): WritableMap {
+    val resultMap = WritableNativeMap()
+    when (dynamic?.type) {
+      ReadableType.Null -> {
+        log("getDynamic as Null", dynamic, dynamic)
+        resultMap.putString("type", "Null")
+        resultMap.putNull("value")
+      }
+      ReadableType.Boolean -> {
+        val result = dynamic.asBoolean()
+        log("getDynamic as Boolean", dynamic, result)
+        resultMap.putString("type", "Boolean")
+        resultMap.putBoolean("value", result)
+      }
+      ReadableType.Number -> {
+        val result = dynamic.asInt()
+        log("getDynamic as Number", dynamic, result)
+        resultMap.putString("type", "Number")
+        resultMap.putInt("value", result)
+      }
+      ReadableType.String -> {
+        val result = dynamic.asString()
+        log("getDynamic as String", dynamic, result)
+        resultMap.putString("type", "String")
+        resultMap.putString("value", result)
+      }
+      ReadableType.Array -> {
+        val result = dynamic.asArray()
+        log("getDynamic as Array", dynamic, result)
+        resultMap.putString("type", "Array")
+        resultMap.putArray("value", result)
+      }
+      ReadableType.Map -> {
+        val result = dynamic.asMap()
+        log("getDynamic as Map", dynamic, result)
+        resultMap.putString("type", "Map")
+        resultMap.putMap("value", result)
+      }
+      else -> error("Unsupported dynamic type")
+    }
+    return resultMap
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getValue(numberArg: Double?, stringArg: String?, mapArg: ReadableMap?): WritableMap {
+    val map: WritableMap =
+        WritableNativeMap().apply {
+          putDouble("x", numberArg ?: 0.0)
+          putString("y", stringArg)
+        }
+    val zMap: WritableMap = WritableNativeMap()
+    mapArg?.let { zMap.merge(it) }
+    map.putMap("z", zMap)
+    log(
+        "getValue",
+        mapOf("1-numberArg" to numberArg, "2-stringArg" to stringArg, "3-mapArg" to mapArg),
+        map)
+    return map
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod
+  public fun getValueWithCallback(callback: Callback?) {
+    val result = "Value From Callback"
+    log("Callback", "Return Time", result)
+    callback?.invoke(result)
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public fun getArray(arg: ReadableArray?): WritableArray {
+    if (arg == null || Arguments.toList(arg) == null) {
+      // Returning an empty array, since the super class always returns non-null
+      return WritableNativeArray()
+    }
+    val result: WritableArray = Arguments.makeNativeArray(Arguments.toList(arg))
+    log("getArray", arg, result)
+    return result
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  @ReactMethod
+  public fun getValueWithPromise(error: Boolean, promise: Promise?) {
+    if (error) {
+      promise?.reject(
+          "code 1", "intentional promise rejection", Throwable("promise intentionally rejected"))
+    } else {
+      promise?.resolve("result")
+    }
+  }
+
+  override fun getConstants(): Map<String, Any> {
+    val result: MutableMap<String, Any> = mutableMapOf()
+    val activity = context.currentActivity
+    if (activity != null) {
+      result["const2"] = 390
+    }
+    result["const1"] = true
+    result["const3"] = "something"
+    log("constantsToExport", "", result)
+    return result
+  }
+
+  private fun log(method: String, input: Any?, output: Any?) {
+    toast?.cancel()
+    val message = StringBuilder("Method :")
+    message
+        .append(method)
+        .append("\nInputs: ")
+        .append(input.toString())
+        .append("\nOutputs: ")
+        .append(output.toString())
+    toast = Toast.makeText(context, message.toString(), Toast.LENGTH_LONG)
+    toast?.show()
+  }
+
+  override fun invalidate(): Unit = Unit
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  public companion object {
+    public const val NAME: String = "SampleLegacyModule"
+  }
+}

package/ReactCommon/react/nativemodule/samples/platform/android/SampleTurboModule.kt

@@ -0,0 +1,245 @@
+/*
+ * 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.
+ */
+
+package com.facebook.fbreact.specs
+
+import android.os.Build
+import android.util.DisplayMetrics
+import android.widget.Toast
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModuleWithJSIBindings
+
+@DoNotStrip
+@ReactModule(name = SampleTurboModule.NAME)
+public class SampleTurboModule(private val context: ReactApplicationContext) :
+    NativeSampleTurboModuleSpec(context), TurboModuleWithJSIBindings {
+
+  private var toast: Toast? = null
+
+  @DoNotStrip
+  override fun getBool(arg: Boolean): Boolean {
+    log("getBool", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  override fun getEnum(arg: Double): Double {
+    log("getEnum", arg, arg)
+    return arg
+  }
+
+  override fun getTypedExportedConstants(): MutableMap<String, Any> {
+    val result: MutableMap<String, Any> = mutableMapOf()
+    val activity = context.currentActivity
+    if (activity != null) {
+      @Suppress("DEPRECATION")
+      val widthPixels =
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            activity.windowManager.currentWindowMetrics.bounds.width()
+          } else {
+            val displayMetrics = DisplayMetrics()
+            activity.windowManager.defaultDisplay.getMetrics(displayMetrics)
+            displayMetrics.widthPixels
+          }
+      result["const2"] = widthPixels
+    }
+    result["const1"] = true
+    result["const3"] = "something"
+    log("constantsToExport", "", result)
+    return result
+  }
+
+  @DoNotStrip
+  override fun getNumber(arg: Double): Double {
+    log("getNumber", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  override fun getString(arg: String?): String? {
+    log("getString", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getRootTag(arg: Double): Double {
+    log("getRootTag", arg, arg)
+    return arg
+  }
+
+  @DoNotStrip
+  override fun voidFunc() {
+    log("voidFunc", "<void>", "<void>")
+    emitOnPress()
+    emitOnClick("click")
+    run {
+      val map =
+          WritableNativeMap().apply {
+            putInt("a", 1)
+            putString("b", "two")
+          }
+      emitOnChange(map)
+    }
+    run {
+      val array = WritableNativeArray()
+      val map1 =
+          WritableNativeMap().apply {
+            putInt("a", 1)
+            putString("b", "two")
+          }
+      val map2 =
+          WritableNativeMap().apply {
+            putInt("a", 3)
+            putString("b", "four")
+          }
+      array.pushMap(map1)
+      array.pushMap(map2)
+      emitOnSubmit(array)
+    }
+  }
+
+  // This function returns {@link WritableMap} instead of {@link Map} for backward compat with
+  // existing native modules that use this Writable* as return types or in events. {@link
+  // WritableMap} is modified in the Java side, and read (or consumed) on the C++ side.
+  // In the future, all native modules should ideally return an immutable Map
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getObject(arg: ReadableMap?): WritableMap {
+    val map = WritableNativeMap()
+    arg?.let { map.merge(it) }
+    log("getObject", arg, map)
+    return map
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getUnsafeObject(arg: ReadableMap?): WritableMap {
+    val map = WritableNativeMap()
+    arg?.let { map.merge(it) }
+    log("getUnsafeObject", arg, map)
+    return map
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getValue(x: Double, y: String?, z: ReadableMap?): WritableMap {
+    val map: WritableMap = WritableNativeMap()
+    map.putDouble("x", x)
+    map.putString("y", y)
+    val zMap: WritableMap = WritableNativeMap()
+    z?.let { zMap.merge(it) }
+    map.putMap("z", zMap)
+    log("getValue", mapOf("1-numberArg" to x, "2-stringArg" to y, "3-mapArg" to z), map)
+    return map
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getValueWithCallback(callback: Callback?) {
+    val result = "Value From Callback"
+    log("Callback", "Return Time", result)
+    callback?.invoke(result)
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getArray(arg: ReadableArray?): WritableArray {
+    if (arg == null || Arguments.toList(arg) == null) {
+      // Returning an empty array, since the super class always returns non-null
+      return WritableNativeArray()
+    }
+    val result: WritableArray = Arguments.makeNativeArray(Arguments.toList(arg))
+    log("getArray", arg, result)
+    return result
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getValueWithPromise(error: Boolean, promise: Promise?) {
+    if (error) {
+      promise?.reject(
+          "code 1", "intentional promise rejection", Throwable("promise intentionally rejected"))
+    } else {
+      promise?.resolve("result")
+    }
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun voidFuncThrows() {
+    error("Intentional exception from JVM voidFuncThrows")
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getObjectThrows(arg: ReadableMap?): WritableMap? {
+    error("Intentional exception from JVM getObjectThrows with $arg")
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun promiseThrows(promise: Promise?) {
+    error("Intentional exception from JVM promiseThrows")
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun voidFuncAssert() {
+    assert(false) { "Intentional assert from JVM voidFuncAssert" }
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun getObjectAssert(arg: ReadableMap?): WritableMap? {
+    assert(false) { "Intentional assert from JVM getObjectAssert with $arg" }
+    return null
+  }
+
+  @DoNotStrip
+  @Suppress("unused")
+  override fun promiseAssert(promise: Promise?) {
+    assert(false) { "Intentional assert from JVM promiseAssert" }
+  }
+
+  private fun log(method: String, input: Any?, output: Any?) {
+    toast?.cancel()
+    val message = StringBuilder("Method :")
+    message
+        .append(method)
+        .append("\nInputs: ")
+        .append(input.toString())
+        .append("\nOutputs: ")
+        .append(output.toString())
+    toast = Toast.makeText(context, message.toString(), Toast.LENGTH_LONG)
+    toast?.show()
+  }
+
+  override fun invalidate(): Unit = Unit
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  @DoNotStrip external override fun getBindingsInstaller(): BindingsInstallerHolder
+
+  public companion object {
+    public const val NAME: String = "SampleTurboModule"
+  }
+}

package/ReactCommon/react/nativemodule/samples/platform/ios/ReactCommon/RCTNativeSampleTurboModuleSpec.h

@@ -15,6 +15,8 @@
 
 #import <ReactCommon/RCTTurboModule.h>
 
+NS_ASSUME_NONNULL_BEGIN
+
 /**
  * The ObjC protocol based on the JS Flow type for SampleTurboModule.
  */
@@ -65,3 +67,5 @@ class JSI_EXPORT NativeSampleTurboModuleSpecJSI : public ObjCTurboModule {
 };
 
 } // namespace facebook::react
+
+NS_ASSUME_NONNULL_END

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

@@ -141,8 +141,8 @@ RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getValue : (double)x y : (NS
 {
   return @{
     @"x" : @(x),
-    @"y" : y ?: [NSNull null],
-    @"z" : z ?: [NSNull null],
+    @"y" : y ? y : [NSNull null],
+    @"z" : z ? z : [NSNull null],
   };
 }
 

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

@@ -73,6 +73,7 @@ RCT_EXPORT_MODULE()
 #pragma mark - RCTTurboModuleWithJSIBindings
 
 - (void)installJSIBindingsWithRuntime:(facebook::jsi::Runtime &)runtime
+                          callInvoker:(const std::shared_ptr<CallInvoker> &)callinvoker
 {
   runtime.global().setProperty(runtime, "__SampleTurboModuleJSIBindings", "Hello JSI!");
 }
@@ -132,8 +133,8 @@ RCT_EXPORT_SYNCHRONOUS_TYPED_METHOD(NSDictionary *, getValue : (double)x y : (NS
 {
   return @{
     @"x" : @(x),
-    @"y" : y ?: [NSNull null],
-    @"z" : z ?: [NSNull null],
+    @"y" : y ? y : [NSNull null],
+    @"z" : z ? z : [NSNull null],
   };
 }