fix: switch between inputs with KeyboardGestureArea on iOS (#938)

## 📜 Description

Fixed a problem with autoclosing keyboard if you switch between inputs +
`KeyboardGestureArea` has active `offset`.

## 💡 Motivation and Context

The key problem here is that in previous implementation
`resignFirstResponder` call gets delayed, so first of all we call
`becomeFirstResponder`, then we call `resignFirstResponder`, but it's
getting delayed, so new input get focus and then we call
`resignFirstResponder` and keyboard gets closed.

First fix that I did was saving pending request in
`resignFirstResponder` - I found out that it's getting called two times,
and I thought if we call it second time and we have pending request ->
we can immediately remove focus and cancel previous task. It works on
simulator, but not on a real device - on a real device keyboard becomes
hidden and then becomes visible.

To fix all problems I decided to intercept `becomeFirstResponder` event,
and save new focused input. If `resignFirstResponder` is getting called
and we have a pending request, then we should remove
`inputAccessoryView` immediately + don't add any delays. In its turn
`becomeFirstResponder` should store new focus request only for short
amount of time - otherwise, if we store it permanently we can not
distinguish a case "focus switch" vs "dismiss a keyboard", so current
algorithm looks like:
- we have `resignFistResponder` and in the past frame we had
`becomeFirstResponder` request -> we switch focus, so do a cleanup
immediately;
- we have `resignFistResponder` and in the past frame we didn't have
`becomeFirstResponder` request -> remove `inputAccessoryView` and close
the keyboard (similar to how it was working before).

## 📢 Changelog

<!-- High level overview of important changes -->
<!-- For example: fixed status bar manipulation; added new types
declarations; -->
<!-- If your changes don't affect one of platform/language below - then
remove this platform/language -->

### iOS

- swizzle `becomeFirstResponder`;
- store current first responder for one frame;
- check in `resignFirstResponder` presence of current first responder
and if we have it -> do a cleanup immediately.

## 🤔 How Has This Been Tested?

Tested manually on iPhone 11 (iOS 17.4), with following code added
before `ScrollView`:

```tsx
      <AnimatedTextInput
        multiline
        nativeID="chat-input"
        style={{width: "100%", height: 50, backgroundColor: "blue"}}
        testID="chat.input"
      />
```

## 📸 Screenshots (if appropriate):


https://github.com/user-attachments/assets/ff7d54d9-452b-432c-b587-2660132c3deb

## 📝 Checklist

- [x] CI successfully passed
- [x] I added new mocks and corresponding unit-tests if library API was
changed

Author: kirillzyusko

ios/swizzling/UIResponderSwizzle.swift

@@ -8,29 +8,64 @@
 import Foundation
 import UIKit
 
+private var pendingBecomeResponder: TextInput?
 private var originalResignFirstResponder: IMP?
+private var originalBecomeFirstResponder: IMP?
 
 @objc
 extension UIResponder {
+  public static func swizzleBecomeFirstResponder() {
+    let originalBecomeSelector = #selector(becomeFirstResponder)
+    guard
+      let originalBecomeMethod = class_getInstanceMethod(UIResponder.self, originalBecomeSelector)
+    else {
+      return
+    }
+
+    originalBecomeFirstResponder = method_getImplementation(originalBecomeMethod)
+
+    let swizzledBecomeImplementation: @convention(block) (UIResponder) -> Bool = { (self) in
+      pendingBecomeResponder = self as? TextInput
+
+      DispatchQueue.main.asyncAfter(deadline: .now() + UIUtils.nextFrame) {
+        pendingBecomeResponder = nil
+      }
+
+      return self.callOriginalBecomeFirstResponder(originalBecomeSelector)
+    }
+
+    let implementation = imp_implementationWithBlock(swizzledBecomeImplementation)
+    method_setImplementation(originalBecomeMethod, implementation)
+  }
+
   public static func swizzleResignFirstResponder() {
-    let originalSelector = #selector(resignFirstResponder)
+    let originalResignSelector = #selector(resignFirstResponder)
 
-    guard let originalMethod = class_getInstanceMethod(UIResponder.self, originalSelector) else {
+    guard
+      let originalResignMethod = class_getInstanceMethod(UIResponder.self, originalResignSelector)
+    else {
       return
     }
 
-    originalResignFirstResponder = method_getImplementation(originalMethod)
+    originalResignFirstResponder = method_getImplementation(originalResignMethod)
 
-    let swizzledImplementation: @convention(block) (UIResponder) -> Bool = { (self) in
+    let swizzledResignImplementation: @convention(block) (UIResponder) -> Bool = { (self) in
       // Check the type of responder
       if let textField = self as? TextInput {
         // check inputAccessoryView and call original method immediately if not InvisibleInputAccessoryView
         if !(textField.inputAccessoryView is InvisibleInputAccessoryView) {
-          return self.callOriginalResignFirstResponder(originalSelector)
+          return self.callOriginalResignFirstResponder(originalResignSelector)
+        } else if pendingBecomeResponder != nil {
+          // if we already have a new focus request
+          pendingBecomeResponder = nil
+          KeyboardAreaExtender.shared.hide()
+          (self as? TextInput)?.inputAccessoryView = nil
+          KeyboardAreaExtender.shared.remove()
+          return self.callOriginalResignFirstResponder(originalResignSelector)
         }
       } else {
         // If casting to TextInput fails
-        return self.callOriginalResignFirstResponder(originalSelector)
+        return self.callOriginalResignFirstResponder(originalResignSelector)
       }
 
       KeyboardAreaExtender.shared.hide()
@@ -39,22 +74,34 @@ extension UIResponder {
       DispatchQueue.main.asyncAfter(deadline: .now() + UIUtils.nextFrame) {
         (self as? TextInput)?.inputAccessoryView = nil
         KeyboardAreaExtender.shared.remove()
-        _ = self.callOriginalResignFirstResponder(originalSelector)
+        _ = self.callOriginalResignFirstResponder(originalResignSelector)
       }
 
       // We need to return a value immediately, even though the actual action is delayed
       return false
     }
 
-    let implementation = imp_implementationWithBlock(swizzledImplementation)
-    method_setImplementation(originalMethod, implementation)
+    let implementation = imp_implementationWithBlock(swizzledResignImplementation)
+    method_setImplementation(originalResignMethod, implementation)
   }
 
   private func callOriginalResignFirstResponder(_ selector: Selector) -> Bool {
     guard let originalResignFirstResponder = originalResignFirstResponder else { return false }
     typealias Function = @convention(c) (AnyObject, Selector) -> Bool
-    let castOriginalResignFirstResponder = unsafeBitCast(originalResignFirstResponder, to: Function.self)
+    let castOriginalResignFirstResponder = unsafeBitCast(
+      originalResignFirstResponder, to: Function.self
+    )
     let result = castOriginalResignFirstResponder(self, selector)
     return result
   }
+
+  private func callOriginalBecomeFirstResponder(_ selector: Selector) -> Bool {
+    guard let originalBecomeFirstResponder = originalBecomeFirstResponder else { return false }
+    typealias Function = @convention(c) (AnyObject, Selector) -> Bool
+    let castOriginalBecomeFirstResponder = unsafeBitCast(
+      originalBecomeFirstResponder, to: Function.self
+    )
+    let result = castOriginalBecomeFirstResponder(self, selector)
+    return result
+  }
 }

ios/views/KeyboardGestureAreaManager.mm

@@ -75,6 +75,7 @@ + (void)load
   [super load];
 
   [UIResponder swizzleResignFirstResponder];
+  [UIResponder swizzleBecomeFirstResponder];
 }
 
 // MARK: Constructor