Improve TalkBack and screen reader accessibility

Add comprehensive accessibility support for Android screen readers
(TalkBack) to improve terminal and Extra Keys navigation for users
with visual impairments.

Terminal view accessibility:
- Add TerminalAccessibilityHelper using ExploreByTouchHelper to expose
  terminal lines as individual accessible items
- Implement line-by-line navigation with automatic hard-wrapped line
  merging for continuous paragraph reading
- Add text sanitization to remove terminal control characters and
  backslash continuation markers from announcements
- Improve accessibility focus tracking during scrolling and text updates
- Suppress redundant status bar announcements during navigation
- Differentiate between jitter events and intentional scrolling

Extra Keys accessibility:
- Add content descriptions to all Extra Keys buttons (e.g., "Up",
  "Backspace", "Control") for better screen reader announcements
- Support navigation keys (arrows, Home, End, Page Up/Down)
- Support modifier keys (Ctrl, Alt, Function)
- Support special keys (Drawer, Keyboard, Scroll, Paste)

This implementation allows screen reader users to:
- Navigate terminal output line-by-line using swipe gestures
- Read hard-wrapped lines as continuous paragraphs
- Access all Extra Keys buttons with proper labels
- Use the terminal effectively without visual feedback

Author: devinprater

app/src/main/java/com/termux/app/terminal/TermuxTerminalViewClient.java

@@ -13,6 +13,7 @@
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
+import android.view.accessibility.AccessibilityManager;
 import android.widget.EditText;
 import android.widget.ListView;
 import android.widget.Toast;
@@ -60,7 +61,7 @@ public class TermuxTerminalViewClient extends TermuxTerminalViewClientBase {
     final TermuxTerminalSessionActivityClient mTermuxTerminalSessionActivityClient;
 
     /** Keeping track of the special keys acting as Ctrl and Fn for the soft keyboard and other hardware keys. */
-    boolean mVirtualControlKeyDown, mVirtualFnKeyDown;
+    boolean mVirtualControlActive, mVirtualFnActive;
 
     private Runnable mShowSoftKeyboardRunnable;
 
@@ -309,20 +310,40 @@ private boolean handleVirtualKeys(int keyCode, KeyEvent event, boolean down) {
             // Do not steal dedicated buttons from a full external keyboard.
             return false;
         } else if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN) {
-            mVirtualControlKeyDown = down;
+            if (down) {
+                mVirtualControlActive = !mVirtualControlActive;
+                announceAssertively(mVirtualControlActive ? "Control On" : "Control Off");
+            }
             return true;
         } else if (keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
-            mVirtualFnKeyDown = down;
+            if (down) {
+                mVirtualFnActive = !mVirtualFnActive;
+                announceAssertively(mVirtualFnActive ? "Fn On" : "Fn Off");
+            }
             return true;
         }
         return false;
     }
 
+    private void announceAssertively(String text) {
+        AccessibilityManager am = (AccessibilityManager) mActivity.getSystemService(Context.ACCESSIBILITY_SERVICE);
+        if (am != null && am.isEnabled()) {
+            am.interrupt();
+        }
+        mActivity.getTerminalView().announceForAccessibility(text);
+    }
+
 
 
     @Override
     public boolean readControlKey() {
-        return readExtraKeysSpecialButton(SpecialButton.CTRL) || mVirtualControlKeyDown;
+        if (readExtraKeysSpecialButton(SpecialButton.CTRL)) return true;
+        if (mVirtualControlActive) {
+            mVirtualControlActive = false;
+            announceAssertively("Control Off");
+            return true;
+        }
+        return false;
     }
 
     @Override
