react-native-keyboard-controller 1.8.0 → 1.9.1

package/README.md

@@ -13,7 +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 👆📱
-- re-worked prebuilt components (such as `KeyboardAvoidingView`) 📚
+- 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/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)
   }
 
   /**
@@ -100,6 +110,7 @@ class KeyboardAnimationCallback(
    * - we dispatch `keyboardDidShow` (onEnd).
    */
   override fun onApplyWindowInsets(v: View, insets: WindowInsetsCompat): WindowInsetsCompat {
+    val keyboardHeight = getCurrentKeyboardHeight()
     // when keyboard appears values will be (false && true)
     // when keyboard disappears values will be (true && false)
     val isKeyboardShown = isKeyboardVisible && isKeyboardVisible()
@@ -111,53 +122,65 @@ class KeyboardAnimationCallback(
     // `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()
+    val isKeyboardFullyVisible = isKeyboardShown && !isMoving
+    // when keyboard is opened and we trigger a transition from screen A to screen B,
+    // then this method is getting called and we start dispatching events, and later original
+    // `onStart`/`onProgress`/`onEnd` emitting their events (since keyboard is closing) and we
+    // are getting race conditions.
+    //
+    // but in general this check is a must because we are detecting keyboard size changes
+    // in this method
+    val isKeyboardSizeEqual = this.persistentKeyboardHeight == keyboardHeight
 
+    if (isKeyboardFullyVisible && !isKeyboardSizeEqual && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      layoutObserver?.syncUpLayout()
       this.emitEvent("KeyboardController::keyboardWillShow", getEventParams(keyboardHeight))
-      this.sendEventToJS(
+      context.dispatchEvent(
+        view.id,
         KeyboardTransitionEvent(
           surfaceId,
           view.id,
           "topKeyboardMoveStart",
           keyboardHeight,
           1.0,
-          duration,
+          DEFAULT_ANIMATION_TIME,
           viewTagFocused,
         ),
       )
 
-      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,
             "topKeyboardMove",
             toValue.toDouble(),
             toValue.toDouble() / keyboardHeight,
-            duration,
+            DEFAULT_ANIMATION_TIME,
             viewTagFocused,
           ),
         )
       }
       animation.doOnEnd {
         this.emitEvent("KeyboardController::keyboardDidShow", getEventParams(keyboardHeight))
-        this.sendEventToJS(
+        context.dispatchEvent(
+          view.id,
           KeyboardTransitionEvent(
             surfaceId,
             view.id,
             "topKeyboardMoveEnd",
             keyboardHeight,
             1.0,
-            duration,
+            DEFAULT_ANIMATION_TIME,
             viewTagFocused,
           ),
         )
       }
-      animation.setDuration(DEFAULT_ANIMATION_TIME).startDelay = 0
+      animation.setDuration(DEFAULT_ANIMATION_TIME.toLong()).startDelay = 0
       animation.start()
 
       this.persistentKeyboardHeight = keyboardHeight
@@ -180,13 +203,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 +252,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 +298,8 @@ class KeyboardAnimationCallback(
       "KeyboardController::" + if (!isKeyboardVisible) "keyboardDidHide" else "keyboardDidShow",
       getEventParams(keyboardHeight),
     )
-    this.sendEventToJS(
+    context.dispatchEvent(
+      view.id,
       KeyboardTransitionEvent(
         surfaceId,
         view.id,
@@ -275,6 +315,11 @@ class KeyboardAnimationCallback(
     duration = 0
   }
 
+  fun destroy() {
+    view.viewTreeObserver.removeOnGlobalFocusChangeListener(focusListener)
+    layoutObserver?.destroy()
+  }
+
   private fun isKeyboardVisible(): Boolean {
     val insets = ViewCompat.getRootWindowInsets(view)
 
@@ -290,12 +335,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)
 
@@ -313,6 +352,6 @@ class KeyboardAnimationCallback(
   }
 
   companion object {
-    private const val DEFAULT_ANIMATION_TIME = 250L
+    private const val DEFAULT_ANIMATION_TIME = 250
   }
 }

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

@@ -33,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,10 +12,10 @@ 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
 
@@ -30,6 +30,7 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
   // internal class members
   private var eventView: ReactViewGroup? = null
   private var wasMounted = false
+  private var callback: KeyboardAnimationCallback? = null
 
   // region View lifecycles
   override fun onAttachedToWindow() {
@@ -47,11 +48,7 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
   override fun onDetachedFromWindow() {
     super.onDetachedFromWindow()
 
-    // 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 { this.removeKeyboardCallbacks() }
+    this.removeKeyboardCallbacks()
   }
   // endregion
 
@@ -118,7 +115,7 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
       val root = this.getContentView()
       root?.addView(eventView)
 
-      val callback = KeyboardAnimationCallback(
+      callback = KeyboardAnimationCallback(
         view = this,
         persistentInsetTypes = WindowInsetsCompat.Type.systemBars(),
         deferredInsetTypes = WindowInsetsCompat.Type.ime(),
@@ -137,7 +134,18 @@ class EdgeToEdgeReactViewGroup(private val reactContext: ThemedReactContext) : R
   }
 
   private fun removeKeyboardCallbacks() {
-    eventView.removeSelf()
+    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? {

package/ios/Extensions.swift

@@ -52,3 +52,10 @@ public extension Optional where Wrapped == UIResponder {
     #endif
   }
 }
+
+public extension UIView {
+  var globalFrame: CGRect? {
+    let rootView = UIApplication.shared.keyWindow?.rootViewController?.view
+    return superview?.convert(frame, to: rootView)
+  }
+}

package/ios/KeyboardController.xcodeproj/project.pbxproj

@@ -8,6 +8,8 @@
 
 /* Begin PBXBuildFile section */
 		0807071E2A34807B00C05A19 /* Extensions.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0807071D2A34807B00C05A19 /* Extensions.swift */; };
+		084AEEC62ACF49A8001A3069 /* FocusedInputLayoutChangedEvent.m in Sources */ = {isa = PBXBuildFile; fileRef = 084AEEC52ACF49A8001A3069 /* FocusedInputLayoutChangedEvent.m */; };
+		084AEEC82ACF4AB2001A3069 /* FocusedInputLayoutObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = 084AEEC72ACF4AB2001A3069 /* FocusedInputLayoutObserver.swift */; };
 		F333F8D428996B8D0015B05F /* KeyboardControllerView.mm in Sources */ = {isa = PBXBuildFile; fileRef = F333F8D228996B8D0015B05F /* KeyboardControllerView.mm */; };
 		F359D34F28133C26000B6AFE /* KeyboardControllerModule.mm in Sources */ = {isa = PBXBuildFile; fileRef = F359D34E28133C26000B6AFE /* KeyboardControllerModule.mm */; };
 		F3626A0728B3FE760021B2D9 /* KeyboardMovementObserver.swift in Sources */ = {isa = PBXBuildFile; fileRef = F3626A0628B3FE760021B2D9 /* KeyboardMovementObserver.swift */; };
@@ -29,6 +31,9 @@
 
 /* Begin PBXFileReference section */
 		0807071D2A34807B00C05A19 /* Extensions.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Extensions.swift; sourceTree = "<group>"; };
+		084AEEC22ACF479A001A3069 /* FocusedInputLayoutChangedEvent.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = FocusedInputLayoutChangedEvent.h; sourceTree = "<group>"; };
+		084AEEC52ACF49A8001A3069 /* FocusedInputLayoutChangedEvent.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = FocusedInputLayoutChangedEvent.m; sourceTree = "<group>"; };
+		084AEEC72ACF4AB2001A3069 /* FocusedInputLayoutObserver.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FocusedInputLayoutObserver.swift; sourceTree = "<group>"; };
 		134814201AA4EA6300B7C361 /* libKeyboardController.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libKeyboardController.a; sourceTree = BUILT_PRODUCTS_DIR; };
 		B3E7B5891CC2AC0600A0062D /* KeyboardControllerViewManager.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KeyboardControllerViewManager.mm; sourceTree = "<group>"; };
 		F333F8D128996B1C0015B05F /* KeyboardControllerView.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = KeyboardControllerView.h; sourceTree = "<group>"; };
@@ -53,6 +58,37 @@
 /* End PBXFrameworksBuildPhase section */
 
 /* Begin PBXGroup section */
+		084AEEBF2ACDFBF1001A3069 /* events */ = {
+			isa = PBXGroup;
+			children = (
+				F3F50667289E653B003091D6 /* KeyboardMoveEvent.h */,
+				F3F50668289E653B003091D6 /* KeyboardMoveEvent.m */,
+				084AEEC22ACF479A001A3069 /* FocusedInputLayoutChangedEvent.h */,
+				084AEEC52ACF49A8001A3069 /* FocusedInputLayoutChangedEvent.m */,
+			);
+			path = events;
+			sourceTree = "<group>";
+		};
+		084AEEC02ACDFC2A001A3069 /* observers */ = {
+			isa = PBXGroup;
+			children = (
+				F3626A0628B3FE760021B2D9 /* KeyboardMovementObserver.swift */,
+				084AEEC72ACF4AB2001A3069 /* FocusedInputLayoutObserver.swift */,
+			);
+			path = observers;
+			sourceTree = "<group>";
+		};
+		084AEEC12ACF405C001A3069 /* views */ = {
+			isa = PBXGroup;
+			children = (
+				F333F8D228996B8D0015B05F /* KeyboardControllerView.mm */,
+				F333F8D128996B1C0015B05F /* KeyboardControllerView.h */,
+				F4FF95D6245B92E800C19C63 /* KeyboardControllerViewManager.swift */,
+				B3E7B5891CC2AC0600A0062D /* KeyboardControllerViewManager.mm */,
+			);
+			path = views;
+			sourceTree = "<group>";
+		};
 		134814211AA4EA7D00B7C361 /* Products */ = {
 			isa = PBXGroup;
 			children = (
@@ -64,16 +100,12 @@
 		58B511D21A9E6C8500147676 = {
 			isa = PBXGroup;
 			children = (
+				084AEEC12ACF405C001A3069 /* views */,
+				084AEEC02ACDFC2A001A3069 /* observers */,
+				084AEEBF2ACDFBF1001A3069 /* events */,
 				0807071D2A34807B00C05A19 /* Extensions.swift */,
-				F3F50667289E653B003091D6 /* KeyboardMoveEvent.h */,
-				F3F50668289E653B003091D6 /* KeyboardMoveEvent.m */,
-				F3626A0628B3FE760021B2D9 /* KeyboardMovementObserver.swift */,
-				F333F8D228996B8D0015B05F /* KeyboardControllerView.mm */,
-				F333F8D128996B1C0015B05F /* KeyboardControllerView.h */,
 				F359D35028133C6F000B6AFE /* KeyboardControllerModule-Header.h */,
 				F359D34E28133C26000B6AFE /* KeyboardControllerModule.mm */,
-				F4FF95D6245B92E800C19C63 /* KeyboardControllerViewManager.swift */,
-				B3E7B5891CC2AC0600A0062D /* KeyboardControllerViewManager.mm */,
 				F4FF95D5245B92E700C19C63 /* KeyboardController-Bridging-Header.h */,
 				134814211AA4EA7D00B7C361 /* Products */,
 			);
@@ -136,9 +168,11 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				084AEEC62ACF49A8001A3069 /* FocusedInputLayoutChangedEvent.m in Sources */,
 				F3626A0728B3FE760021B2D9 /* KeyboardMovementObserver.swift in Sources */,
 				0807071E2A34807B00C05A19 /* Extensions.swift in Sources */,
 				F359D34F28133C26000B6AFE /* KeyboardControllerModule.mm in Sources */,
+				084AEEC82ACF4AB2001A3069 /* FocusedInputLayoutObserver.swift in Sources */,
 				F4FF95D7245B92E800C19C63 /* KeyboardControllerViewManager.swift in Sources */,
 				F333F8D428996B8D0015B05F /* KeyboardControllerView.mm in Sources */,
 				F3F50669289E653B003091D6 /* KeyboardMoveEvent.m in Sources */,

package/ios/events/FocusedInputLayoutChangedEvent.h

@@ -0,0 +1,16 @@
+//
+//  FocusedInputLayoutChangedEvent.h
+//  KeyboardController
+//
+//  Created by Kiryl Ziusko on 05/10/2023.
+//  Copyright © 2023 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTEventDispatcherProtocol.h>
+
+@interface FocusedInputLayoutChangedEvent : NSObject <RCTEvent>
+
+- (instancetype)initWithReactTag:(NSNumber *)reactTag event:(NSObject *)event;
+
+@end