react-native-keyboard-controller 1.16.2 → 1.16.4

package/android/build.gradle

@@ -70,6 +70,12 @@ android {
       } else {
         java.srcDirs += ['src/paper']
       }
+
+      if (project.ext.shouldUseBaseReactPackage()) {
+        java.srcDirs += ['src/base']
+      } else {
+        java.srcDirs += ['src/turbo']
+      }
     }
   }
 

package/android/react-native-helpers.gradle

@@ -39,4 +39,8 @@ project.ext.resolveReactNativeDirectory = { ->
 
 project.ext.shouldConsumeReactNativeFromMavenCentral = { ->
   return REACT_NATIVE_MINOR_VERSION >= 71
-}
+}
+
+project.ext.shouldUseBaseReactPackage = { ->
+  return REACT_NATIVE_MINOR_VERSION >= 74
+}

package/android/src/base/java/com/reactnativekeyboardcontroller/KeyboardControllerPackage.kt

@@ -0,0 +1,61 @@
+package com.reactnativekeyboardcontroller
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+import com.reactnativekeyboardcontroller.modules.KeyboardControllerModuleImpl
+import com.reactnativekeyboardcontroller.modules.StatusBarManagerCompatModuleImpl
+
+class KeyboardControllerPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    when (name) {
+      KeyboardControllerModuleImpl.NAME -> {
+        KeyboardControllerModule(reactContext)
+      }
+      StatusBarManagerCompatModuleImpl.NAME -> {
+        StatusBarManagerCompatModule(reactContext)
+      }
+      else -> {
+        null
+      }
+    }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      val isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+
+      moduleInfos[KeyboardControllerModuleImpl.NAME] =
+        ReactModuleInfo(
+          KeyboardControllerModuleImpl.NAME,
+          KeyboardControllerModuleImpl.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          isTurboModule, // isTurboModule
+        )
+      moduleInfos[StatusBarManagerCompatModuleImpl.NAME] =
+        ReactModuleInfo(
+          StatusBarManagerCompatModuleImpl.NAME,
+          StatusBarManagerCompatModuleImpl.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          isTurboModule, // isTurboModule
+        )
+      moduleInfos
+    }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf(
+      KeyboardControllerViewManager(reactContext),
+      KeyboardGestureAreaViewManager(reactContext),
+      OverKeyboardViewManager(reactContext),
+    )
+}

package/android/src/main/java/com/reactnativekeyboardcontroller/interactive/InteractiveKeyboardProvider.kt