@@ -337,7 +358,13 @@ public boolean readShiftKey() {
 
     @Override
     public boolean readFnKey() {
-        return readExtraKeysSpecialButton(SpecialButton.FN);
+        if (readExtraKeysSpecialButton(SpecialButton.FN)) return true;
+        if (mVirtualFnActive) {
+            mVirtualFnActive = false;
+            announceAssertively("Fn Off");
+            return true;
+        }
+        return false;
     }
 
     public boolean readExtraKeysSpecialButton(SpecialButton specialButton) {
@@ -359,7 +386,10 @@ public boolean onLongPress(MotionEvent event) {
 
     @Override
     public boolean onCodePoint(final int codePoint, boolean ctrlDown, TerminalSession session) {
-        if (mVirtualFnKeyDown) {
+        if (mVirtualFnActive) {
+            mVirtualFnActive = false;
+            announceAssertively("Fn Off");
+            
             int resultingKeyCode = -1;
             int resultingCodePoint = -1;
             boolean altDown = false;
@@ -448,7 +478,7 @@ public boolean onCodePoint(final int codePoint, boolean ctrlDown, TerminalSessio
                 case 'q':
                 case 'k':
                     mActivity.toggleTerminalToolbar();
-                    mVirtualFnKeyDown=false; // force disable fn key down to restore keyboard input into terminal view, fixes termux/termux-app#1420
+                    // mVirtualFnActive=false; // Keep Manual Toggle
                     break;
             }
 

terminal-view/build.gradle

@@ -6,6 +6,8 @@ android {
 
     dependencies {
         implementation "androidx.annotation:annotation:1.3.0"
+        implementation "androidx.core:core:1.6.0"
+        implementation "androidx.customview:customview:1.1.0"
         api project(":terminal-emulator")
     }
 

terminal-view/src/main/java/com/termux/view/TerminalAccessibilityHelper.java

@@ -0,0 +1,125 @@
+package com.termux.view;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.os.Bundle;
+import android.os.SystemClock;
+import android.view.InputDevice;
+import android.view.MotionEvent;
+import android.view.inputmethod.InputMethodManager;
+
+import androidx.annotation.NonNull;
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat;
+import androidx.customview.widget.ExploreByTouchHelper;
+
+import com.termux.terminal.TerminalEmulator;
+
+import java.util.List;
+
+public class TerminalAccessibilityHelper extends ExploreByTouchHelper {
+    private final TerminalView mView;
+
+    public TerminalAccessibilityHelper(@NonNull TerminalView view) {
+        super(view);
+        mView = view;
+    }
+
+    @Override
+    protected int getVirtualViewAt(float x, float y) {
+        if (mView.mEmulator == null || mView.mRenderer == null) return HOST_ID;
+        int row = (int) (y / mView.mRenderer.getFontLineSpacing());
+        if (row >= 0 && row < mView.mEmulator.mRows) {
+            // Find the start of the logical block (paragraph) this row belongs to
+            int startRow = row;
+            while (startRow > 0 && mView.mEmulator.getScreen().getLineWrap(mView.mTopRow + startRow - 1)) {
+                startRow--;
+            }
+            return startRow;
+        }
+        return HOST_ID;
+    }
+
+    @Override
+    protected void getVisibleVirtualViews(List<Integer> virtualViewIds) {
+        if (mView.mEmulator == null) return;
+        for (int i = 0; i < mView.mEmulator.mRows; ) {
+            virtualViewIds.add(i);
+            int current = i;
+            while (current < mView.mEmulator.mRows - 1 && 
+                   mView.mEmulator.getScreen().getLineWrap(mView.mTopRow + current)) {
+                current++;
+            }
+            i = current + 1;
+        }
+    }
+
+    @Override
+    protected void onPopulateNodeForVirtualView(int virtualViewId, @NonNull AccessibilityNodeInfoCompat node) {
+        if (mView.mEmulator == null || mView.mRenderer == null) {
+            node.setText("");
+            node.setBoundsInParent(new Rect(0, 0, 1, 1));
+            return;
+        }
+
+        int startRow = virtualViewId;
+        int endRow = startRow;
+        while (endRow < mView.mEmulator.mRows - 1 && 
+               mView.mEmulator.getScreen().getLineWrap(mView.mTopRow + endRow)) {
+            endRow++;
+        }
+
+        // Get text for the logical block
+        int externalStartRow = mView.mTopRow + startRow;
+        int externalEndRow = mView.mTopRow + endRow;
+        
+        // getSelectedText(..., Y2) is inclusive in TerminalBuffer
+        String text = mView.mEmulator.getScreen().getSelectedText(0, externalStartRow, mView.mEmulator.mColumns, externalEndRow, true, false).trim();
+        if (text.isEmpty()) text = "Blank";
+
+        node.setText(text);
+        node.setContentDescription(text);
+        
+        // Bounds: from top of startRow to bottom of endRow
+        int top = startRow * mView.mRenderer.getFontLineSpacing();
+        int bottom = (endRow + 1) * mView.mRenderer.getFontLineSpacing();
+        int width = mView.getWidth();
+        node.setBoundsInParent(new Rect(0, top, width, bottom));
+        
+        node.addAction(AccessibilityNodeInfoCompat.ACTION_CLICK);
+    }
+
+    @Override
+    protected boolean onPerformActionForVirtualView(int virtualViewId, int action, Bundle arguments) {
+        if (action == AccessibilityNodeInfoCompat.ACTION_CLICK) {
+            // 1. Request Focus & Show Keyboard
+            mView.requestFocus();
+            InputMethodManager imm = (InputMethodManager) mView.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+            if (imm != null) {
+                imm.showSoftInput(mView, 0);
+            }
+
+            // 2. Simulate Mouse Click to move cursor (if supported by app like Emacs)
+            // We aim for the start of the line (x=5 pixels buffer) vertically centered in the row
+            // Check if mouse tracking is active to avoid sending escape codes to shells that don't support it.
+            if (mView.mEmulator.isMouseTrackingActive()) {
+                int row = virtualViewId; 
+                float y = (row + 0.5f) * mView.mRenderer.getFontLineSpacing();
+                float x = 5.0f; 
+                
+                long downTime = SystemClock.uptimeMillis();
+                MotionEvent eventDown = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, x, y, 0);
+                eventDown.setSource(InputDevice.SOURCE_MOUSE);
+                mView.sendMouseEventCode(eventDown, TerminalEmulator.MOUSE_LEFT_BUTTON, true);
+                eventDown.recycle();
+                
+                MotionEvent eventUp = MotionEvent.obtain(downTime, downTime + 10, MotionEvent.ACTION_UP, x, y, 0);
+                eventUp.setSource(InputDevice.SOURCE_MOUSE);
+                mView.sendMouseEventCode(eventUp, TerminalEmulator.MOUSE_LEFT_BUTTON, false);
+                eventUp.recycle();
+            }
+
+            return true;
+        }
+        return false;
+    }
+}