react-native-keyboard-controller 1.7.0 → 1.9.0

package/README.md

@@ -13,6 +13,8 @@ Keyboard manager which works in identical way on both iOS and Android.
 - module for changing soft input mode on Android 🤔
 - reanimated support 🚀
 - interactive keyboard dismissing 👆📱
+- prebuilt components (`KeyboardStickyView`, re-worked `KeyboardAvoidingView`) 📚
+- easy focused input information retrieval 📝 🔮
 - works with any navigation library 🧭
 - and more is coming... Stay tuned! 😊
 

package/android/gradle.properties

@@ -1,4 +1,4 @@
-KeyboardController_kotlinVersion=1.6.21
+KeyboardController_kotlinVersion=1.8.22
 KeyboardController_compileSdkVersion=33
 KeyboardController_targetSdkVersion=33
 KeyboardController_minSdkVersion=16

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

@@ -37,6 +37,11 @@ class KeyboardControllerViewManager(mReactContext: ReactApplicationContext) :
     return manager.setNavigationBarTranslucent(view as EdgeToEdgeReactViewGroup, value)
   }
 
+  @ReactProp(name = "enabled")
+  override fun setEnabled(view: ReactViewGroup, value: Boolean) {
+    return manager.setEnabled(view as EdgeToEdgeReactViewGroup, value)
+  }
+
   override fun getExportedCustomDirectEventTypeConstants(): MutableMap<String, Any> {
     return manager.getExportedCustomDirectEventTypeConstants()
   }

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

@@ -0,0 +1,41 @@
+package com.reactnativekeyboardcontroller.events
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+data class FocusedInputLayoutChangedEventData(
+  val x: Double,
+  val y: Double,
+  val width: Double,
+  val height: Double,
+  val absoluteX: Double,
+  val absoluteY: Double,
+  val target: Int,
+)
+
+class FocusedInputLayoutChangedEvent(
+  surfaceId: Int,
+  viewId: Int,
+  private val event: FocusedInputLayoutChangedEventData,
+) : Event<KeyboardTransitionEvent>(surfaceId, viewId) {
+  override fun getEventName() = "topFocusedInputLayoutChanged"
+
+  // All events for a given view can be coalesced
+  override fun getCoalescingKey(): Short = 0
+
+  override fun getEventData(): WritableMap? = Arguments.createMap().apply {
+    putInt("target", event.target)
+    putMap(
+      "layout",
+      Arguments.createMap().apply {
+        putDouble("x", event.x)
+        putDouble("y", event.y)
+        putDouble("width", event.width)
+        putDouble("height", event.height)
+        putDouble("absoluteX", event.absoluteX)
+        putDouble("absoluteY", event.absoluteY)
+      },
+    )
+  }
+}

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

@@ -2,6 +2,15 @@ package com.reactnativekeyboardcontroller.extensions
 
 import android.view.View
 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
 
 val ThemedReactContext.rootView: View?
   get() = this.currentActivity?.window?.decorView?.rootView
+
+fun ThemedReactContext?.dispatchEvent(viewId: Int, event: Event<*>) {
+  val eventDispatcher: EventDispatcher? =
+    UIManagerHelper.getEventDispatcherForReactTag(this, viewId)
+  eventDispatcher?.dispatchEvent(event)
+}

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

@@ -48,3 +48,10 @@ fun View.copyBoundsInWindow(rect: Rect) {
     )
   }
 }
+
+val View.screenLocation get(): IntArray {
+  val point = IntArray(2)
+  getLocationOnScreen(point)
+
+  return point
+}

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

