react-native-tvos 0.79.2-0 → 0.80.0-0

package/ReactAndroid/src/main/java/com/facebook/react/internal/turbomodule/core/TurboModuleManager.kt

@@ -0,0 +1,405 @@
+/*
+ * 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.internal.turbomodule.core
+
+import androidx.annotation.GuardedBy
+import com.facebook.common.logging.FLog
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.CxxModuleWrapper
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.RuntimeExecutor
+import com.facebook.react.common.annotations.FrameworkAPI
+import com.facebook.react.internal.turbomodule.core.interfaces.TurboModuleRegistry
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl
+import com.facebook.react.turbomodule.core.NativeMethodCallInvokerHolderImpl
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.facebook.soloader.SoLoader
+import kotlin.concurrent.Volatile
+
+/**
+ * This is the main class and entry point for TurboModules. Note that this is a hybrid class, and
+ * has a C++ counterpart This class installs the JSI bindings. It also implements the method to get
+ * a Java module, that the C++ counterpart calls.
+ */
+@OptIn(FrameworkAPI::class)
+public class TurboModuleManager(
+    runtimeExecutor: RuntimeExecutor,
+    private val delegate: TurboModuleManagerDelegate?,
+    jsCallInvokerHolder: CallInvokerHolder,
+    nativeMethodCallInvokerHolder: NativeMethodCallInvokerHolder
+) : TurboModuleRegistry {
+
+  public override val eagerInitModuleNames: List<String>
+  private val turboModuleProvider: ModuleProvider
+  private val legacyModuleProvider: ModuleProvider
+
+  // Prevents the creation of new TurboModules once cleanup as been initiated.
+  private val moduleCleanupLock = Object()
+
+  @GuardedBy("moduleCleanupLock") private var moduleCleanupStarted = false
+
+  // List of TurboModules that have been, or are currently being, instantiated
+  @GuardedBy("moduleCleanupLock") private val moduleHolders = mutableMapOf<String, ModuleHolder>()
+
+  @Suppress("NoHungarianNotation")
+  @DoNotStrip
+  private val mHybridData: HybridData =
+      initHybrid(
+          runtimeExecutor,
+          jsCallInvokerHolder as CallInvokerHolderImpl,
+          nativeMethodCallInvokerHolder as NativeMethodCallInvokerHolderImpl,
+          delegate)
+
+  init {
+
+    installJSIBindings(shouldEnableLegacyModuleInterop())
+
+    eagerInitModuleNames = delegate?.getEagerInitModuleNames() ?: emptyList()
+
+    val nullProvider: ModuleProvider = ModuleProvider { _: String -> null }
+
+    turboModuleProvider =
+        if (delegate == null) nullProvider
+        else
+            ModuleProvider { moduleName: String -> delegate.getModule(moduleName) as NativeModule? }
+
+    legacyModuleProvider =
+        if (delegate == null || !shouldEnableLegacyModuleInterop()) nullProvider
+        else
+            ModuleProvider { moduleName: String ->
+              val nativeModule = delegate.getLegacyModule(moduleName)
+              if (nativeModule != null) {
+                // TurboModuleManagerDelegate.getLegacyModule must never return a TurboModule
+                require(nativeModule !is TurboModule) {
+                  "NativeModule \"$moduleName\" is a TurboModule"
+                }
+                return@ModuleProvider nativeModule
+              }
+              null
+            }
+  }
+
+  private fun isTurboModule(moduleName: String): Boolean =
+      delegate?.unstable_isModuleRegistered(moduleName) == true
+
+  private fun isLegacyModule(moduleName: String): Boolean =
+      delegate?.unstable_isLegacyModuleRegistered(moduleName) == true
+
+  private fun shouldEnableLegacyModuleInterop(): Boolean =
+      delegate?.unstable_shouldEnableLegacyModuleInterop() == true
+
+  // used from TurboModuleManager.cpp
+  @Suppress("unused")
+  @DoNotStrip
+  private fun getLegacyJavaModule(moduleName: String): NativeModule? {
+    /*
+     * This API is invoked from global.nativeModuleProxy.
+     * Only call getModule if the native module is a legacy module.
+     */
+    if (!isLegacyModule(moduleName)) {
+      return null
+    }
+
+    val module = getModule(moduleName)
+    return if (module !is CxxModuleWrapper && module !is TurboModule) module else null
+  }
+
+  // used from TurboModuleManager.cpp
+  @Suppress("unused")
+  @DoNotStrip
+  private fun getLegacyCxxModule(moduleName: String): CxxModuleWrapper? {
+    /*
+     * This API is invoked from global.nativeModuleProxy.
+     * Only call getModule if the native module is a legacy module.
+     */
+    if (!isLegacyModule(moduleName)) {
+      return null
+    }
+
+    val module = getModule(moduleName)
+    return if (module is CxxModuleWrapper && module !is TurboModule) module else null
+  }
+
+  // used from TurboModuleManager.cpp
+  @Suppress("unused")
+  @DoNotStrip
+  private fun getTurboLegacyCxxModule(moduleName: String): CxxModuleWrapper? {
+    /*
+     * This API is invoked from global.__turboModuleProxy.
+     * Only call getModule if the native module is a turbo module.
+     */
+    if (!isTurboModule(moduleName)) {
+      return null
+    }
+
+    val module = getModule(moduleName)
+    return if (module is CxxModuleWrapper && module is TurboModule) module else null
+  }
+
+  // used from TurboModuleManager.cpp
+  @Suppress("unused")
+  @DoNotStrip
+  private fun getTurboJavaModule(moduleName: String): TurboModule? {
+    /*
+     * This API is invoked from global.__turboModuleProxy.
+     * Only call getModule if the native module is a turbo module.
+     */
+    if (!isTurboModule(moduleName)) {
+      return null
+    }
+
+    val module = getModule(moduleName)
+    return if (module !is CxxModuleWrapper && module is TurboModule) module else null
+  }
+
+  /**
+   * Return the NativeModule instance that corresponds to the provided moduleName.
+   *
+   * This method: - Creates and initializes the module if it doesn't already exist. - Returns null
+   * after TurboModuleManager has been torn down.
+   */
+  override fun getModule(moduleName: String): NativeModule? {
+    val moduleHolder: ModuleHolder?
+
+    synchronized(moduleCleanupLock) {
+      if (moduleCleanupStarted) {
+        /*
+         * Always return null after cleanup has started, so that getNativeModule(moduleName) returns null.
+         */
+        FLog.e(
+            TAG,
+            "getModule(): Tried to get module \"%s\", but TurboModuleManager was tearing down (legacy: %b, turbo: %b)",
+            moduleName,
+            isLegacyModule(moduleName),
+            isTurboModule(moduleName))
+        return null
+      }
+      /*
+       * TODO(T64619790): Should we populate moduleHolders ahead of time, to avoid having
+       * * to control concurrent access to it?
+       */
+      if (!moduleHolders.containsKey(moduleName)) {
+        moduleHolders[moduleName] = ModuleHolder()
+      }
+      moduleHolder = moduleHolders[moduleName]
+    }
+
+    if (moduleHolder == null) {
+      FLog.e(TAG, "getModule(): Tried to get module \"%s\", but moduleHolder was null", moduleName)
+      return null
+    }
+
+    TurboModulePerfLogger.moduleCreateStart(moduleName, moduleHolder.moduleId)
+    val module = getOrCreateModule(moduleName, moduleHolder, true)
+
+    if (module != null) {
+      TurboModulePerfLogger.moduleCreateEnd(moduleName, moduleHolder.moduleId)
+    } else {
+      TurboModulePerfLogger.moduleCreateFail(moduleName, moduleHolder.moduleId)
+    }
+
+    return module
+  }
+
+  /**
+   * Given a ModuleHolder, and the TurboModule's moduleName, return the TurboModule instance.
+   *
+   * Use the ModuleHolder to ensure that if n threads race to create TurboModule x, then only the
+   * first thread creates x. All n - 1 other threads wait until the x is created and initialized.
+   */
+  private fun getOrCreateModule(
+      moduleName: String,
+      moduleHolder: ModuleHolder,
+      shouldPerfLog: Boolean
+  ): NativeModule? {
+    var shouldCreateModule = false
+
+    synchronized(moduleHolder) {
+      if (moduleHolder.isDoneCreatingModule) {
+        if (shouldPerfLog) {
+          TurboModulePerfLogger.moduleCreateCacheHit(moduleName, moduleHolder.moduleId)
+        }
+
+        return moduleHolder.module
+      }
+      if (!moduleHolder.isCreatingModule) {
+        // Only one thread gets here
+        shouldCreateModule = true
+        moduleHolder.startCreatingModule()
+      }
+    }
+
+    if (shouldCreateModule) {
+      TurboModulePerfLogger.moduleCreateConstructStart(moduleName, moduleHolder.moduleId)
+      var nativeModule = turboModuleProvider.getModule(moduleName)
+
+      if (nativeModule == null) {
+        nativeModule = legacyModuleProvider.getModule(moduleName)
+      }
+
+      TurboModulePerfLogger.moduleCreateConstructEnd(moduleName, moduleHolder.moduleId)
+      TurboModulePerfLogger.moduleCreateSetUpStart(moduleName, moduleHolder.moduleId)
+
+      if (nativeModule != null) {
+        synchronized(moduleHolder) { moduleHolder.module = nativeModule }
+
+        /*
+         * TurboModuleManager is initialized after ReactApplicationContext has been set up.
+         * NativeModules should be initialized after ReactApplicationContext has been set up.
+         * Therefore, we should initialize on the TurboModule now.
+         */
+        nativeModule.initialize()
+      } else {
+        FLog.e(
+            TAG,
+            "getOrCreateModule(): Unable to create module \"%s\" (legacy: %b, turbo: %b)",
+            moduleName,
+            isLegacyModule(moduleName),
+            isTurboModule(moduleName))
+      }
+
+      TurboModulePerfLogger.moduleCreateSetUpEnd(moduleName, moduleHolder.moduleId)
+      synchronized(moduleHolder) {
+        moduleHolder.endCreatingModule()
+        (moduleHolder as Object).notifyAll()
+      }
+
+      return nativeModule
+    }
+
+    synchronized(moduleHolder) {
+      var wasInterrupted = false
+      while (moduleHolder.isCreatingModule) {
+        try {
+          // Wait until TurboModule is created and initialized
+          (moduleHolder as Object).wait()
+        } catch (e: InterruptedException) {
+          wasInterrupted = true
+        }
+      }
+
+      if (wasInterrupted) {
+        /*
+         * TurboModules should ideally be quick to create and initialize. Therefore,
+         * we wait until the TurboModule is done initializing before re-interrupting the
+         * current thread.
+         */
+        Thread.currentThread().interrupt()
+      }
+      return moduleHolder.module
+    }
+  }
+
+  public override val modules: Collection<NativeModule>
+    get() {
+      val holders = synchronized(moduleCleanupLock) { this.moduleHolders.values.toList() }
+      val moduleList = holders.mapNotNull { holder -> synchronized(holders) { holder.module } }
+      return moduleList
+    }
+
+  override fun hasModule(moduleName: String): Boolean {
+    val moduleHolder = synchronized(moduleCleanupLock) { moduleHolders[moduleName] ?: return false }
+    return synchronized(moduleHolder) { moduleHolder.module != null }
+  }
+
+  private external fun initHybrid(
+      runtimeExecutor: RuntimeExecutor,
+      jsCallInvokerHolder: CallInvokerHolderImpl,
+      nativeMethodCallInvoker: NativeMethodCallInvokerHolderImpl,
+      tmmDelegate: TurboModuleManagerDelegate?
+  ): HybridData
+
+  private external fun installJSIBindings(shouldCreateLegacyModules: Boolean)
+
+  override fun invalidate() {
+    /*
+     * Halt the production of new TurboModules.
+     *
+     * <p>After this point, mModuleHolders will not be accessed by TurboModuleManager.
+     * Therefore, it won't be modified.
+     *
+     * <p>The ModuleHolders in mModuleHolders, however, can still be populated with newly
+     * created TurboModules.
+     */
+    synchronized(moduleCleanupLock) { moduleCleanupStarted = true }
+
+    for ((moduleName, moduleHolder) in moduleHolders) {
+      /**
+       * ReactNative could start tearing down before this particular TurboModule has been fully
+       * initialized. In this case, we should wait for initialization to complete, before destroying
+       * the TurboModule.
+       */
+      val nativeModule = getOrCreateModule(moduleName, moduleHolder, false)
+
+      nativeModule?.invalidate()
+    }
+
+    moduleHolders.clear()
+
+    // Delete the native part of this hybrid class.
+    mHybridData.resetNative()
+  }
+
+  private class ModuleHolder {
+    @Volatile var module: NativeModule? = null
+
+    @Volatile
+    var isCreatingModule: Boolean = false
+      private set
+
+    @Volatile
+    var isDoneCreatingModule: Boolean = false
+      private set
+
+    @Volatile
+    var moduleId: Int
+      private set
+
+    init {
+      moduleId = holderCount
+      holderCount += 1
+    }
+
+    fun startCreatingModule() {
+      isCreatingModule = true
+    }
+
+    fun endCreatingModule() {
+      isCreatingModule = false
+      isDoneCreatingModule = true
+    }
+
+    companion object {
+      @Volatile private var holderCount = 0
+    }
+  }
+
+  private fun interface ModuleProvider {
+    fun getModule(name: String): NativeModule?
+  }
+
+  public companion object {
+    private const val TAG = "TurboModuleManager"
+
+    init {
+      SoLoader.loadLibrary("turbomodulejsijni")
+    }
+
+    // used from TurboModuleManager.cpp
+    @JvmStatic
+    @Suppress("unused")
+    @DoNotStrip
+    private fun getMethodDescriptorsFromModule(
+        module: NativeModule
+    ): List<TurboModuleInteropUtils.MethodDescriptor> =
+        TurboModuleInteropUtils.getMethodDescriptorsFromModule(module)
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/internal/turbomodule/core/TurboModuleManagerDelegate.kt

@@ -0,0 +1,63 @@
+/*
+ * 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.internal.turbomodule.core
+
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import com.facebook.soloader.SoLoader
+
+public abstract class TurboModuleManagerDelegate {
+
+  // NOTE: This *must* be called "mHybridData"
+  @DoNotStrip @Suppress("unused", "NoHungarianNotation") private val mHybridData: HybridData
+
+  protected abstract fun initHybrid(): HybridData
+
+  protected constructor() {
+    maybeLoadOtherSoLibraries()
+    mHybridData = initHybrid()
+  }
+
+  protected constructor(hybridData: HybridData) {
+    maybeLoadOtherSoLibraries()
+    this.mHybridData = hybridData
+  }
+
+  /**
+   * Create and return a TurboModule Java object with name `moduleName`. If `moduleName` isn't a
+   * TurboModule, return null.
+   */
+  public abstract fun getModule(moduleName: String?): TurboModule?
+
+  public abstract fun unstable_isModuleRegistered(moduleName: String?): Boolean
+
+  /**
+   * Create an return a legacy NativeModule with name `moduleName`. If `moduleName` is a
+   * TurboModule, return null.
+   */
+  public open fun getLegacyModule(moduleName: String?): NativeModule? = null
+
+  public open fun unstable_isLegacyModuleRegistered(moduleName: String?): Boolean = false
+
+  public open fun getEagerInitModuleNames(): List<String> = emptyList()
+
+  /** Can the TurboModule system create legacy modules? */
+  public open fun unstable_shouldEnableLegacyModuleInterop(): Boolean = false
+
+  // TODO(T171231381): Consider removing this method: could we just use the static initializer
+  // of derived classes instead?
+  @Synchronized protected fun maybeLoadOtherSoLibraries(): Unit = Unit
+
+  private companion object {
+    init {
+      SoLoader.loadLibrary("turbomodulejsijni")
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/internal/turbomodule/core/TurboModulePerfLogger.kt

@@ -8,15 +8,15 @@
 package com.facebook.react.internal.turbomodule.core
 
 import com.facebook.proguard.annotations.DoNotStrip
-import com.facebook.react.internal.turbomodule.core.NativeModuleSoLoader.Companion.maybeLoadSoLibrary
 import com.facebook.react.reactperflogger.NativeModulePerfLogger
+import com.facebook.soloader.SoLoader
 
 @DoNotStrip
 internal object TurboModulePerfLogger {
   private var nativeModulePerfLogger: NativeModulePerfLogger? = null
 
   init {
-    maybeLoadSoLibrary()
+    SoLoader.loadLibrary("turbomodulejsijni")
   }
 
   @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/jscexecutor/JSCExecutor.kt

@@ -11,11 +11,15 @@ import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.facebook.react.bridge.JavaScriptExecutor
 import com.facebook.react.bridge.ReadableNativeMap
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 import com.facebook.soloader.SoLoader
 
 @DoNotStrip
+@LegacyArchitecture
 public class JSCExecutor internal constructor(jscConfig: ReadableNativeMap) :
     JavaScriptExecutor(initHybrid(jscConfig)) {
+
   override fun getName(): String {
     return "JSCExecutor"
   }
@@ -23,6 +27,7 @@ public class JSCExecutor internal constructor(jscConfig: ReadableNativeMap) :
   private companion object {
     init {
       loadLibrary()
+      LegacyArchitectureLogger.assertLegacyArchitecture("JSCExecutor")
     }
 
     @JvmStatic

package/ReactAndroid/src/main/java/com/facebook/react/jscexecutor/JSCExecutorFactory.kt

@@ -10,10 +10,17 @@ package com.facebook.react.jscexecutor
 import com.facebook.react.bridge.JavaScriptExecutor
 import com.facebook.react.bridge.JavaScriptExecutorFactory
 import com.facebook.react.bridge.WritableNativeMap
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger
 
+@LegacyArchitecture
 public class JSCExecutorFactory(private val appName: String, private val deviceName: String) :
     JavaScriptExecutorFactory {
 
+  init {
+    LegacyArchitectureLogger.assertLegacyArchitecture("JSCExecutorFactory")
+  }
+
   @Throws(Exception::class)
   override fun create(): JavaScriptExecutor {
     val jscConfig =

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskConfig.kt

@@ -20,11 +20,7 @@ import com.facebook.react.bridge.WritableMap
  *   accidentally keeping the device awake for long periods of time because JS crashed or some
  *   request timed out. A value of 0 means no timeout (should only be used for long-running tasks
  *   such as music playback).
- * @property allowedInForeground whether to allow this task to run while the app is in the
- *   foreground (i.e. there is a host in resumed mode for the current ReactContext). Only set this
- *   to true if you really need it. Note that tasks run in the same JS thread as UI code, so doing
- *   expensive operations would degrade user experience.
- * @property allowedInForeground whether to allow this task to run while the app is in the
+ * @property isAllowedInForeground whether to allow this task to run while the app is in the
  *   foreground (i.e. there is a host in resumed mode for the current ReactContext). Only set this
  *   to true if you really need it. Note that tasks run in the same JS thread as UI code, so doing
  *   expensive operations would degrade user experience.

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskEventListener.kt

@@ -18,8 +18,9 @@ public interface HeadlessJsTaskEventListener {
   public fun onHeadlessJsTaskStart(taskId: Int)
 
   /**
-   * Called when a JS task finishes (i.e. when [HeadlessJsTaskSupportModule.notifyTaskFinished] is
-   * called, or when it times out), on the UI thread.
+   * Called when a JS task finishes (i.e. when
+   * [com.facebook.react.modules.core.HeadlessJsTaskSupportModule.notifyTaskFinished] is called, or
+   * when it times out), on the UI thread.
    */
   public fun onHeadlessJsTaskFinish(taskId: Int)
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/accessibilityinfo/AccessibilityInfoModule.kt

@@ -7,7 +7,6 @@
 
 package com.facebook.react.modules.accessibilityinfo
 
-import android.annotation.TargetApi
 import android.content.ContentResolver
 import android.content.Context
 import android.database.ContentObserver
@@ -30,7 +29,6 @@ import com.facebook.react.module.annotations.ReactModule
 @ReactModule(name = NativeAccessibilityInfoSpec.NAME)
 internal class AccessibilityInfoModule(context: ReactApplicationContext) :
     NativeAccessibilityInfoSpec(context), LifecycleEventListener {
-  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private inner class ReactTouchExplorationStateChangeListener :
       AccessibilityManager.TouchExplorationStateChangeListener {
     override fun onTouchExplorationStateChanged(enabled: Boolean) {
@@ -41,7 +39,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
   // Android can listen for accessibility service enable with `accessibilityStateChange`, but
   // `accessibilityState` conflicts with React Native props and confuses developers. Therefore, the
   // name `accessibilityServiceChange` is used here instead.
-  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private inner class ReactAccessibilityServiceChangeListener :
       AccessibilityManager.AccessibilityStateChangeListener {
     override fun onAccessibilityStateChanged(enabled: Boolean) {
@@ -101,7 +98,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
     grayscaleModeEnabled = isGrayscaleEnabledValue
   }
 
-  @get:TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private val isReduceMotionEnabledValue: Boolean
     get() {
       // Disabling animations in developer settings will set the animation scale to "0.0"
@@ -109,12 +105,21 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
       val rawValue =
           Settings.Global.getString(contentResolver, Settings.Global.TRANSITION_ANIMATION_SCALE)
 
-      // Parse the value as a float so we can check for a single value.
-      val parsedValue = rawValue?.toFloat() ?: 1f
-      return parsedValue == 0f
+      if (rawValue == null) {
+        return false
+      }
+
+      try {
+        // In some locales, the decimal separator is a comma instead of a dot,
+        // but "toFloat" would crash failing to conver these.
+        val parsedValue = rawValue.replace(',', '.').toFloat()
+        return parsedValue == 0f
+      } catch (e: NumberFormatException) {
+        // If the value is not a valid number, we assume reduced motion is not enabled
+        return false
+      }
     }
 
-  @get:TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private val isInvertColorsEnabledValue: Boolean
     get() {
       try {
@@ -125,7 +130,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
       }
     }
 
-  @get:TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private val isGrayscaleEnabledValue: Boolean
     get() {
       try {
@@ -140,7 +144,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
       }
     }
 
-  @get:TargetApi(Build.VERSION_CODES.LOLLIPOP)
   private val isHighTextContrastEnabledValue: Boolean
     get() {
       return Settings.Secure.getInt(
@@ -243,7 +246,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
     }
   }
 
-  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
   override fun onHostResume() {
     accessibilityManager?.addTouchExplorationStateChangeListener(
         touchExplorationStateChangeListener)
@@ -262,7 +264,6 @@ internal class AccessibilityInfoModule(context: ReactApplicationContext) :
     updateAndSendGrayscaleModeChangeEvent()
   }
 
-  @TargetApi(Build.VERSION_CODES.LOLLIPOP)
   override fun onHostPause() {
     accessibilityManager?.removeTouchExplorationStateChangeListener(
         touchExplorationStateChangeListener)

package/ReactAndroid/src/main/java/com/facebook/react/modules/appearance/AppearanceModule.kt

@@ -54,8 +54,8 @@ constructor(
     // Attempt to use the Activity context first in order to get the most up to date
     // scheme. This covers the scenario when AppCompatDelegate.setDefaultNightMode()
     // is called directly (which can occur in Brownfield apps for example).
-    val activity = getCurrentActivity()
-    return colorSchemeForCurrentConfiguration(activity ?: getReactApplicationContext())
+    val activity = reactApplicationContext.getCurrentActivity()
+    return colorSchemeForCurrentConfiguration(activity ?: reactApplicationContext)
   }
 
   public override fun setColorScheme(style: String) {