t3dotgg · Oct 3, 2026 · Oct 3, 2026 · Oct 3, 2026 · Oct 3, 2026 · Oct 19, 2026
diff --git a/...oser-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorModule.kt b/...oser-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorModule.kt
@@ -62,6 +62,7 @@ internal object T3ComposerClipboard {
 }
 
 class T3ComposerEditorModule : Module() {
+  @Suppress("LongMethod")
   override fun definition() = ModuleDefinition {
     Name("T3ComposerEditor")
 
@@ -104,6 +105,12 @@ class T3ComposerEditorModule : Module() {
       Prop("readOnly") { view: T3ComposerEditorView, readOnly: Boolean ->
         view.setReadOnly(readOnly)
       }
+      Prop("enterBehavior") { view: T3ComposerEditorView, behavior: String ->
+        view.setEnterBehavior(behavior)
+      }
+      Prop("submitEnabled") { view: T3ComposerEditorView, enabled: Boolean ->
+        view.setSubmitEnabled(enabled)
+      }
       Prop("scrollEnabled") { view: T3ComposerEditorView, scrollEnabled: Boolean ->
         view.setScrollEnabled(scrollEnabled)
       }
@@ -128,6 +135,7 @@ class T3ComposerEditorModule : Module() {
         "onComposerSelectionChange",
         "onComposerFocus",
         "onComposerBlur",
+        "onComposerSubmit",
         "onComposerPasteImages",
         "onComposerContextPress",
         "onComposerPasteContext",

diff --git a/...mposer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt b/...mposer-editor/android/src/main/java/expo/modules/t3composereditor/T3ComposerEditorView.kt
@@ -18,9 +18,12 @@ import android.text.style.ReplacementSpan
 import android.util.TypedValue
 import android.view.Gravity
 import android.view.GestureDetector
+import android.view.InputDevice
+import android.view.KeyCharacterMap
 import android.view.MotionEvent
 import android.view.KeyEvent
 import android.view.ViewGroup
+import android.view.inputmethod.BaseInputConnection
 import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputConnectionWrapper
@@ -49,6 +52,7 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(
   private val onComposerSelectionChange by EventDispatcher()
   private val onComposerFocus by EventDispatcher()
   private val onComposerBlur by EventDispatcher()
+  private val onComposerSubmit by EventDispatcher()
   private val onComposerPasteImages by EventDispatcher()
   private val onComposerContextPress by EventDispatcher()
   private val onComposerPasteContext by EventDispatcher()
@@ -145,6 +149,9 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(
         ),
       )
     }
+    editor.submitListener = { alternate ->
+      onComposerSubmit(mapOf("alternate" to alternate))
+    }
     editor.setOnFocusChangeListener { _, hasFocus ->
       if (hasFocus) {
         onComposerFocus(emptyMap<String, Any>())
@@ -312,6 +319,14 @@ class T3ComposerEditorView(context: Context, appContext: AppContext) : ExpoView(
     editor.isCursorVisible = editor.isEnabled && !readOnly
   }
 
+  fun setEnterBehavior(behavior: String) {
+    editor.returnSends = behavior != "newline"
+  }
+
+  fun setSubmitEnabled(enabled: Boolean) {
+    editor.submitEnabled = enabled
+  }
+
   fun setScrollEnabled(scrollEnabled: Boolean) {
     editor.isVerticalScrollBarEnabled = scrollEnabled
   }
@@ -588,9 +603,13 @@ internal class SelectionAwareEditText(context: Context) : EditText(context) {
   var pasteImagesListener: ((List<String>) -> Unit)? = null
   var pasteContextListener: ((Map<String, String>) -> Unit)? = null
   var pasteTextListener: ((String, Int, Int) -> Unit)? = null
+
+  var submitListener: ((Boolean) -> Unit)? = null
   var textPasteThresholdBytes = 0
   var maxInputChars = Int.MAX_VALUE
   var clipboardFragment = ""
+  var returnSends = true
+  var submitEnabled = false
 
   /**
    * Placeholder shown while the draft is empty. An editable TextView never ellipsizes its hint,
@@ -644,7 +663,33 @@ internal class SelectionAwareEditText(context: Context) : EditText(context) {
     return spans.isNotEmpty()
   }
 
+  // Match iPad submission chords with Ctrl in place of Command; null leaves normal editing.
+  private fun submitChord(keyCode: Int, event: KeyEvent): Boolean? {
+    val isReturn = keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER
+    val fromSoftKeyboard =
+      event.deviceId == KeyCharacterMap.VIRTUAL_KEYBOARD ||
+        (event.flags and KeyEvent.FLAG_SOFT_KEYBOARD) != 0
+    val canSubmit = isEnabled && !readOnly && submitEnabled && submitListener != null
+    val composing = BaseInputConnection.getComposingSpanStart(text) >= 0
+    if (!isReturn || fromSoftKeyboard || !canSubmit || composing) {
+      return null
+    }
+    return when {
+      event.hasNoModifiers() -> if (returnSends) false else null
+      event.hasModifiers(KeyEvent.META_CTRL_ON) -> returnSends
+      event.hasModifiers(KeyEvent.META_CTRL_ON or KeyEvent.META_SHIFT_ON) ->
+        if (returnSends) null else true
+      else -> null
+    }
+  }
-  private fun submitChord(keyCode: Int, event: KeyEvent): Boolean? {
-    val isReturn = keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER
-    val fromSoftKeyboard =
-      event.deviceId == KeyCharacterMap.VIRTUAL_KEYBOARD ||
-        (event.flags and KeyEvent.FLAG_SOFT_KEYBOARD) != 0
-    val canSubmit = isEnabled && !readOnly && submitEnabled && submitListener != null
-    val composing = BaseInputConnection.getComposingSpanStart(text) >= 0
-    if (!isReturn || fromSoftKeyboard || !canSubmit || composing) {
-      return null
-    }
-    return when {
-      event.hasNoModifiers() -> if (returnSends) false else null
-      event.hasModifiers(KeyEvent.META_CTRL_ON) -> returnSends
-      event.hasModifiers(KeyEvent.META_CTRL_ON or KeyEvent.META_SHIFT_ON) ->
-        if (returnSends) null else true
-      else -> null
-    }
-  }
+  private fun isHardwareReturn(keyCode: Int, event: KeyEvent): Boolean {
+    val isReturn = keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER
+    val fromSoftKeyboard =
+      event.deviceId == KeyCharacterMap.VIRTUAL_KEYBOARD ||
+        (event.flags and KeyEvent.FLAG_SOFT_KEYBOARD) != 0
+    return isReturn && !fromSoftKeyboard
+  }
+
+  private fun canSubmit(): Boolean {
+    if (!isEnabled) return false
+    if (readOnly) return false
+    if (!submitEnabled) return false
+    if (submitListener == null) return false
+    return BaseInputConnection.getComposingSpanStart(text) < 0
+  }
+
+  private fun chordAlternate(event: KeyEvent): Boolean? = when {
+    event.hasNoModifiers() -> if (returnSends) false else null
+    event.hasModifiers(KeyEvent.META_CTRL_ON) -> returnSends
+    event.hasModifiers(KeyEvent.META_CTRL_ON or KeyEvent.META_SHIFT_ON) ->
+      if (returnSends) null else true
+    else -> null
+  }
+
+  private fun submitChord(keyCode: Int, event: KeyEvent): Boolean? =
+    if (isHardwareReturn(keyCode, event) && canSubmit()) chordAlternate(event) else null
-  private fun submitChord(keyCode: Int, event: KeyEvent): Boolean? {
-    val isReturn = keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER
-    val fromSoftKeyboard =
-      event.deviceId == KeyCharacterMap.VIRTUAL_KEYBOARD ||
-        (event.flags and KeyEvent.FLAG_SOFT_KEYBOARD) != 0
-    val canSubmit = isEnabled && !readOnly && submitEnabled && submitListener != null
-    val composing = BaseInputConnection.getComposingSpanStart(text) >= 0
-    if (!isReturn || fromSoftKeyboard || !canSubmit || composing) {
-      return null
-    }
-    return when {
-      event.hasNoModifiers() -> if (returnSends) false else null
-      event.hasModifiers(KeyEvent.META_CTRL_ON) -> returnSends
-      event.hasModifiers(KeyEvent.META_CTRL_ON or KeyEvent.META_SHIFT_ON) ->
-        if (returnSends) null else true
-      else -> null
-    }
-  }
+  private fun isHardwareReturn(keyCode: Int, event: KeyEvent): Boolean {
+    val isReturn = keyCode == KeyEvent.KEYCODE_ENTER || keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER
+    val fromSoftKeyboard =
+      event.deviceId == KeyCharacterMap.VIRTUAL_KEYBOARD ||
+        (event.flags and KeyEvent.FLAG_SOFT_KEYBOARD) != 0
+    return isReturn && !fromSoftKeyboard
+  }
+
+  private fun canSubmit(): Boolean {
+    if (!isEnabled) return false
+    if (readOnly) return false
+    if (!submitEnabled) return false
+    if (submitListener == null) return false
+    return BaseInputConnection.getComposingSpanStart(text) < 0
+  }
+
+  private fun chordAlternate(event: KeyEvent): Boolean? = when {
+    event.hasNoModifiers() -> if (returnSends) false else null
+    event.hasModifiers(KeyEvent.META_CTRL_ON) -> returnSends
+    event.hasModifiers(KeyEvent.META_CTRL_ON or KeyEvent.META_SHIFT_ON) ->
+      if (returnSends) null else true
+    else -> null
+  }
+
+  private fun submitChord(keyCode: Int, event: KeyEvent): Boolean? =
+    if (isHardwareReturn(keyCode, event) && canSubmit()) chordAlternate(event) else null
+
   override fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
+    val alternate = submitChord(keyCode, event)
+    if (alternate != null) {
+      // A held Return repeats. Send once, and drop the repeats instead of typing newlines.
+      if (event.repeatCount == 0) submitListener?.invoke(alternate)
+      return true
+    }
     val handled = when (keyCode) {
       KeyEvent.KEYCODE_DEL -> deleteChip(true)
       KeyEvent.KEYCODE_FORWARD_DEL -> deleteChip(false)
@@ -662,6 +707,23 @@ internal class SelectionAwareEditText(context: Context) : EditText(context) {
   override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection? {
     val connection = super.onCreateInputConnection(outAttrs) ?: return null
     return object : InputConnectionWrapper(connection, false) {
+      // IMEs can also forward physical keys with their original device ID.
+      override fun sendKeyEvent(event: KeyEvent): Boolean {
+        val device = InputDevice.getDevice(event.deviceId)
+        val fromHardwareKeyboard = device != null && !device.isVirtual &&
+          device.keyboardType == InputDevice.KEYBOARD_TYPE_ALPHABETIC
+        return super.sendKeyEvent(
+          if (fromHardwareKeyboard) {
+            event
+          } else {
+            KeyEvent.changeFlags(
+              event,
+              event.flags or KeyEvent.FLAG_SOFT_KEYBOARD
+            )
+          }
+        )
+      }
+
       override fun deleteSurroundingText(
         beforeLength: Int,
         afterLength: Int