@@ -0,0 +1,93 @@
+package com.reactnativekeyboardcontroller.listeners
+
+import android.view.View.OnLayoutChangeListener
+import android.view.ViewTreeObserver.OnGlobalFocusChangeListener
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.views.textinput.ReactEditText
+import com.facebook.react.views.view.ReactViewGroup
+import com.reactnativekeyboardcontroller.events.FocusedInputLayoutChangedEvent
+import com.reactnativekeyboardcontroller.events.FocusedInputLayoutChangedEventData
+import com.reactnativekeyboardcontroller.extensions.dispatchEvent
+import com.reactnativekeyboardcontroller.extensions.dp
+import com.reactnativekeyboardcontroller.extensions.screenLocation
+
+val noFocusedInputEvent = FocusedInputLayoutChangedEventData(
+  x = 0.0,
+  y = 0.0,
+  width = 0.0,
+  height = 0.0,
+  absoluteX = 0.0,
+  absoluteY = 0.0,
+  target = -1,
+)
+
+class FocusedInputLayoutObserver(val view: ReactViewGroup, private val context: ThemedReactContext?) {
+  // constructor variables
+  private val surfaceId = UIManagerHelper.getSurfaceId(view)
+
+  // state variables
+  private var lastFocusedInput: ReactEditText? = null
+  private var lastEventDispatched: FocusedInputLayoutChangedEventData = noFocusedInputEvent
+
+  // listeners
+  private val layoutListener =
+    OnLayoutChangeListener { v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom ->
+      this.syncUpLayout()
+    }
+  private val focusListener = OnGlobalFocusChangeListener { oldFocus, newFocus ->
+    // unfocused or focused was changed
+    if (newFocus == null || oldFocus != null) {
+      lastFocusedInput?.removeOnLayoutChangeListener(layoutListener)
+      lastFocusedInput = null
+    }
+    if (newFocus is ReactEditText) {
+      lastFocusedInput = newFocus
+      newFocus.addOnLayoutChangeListener(layoutListener)
+      this.syncUpLayout()
+    }
+    // unfocused
+    if (newFocus == null) {
+      dispatchEventToJS(noFocusedInputEvent)
+    }
+  }
+
+  init {
+    view.viewTreeObserver.addOnGlobalFocusChangeListener(focusListener)
+  }
+
+  fun syncUpLayout() {
+    val input = lastFocusedInput ?: return
+
+    val (x, y) = input.screenLocation
+    val event = FocusedInputLayoutChangedEventData(
+      x = input.x.dp,
+      y = input.y.dp,
+      width = input.width.toFloat().dp,
+      height = input.height.toFloat().dp,
+      absoluteX = x.toFloat().dp,
+      absoluteY = y.toFloat().dp,
+      target = input.id,
+    )
+
+    dispatchEventToJS(event)
+  }
+
+  fun destroy() {
+    view.viewTreeObserver.removeOnGlobalFocusChangeListener(focusListener)
+  }
+
+  private fun dispatchEventToJS(event: FocusedInputLayoutChangedEventData) {
+    if (event != lastEventDispatched) {
+      lastEventDispatched = event
+      context.dispatchEvent(
+        view.id,
+        FocusedInputLayoutChangedEvent(
+          surfaceId,
+          view.id,
+          event = event,
+        ),
+      )
+    }
+  }
+}

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

@@ -1,9 +1,10 @@
-package com.reactnativekeyboardcontroller
+package com.reactnativekeyboardcontroller.listeners
 
 import android.animation.ValueAnimator
 import android.os.Build
 import android.util.Log
 import android.view.View
+import android.view.ViewTreeObserver.OnGlobalFocusChangeListener
 import androidx.core.animation.doOnEnd
 import androidx.core.graphics.Insets
 import androidx.core.view.OnApplyWindowInsetsListener
@@ -15,11 +16,11 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 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.InteractiveKeyboardProvider
 import com.reactnativekeyboardcontroller.events.KeyboardTransitionEvent
+import com.reactnativekeyboardcontroller.extensions.dispatchEvent
 import com.reactnativekeyboardcontroller.extensions.dp
 import kotlin.math.abs
 