@@ -1,6 +1,5 @@
 package com.reactnativekeyboardcontroller.interactive
 
 object InteractiveKeyboardProvider {
-  var shown = false
   var isInteractive = false
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/interactive/KeyboardAnimationController.kt

@@ -233,22 +233,18 @@ internal class KeyboardAnimationController {
     when (current) {
       // The current inset matches either the shown/hidden inset, finish() immediately
       shown -> {
-        InteractiveKeyboardProvider.shown = true
         controller.finish(true)
       }
       hidden -> {
-        InteractiveKeyboardProvider.shown = false
         controller.finish(false)
       }
       else -> {
         // Otherwise, we'll look at the current position...
         if (controller.currentFraction >= SCROLL_THRESHOLD) {
           // If the IME is past the 'threshold' we snap to the toggled state
-          InteractiveKeyboardProvider.shown = !isImeShownAtStart
           controller.finish(!isImeShownAtStart)
         } else {
           // ...otherwise, we snap back to the original visibility
-          InteractiveKeyboardProvider.shown = isImeShownAtStart
           controller.finish(isImeShownAtStart)
         }
       }
@@ -287,11 +283,9 @@ internal class KeyboardAnimationController {
         )
       // The current inset matches either the shown/hidden inset, finish() immediately
       current == shown -> {
-        InteractiveKeyboardProvider.shown = true
         controller.finish(true)
       }
       current == hidden -> {
-        InteractiveKeyboardProvider.shown = false
         controller.finish(false)
       }
       else -> {

package/android/src/main/java/com/reactnativekeyboardcontroller/listeners/FocusedInputObserver.kt

@@ -101,7 +101,14 @@ class FocusedInputObserver(
       // unfocused or focus was changed
       if (newFocus == null || oldFocus != null) {
         lastFocusedInput?.removeOnLayoutChangeListener(layoutListener)
-        lastFocusedInput?.removeTextChangedListener(textWatcher)
+        lastFocusedInput?.let { input ->
+          val watcher = textWatcher
+          // remove it asynchronously to avoid crash in stripe input
+          // see https://github.com/stripe/stripe-android/issues/10178
+          input.post {
+            input.removeTextChangedListener(watcher)
+          }
+        }
         selectionSubscription?.invoke()
         lastFocusedInput = null
       }

package/android/src/main/java/com/reactnativekeyboardcontroller/listeners/KeyboardAnimationCallback.kt

@@ -33,7 +33,7 @@ data class KeyboardAnimationCallbackConfig(
   val persistentInsetTypes: Int,
   val deferredInsetTypes: Int,
   val dispatchMode: Int = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_STOP,
-  val hasTranslucentNavigationBar: Boolean = false,
+  var hasTranslucentNavigationBar: Boolean,
 )
 
 interface Suspendable {
@@ -62,6 +62,8 @@ class KeyboardAnimationCallback(
   private var duration = 0
   private var viewTagFocused = -1
   private var animationsToSkip = hashSetOf<WindowInsetsAnimationCompat>()
+  private val isKeyboardInteractive: Boolean
+    get() = duration == -1
   override var isSuspended: Boolean = false
 
   // listeners
@@ -293,46 +295,47 @@ class KeyboardAnimationCallback(
     isTransitioning = false
     duration = animation.durationMillis.toInt()
 
-    var keyboardHeight = this.persistentKeyboardHeight
-    // if keyboard becomes shown after interactive animation completion
-    // getCurrentKeyboardHeight() will be `0` and isKeyboardVisible will be `false`
-    // it's not correct behavior, so we are handling it here
-    val isKeyboardShown = InteractiveKeyboardProvider.shown
-    if (!isKeyboardShown) {
-      keyboardHeight = getCurrentKeyboardHeight()
-    } else {
-      // if keyboard is shown after interactions and the animation has finished
-      // then we need to reset the state
-      InteractiveKeyboardProvider.shown = false
-    }
-    isKeyboardVisible = isKeyboardVisible || isKeyboardShown
-    prevKeyboardHeight = keyboardHeight
+    val runnable =
+      Runnable {
+        val keyboardHeight = getCurrentKeyboardHeight()
 
-    if (animation in animationsToSkip) {
-      duration = 0
-      animationsToSkip.remove(animation)
-      return
-    }
+        isKeyboardVisible = isKeyboardVisible()
+        prevKeyboardHeight = keyboardHeight
 
-    context.emitEvent(
-      "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow",
-      getEventParams(keyboardHeight),
-    )
-    context.dispatchEvent(
-      eventPropagationView.id,
-      KeyboardTransitionEvent(
-        surfaceId,
-        eventPropagationView.id,
-        KeyboardTransitionEvent.End,
-        keyboardHeight,
-        if (!isKeyboardVisible) 0.0 else 1.0,
-        duration,
-        viewTagFocused,
-      ),
-    )
+        if (animation in animationsToSkip) {
+          duration = 0
+          animationsToSkip.remove(animation)
+          return@Runnable
+        }
 
-    // reset to initial state
-    duration = 0
+        context.emitEvent(
+          "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow",
+          getEventParams(keyboardHeight),
+        )
+        context.dispatchEvent(
+          eventPropagationView.id,
+          KeyboardTransitionEvent(
+            surfaceId,
+            eventPropagationView.id,
+            KeyboardTransitionEvent.End,
+            keyboardHeight,
+            if (!isKeyboardVisible) 0.0 else 1.0,
+            duration,
+            viewTagFocused,
+          ),
+        )
+
+        // reset to initial state
+        duration = 0
+      }
+
+    if (isKeyboardInteractive) {
+      // in case of interactive keyboard we can not read keyboard frame straight away
+      // (because we'll always read `0`), so we are posting runnable to the main thread
+      view.post(runnable)
+    } else {
+      runnable.run()
+    }
   }
 
   fun syncKeyboardPosition(

package/android/src/main/java/com/reactnativekeyboardcontroller/modal/ModalAttachedWatcher.kt

@@ -23,15 +23,15 @@ private val areEventsComingFromOwnWindow = !Keyboard.IS_ANIMATION_EMULATED
 class ModalAttachedWatcher(
   private val view: ReactViewGroup,
   private val reactContext: ThemedReactContext,
-  private val config: () -> KeyboardAnimationCallbackConfig,
+  private val config: KeyboardAnimationCallbackConfig,
   private var callback: () -> KeyboardAnimationCallback?,
 ) : EventDispatcherListener {
   private val archType = if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) UIManagerType.FABRIC else UIManagerType.DEFAULT
   private val uiManager = UIManagerHelper.getUIManager(reactContext.reactApplicationContext, archType)
   private val eventDispatcher = UIManagerHelper.getEventDispatcher(reactContext.reactApplicationContext, archType)
 
-  override fun onEventDispatch(event: Event<out Event<*>>?) {
-    if (event?.eventName != MODAL_SHOW_EVENT) {
+  override fun onEventDispatch(event: Event<*>) {
+    if (event.eventName != MODAL_SHOW_EVENT) {
       return
     }
 
@@ -61,7 +61,7 @@ class ModalAttachedWatcher(
           view = rootView,
           eventPropagationView = view,
           context = reactContext,
-          config = config(),
+          config = config,
         )
 
       rootView.addView(eventView)

package/android/src/main/java/com/reactnativekeyboardcontroller/views/EdgeToEdgeReactViewGroup.kt

@@ -39,17 +39,16 @@ class EdgeToEdgeReactViewGroup(
   private var eventView: ReactViewGroup? = null
   private var wasMounted = false
   private var callback: KeyboardAnimationCallback? = null
-  private val config: KeyboardAnimationCallbackConfig
-    get() =
-      KeyboardAnimationCallbackConfig(
-        persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
-        deferredInsetTypes = WindowInsetsCompat.Type.ime(),
-        dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
-        hasTranslucentNavigationBar = isNavigationBarTranslucent,
-      )
+  private val config =
+    KeyboardAnimationCallbackConfig(
+      persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
+      deferredInsetTypes = WindowInsetsCompat.Type.ime(),
+      dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
+      hasTranslucentNavigationBar = isNavigationBarTranslucent,
+    )
 
   // managers/watchers
-  private val modalAttachedWatcher = ModalAttachedWatcher(this, reactContext, ::config, ::getKeyboardCallback)
+  private val modalAttachedWatcher = ModalAttachedWatcher(this, reactContext, config, ::getKeyboardCallback)
 
   init {
     reactContext.setupWindowDimensionsListener()
@@ -212,6 +211,7 @@ class EdgeToEdgeReactViewGroup(
 
   fun setNavigationBarTranslucent(isNavigationBarTranslucent: Boolean) {
     this.isNavigationBarTranslucent = isNavigationBarTranslucent
+    this.config.hasTranslucentNavigationBar = isNavigationBarTranslucent
   }
 
   fun setPreserveEdgeToEdge(isPreservingEdgeToEdge: Boolean) {

package/android/src/main/java/com/reactnativekeyboardcontroller/views/overlay/OverKeyboardViewGroup.kt

@@ -163,7 +163,7 @@ class OverKeyboardRootViewGroup(
 
   // region RootView methods
   override fun onChildStartedNativeGesture(
-    childView: View,
+    childView: View?,
     ev: MotionEvent,
   ) {
     eventDispatcher?.let { eventDispatcher ->

package/android/src/main/java/com/reactnativekeyboardcontroller/views/overlay/RootViewCompat.kt

@@ -12,7 +12,7 @@ interface RootViewCompat : RootView {
     "This method shouldn't be used anymore.",
     ReplaceWith("onChildStartedNativeGesture(View childView, MotionEvent ev)"),
   )
-  override fun onChildStartedNativeGesture(ev: MotionEvent?) {
+  override fun onChildStartedNativeGesture(ev: MotionEvent) {
     onChildStartedNativeGesture(null, ev)
   }
 }

package/ios/observers/FocusedInputObserver.swift

@@ -80,12 +80,6 @@ public class FocusedInputObserver: NSObject {
       name: UIResponder.keyboardWillShowNotification,
       object: nil
     )
-    NotificationCenter.default.addObserver(
-      self,
-      selector: #selector(keyboardWillHide),
-      name: UIResponder.keyboardWillHideNotification,
-      object: nil
-    )
     NotificationCenter.default.addObserver(
       self,
       selector: #selector(didReceiveFocus),
@@ -118,10 +112,6 @@ public class FocusedInputObserver: NSObject {
     NotificationCenter.default.removeObserver(self)
   }
 
-  @objc func keyboardWillHide(_: Notification) {
-    onBlur()
-  }
-
   @objc func didReceiveFocus(_: Notification) {
     if UIResponder.current == currentResponder {
       // focus was already handled by keyboard event
@@ -131,22 +121,13 @@ public class FocusedInputObserver: NSObject {
     onFocus()
   }
 
-  /**
-   * We handle blur events in `keyboardWillHide` handler
-   * And this additional handler is needed only to have
-   * a consistent state when keyboard is not shown
-   */
   @objc func didReceiveBlur(_: Notification) {
-    if currentResponder == nil {
-      // blur was already handled by keyboard event
-      return
-    }
     // blur gets triggered on endEditing, so we check if no upcoming
     // didReceiveFocus events are coming to exclude `noFocusedInput`
     // event when user switches between inputs
     DispatchQueue.main.async {
       // check that it wasn't a switch between inputs
-      if self.currentResponder == nil {
+      if !(UIResponder.current is TextInput) {
         self.onBlur()
       }
     }
@@ -173,10 +154,6 @@ public class FocusedInputObserver: NSObject {
   }
 
   func onBlur() {
-    // when we switch to next input, but `showSoftInput={false}`
-    if UIResponder.current is TextInput {
-      return
-    }
     removeObservers(newResponder: nil)
     currentInput = nil
     currentResponder = nil

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-keyboard-controller",
-  "version": "1.16.2",
+  "version": "1.16.4",
   "description": "Keyboard manager which works in identical way on both iOS and Android",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -80,11 +80,11 @@
   },
   "devDependencies": {
     "@commitlint/config-conventional": "^11.0.0",
-    "@react-native/babel-preset": "0.76.2",
-    "@react-native/eslint-config": "0.76.2",
+    "@react-native/babel-preset": "0.77.0",
+    "@react-native/eslint-config": "0.77.0",
     "@release-it/conventional-changelog": "^2.0.0",
     "@testing-library/react-hooks": "^8.0.1",
-    "@types/jest": "^29.2.1",
+    "@types/jest": "^29.5.13",
     "@types/react": "^18.2.6",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
@@ -105,9 +105,9 @@
     "pod-install": "^0.1.0",
     "prettier": "^2.8.8",
     "react": "18.3.1",
-    "react-native": "0.76.2",
+    "react-native": "0.77.0",
     "react-native-builder-bob": "^0.18.0",
-    "react-native-reanimated": "3.16.1",
+    "react-native-reanimated": "3.16.7",
     "react-test-renderer": "18.2.0",
     "release-it": "^14.2.2",
     "typescript": "5.6.3"
@@ -170,6 +170,13 @@
     "jsSrcsDir": "./src/specs",
     "android": {
       "javaPackageName": "com.reactnativekeyboardcontroller"
+    },
+    "ios": {
+      "componentProvider": {
+        "KeyboardControllerView": "KeyboardControllerView",
+        "KeyboardGestureArea": "KeyboardGestureArea",
+        "OverKeyboardView": "OverKeyboardView"
+      }
     }
   }
 }