react-native-controlled-input 0.18.0 → 0.20.0

package/android/src/main/java/com/controlledinput/ControlledInputView.kt

@@ -5,7 +5,6 @@ import android.util.AttributeSet
 import android.util.Log
 import android.util.TypedValue
 import android.view.View
-import android.view.ViewTreeObserver
 import android.view.inputmethod.InputMethodManager
 import android.widget.EditText
 import android.widget.LinearLayout
@@ -27,6 +26,7 @@ import androidx.savedstate.SavedStateRegistryOwner
 import androidx.savedstate.setViewTreeSavedStateRegistryOwner
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
 import kotlinx.coroutines.flow.MutableStateFlow
 
 /**
@@ -67,176 +67,184 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   private var windowLifecycleBound = false
 
   /**
-   * True while we are in the focus-restoration dance:
-   *   proxy stole Android focus from Compose → onBlur fired → we're restoring Compose focus.
-   * During this window the second onFocus must NOT call requestFocusProxy() again.
+   * Hidden [EditText] used only as KBC's [FocusedInputObserver.lastFocusedInput]: [syncUpLayout]
+   * reads [EditText]-scoped geometry. It is NOT focused and does not participate in the focus
+   * chain — we push state via reflection + synthetic selection events instead.
    */
-  private var isRestoringComposeFocus = false
-
-  /**
-   * Invisible EditText that acts as a focus proxy for react-native-keyboard-controller.
-   *
-   * keyboard-controller's FocusedInputObserver only tracks views that are `EditText` instances.
-   * Since ControlledInputView uses Compose BasicTextField, it is invisible to that observer.
-   * Focusing this proxy when Compose gains focus makes keyboard-controller aware of the input
-   * and allows KeyboardAwareScrollView to scroll correctly.
-   *
-   * Layout height is 0 so LinearLayout ignores it visually. onLayout() forces its bounds to
-   * match ControlledInputView so keyboard-controller reads the correct width/height/position.
-   */
-  private val focusProxy: EditText by lazy {
-    EditText(context).also { proxy ->
-      proxy.layoutParams = LayoutParams(0, 0)
-      // Must stay VISIBLE — Android's canTakeFocus() returns false for INVISIBLE/GONE views,
-      // causing requestFocus() to silently fail. Use alpha=0 to hide it visually instead.
-      proxy.alpha = 0f
-      proxy.isFocusableInTouchMode = true
-      proxy.showSoftInputOnFocus = false
-      proxy.isClickable = false
-      proxy.isCursorVisible = false
-      proxy.isLongClickable = false
-    }
-  }
-
-  private fun requestFocusProxy() {
-    val fontSize = viewModel.inputStyle.value?.fontSize?.toFloat()
-    Log.d(TAG, "──── requestFocusProxy ────")
-    Log.d(TAG, "  fontSize=$fontSize")
-    Log.d(TAG, "  proxy before: isFocused=${focusProxy.isFocused} size=${focusProxy.width}x${focusProxy.height}")
-
-    // Sync proxy ID with ControlledInputView's React Native tag BEFORE requestFocus(),
-    // so KeyboardAnimationCallback.focusListener sets viewTagFocused = this.id (not -1).
-    // Without this, KeyboardAwareScrollView JS sees e.target=-1 → focusWasChanged=false
-    // → layout.value never updated → maybeScroll() always returns 0 → no scroll.
-    focusProxy.id = this.id
-    Log.d(TAG, "  proxy.id set to ${focusProxy.id} (= ControlledInputView RN tag)")
-
-    // Sync textSize so KeyboardControllerSelectionWatcher computes the correct
-    // cursor Y via android.text.Layout.getLineBottom() — used as `customHeight`
-    // in KeyboardAwareScrollView to determine how far to scroll.
-    fontSize?.let {
-      focusProxy.setTextSize(TypedValue.COMPLEX_UNIT_SP, it)
-      Log.d(TAG, "  proxy textSize set to ${focusProxy.textSize}px (${it}sp)")
-    }
-
-    focusProxy.requestFocus()
-    Log.d(TAG, "  proxy after requestFocus: isFocused=${focusProxy.isFocused} hasFocus=${focusProxy.hasFocus()}")
-
-    if (focusProxy.isFocused) {
-      // Proxy stole Android focus from AndroidComposeView → Compose will fire onBlur.
-      // Mark restoration mode so onBlur knows to recover (not dispatch BlurEvent to JS).
-      isRestoringComposeFocus = true
-      Log.d(TAG, "  isRestoringComposeFocus=true (proxy has Android focus)")
+  private val kbcLayoutHost: EditText by lazy {
+    EditText(context).also { v ->
+      v.layoutParams = LayoutParams(0, 0)
+      v.alpha = 0f
+      v.isFocusable = false
+      v.isFocusableInTouchMode = false
+      v.showSoftInputOnFocus = false
+      v.isClickable = false
+      v.isCursorVisible = false
+      v.isLongClickable = false
     }
-
-    // setSelection triggers a selection change (lastSelectionStart starts at -1),
-    // guaranteeing the watcher fires on the next pre-draw frame even if focus
-    // was just transferred.
-    focusProxy.setSelection(0)
-    Log.d(TAG, "  proxy selectionStart=${focusProxy.selectionStart} layout=${focusProxy.layout != null}")
-
-    // Log absolute screen position — this is what keyboard-controller reads for scroll calculation
-    val loc = IntArray(2)
-    focusProxy.getLocationOnScreen(loc)
-    Log.d(TAG, "  proxy screenLocation x=${loc[0]} y=${loc[1]} → absoluteY for KBC=${loc[1]}px")
-    Log.d(TAG, "──────────────────────────")
-  }
-
-  private fun clearFocusProxy() {
-    Log.d(TAG, "clearFocusProxy: proxy.isFocused=${focusProxy.isFocused} hasFocus=${focusProxy.hasFocus()}")
-    focusProxy.clearFocus()
-    Log.d(TAG, "clearFocusProxy: after clearFocus isFocused=${focusProxy.isFocused}")
   }
 
   /**
-   * Fires when the proxy loses Android focus (i.e. after composeView.requestFocus() restores
-   * Compose). At this point KBC's listener has already cleared lastFocusedInput (KBC registered
-   * its ViewTreeObserver listener before us → it fires first). We post restoreKbcTracking() to
-   * run after all synchronous focus-change handlers complete.
-   */
-  private val proxyFocusLostListener =
-    ViewTreeObserver.OnGlobalFocusChangeListener { oldFocus, newFocus ->
-      // Fire for ANY proxy focus loss while we're in the restoration dance.
-      // newFocus can be null (proxy→null→AndroidComposeView, two steps on first focus)
-      // or AndroidComposeView directly (proxy→AndroidComposeView, subsequent focuses).
-      // Both cases need restoreKbcTracking(); KBC's null→AndroidComposeView transition does
-      // NOT clear lastFocusedInput, so restoring it once is enough for both paths.
-      if (oldFocus == focusProxy && isRestoringComposeFocus) {
-        Log.d(
-          TAG,
-          "proxyFocusLostListener: proxy → ${newFocus?.javaClass?.simpleName ?: "null"}, posting restoreKbcTracking()",
-        )
-        post { restoreKbcTracking() }
-      }
-    }
-
-  /**
-   * Uses reflection to restore KBC's lastFocusedInput = focusProxy and call syncUpLayout(),
-   * so that KeyboardAwareScrollView receives the correct absoluteY / height to scroll to.
-   *
-   * Chain: EdgeToEdgeViewRegistry.get() → .callback → .layoutObserver → .lastFocusedInput / .syncUpLayout()
+   * EdgeToEdgeViewRegistry → KeyboardAnimationCallback + FocusedInputObserver.
+   * Null if react-native-keyboard-controller is missing or not initialized.
    */
-  private fun restoreKbcTracking() {
-    Log.d(TAG, "restoreKbcTracking: starting reflection chain")
+  private fun resolveKbcCallbackAndObserver(): Pair<Any, Any>? {
     try {
-      // 1. EdgeToEdgeViewRegistry is a Kotlin object — access via INSTANCE field
       val registryClass =
         Class.forName("com.reactnativekeyboardcontroller.views.EdgeToEdgeViewRegistry")
       val registryInstance = registryClass.getField("INSTANCE").get(null)
       val edgeToEdgeView =
         registryClass.getDeclaredMethod("get").invoke(registryInstance)
           ?: run {
-            Log.w(TAG, "restoreKbcTracking: EdgeToEdgeViewRegistry.get() == null")
-            return
+            Log.w(TAG, "resolveKbcCallbackAndObserver: EdgeToEdgeViewRegistry.get() == null")
+            return null
           }
 
-      // 2. callback: KeyboardAnimationCallback (internal var — find by type)
       val callbackField =
         edgeToEdgeView.javaClass.declaredFields.firstOrNull {
           it.type.simpleName == "KeyboardAnimationCallback"
         }
           ?: run {
-            Log.w(TAG, "restoreKbcTracking: KeyboardAnimationCallback field not found")
-            return
+            Log.w(TAG, "resolveKbcCallbackAndObserver: KeyboardAnimationCallback field not found")
+            return null
           }
       callbackField.isAccessible = true
       val callback =
         callbackField.get(edgeToEdgeView)
           ?: run {
-            Log.w(TAG, "restoreKbcTracking: callback == null")
-            return
+            Log.w(TAG, "resolveKbcCallbackAndObserver: callback == null")
+            return null
           }
 
-      // 3. layoutObserver: FocusedInputObserver (internal var — find by type)
       val observerField =
         callback.javaClass.declaredFields.firstOrNull {
           it.type.simpleName == "FocusedInputObserver"
         }
           ?: run {
-            Log.w(TAG, "restoreKbcTracking: FocusedInputObserver field not found")
-            return
+            Log.w(TAG, "resolveKbcCallbackAndObserver: FocusedInputObserver field not found")
+            return null
           }
       observerField.isAccessible = true
       val observer =
         observerField.get(callback)
           ?: run {
-            Log.w(TAG, "restoreKbcTracking: layoutObserver == null")
+            Log.w(TAG, "resolveKbcCallbackAndObserver: layoutObserver == null")
+            return null
+          }
+      return Pair(callback, observer)
+    } catch (_: ClassNotFoundException) {
+      Log.d(TAG, "resolveKbcCallbackAndObserver: keyboard-controller not on classpath")
+      return null
+    } catch (e: Exception) {
+      Log.w(TAG, "resolveKbcCallbackAndObserver: ${e.javaClass.simpleName}: ${e.message}")
+      return null
+    }
+  }
+
+  private fun setKbcViewTagFocused(callback: Any) {
+    try {
+      val f = callback.javaClass.getDeclaredField("viewTagFocused")
+      f.isAccessible = true
+      f.setInt(callback, id)
+      Log.d(TAG, "setKbcViewTagFocused: viewTagFocused=$id")
+    } catch (e: Exception) {
+      Log.w(TAG, "setKbcViewTagFocused: ${e.javaClass.simpleName}: ${e.message}")
+    }
+  }
+
+  private fun setKbcFocusedInputHolder() {
+    try {
+      val holderClass =
+        Class.forName("com.reactnativekeyboardcontroller.traversal.FocusedInputHolder")
+      val instance = holderClass.getField("INSTANCE").get(null)
+      holderClass
+        .getMethod("set", EditText::class.java)
+        .invoke(instance, kbcLayoutHost)
+    } catch (e: Exception) {
+      Log.w(TAG, "setKbcFocusedInputHolder: ${e.javaClass.simpleName}: ${e.message}")
+    }
+  }
+
+  /** Approximate one line height in dp for JS customHeight. */
+  private fun approximateSelectionEndYDp(): Double {
+    viewModel.inputStyle.value?.fontSize?.toDouble()?.takeIf { it > 0 }?.let { return it }
+    val dm = resources.displayMetrics
+    return (kbcLayoutHost.textSize / dm.density).toDouble().coerceAtLeast(12.0)
+  }
+
+  private fun dispatchSyntheticKbcSelectionEvent(observer: Any) {
+    val reactContext = context as? ReactContext ?: return
+    try {
+      val epField = observer.javaClass.getDeclaredField("eventPropagationView")
+      epField.isAccessible = true
+      val propagationId = (epField.get(observer) as View).id
+
+      val surfaceId = UIManagerHelper.getSurfaceId(this)
+      val targetId = id
+      val endY = approximateSelectionEndYDp()
+
+      val dataClz =
+        Class.forName("com.reactnativekeyboardcontroller.events.FocusedInputSelectionChangedEventData")
+      val dataCtor =
+        dataClz.declaredConstructors.singleOrNull { it.parameterTypes.size == 7 }
+          ?: run {
+            Log.w(TAG, "dispatchSyntheticKbcSelectionEvent: no 7-arg data ctor")
             return
           }
+      dataCtor.isAccessible = true
+      val data =
+        dataCtor.newInstance(targetId, 0.0, 0.0, 0.0, endY, 0, 0)
+
+      val eventClz =
+        Class.forName("com.reactnativekeyboardcontroller.events.FocusedInputSelectionChangedEvent")
+      val eventCtor =
+        eventClz.getConstructor(
+          Int::class.javaPrimitiveType,
+          Int::class.javaPrimitiveType,
+          dataClz,
+        )
+      val event = eventCtor.newInstance(surfaceId, propagationId, data) as Event<*>
+
+      UIManagerHelper.getEventDispatcherForReactTag(reactContext, propagationId)
+        ?.dispatchEvent(event)
+      Log.d(
+        TAG,
+        "dispatchSyntheticKbcSelectionEvent: propagationId=$propagationId target=$targetId endY(dp)=$endY",
+      )
+    } catch (e: Exception) {
+      Log.w(TAG, "dispatchSyntheticKbcSelectionEvent: ${e.javaClass.simpleName}: ${e.message}")
+    }
+  }
 
-      // 4. Set lastFocusedInput = focusProxy (private var)
+  /**
+   * Pushes ControlledInput state into KBC without stealing Compose focus:
+   * viewTagFocused, lastFocusedInput, FocusedInputHolder, syncUpLayout, synthetic selection.
+   */
+  private fun syncKeyboardControllerFocusedInput() {
+    Log.d(TAG, "syncKeyboardControllerFocusedInput: id=$id")
+    kbcLayoutHost.id = id
+    viewModel.inputStyle.value?.fontSize?.toFloat()?.let {
+      kbcLayoutHost.setTextSize(TypedValue.COMPLEX_UNIT_SP, it)
+    }
+
+    val (callback, observer) = resolveKbcCallbackAndObserver() ?: return
+
+    setKbcViewTagFocused(callback)
+    setKbcFocusedInputHolder()
+
+    try {
       val lastFocusedField = observer.javaClass.getDeclaredField("lastFocusedInput")
       lastFocusedField.isAccessible = true
-      lastFocusedField.set(observer, focusProxy)
-      Log.d(TAG, "restoreKbcTracking: lastFocusedInput set to focusProxy")
+      lastFocusedField.set(observer, kbcLayoutHost)
 
-      // 5. Call syncUpLayout() — public fun, dispatches FocusedInputLayoutChangedEvent to JS
       val syncMethod = observer.javaClass.getDeclaredMethod("syncUpLayout")
       syncMethod.isAccessible = true
       syncMethod.invoke(observer)
-      Log.d(TAG, "restoreKbcTracking: ✅ syncUpLayout() invoked — KBC layout event sent to JS")
+      Log.d(TAG, "syncKeyboardControllerFocusedInput: syncUpLayout() ok")
+
+      dispatchSyntheticKbcSelectionEvent(observer)
     } catch (e: Exception) {
-      Log.w(TAG, "restoreKbcTracking: ❌ ${e.javaClass.simpleName}: ${e.message}")
+      Log.w(TAG, "syncKeyboardControllerFocusedInput: ${e.javaClass.simpleName}: ${e.message}")
     }
   }
 
@@ -244,19 +252,15 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
 
   override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
     super.onLayout(changed, l, t, r, b)
-    // Force proxy bounds to match ControlledInputView so keyboard-controller reads
-    // the correct width/height/absolutePosition when the proxy is focused.
-    focusProxy.layout(0, 0, width, height)
+    kbcLayoutHost.layout(0, 0, width, height)
     if (changed) {
       val loc = IntArray(2)
       getLocationOnScreen(loc)
       Log.d(TAG, "onLayout: view=${width}x${height} screenX=${loc[0]} screenY=${loc[1]}")
-      Log.d(TAG, "onLayout: proxy=${focusProxy.width}x${focusProxy.height} (should match view)")
     }
   }
 
   override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
-    // Do not measure ComposeView until attached to a window.
     if (shouldUseAndroidLayout && !isAttachedToWindow) {
       setMeasuredDimension(
         MeasureSpec.getSize(widthMeasureSpec).coerceAtLeast(0),
@@ -267,7 +271,6 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
     super.onMeasure(widthMeasureSpec, heightMeasureSpec)
   }
 
-  // Fabric/Yoga often won't drive Android layout for native children.
   override fun requestLayout() {
     super.requestLayout()
     if (shouldUseAndroidLayout) {
@@ -287,14 +290,11 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
     Log.d(TAG, "onAttachedToWindow: id=$id")
-    viewTreeObserver.addOnGlobalFocusChangeListener(proxyFocusLostListener)
     bindComposeToWindowLifecycle()
   }
 
   override fun onDetachedFromWindow() {
     Log.d(TAG, "onDetachedFromWindow: id=$id")
-    viewTreeObserver.removeOnGlobalFocusChangeListener(proxyFocusLostListener)
-    isRestoringComposeFocus = false
     if (usesLocalFallbackLifecycle) {
       lifecycleRegistry.currentState = Lifecycle.State.CREATED
     }
@@ -340,12 +340,10 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
 
   fun blur() {
     Log.d(TAG, "blur() called from JS ref")
-    isRestoringComposeFocus = false
     blurSignal.value = blurSignal.value + 1
     val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
     imm.hideSoftInputFromWindow(windowToken, 0)
     clearFocus()
-    clearFocusProxy()
   }
 
   fun focus() {
@@ -365,7 +363,7 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
 
     viewModel = JetpackComposeViewModel()
 
-    addView(focusProxy)
+    addView(kbcLayoutHost)
 
     composeView = ComposeView(context).also { cv ->
       cv.layoutParams = LayoutParams(
@@ -417,47 +415,21 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
               )
           },
           onFocus = {
-            Log.d(TAG, "━━ Compose onFocus ━━ id=$id isRestoring=$isRestoringComposeFocus")
-            if (isRestoringComposeFocus) {
-              // Second onFocus triggered by focusRequester.requestFocus() inside the restoration
-              // dance — KBC is being synced via reflection, keyboard is showing.
-              // Do NOT dispatch FocusEvent again (already sent on first onFocus).
-              // Do NOT call requestFocusProxy() again (would cause infinite loop).
-              Log.d(TAG, "  → restoration onFocus: clearing flag, skipping proxy request")
-              isRestoringComposeFocus = false
-            } else {
-              val surfaceId = UIManagerHelper.getSurfaceId(context)
-              val viewId = this@ControlledInputView.id
-              UIManagerHelper
-                .getEventDispatcherForReactTag(context as ReactContext, viewId)
-                ?.dispatchEvent(FocusEvent(surfaceId, viewId))
-              requestFocusProxy()
-            }
+            Log.d(TAG, "Compose onFocus id=$id")
+            val surfaceId = UIManagerHelper.getSurfaceId(context)
+            val viewId = this@ControlledInputView.id
+            UIManagerHelper
+              .getEventDispatcherForReactTag(context as ReactContext, viewId)
+              ?.dispatchEvent(FocusEvent(surfaceId, viewId))
+            post { syncKeyboardControllerFocusedInput() }
           },
           onBlur = {
-            Log.d(TAG, "━━ Compose onBlur ━━ id=$id proxyFocused=${focusProxy.isFocused}")
-            if (focusProxy.isFocused) {
-              // Proxy stole Android focus from AndroidComposeView → this blur is synthetic.
-              // Restore Compose focus so the keyboard stays/re-appears.
-              // Do NOT dispatch BlurEvent to JS.
-              Log.d(TAG, "  → proxy-caused blur: restoring Compose focus")
-              post {
-                // Give AndroidComposeView Android focus back (needed for showSoftInput to work)
-                composeView.requestFocus()
-                // Trigger BasicTextField to re-gain Compose focus → shows keyboard → fires onFocus
-                focusSignal.value = focusSignal.value + 1
-              }
-            } else {
-              // Real blur (user dismissed keyboard / tapped elsewhere)
-              Log.d(TAG, "  → real blur: dispatching BlurEvent")
-              isRestoringComposeFocus = false
-              val surfaceId = UIManagerHelper.getSurfaceId(context)
-              val viewId = this@ControlledInputView.id
-              UIManagerHelper
-                .getEventDispatcherForReactTag(context as ReactContext, viewId)
-                ?.dispatchEvent(BlurEvent(surfaceId, viewId))
-              clearFocusProxy()
-            }
+            Log.d(TAG, "Compose onBlur id=$id")
+            val surfaceId = UIManagerHelper.getSurfaceId(context)
+            val viewId = this@ControlledInputView.id
+            UIManagerHelper
+              .getEventDispatcherForReactTag(context as ReactContext, viewId)
+              ?.dispatchEvent(BlurEvent(surfaceId, viewId))
           },
           focusRequester = focusRequester
         )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-controlled-input",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "React Native controlled TextInput with strict value sync (Fabric)",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",