@@ -33,56 +34,65 @@ class KeyboardAnimationCallback(
   val context: ThemedReactContext?,
 ) : WindowInsetsAnimationCompat.Callback(dispatchMode), OnApplyWindowInsetsListener {
   private val surfaceId = UIManagerHelper.getSurfaceId(view)
+
+  // state variables
   private var persistentKeyboardHeight = 0.0
   private var isKeyboardVisible = false
   private var isTransitioning = false
   private var duration = 0
   private var viewTagFocused = -1
 
+  // listeners
+  private val focusListener = OnGlobalFocusChangeListener { 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
+        context.dispatchEvent(
+          view.id,
+          KeyboardTransitionEvent(
+            surfaceId,
+            view.id,
+            "topKeyboardMoveStart",
+            this.persistentKeyboardHeight,
+            1.0,
+            0,
+            viewTagFocused,
+          ),
+        )
+        context.dispatchEvent(
+          view.id,
+          KeyboardTransitionEvent(
+            surfaceId,
+            view.id,
+            "topKeyboardMoveEnd",
+            this.persistentKeyboardHeight,
+            1.0,
+            0,
+            viewTagFocused,
+          ),
+        )
+        this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(this.persistentKeyboardHeight))
+        this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
+      }
+    }
+  }
+  private var layoutObserver: FocusedInputLayoutObserver? = null
+
   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(
-              surfaceId,
-              view.id,
-              "topKeyboardMoveStart",
-              this.persistentKeyboardHeight,
-              1.0,
-              0,
-              viewTagFocused,
-            ),
-          )
-          this.sendEventToJS(
-            KeyboardTransitionEvent(
-              surfaceId,
-              view.id,
-              "topKeyboardMoveEnd",
-              this.persistentKeyboardHeight,
-              1.0,
-              0,
-              viewTagFocused,
-            ),
-          )
-          this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(this.persistentKeyboardHeight))
-          this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(this.persistentKeyboardHeight))
-        }
-      }
-    }
+    layoutObserver = FocusedInputLayoutObserver(view = view, context = context)
+    view.viewTreeObserver.addOnGlobalFocusChangeListener(focusListener)
   }
 
   /**
@@ -115,8 +125,10 @@ class KeyboardAnimationCallback(
       val keyboardHeight = getCurrentKeyboardHeight()
       val duration = DEFAULT_ANIMATION_TIME.toInt()
 
+      layoutObserver?.syncUpLayout()
       this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(keyboardHeight))
-      this.sendEventToJS(
+      context.dispatchEvent(
+        view.id,
         KeyboardTransitionEvent(
           surfaceId,
           view.id,
@@ -128,10 +140,12 @@ class KeyboardAnimationCallback(
         ),
       )
 
-      val animation = ValueAnimator.ofFloat(this.persistentKeyboardHeight.toFloat(), keyboardHeight.toFloat())
+      val animation =
+        ValueAnimator.ofFloat(this.persistentKeyboardHeight.toFloat(), keyboardHeight.toFloat())
       animation.addUpdateListener { animator ->
         val toValue = animator.animatedValue as Float
-        this.sendEventToJS(
+        context.dispatchEvent(
+          view.id,
           KeyboardTransitionEvent(
             surfaceId,
             view.id,
@@ -145,7 +159,8 @@ class KeyboardAnimationCallback(
       }
       animation.doOnEnd {
         this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(keyboardHeight))
-        this.sendEventToJS(
+        context.dispatchEvent(
+          view.id,
           KeyboardTransitionEvent(
             surfaceId,
             view.id,
@@ -180,13 +195,15 @@ class KeyboardAnimationCallback(
       this.persistentKeyboardHeight = keyboardHeight
     }
 
+    layoutObserver?.syncUpLayout()
     this.emitEvent(
       "KeyboardController::" + if (!isKeyboardVisible) "keyboardWillHide" else "keyboardWillShow",
       getEventParams(keyboardHeight),
     )
 
     Log.i(TAG, "HEIGHT:: $keyboardHeight TAG:: $viewTagFocused")
-    this.sendEventToJS(
+    context.dispatchEvent(
+      view.id,
       KeyboardTransitionEvent(
         surfaceId,
         view.id,
@@ -227,10 +244,24 @@ class KeyboardAnimationCallback(
       // 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} $viewTagFocused")
+    Log.i(
+      TAG,
+      "DiffY: $diffY $height $progress ${InteractiveKeyboardProvider.isInteractive} $viewTagFocused",
+    )
 
     val event = if (InteractiveKeyboardProvider.isInteractive) "topKeyboardMoveInteractive" else "topKeyboardMove"
-    this.sendEventToJS(KeyboardTransitionEvent(surfaceId, view.id, event, height, progress, duration, viewTagFocused))
+    context.dispatchEvent(
+      view.id,
+      KeyboardTransitionEvent(
+        surfaceId,
+        view.id,
+        event,
+        height,
+        progress,
+        duration,
+        viewTagFocused,
+      ),
+    )
 
     return insets
   }
@@ -259,7 +290,8 @@ class KeyboardAnimationCallback(
       "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow",
       getEventParams(keyboardHeight),
     )
-    this.sendEventToJS(
+    context.dispatchEvent(
+      view.id,
       KeyboardTransitionEvent(
         surfaceId,
         view.id,
@@ -275,6 +307,11 @@ class KeyboardAnimationCallback(
     duration = 0
   }
 
+  fun destroy() {
+    view.viewTreeObserver.removeOnGlobalFocusChangeListener(focusListener)
+    layoutObserver?.destroy()
+  }
+
   private fun isKeyboardVisible(): Boolean {
     val insets = ViewCompat.getRootWindowInsets(view)
 
@@ -290,12 +327,6 @@ class KeyboardAnimationCallback(
     return (keyboardHeight - navigationBar).toFloat().dp.coerceAtLeast(0.0)
   }
 
-  private fun sendEventToJS(event: Event<*>) {
-    val eventDispatcher: EventDispatcher? =
-      UIManagerHelper.getEventDispatcherForReactTag(context, view.id)
-    eventDispatcher?.dispatchEvent(event)
-  }
-
   private fun emitEvent(event: String, params: WritableMap) {
     context?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(event, params)
 

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

@@ -11,6 +11,10 @@ class KeyboardControllerViewManagerImpl(mReactContext: ReactApplicationContext)
     return EdgeToEdgeReactViewGroup(reactContext)
   }
 
+  fun setEnabled(view: EdgeToEdgeReactViewGroup, enabled: Boolean) {
+    view.setActive(enabled)
+  }
+
   fun setStatusBarTranslucent(view: EdgeToEdgeReactViewGroup, isStatusBarTranslucent: Boolean) {
     view.setStatusBarTranslucent(isStatusBarTranslucent)
   }
@@ -29,6 +33,8 @@ class KeyboardControllerViewManagerImpl(mReactContext: ReactApplicationContext)
       MapBuilder.of("registrationName", "onKeyboardMoveEnd"),
       "topKeyboardMoveInteractive",
       MapBuilder.of("registrationName", "onKeyboardMoveInteractive"),
+      "topFocusedInputLayoutChanged",
+      MapBuilder.of("registrationName", "onFocusedInputLayoutChanged"),
     )
 
     return map

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

@@ -12,78 +12,47 @@ import androidx.core.view.WindowInsetsAnimationCompat
 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.extensions.removeSelf
 import com.reactnativekeyboardcontroller.extensions.requestApplyInsetsWhenAttached
 import com.reactnativekeyboardcontroller.extensions.rootView
+import com.reactnativekeyboardcontroller.listeners.KeyboardAnimationCallback
 
 private val TAG = EdgeToEdgeReactViewGroup::class.qualifiedName
 
+@Suppress("detekt:TooManyFunctions")
 @SuppressLint("ViewConstructor")
 class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
+  // props
   private var isStatusBarTranslucent = false
   private var isNavigationBarTranslucent = false
+  private var active = false
+
+  // internal class members
   private var eventView: ReactViewGroup? = null
+  private var wasMounted = false
+  private var callback: KeyboardAnimationCallback? = null
 
   // region View lifecycles
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
 
-    val activity = reactContext.currentActivity
-    if (activity == null) {
-      Log.w(TAG, "Can not setup keyboard animation listener, since `currentActivity` is null")
+    if (!wasMounted) {
+      // skip logic with callback re-creation if it was first render/mount
+      wasMounted = true
       return
     }
 
-    Handler(Looper.getMainLooper()).post(this::setupWindowInsets)
-    WindowCompat.setDecorFitsSystemWindows(
-      activity.window,
-      false,
-    )
-
-    eventView = ReactViewGroup(context)
-    val root = this.getContentView()
-    root?.addView(eventView)
-
-    val callback = KeyboardAnimationCallback(
-      view = this,
-      persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
-      deferredInsetTypes = WindowInsetsCompat.Type.ime(),
-      dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
-      context = reactContext,
-    )
-
-    eventView?.let {
-      ViewCompat.setWindowInsetsAnimationCallback(it, callback)
-      ViewCompat.setOnApplyWindowInsetsListener(it, callback)
-      it.requestApplyInsetsWhenAttached()
-    }
+    this.setupKeyboardCallbacks()
   }
 
   override fun onDetachedFromWindow() {
     super.onDetachedFromWindow()
 
-    eventView.removeSelf()
+    this.removeKeyboardCallbacks()
   }
   // endregion
 
-  // region Props setters
-  fun setStatusBarTranslucent(isStatusBarTranslucent: Boolean) {
-    this.isStatusBarTranslucent = isStatusBarTranslucent
-  }
-
-  fun setNavigationBarTranslucent(isNavigationBarTranslucent: Boolean) {
-    this.isNavigationBarTranslucent = isNavigationBarTranslucent
-  }
-  // endregion
-
-  // region Private functions/class helpers
-  private fun getContentView(): FitWindowsLinearLayout? {
-    return reactContext.currentActivity?.window?.decorView?.rootView?.findViewById(
-      androidx.appcompat.R.id.action_bar_root,
-    )
-  }
-
+  // region State manager helpers
   private fun setupWindowInsets() {
     val rootView = reactContext.rootView
     if (rootView != null) {
@@ -94,16 +63,20 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
           FrameLayout.LayoutParams.MATCH_PARENT,
         )
 
+        val shouldApplyZeroPaddingTop = !active || this.isStatusBarTranslucent
+        val shouldApplyZeroPaddingBottom = !active || this.isNavigationBarTranslucent
         params.setMargins(
           0,
-          if (this.isStatusBarTranslucent) {
+          if (shouldApplyZeroPaddingTop) {
             0
           } else {
-            insets?.getInsets(WindowInsetsCompat.Type.systemBars())?.top
-              ?: 0
+            (
+              insets?.getInsets(WindowInsetsCompat.Type.systemBars())?.top
+                ?: 0
+              )
           },
           0,
-          if (this.isNavigationBarTranslucent) {
+          if (shouldApplyZeroPaddingBottom) {
             0
           } else {
             insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom
@@ -113,9 +86,106 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
 
         content?.layoutParams = params
 
-        insets
+        val defaultInsets = ViewCompat.onApplyWindowInsets(v, insets)
+
+        defaultInsets.replaceSystemWindowInsets(
+          defaultInsets.systemWindowInsetLeft,
+          if (this.isStatusBarTranslucent) 0 else defaultInsets.systemWindowInsetTop,
+          defaultInsets.systemWindowInsetRight,
+          defaultInsets.systemWindowInsetBottom,
+        )
       }
     }
   }
+
+  private fun goToEdgeToEdge(edgeToEdge: Boolean) {
+    reactContext.currentActivity?.let {
+      WindowCompat.setDecorFitsSystemWindows(
+        it.window,
+        !edgeToEdge,
+      )
+    }
+  }
+
+  private fun setupKeyboardCallbacks() {
+    val activity = reactContext.currentActivity
+
+    if (activity != null) {
+      eventView = ReactViewGroup(context)
+      val root = this.getContentView()
+      root?.addView(eventView)
+
+      callback = KeyboardAnimationCallback(
+        view = this,
+        persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
+        deferredInsetTypes = WindowInsetsCompat.Type.ime(),
+        dispatchMode = WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE,
+        context = reactContext,
+      )
+
+      eventView?.let {
+        ViewCompat.setWindowInsetsAnimationCallback(it, callback)
+        ViewCompat.setOnApplyWindowInsetsListener(it, callback)
+        it.requestApplyInsetsWhenAttached()
+      }
+    } else {
+      Log.w(TAG, "Can not setup keyboard animation listener, since `currentActivity` is null")
+    }
+  }
+
+  private fun removeKeyboardCallbacks() {
+    callback?.destroy()
+
+    // capture view into closure, because if `onDetachedFromWindow` and `onAttachedToWindow`
+    // dispatched synchronously after each other (open application on Fabric), then `.post`
+    // will destroy just newly created view (if we have a reference via `this`)
+    // and we'll have a memory leak or zombie-view
+    val view = eventView
+    // we need to remove view asynchronously from `onDetachedFromWindow` method
+    // otherwise we may face NPE when app is getting opened via universal link
+    // see https://github.com/kirillzyusko/react-native-keyboard-controller/issues/242
+    // for more details
+    Handler(Looper.getMainLooper()).post { view.removeSelf() }
+  }
+
+  private fun getContentView(): FitWindowsLinearLayout? {
+    return reactContext.currentActivity?.window?.decorView?.rootView?.findViewById(
+      androidx.appcompat.R.id.action_bar_root,
+    )
+  }
+  // endregion
+
+  // region State managers
+  private fun enable() {
+    this.goToEdgeToEdge(true)
+    this.setupWindowInsets()
+    this.setupKeyboardCallbacks()
+  }
+
+  private fun disable() {
+    this.goToEdgeToEdge(false)
+    this.setupWindowInsets()
+    this.removeKeyboardCallbacks()
+  }
+  // endregion
+
+  // region Props setters
+  fun setStatusBarTranslucent(isStatusBarTranslucent: Boolean) {
+    this.isStatusBarTranslucent = isStatusBarTranslucent
+  }
+
+  fun setNavigationBarTranslucent(isNavigationBarTranslucent: Boolean) {
+    this.isNavigationBarTranslucent = isNavigationBarTranslucent
+  }
+
+  fun setActive(active: Boolean) {
+    this.active = active
+
+    if (active) {
+      this.enable()
+    } else {
+      this.disable()
+    }
+  }
   // endregion
 }