react-native-tvos 0.76.5-0 → 0.77.0-0

package/ReactAndroid/src/main/java/com/facebook/react/modules/intent/IntentModule.kt

@@ -0,0 +1,270 @@
+/*
+ * 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.react.modules.intent
+
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.nfc.NfcAdapter
+import android.provider.Settings
+import com.facebook.fbreact.specs.NativeIntentAndroidSpec
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.module.annotations.ReactModule
+import java.util.ArrayList
+
+/** Intent module. Launch other activities or open URLs. */
+@ReactModule(name = NativeIntentAndroidSpec.NAME)
+public open class IntentModule(reactContext: ReactApplicationContext) :
+    NativeIntentAndroidSpec(reactContext) {
+
+  private var initialURLListener: LifecycleEventListener? = null
+  private val pendingOpenURLPromises: MutableList<Promise> = ArrayList<Promise>()
+
+  override fun invalidate() {
+    synchronized(this) {
+      pendingOpenURLPromises.clear()
+      initialURLListener
+          ?.let { listener -> getReactApplicationContext().removeLifecycleEventListener(listener) }
+          .also { initialURLListener = null }
+    }
+    super.invalidate()
+  }
+
+  /**
+   * Return the URL the activity was started with
+   *
+   * @param promise a promise which is resolved with the initial URL
+   */
+  override fun getInitialURL(promise: Promise) {
+    try {
+      val currentActivity = getCurrentActivity()
+      if (currentActivity == null) {
+        waitForActivityAndGetInitialURL(promise)
+        return
+      }
+
+      val intent = currentActivity.intent
+      val action = intent.action
+      val uri = intent.data
+
+      val initialURL =
+          if (uri != null &&
+              (Intent.ACTION_VIEW == action || NfcAdapter.ACTION_NDEF_DISCOVERED == action)) {
+            uri.toString()
+          } else {
+            null
+          }
+
+      promise.resolve(initialURL)
+    } catch (e: Exception) {
+      promise.reject(
+          JSApplicationIllegalArgumentException("Could not get the initial URL : ${e.message}"))
+    }
+  }
+
+  @Synchronized
+  private fun waitForActivityAndGetInitialURL(promise: Promise) {
+    pendingOpenURLPromises.add(promise)
+    if (initialURLListener != null) {
+      return
+    }
+
+    initialURLListener =
+        object : LifecycleEventListener {
+          override fun onHostResume() {
+            getReactApplicationContext().removeLifecycleEventListener(this)
+            synchronized(this@IntentModule) {
+              for (pendingPromise in pendingOpenURLPromises) {
+                getInitialURL(pendingPromise)
+              }
+              initialURLListener = null
+              pendingOpenURLPromises.clear()
+            }
+          }
+
+          override fun onHostPause() = Unit
+
+          override fun onHostDestroy() = Unit
+        }
+    getReactApplicationContext().addLifecycleEventListener(initialURLListener)
+  }
+
+  /**
+   * Starts a corresponding external activity for the given URL.
+   *
+   * For example, if the URL is "https://www.facebook.com", the system browser will be opened, or
+   * the "choose application" dialog will be shown.
+   *
+   * @param url the URL to open
+   */
+  override fun openURL(url: String?, promise: Promise) {
+    if (url == null || url.isEmpty()) {
+      promise.reject(JSApplicationIllegalArgumentException("Invalid URL: $url"))
+      return
+    }
+
+    try {
+      val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url).normalizeScheme())
+      sendOSIntent(intent, false)
+
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject(
+          JSApplicationIllegalArgumentException("Could not open URL '${url}': ${e.message}"))
+    }
+  }
+
+  /**
+   * Determine whether or not an installed app can handle a given URL.
+   *
+   * @param url the URL to open
+   * @param promise a promise that is always resolved with a boolean argument
+   */
+  override fun canOpenURL(url: String?, promise: Promise) {
+    if (url == null || url.isEmpty()) {
+      promise.reject(JSApplicationIllegalArgumentException("Invalid URL: $url"))
+      return
+    }
+
+    try {
+      val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
+      // We need Intent.FLAG_ACTIVITY_NEW_TASK since getReactApplicationContext() returns
+      // the ApplicationContext instead of the Activity context.
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      val packageManager = getReactApplicationContext().getPackageManager()
+      val canOpen = packageManager != null && intent.resolveActivity(packageManager) != null
+      promise.resolve(canOpen)
+    } catch (e: Exception) {
+      promise.reject(
+          JSApplicationIllegalArgumentException(
+              "Could not check if URL '${url}' can be opened: ${e.message}"))
+    }
+  }
+
+  /**
+   * Starts an external activity to open app's settings into Android Settings
+   *
+   * @param promise a promise which is resolved when the Settings is opened
+   */
+  override fun openSettings(promise: Promise) {
+    try {
+      val intent = Intent()
+      val currentActivity: Activity = checkNotNull(getCurrentActivity())
+      val selfPackageName = getReactApplicationContext().getPackageName()
+
+      intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
+      intent.addCategory(Intent.CATEGORY_DEFAULT)
+      intent.setData(Uri.parse("package:$selfPackageName"))
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY)
+      intent.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS)
+      currentActivity.startActivity(intent)
+
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject(
+          JSApplicationIllegalArgumentException("Could not open the Settings: ${e.message}"))
+    }
+  }
+
+  /**
+   * Allows to send intents on Android
+   *
+   * For example, you can open the Notification Category screen for a specific application passing
+   * action = 'android.settings.CHANNEL_NOTIFICATION_SETTINGS' and extras =
+   * [ { 'android.provider.extra.APP_PACKAGE': 'your.package.name.here' }, { 'android.provider.extra.CHANNEL_ID': 'your.channel.id.here } ]
+   *
+   * @param action The general action to be performed
+   * @param extras An array of extras [{ String, String | Number | Boolean }]
+   */
+  override fun sendIntent(action: String?, extras: ReadableArray?, promise: Promise) {
+    if (action == null || action.isEmpty()) {
+      promise.reject(JSApplicationIllegalArgumentException("Invalid Action: $action."))
+      return
+    }
+
+    val intent = Intent(action)
+
+    val packageManager = getReactApplicationContext().getPackageManager()
+    if (packageManager == null || intent.resolveActivity(packageManager) == null) {
+      promise.reject(
+          JSApplicationIllegalArgumentException("Could not launch Intent with action $action."))
+      return
+    }
+
+    if (extras != null) {
+      for (i in 0..<extras.size()) {
+        val map = extras.getMap(i) ?: continue
+        val name = map.getString("key")
+        val type = map.getType(EXTRA_MAP_KEY_FOR_VALUE)
+
+        when (type) {
+          ReadableType.String -> {
+            intent.putExtra(name, map.getString(EXTRA_MAP_KEY_FOR_VALUE))
+          }
+
+          ReadableType.Number -> {
+            // We cannot know from JS if is an Integer or Double
+            // See: https://github.com/facebook/react-native/issues/4141
+            // We might need to find a workaround if this is really an issue
+            val number = map.getDouble(EXTRA_MAP_KEY_FOR_VALUE)
+            intent.putExtra(name, number)
+          }
+
+          ReadableType.Boolean -> {
+            intent.putExtra(name, map.getBoolean(EXTRA_MAP_KEY_FOR_VALUE))
+          }
+
+          else -> {
+            promise.reject(
+                JSApplicationIllegalArgumentException("Extra type for $name not supported."))
+            return
+          }
+        }
+      }
+    }
+
+    sendOSIntent(intent, true)
+  }
+
+  private fun sendOSIntent(intent: Intent, useNewTaskFlag: Boolean) {
+    val currentActivity = getCurrentActivity()
+
+    val selfPackageName = getReactApplicationContext().getPackageName()
+    val packageManager = getReactApplicationContext().getPackageManager()
+    val componentName =
+        if (packageManager == null) {
+          intent.component
+        } else {
+          intent.resolveActivity(packageManager)
+        }
+    val otherPackageName = componentName?.packageName ?: ""
+
+    // If there is no currentActivity or we are launching to a different package we need to set
+    // the FLAG_ACTIVITY_NEW_TASK flag
+    if (useNewTaskFlag || currentActivity == null || (selfPackageName != otherPackageName)) {
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+
+    if (currentActivity != null) {
+      currentActivity.startActivity(intent)
+    } else {
+      getReactApplicationContext().startActivity(intent)
+    }
+  }
+
+  public companion object {
+    private const val EXTRA_MAP_KEY_FOR_VALUE = "value"
+    public const val NAME: String = NativeIntentAndroidSpec.NAME
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/permissions/PermissionsModule.kt

@@ -108,7 +108,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
     var checkedPermissionsCount = 0
     val context = getReactApplicationContext().getBaseContext()
     for (i in 0 until permissions.size()) {
-      val perm = permissions.getString(i)
+      val perm = permissions.getString(i) ?: continue
       if (context.checkSelfPermission(perm) == PackageManager.PERMISSION_GRANTED) {
         grantedPermissions.putString(perm, GRANTED)
         checkedPermissionsCount++
@@ -130,7 +130,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
               val callbackActivity = args[1] as PermissionAwareActivity
               for (j in permissionsToCheck.indices) {
                 val permission = permissionsToCheck[j]
-                if (results.size > 0 && results[j] == PackageManager.PERMISSION_GRANTED) {
+                if (results.size > j && results[j] == PackageManager.PERMISSION_GRANTED) {
                   grantedPermissions.putString(permission, GRANTED)
                 } else {
                   if (callbackActivity.shouldShowRequestPermissionRationale(permission)) {
@@ -183,7 +183,8 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
       return activity
     }
 
-  private companion object {
+  public companion object {
+    public const val NAME: String = NativePermissionsAndroidSpec.NAME
     private const val ERROR_INVALID_ACTIVITY = "E_INVALID_ACTIVITY"
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/reactdevtoolssettings/ReactDevToolsSettingsManagerModule.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.react.modules.reactdevtoolssettings
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.facebook.fbreact.specs.NativeReactDevToolsSettingsManagerSpec
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = NativeReactDevToolsSettingsManagerSpec.NAME)
+internal class ReactDevToolsSettingsManagerModule(reactContext: ReactApplicationContext) :
+    NativeReactDevToolsSettingsManagerSpec(reactContext) {
+
+  private val sharedPreferences: SharedPreferences =
+      reactContext.getSharedPreferences(SHARED_PREFERENCES_PREFIX, Context.MODE_PRIVATE)
+
+  override fun setGlobalHookSettings(settings: String): Unit =
+      sharedPreferences.edit().putString(KEY_HOOK_SETTINGS, settings).apply()
+
+  override fun getGlobalHookSettings(): String? =
+      sharedPreferences.getString(KEY_HOOK_SETTINGS, null)
+
+  companion object {
+    const val NAME: String = NativeReactDevToolsSettingsManagerSpec.NAME
+    private const val SHARED_PREFERENCES_PREFIX = "ReactNative__DevToolsSettings"
+    private const val KEY_HOOK_SETTINGS = "HookSettings"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/share/ShareModule.kt

@@ -59,6 +59,7 @@ public class ShareModule(reactContext: ReactApplicationContext) :
   }
 
   public companion object {
+    public const val NAME: String = NativeShareModuleSpec.NAME
     const private val ACTION_SHARED: String = "sharedAction"
     const public val ERROR_INVALID_CONTENT: String = "E_INVALID_CONTENT"
     const private val ERROR_UNABLE_TO_OPEN_DIALOG: String = "E_UNABLE_TO_OPEN_DIALOG"

package/ReactAndroid/src/main/java/com/facebook/react/modules/sound/SoundManagerModule.kt

@@ -23,4 +23,8 @@ public class SoundManagerModule(reactContext: ReactApplicationContext?) :
         getReactApplicationContext().getSystemService(Context.AUDIO_SERVICE) as AudioManager
     audioManager.playSoundEffect(AudioManager.FX_KEY_CLICK)
   }
+
+  public companion object {
+    public const val NAME: String = NativeSoundManagerSpec.NAME
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/AndroidInfoHelpers.kt

@@ -0,0 +1,126 @@
+/*
+ * 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.react.modules.systeminfo
+
+import android.content.Context
+import android.os.Build
+import com.facebook.common.logging.FLog
+import com.facebook.react.R
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.nio.charset.Charset
+import java.util.Locale
+
+public object AndroidInfoHelpers {
+
+  public const val EMULATOR_LOCALHOST: String = "10.0.2.2"
+  public const val GENYMOTION_LOCALHOST: String = "10.0.3.2"
+  public const val DEVICE_LOCALHOST: String = "localhost"
+  public const val METRO_HOST_PROP_NAME: String = "metro.host"
+  private val TAG = AndroidInfoHelpers::class.java.simpleName
+  private var metroHostPropValue: String? = null
+
+  private fun isRunningOnGenymotion(): Boolean = Build.FINGERPRINT.contains("vbox")
+
+  private fun isRunningOnStockEmulator(): Boolean =
+      Build.FINGERPRINT.contains("generic") || Build.FINGERPRINT.startsWith("google/sdk_gphone")
+
+  @JvmStatic public fun getServerHost(port: Int): String = getServerIpAddress(port)
+
+  @JvmStatic
+  public fun getServerHost(context: Context): String = getServerIpAddress(getDevServerPort(context))
+
+  @JvmStatic
+  public fun getAdbReverseTcpCommand(port: Int): String = "adb reverse tcp:$port tcp:$port"
+
+  @JvmStatic
+  public fun getAdbReverseTcpCommand(context: Context): String =
+      getAdbReverseTcpCommand(getDevServerPort(context))
+
+  @JvmStatic
+  public fun getFriendlyDeviceName(): String {
+    return if (isRunningOnGenymotion()) {
+      Build.MODEL
+    } else {
+      "${Build.MODEL} - ${Build.VERSION.RELEASE} - API ${Build.VERSION.SDK_INT}"
+    }
+  }
+
+  @JvmStatic
+  public fun getInspectorHostMetadata(applicationContext: Context?): Map<String, String?> {
+    var appIdentifier: String? = null
+    var appDisplayName: String? = null
+
+    if (applicationContext != null) {
+      val applicationInfo = applicationContext.applicationInfo
+      val labelResourceId = applicationInfo.labelRes
+
+      appIdentifier = applicationContext.packageName
+      appDisplayName =
+          if (labelResourceId == 0) {
+            applicationInfo.nonLocalizedLabel.toString()
+          } else {
+            applicationContext.getString(labelResourceId)
+          }
+    }
+
+    return mapOf(
+        "appDisplayName" to appDisplayName,
+        "appIdentifier" to appIdentifier,
+        "platform" to "android",
+        "deviceName" to Build.MODEL,
+        "reactNativeVersion" to getReactNativeVersionString())
+  }
+
+  private fun getReactNativeVersionString(): String {
+    val version = ReactNativeVersion.VERSION
+    return "${version["major"]}.${version["minor"]}.${version["patch"]}" +
+        (version["prerelease"]?.let { "-$it" } ?: "")
+  }
+
+  private fun getDevServerPort(context: Context): Int =
+      context.resources.getInteger(R.integer.react_native_dev_server_port)
+
+  private fun getServerIpAddress(port: Int): String {
+    val ipAddress: String =
+        when {
+          getMetroHostPropValue().isNotEmpty() -> getMetroHostPropValue()
+          isRunningOnGenymotion() -> GENYMOTION_LOCALHOST
+          isRunningOnStockEmulator() -> EMULATOR_LOCALHOST
+          else -> DEVICE_LOCALHOST
+        }
+    return String.format(Locale.US, "%s:%d", ipAddress, port)
+  }
+
+  @Synchronized
+  private fun getMetroHostPropValue(): String {
+    if (metroHostPropValue != null) {
+      return metroHostPropValue!!
+    }
+    var process: Process? = null
+    var reader: BufferedReader? = null
+    try {
+      process = Runtime.getRuntime().exec(arrayOf("/system/bin/getprop", METRO_HOST_PROP_NAME))
+      reader = BufferedReader(InputStreamReader(process.inputStream, Charset.forName("UTF-8")))
+
+      var lastLine = ""
+      var line: String?
+      while (reader.readLine().also { line = it } != null) {
+        lastLine = line ?: ""
+      }
+      metroHostPropValue = lastLine
+    } catch (e: Exception) {
+      FLog.w(TAG, "Failed to query for metro.host prop:", e)
+      metroHostPropValue = ""
+    } finally {
+      reader?.close()
+      process?.destroy()
+    }
+    return metroHostPropValue ?: ""
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/AndroidInfoModule.kt

@@ -0,0 +1,87 @@
+/*
+ * 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.react.modules.systeminfo
+
+import android.annotation.SuppressLint
+import android.app.UiModeManager
+import android.content.Context.UI_MODE_SERVICE
+import android.content.res.Configuration
+import android.os.Build
+import android.provider.Settings.Secure
+import com.facebook.fbreact.specs.NativePlatformConstantsAndroidSpec
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.common.build.ReactBuildConfig
+import com.facebook.react.module.annotations.ReactModule
+
+/** Module that exposes Android Constants to JS. */
+@ReactModule(name = NativePlatformConstantsAndroidSpec.NAME)
+@SuppressLint("HardwareIds")
+@Suppress("DEPRECATION")
+public class AndroidInfoModule(reactContext: ReactApplicationContext) :
+    NativePlatformConstantsAndroidSpec(reactContext) {
+
+  private companion object {
+    private const val IS_TESTING = "IS_TESTING"
+    private const val IS_DISABLE_ANIMATIONS = "IS_DISABLE_ANIMATIONS"
+  }
+
+  /**
+   * See:
+   * https://developer.android.com/reference/android/app/UiModeManager.html#getCurrentModeType()
+   */
+  private fun uiMode(): String {
+    val uiModeManager = reactApplicationContext.getSystemService(UI_MODE_SERVICE) as UiModeManager
+    return when (uiModeManager.currentModeType) {
+      Configuration.UI_MODE_TYPE_TELEVISION -> "tv"
+      Configuration.UI_MODE_TYPE_CAR -> "car"
+      Configuration.UI_MODE_TYPE_DESK -> "desk"
+      Configuration.UI_MODE_TYPE_WATCH -> "watch"
+      Configuration.UI_MODE_TYPE_VR_HEADSET -> "vrheadset"
+      Configuration.UI_MODE_TYPE_NORMAL -> "normal"
+      else -> "unknown"
+    }
+  }
+
+  override fun getTypedExportedConstants(): Map<String, Any?> {
+    val constants = mutableMapOf<String, Any?>()
+    constants["Version"] = Build.VERSION.SDK_INT
+    constants["Release"] = Build.VERSION.RELEASE
+    constants["Serial"] = Build.SERIAL
+    constants["Fingerprint"] = Build.FINGERPRINT
+    constants["Model"] = Build.MODEL
+    constants["Manufacturer"] = Build.MANUFACTURER
+    constants["Brand"] = Build.BRAND
+    if (ReactBuildConfig.DEBUG) {
+      constants["ServerHost"] =
+          AndroidInfoHelpers.getServerHost(reactApplicationContext.applicationContext)
+    }
+    constants["isTesting"] = "true" == System.getProperty(IS_TESTING) || isRunningScreenshotTest()
+    val isDisableAnimations = System.getProperty(IS_DISABLE_ANIMATIONS)
+    if (isDisableAnimations != null) {
+      constants["isDisableAnimations"] = "true" == isDisableAnimations
+    }
+    constants["reactNativeVersion"] = ReactNativeVersion.VERSION
+    constants["uiMode"] = uiMode()
+    return constants
+  }
+
+  override fun getAndroidID(): String {
+    return Secure.getString(reactApplicationContext.contentResolver, Secure.ANDROID_ID)
+  }
+
+  override fun invalidate() {}
+
+  private fun isRunningScreenshotTest(): Boolean {
+    return try {
+      Class.forName("com.facebook.testing.react.screenshots.ReactAppScreenshotTestActivity")
+      true
+    } catch (ignored: ClassNotFoundException) {
+      false
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -16,7 +16,7 @@ import java.util.Map;
 public class ReactNativeVersion {
   public static final Map<String, Object> VERSION = MapBuilder.<String, Object>of(
       "major", 0,
-      "minor", 76,
-      "patch", 5,
+      "minor", 77,
+      "patch", 0,
       "prerelease", "0");
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/vibration/VibrationModule.kt

@@ -20,10 +20,10 @@ import com.facebook.react.module.annotations.ReactModule
 
 @SuppressLint("MissingPermission")
 @ReactModule(name = NativeVibrationSpec.NAME)
-public class VibrationModule(reactContext: ReactApplicationContext) :
+internal class VibrationModule(reactContext: ReactApplicationContext) :
     NativeVibrationSpec(reactContext) {
 
-  public override fun vibrate(durationDouble: Double) {
+  override fun vibrate(durationDouble: Double) {
     val duration = durationDouble.toInt()
     val v = getVibrator() ?: return
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -33,7 +33,7 @@ public class VibrationModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  public override fun vibrateByPattern(pattern: ReadableArray, repeatDouble: Double) {
+  override fun vibrateByPattern(pattern: ReadableArray, repeatDouble: Double) {
     val repeat = repeatDouble.toInt()
     val v = getVibrator() ?: return
     val patternLong = LongArray(pattern.size())
@@ -47,7 +47,7 @@ public class VibrationModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  public override fun cancel() {
+  override fun cancel() {
     getVibrator()?.cancel()
   }
 
@@ -61,4 +61,8 @@ public class VibrationModule(reactContext: ReactApplicationContext) :
         @Suppress("DEPRECATION")
         getReactApplicationContext().getSystemService(Context.VIBRATOR_SERVICE) as Vibrator?
       }
+
+  companion object {
+    const val NAME: String = NativeVibrationSpec.NAME
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/processing/ReactPropertyProcessor.java

@@ -19,6 +19,7 @@ import com.facebook.react.bridge.Dynamic;
 import com.facebook.react.bridge.DynamicFromObject;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
 import com.facebook.react.uimanager.annotations.ReactProp;
 import com.facebook.react.uimanager.annotations.ReactPropGroup;
 import com.facebook.react.uimanager.annotations.ReactPropertyHolder;
@@ -268,6 +269,7 @@ public class ReactPropertyProcessor extends ProcessorBase {
     TypeSpec holderClass =
         TypeSpec.classBuilder(holderClassName)
             .addSuperinterface(superType)
+            .addAnnotation(UnstableReactNativeAPI.class)
             .addModifiers(PUBLIC)
             .addMethod(generateSetPropertySpec(classInfo, properties))
             .addMethod(getMethods)

package/ReactAndroid/src/main/java/com/facebook/react/reactperflogger/NativeModulePerfLogger.kt

@@ -9,7 +9,7 @@ package com.facebook.react.reactperflogger
 
 import com.facebook.jni.HybridData
 
-public abstract class NativeModulePerfLogger protected constructor() {
+internal abstract class NativeModulePerfLogger protected constructor() {
 
   @Suppress("NoHungarianNotation") private val mHybridData: HybridData
 
@@ -20,25 +20,25 @@ public abstract class NativeModulePerfLogger protected constructor() {
 
   protected abstract fun initHybrid(): HybridData
 
-  public abstract fun moduleDataCreateStart(moduleName: String, id: Int)
+  abstract fun moduleDataCreateStart(moduleName: String, id: Int)
 
-  public abstract fun moduleDataCreateEnd(moduleName: String, id: Int)
+  abstract fun moduleDataCreateEnd(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateStart(moduleName: String, id: Int)
+  abstract fun moduleCreateStart(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateCacheHit(moduleName: String, id: Int)
+  abstract fun moduleCreateCacheHit(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateConstructStart(moduleName: String, id: Int)
+  abstract fun moduleCreateConstructStart(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateConstructEnd(moduleName: String, id: Int)
+  abstract fun moduleCreateConstructEnd(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateSetUpStart(moduleName: String, id: Int)
+  abstract fun moduleCreateSetUpStart(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateSetUpEnd(moduleName: String, id: Int)
+  abstract fun moduleCreateSetUpEnd(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateEnd(moduleName: String, id: Int)
+  abstract fun moduleCreateEnd(moduleName: String, id: Int)
 
-  public abstract fun moduleCreateFail(moduleName: String, id: Int)
+  abstract fun moduleCreateFail(moduleName: String, id: Int)
 
   /** Subclasses will override this method to load their own SO libraries. */
   @Synchronized