react-native-controlled-input 0.17.0 → 0.19.0

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

@@ -2,8 +2,10 @@ package com.controlledinput
 
 import android.content.Context
 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
@@ -25,6 +27,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
 
 /**
@@ -35,6 +38,9 @@ import kotlinx.coroutines.flow.MutableStateFlow
  * @see expo.modules.kotlin.views.ExpoView
  */
 class ControlledInputView : LinearLayout, LifecycleOwner {
+  companion object {
+    private const val TAG = "ControlledInputView"
+  }
   constructor(context: Context) : super(context) {
     configureComponent(context)
   }
@@ -61,6 +67,13 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   private var usesLocalFallbackLifecycle = false
   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.
+   */
+  private var isRestoringComposeFocus = false
+
   /**
    * Invisible EditText that acts as a focus proxy for react-native-keyboard-controller.
    *
@@ -75,7 +88,9 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   private val focusProxy: EditText by lazy {
     EditText(context).also { proxy ->
       proxy.layoutParams = LayoutParams(0, 0)
-      proxy.visibility = View.INVISIBLE
+      // 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
@@ -85,21 +100,210 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   }
 
   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.
-    viewModel.inputStyle.value?.fontSize?.toFloat()?.let { fontSize ->
-      focusProxy.setTextSize(TypedValue.COMPLEX_UNIT_SP, fontSize)
+    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)")
+    }
+
     // 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() }
+      }
+    }
+
+  /**
+   * EdgeToEdgeViewRegistry.get() → callback → FocusedInputObserver.
+   * Null if react-native-keyboard-controller is missing or not initialized.
+   */
+  private fun resolveKbcFocusedInputObserver(): Any? {
+    try {
+      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, "resolveKbcFocusedInputObserver: EdgeToEdgeViewRegistry.get() == null")
+            return null
+          }
+
+      val callbackField =
+        edgeToEdgeView.javaClass.declaredFields.firstOrNull {
+          it.type.simpleName == "KeyboardAnimationCallback"
+        }
+          ?: run {
+            Log.w(TAG, "resolveKbcFocusedInputObserver: KeyboardAnimationCallback field not found")
+            return null
+          }
+      callbackField.isAccessible = true
+      val callback =
+        callbackField.get(edgeToEdgeView)
+          ?: run {
+            Log.w(TAG, "resolveKbcFocusedInputObserver: callback == null")
+            return null
+          }
+
+      val observerField =
+        callback.javaClass.declaredFields.firstOrNull {
+          it.type.simpleName == "FocusedInputObserver"
+        }
+          ?: run {
+            Log.w(TAG, "resolveKbcFocusedInputObserver: FocusedInputObserver field not found")
+            return null
+          }
+      observerField.isAccessible = true
+      return observerField.get(callback)
+        ?: run {
+          Log.w(TAG, "resolveKbcFocusedInputObserver: layoutObserver == null")
+          null
+        }
+    } catch (_: ClassNotFoundException) {
+      Log.d(TAG, "resolveKbcFocusedInputObserver: keyboard-controller not on classpath")
+      return null
+    } catch (e: Exception) {
+      Log.w(TAG, "resolveKbcFocusedInputObserver: ${e.javaClass.simpleName}: ${e.message}")
+      return null
+    }
+  }
+
+  /** Approximate one line height in dp for JS customHeight when proxy has no Layout yet. */
+  private fun approximateSelectionEndYDp(): Double {
+    viewModel.inputStyle.value?.fontSize?.toDouble()?.takeIf { it > 0 }?.let { return it }
+    val dm = resources.displayMetrics
+    return (focusProxy.textSize / dm.density).toDouble().coerceAtLeast(12.0)
+  }
+
+  /**
+   * Synthetic topFocusedInputSelectionChanged without a compile dependency on KBC.
+   * Helps older KeyboardAwareScrollView when proxy never gets android.text.Layout in time.
+   */
+  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}")
+    }
+  }
+
+  /**
+   * Reflection: lastFocusedInput = focusProxy, syncUpLayout(), then synthetic selection
+   * so JS gets customHeight (selection.end.y) without waiting for KeyboardControllerSelectionWatcher.
+   */
+  private fun restoreKbcTracking() {
+    Log.d(TAG, "restoreKbcTracking: starting reflection chain")
+    try {
+      val observer = resolveKbcFocusedInputObserver() ?: return
+
+      val lastFocusedField = observer.javaClass.getDeclaredField("lastFocusedInput")
+      lastFocusedField.isAccessible = true
+      lastFocusedField.set(observer, focusProxy)
+      Log.d(TAG, "restoreKbcTracking: lastFocusedInput set to focusProxy")
+
+      val syncMethod = observer.javaClass.getDeclaredMethod("syncUpLayout")
+      syncMethod.isAccessible = true
+      syncMethod.invoke(observer)
+      Log.d(TAG, "restoreKbcTracking: syncUpLayout() invoked")
+
+      dispatchSyntheticKbcSelectionEvent(observer)
+    } catch (e: Exception) {
+      Log.w(TAG, "restoreKbcTracking: ${e.javaClass.simpleName}: ${e.message}")
+    }
   }
 
   private val shouldUseAndroidLayout = true
@@ -109,6 +313,12 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
     // 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)
+    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) {
@@ -142,10 +352,15 @@ 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
     }
@@ -190,6 +405,8 @@ 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)
@@ -198,6 +415,7 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
   }
 
   fun focus() {
+    Log.d(TAG, "focus() called from JS ref")
     focusSignal.value = focusSignal.value + 1
   }
 
@@ -265,30 +483,47 @@ class ControlledInputView : LinearLayout, LifecycleOwner {
               )
           },
           onFocus = {
-            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 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()
+            }
           },
           onBlur = {
-            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 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()
+            }
           },
           focusRequester = focusRequester
         )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-controlled-input",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "React Native controlled TextInput with strict value sync (Fabric)",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -82,6 +82,7 @@
     "react": "19.2.0",
     "react-native": "0.83.0",
     "react-native-builder-bob": "^0.40.17",
+    "react-native-worklets": "0.8.1",
     "release-it": "^19.0.4",
     "turbo": "^2.5.6",
     "typescript": "^5.7.3",
@@ -94,6 +95,9 @@
   "workspaces": [
     "example"
   ],
+  "overrides": {
+    "react-native-worklets": "0.8.1"
+  },
   "react-native-builder-bob": {
     "source": "src",
     "output": "lib",
@@ -142,7 +146,10 @@
     "git": {
       "commitMessage": "chore: release ${version}",
       "tagName": "v${version}",
-      "requireBranch": ["main", "test-keboard--controller"]
+      "requireBranch": [
+        "main",
+        "test-keboard--controller"
+      ]
     },
     "npm": {
       "publish": true,