react-native-keyboard-controller 1.5.7 → 1.6.0

package/android/src/fabric/java/com/reactnativekeyboardcontroller/KeyboardControllerViewManager.kt

@@ -11,7 +11,9 @@ import com.facebook.react.views.view.ReactViewManager
 import com.reactnativekeyboardcontroller.managers.KeyboardControllerViewManagerImpl
 import com.reactnativekeyboardcontroller.views.EdgeToEdgeReactViewGroup
 
-class KeyboardControllerViewManager(mReactContext: ReactApplicationContext) : ReactViewManager(), KeyboardControllerViewManagerInterface<ReactViewGroup> {
+class KeyboardControllerViewManager(mReactContext: ReactApplicationContext) :
+  ReactViewManager(),
+  KeyboardControllerViewManagerInterface<ReactViewGroup> {
   private val manager = KeyboardControllerViewManagerImpl(mReactContext)
   private val mDelegate = KeyboardControllerViewManagerDelegate(this)
 

package/android/src/fabric/java/com/reactnativekeyboardcontroller/StatusBarManagerCompatModule.kt

@@ -3,7 +3,8 @@ package com.reactnativekeyboardcontroller
 import com.facebook.react.bridge.ReactApplicationContext
 import com.reactnativekeyboardcontroller.modules.StatusBarManagerCompatModuleImpl
 
-class StatusBarManagerCompatModule(private val mReactContext: ReactApplicationContext) : NativeStatusBarManagerCompatSpec(mReactContext) {
+class StatusBarManagerCompatModule(mReactContext: ReactApplicationContext) :
+  NativeStatusBarManagerCompatSpec(mReactContext) {
   private val module = StatusBarManagerCompatModuleImpl(mReactContext)
 
   override fun getName(): String = StatusBarManagerCompatModuleImpl.NAME

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

@@ -17,29 +17,69 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.EventDispatcher
+import com.facebook.react.views.textinput.ReactEditText
 import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
 import com.reactnativekeyboardcontroller.extensions.dp
 import kotlin.math.abs
 
+private val TAG = KeyboardAnimationCallback::class.qualifiedName
+
 class KeyboardAnimationCallback(
   val view: ReactViewGroup,
   val persistentInsetTypes: Int,
   val deferredInsetTypes: Int,
   dispatchMode: Int = DISPATCH_MODE_STOP,
   val context: ThemedReactContext?,
-  val onApplyWindowInsetsListener: OnApplyWindowInsetsListener,
 ) : WindowInsetsAnimationCompat.Callback(dispatchMode), OnApplyWindowInsetsListener {
-  private val TAG = KeyboardAnimationCallback::class.qualifiedName
   private var persistentKeyboardHeight = 0.0
   private var isKeyboardVisible = false
   private var isTransitioning = false
+  private var duration = 0
+  private var viewTagFocused = -1
 
   init {
     require(persistentInsetTypes and deferredInsetTypes == 0) {
       "persistentInsetTypes and deferredInsetTypes can not contain any of " +
         " same WindowInsetsCompat.Type values"
     }
+
+    view.viewTreeObserver.addOnGlobalFocusChangeListener { oldFocus, newFocus ->
+      if (newFocus is ReactEditText) {
+        viewTagFocused = newFocus.id
+
+        // keyboard is visible and focus has been changed
+        if (this.isKeyboardVisible && oldFocus !== null) {
+          // imitate iOS behavior and send two instant start/end events containing an info about new tag
+          // 1. onStart/onMove/onEnd can be still dispatched after, if keyboard change size (numeric -> alphabetic type)
+          // 2. event should be send only when keyboard is visible, since this event arrives earlier -> `tag` will be
+          // 100% included in onStart/onMove/onEnd lifecycles, but triggering onStart/onEnd several time
+          // can bring breaking changes
+          this.sendEventToJS(
+            KeyboardTransitionEvent(
+              view.id,
+              "topKeyboardMoveStart",
+              this.persistentKeyboardHeight,
+              1.0,
+              0,
+              viewTagFocused,
+            ),
+          )
+          this.sendEventToJS(
+            KeyboardTransitionEvent(
+              view.id,
+              "topKeyboardMoveEnd",
+              this.persistentKeyboardHeight,
+              1.0,
+              0,
+              viewTagFocused,
+            ),
+          )
+          this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(this.persistentKeyboardHeight))
+          this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
+        }
+      }
+    }
   }
 
   /**
@@ -59,32 +99,65 @@ class KeyboardAnimationCallback(
   override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
     // when keyboard appears values will be (false && true)
     // when keyboard disappears values will be (true && false)
-    // `!isTransitioning` check is needed to avoid calls of `onApplyWindowInsets` during keyboard animation
+    val isKeyboardShown = isKeyboardVisible && isKeyboardVisible()
+    // `isTransitioning` check is needed to avoid calls of `onApplyWindowInsets` during keyboard animation
     // having such check allows us not to dispatch unnecessary incorrect events
     // the condition will be executed only when keyboard is opened and changes its size
     // (for example it happens when user changes keyboard type from 'text' to 'emoji' input
-    if (isKeyboardVisible && isKeyboardVisible() && !isTransitioning && Build.VERSION.SDK_INT >= 30 && !InteractiveKeyboardProvider.isInteractive) {
+    //
+    // `InteractiveKeyboardProvider.isInteractive` detect case when keyboard moves
+    // because of the gesture
+    val isMoving = isTransitioning || InteractiveKeyboardProvider.isInteractive
+    if (isKeyboardShown && !isMoving && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
       val keyboardHeight = getCurrentKeyboardHeight()
+      val duration = DEFAULT_ANIMATION_TIME.toInt()
 
       this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(keyboardHeight))
-      this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveStart", keyboardHeight, 1.0))
+      this.sendEventToJS(
+        KeyboardTransitionEvent(
+          view.id,
+          "topKeyboardMoveStart",
+          keyboardHeight,
+          1.0,
+          duration,
+          viewTagFocused,
+        ),
+      )
 
       val animation = ValueAnimator.ofFloat(this.persistentKeyboardHeight.toFloat(), keyboardHeight.toFloat())
       animation.addUpdateListener { animator ->
         val toValue = animator.animatedValue as Float
-        this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMove", toValue.toDouble(), toValue.toDouble() / keyboardHeight))
+        this.sendEventToJS(
+          KeyboardTransitionEvent(
+            view.id,
+            "topKeyboardMove",
+            toValue.toDouble(),
+            toValue.toDouble() / keyboardHeight,
+            duration,
+            viewTagFocused,
+          ),
+        )
       }
       animation.doOnEnd {
         this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(keyboardHeight))
-        this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveEnd", keyboardHeight, 1.0))
+        this.sendEventToJS(
+          KeyboardTransitionEvent(
+            view.id,
+            "topKeyboardMoveEnd",
+            keyboardHeight,
+            1.0,
+            duration,
+            viewTagFocused,
+          ),
+        )
       }
-      animation.setDuration(250).startDelay = 0
+      animation.setDuration(DEFAULT_ANIMATION_TIME).startDelay = 0
       animation.start()
 
       this.persistentKeyboardHeight = keyboardHeight
     }
 
-    return onApplyWindowInsetsListener.onApplyWindowInsets(v, insets)
+    return insets
   }
 
   override fun onStart(
@@ -93,6 +166,7 @@ class KeyboardAnimationCallback(
   ): WindowInsetsAnimationCompat.BoundsCompat {
     isTransitioning = true
     isKeyboardVisible = isKeyboardVisible()
+    duration = animation.durationMillis.toInt()
     val keyboardHeight = getCurrentKeyboardHeight()
 
     if (isKeyboardVisible) {
@@ -100,10 +174,22 @@ class KeyboardAnimationCallback(
       this.persistentKeyboardHeight = keyboardHeight
     }
 
-    this.emitEvent("KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow", getEventParams(keyboardHeight))
+    this.emitEvent(
+      "KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow",
+      getEventParams(keyboardHeight),
+    )
 
-    Log.i(TAG, "HEIGHT:: $keyboardHeight")
-    this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveStart", keyboardHeight, if (!isKeyboardVisible) 0.0 else 1.0))
+    Log.i(TAG, "HEIGHT:: $keyboardHeight TAG:: $viewTagFocused")
+    this.sendEventToJS(
+      KeyboardTransitionEvent(
+        view.id,
+        "topKeyboardMoveStart",
+        keyboardHeight,
+        if (!isKeyboardVisible) 0.0 else 1.0,
+        duration,
+        viewTagFocused,
+      ),
+    )
 
     return super.onStart(animation, bounds)
   }
@@ -131,12 +217,13 @@ class KeyboardAnimationCallback(
     try {
       progress = abs((height / persistentKeyboardHeight)).let { if (it.isNaN()) 0.0 else it }
     } catch (e: ArithmeticException) {
-      // do nothing, send progress as 0
+      // do nothing, just log an exception send progress as 0
+      Log.w(TAG, "Caught arithmetic exception during `progress` calculation: $e")
     }
-    Log.i(TAG, "DiffY: $diffY $height $progress ${InteractiveKeyboardProvider.isInteractive}")
+    Log.i(TAG, "DiffY: $diffY $height $progress ${InteractiveKeyboardProvider.isInteractive} $viewTagFocused")
 
     val event = if (InteractiveKeyboardProvider.isInteractive) "topKeyboardMoveInteractive" else "topKeyboardMove"
-    this.sendEventToJS(KeyboardTransitionEvent(view.id, event, height, progress))
+    this.sendEventToJS(KeyboardTransitionEvent(view.id, event, height, progress, duration, viewTagFocused))
 
     return insets
   }
@@ -145,12 +232,15 @@ class KeyboardAnimationCallback(
     super.onEnd(animation)
 
     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) {
-      this.persistentKeyboardHeight = getCurrentKeyboardHeight()
+      keyboardHeight = getCurrentKeyboardHeight()
     } else {
       // if keyboard is shown after interactions and the animation has finished
       // then we need to reset the state
@@ -158,8 +248,23 @@ class KeyboardAnimationCallback(
     }
     isKeyboardVisible = isKeyboardVisible || isKeyboardShown
 
-    this.emitEvent("KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
-    this.sendEventToJS(KeyboardTransitionEvent(view.id, "topKeyboardMoveEnd", this.persistentKeyboardHeight, if (!isKeyboardVisible) 0.0 else 1.0))
+    this.emitEvent(
+      "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow",
+      getEventParams(keyboardHeight),
+    )
+    this.sendEventToJS(
+      KeyboardTransitionEvent(
+        view.id,
+        "topKeyboardMoveEnd",
+        keyboardHeight,
+        if (!isKeyboardVisible) 0.0 else 1.0,
+        duration,
+        viewTagFocused,
+      ),
+    )
+
+    // reset to initial state
+    duration = 0
   }
 
   private fun isKeyboardVisible(): Boolean {
@@ -192,7 +297,14 @@ class KeyboardAnimationCallback(
   private fun getEventParams(height: Double): WritableMap {
     val params: WritableMap = Arguments.createMap()
     params.putDouble("height", height)
+    params.putInt("duration", duration)
+    params.putDouble("timestamp", System.currentTimeMillis().toDouble())
+    params.putInt("target", viewTagFocused)
 
     return params
   }
+
+  companion object {
+    private const val DEFAULT_ANIMATION_TIME = 250L
+  }
 }

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

@@ -14,6 +14,7 @@ import androidx.dynamicanimation.animation.springAnimationOf
 import androidx.dynamicanimation.animation.withSpringForceProperties
 import kotlin.math.roundToInt
 
+@Suppress("detekt:TooManyFunctions")
 internal class KeyboardAnimationController {
   private var insetsAnimationController: WindowInsetsAnimationControllerCompat? = null
   private var pendingRequestCancellationSignal: CancellationSignal? = null
@@ -284,8 +285,14 @@ internal class KeyboardAnimationController {
         velocityY = velocityY,
       )
       // The current inset matches either the shown/hidden inset, finish() immediately
-      current == shown -> controller.finish(true)
-      current == hidden -> controller.finish(false)
+      current == shown -> {
+        InteractiveKeyboardProvider.shown = true
+        controller.finish(true)
+      }
+      current == hidden -> {
+        InteractiveKeyboardProvider.shown = false
+        controller.finish(false)
+      }
       else -> {
         // Otherwise, we'll look at the current position...
         if (controller.currentFraction >= SCROLL_THRESHOLD) {
@@ -348,6 +355,7 @@ internal class KeyboardAnimationController {
     visible: Boolean,
     velocityY: Float? = null,
   ) {
+    @Suppress("detekt:UseCheckOrError")
     val controller = insetsAnimationController
       ?: throw IllegalStateException("Controller should not be null")
 

package/android/src/main/java/com/reactnativekeyboardcontroller/events/KeyboardTransitionEvent.kt

@@ -4,16 +4,25 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.uimanager.events.Event
 import com.facebook.react.uimanager.events.RCTEventEmitter
 
-class KeyboardTransitionEvent(viewId: Int, private val event: String, private val height: Double, private val progress: Double) : Event<KeyboardTransitionEvent>(viewId) {
+class KeyboardTransitionEvent(
+  viewId: Int,
+  private val event: String,
+  private val height: Double,
+  private val progress: Double,
+  private val duration: Int,
+  private val target: Int,
+) : Event<KeyboardTransitionEvent>(viewId) {
   override fun getEventName() = event
 
-  // TODO: All events for a given view can be coalesced?
+  // All events for a given view can be coalesced?
   override fun getCoalescingKey(): Short = 0
 
   override fun dispatch(rctEventEmitter: RCTEventEmitter) {
     val map = Arguments.createMap()
     map.putDouble("progress", progress)
     map.putDouble("height", height)
+    map.putInt("duration", duration)
+    map.putInt("target", target)
     rctEventEmitter.receiveEvent(viewTag, eventName, map)
   }
 }

package/android/src/main/java/com/reactnativekeyboardcontroller/extensions/ThemedReactContext.kt

@@ -0,0 +1,7 @@
+package com.reactnativekeyboardcontroller.extensions
+
+import android.view.View
+import com.facebook.react.uimanager.ThemedReactContext
+
+val ThemedReactContext.rootView: View?
+  get() = this.currentActivity?.window?.decorView?.rootView

package/android/src/main/java/com/reactnativekeyboardcontroller/managers/KeyboardControllerViewManagerImpl.kt

@@ -5,7 +5,8 @@ import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.ThemedReactContext
 import com.reactnativekeyboardcontroller.views.EdgeToEdgeReactViewGroup
 
-class KeyboardControllerViewManagerImpl(private val mReactContext: ReactApplicationContext) {
+@Suppress("detekt:UnusedPrivateProperty")
+class KeyboardControllerViewManagerImpl(mReactContext: ReactApplicationContext) {
   fun createViewInstance(reactContext: ThemedReactContext): EdgeToEdgeReactViewGroup {
     return EdgeToEdgeReactViewGroup(reactContext)
   }

package/android/src/main/java/com/reactnativekeyboardcontroller/managers/KeyboardGestureAreaViewManagerImpl.kt

@@ -4,6 +4,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ThemedReactContext
 import com.reactnativekeyboardcontroller.views.KeyboardGestureAreaReactViewGroup
 
+@Suppress("detekt:UnusedPrivateProperty")
 class KeyboardGestureAreaViewManagerImpl(mReactContext: ReactApplicationContext) {
   fun createViewInstance(reactContext: ThemedReactContext): KeyboardGestureAreaReactViewGroup {
     return KeyboardGestureAreaReactViewGroup(reactContext)

package/android/src/main/java/com/reactnativekeyboardcontroller/modules/KeyboardControllerModuleImpl.kt

@@ -5,7 +5,12 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.UiThreadUtil
 
 class KeyboardControllerModuleImpl(private val mReactContext: ReactApplicationContext) {
-  private val mDefaultMode: Int = mReactContext.currentActivity?.window?.attributes?.softInputMode ?: WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED
+  private val mDefaultMode: Int = mReactContext
+    .currentActivity
+    ?.window
+    ?.attributes
+    ?.softInputMode
+    ?: WindowManager.LayoutParams.SOFT_INPUT_STATE_UNSPECIFIED
 
   fun setInputMode(mode: Int) {
     setSoftInputMode(mode)

package/android/src/main/java/com/reactnativekeyboardcontroller/modules/StatusBarManagerCompatModuleImpl.kt

@@ -10,8 +10,9 @@ import androidx.core.view.WindowInsetsControllerCompat
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.UiThreadUtil
 
+private val TAG = StatusBarManagerCompatModuleImpl::class.qualifiedName
+
 class StatusBarManagerCompatModuleImpl(private val mReactContext: ReactApplicationContext) {
-  private val TAG = StatusBarManagerCompatModuleImpl::class.qualifiedName
   private var controller: WindowInsetsControllerCompat? = null
 
   fun setHidden(hidden: Boolean) {
@@ -41,7 +42,7 @@ class StatusBarManagerCompatModuleImpl(private val mReactContext: ReactApplicati
         colorAnimation.addUpdateListener { animator ->
           window.statusBarColor = animator.animatedValue as Int
         }
-        colorAnimation.setDuration(300).startDelay = 0
+        colorAnimation.setDuration(DEFAULT_ANIMATION_TIME).startDelay = 0
         colorAnimation.start()
       } else {
         window.statusBarColor = color
@@ -49,6 +50,7 @@ class StatusBarManagerCompatModuleImpl(private val mReactContext: ReactApplicati
     }
   }
 
+  @Suppress("detekt:UnusedParameter")
   fun setTranslucent(translucent: Boolean) {
     // the status bar is translucent by default (once you wrapped App in Provider,
     // and EdgeToEdgeReactViewGroup has been mounted and called
@@ -73,7 +75,10 @@ class StatusBarManagerCompatModuleImpl(private val mReactContext: ReactApplicati
     if (this.controller == null) {
       val activity = mReactContext.currentActivity
       if (activity == null) {
-        Log.w(TAG, "StatusBarManagerCompatModule: can not get `WindowInsetsControllerCompat` because current activity is null.")
+        Log.w(
+          TAG,
+          "StatusBarManagerCompatModule: can not get `WindowInsetsControllerCompat` because current activity is null.",
+        )
         return this.controller
       }
 
@@ -87,5 +92,6 @@ class StatusBarManagerCompatModuleImpl(private val mReactContext: ReactApplicati
 
   companion object {
     const val NAME = "StatusBarManagerCompat"
+    private const val DEFAULT_ANIMATION_TIME = 300L
   }
 }

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

@@ -1,7 +1,10 @@
 package com.reactnativekeyboardcontroller.views
 
 import android.annotation.SuppressLint
+import android.os.Handler
+import android.os.Looper
 import android.util.Log
+import android.widget.FrameLayout
 import androidx.appcompat.widget.FitWindowsLinearLayout
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
@@ -10,12 +13,13 @@ import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
 import com.reactnativekeyboardcontroller.KeyboardAnimationCallback
-import com.reactnativekeyboardcontroller.R
 import com.reactnativekeyboardcontroller.extensions.requestApplyInsetsWhenAttached
+import com.reactnativekeyboardcontroller.extensions.rootView
+
+private val TAG = EdgeToEdgeReactViewGroup::class.qualifiedName
 
 @SuppressLint("ViewConstructor")
 class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
-  private val TAG = EdgeToEdgeReactViewGroup::class.qualifiedName
   private var isStatusBarTranslucent = false
   private var isNavigationBarTranslucent = false
 
@@ -23,7 +27,6 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
     val activity = reactContext.currentActivity
 
     if (activity != null) {
-
       val callback = KeyboardAnimationCallback(
         view = this,
         persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
@@ -32,30 +35,6 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
         // child views, so that step 2.5 below receives the call
         dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
         context = reactContext,
-        onApplyWindowInsetsListener = { v, insets ->
-          val content =
-            reactContext.currentActivity?.window?.decorView?.rootView?.findViewById<FitWindowsLinearLayout>(
-              androidx.appcompat.R.id.action_bar_root,
-            )
-          content?.setPadding(
-            0,
-            if (this.isStatusBarTranslucent) {
-              0
-            } else {
-              insets?.getInsets(WindowInsetsCompat.Type.systemBars())?.top
-                ?: 0
-            },
-            0,
-            if (this.isNavigationBarTranslucent) {
-              0
-            } else {
-              insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom
-                ?: 0
-            },
-          )
-
-          insets
-        },
       )
       ViewCompat.setWindowInsetsAnimationCallback(this, callback)
       ViewCompat.setOnApplyWindowInsetsListener(this, callback)
@@ -65,9 +44,47 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
     }
   }
 
+  private fun setupWindowInsets() {
+    val rootView = reactContext.rootView
+    if (rootView != null) {
+      ViewCompat.setOnApplyWindowInsetsListener(rootView) { v, insets ->
+        val content =
+          reactContext.rootView?.findViewById<FitWindowsLinearLayout>(
+            androidx.appcompat.R.id.action_bar_root,
+          )
+        val params = FrameLayout.LayoutParams(
+          FrameLayout.LayoutParams.MATCH_PARENT,
+          FrameLayout.LayoutParams.MATCH_PARENT,
+        )
+
+        params.setMargins(
+          0,
+          if (this.isStatusBarTranslucent) {
+            0
+          } else {
+            insets?.getInsets(WindowInsetsCompat.Type.systemBars())?.top
+              ?: 0
+          },
+          0,
+          if (this.isNavigationBarTranslucent) {
+            0
+          } else {
+            insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom
+              ?: 0
+          },
+        )
+
+        content?.layoutParams = params
+
+        insets
+      }
+    }
+  }
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
 
+    Handler(Looper.getMainLooper()).post(this::setupWindowInsets)
     reactContext.currentActivity?.let {
       WindowCompat.setDecorFitsSystemWindows(
         it.window,