Allow the soft keyboard only on fields a person taps

Every field keeps inputmode="none" and the forced hide. A finger tap
(pointerdown, also through its label) gives that field the site's own
inputmode back before Chromium focuses it, so numeric fields get a numeric
keypad; it is suppressed again on blur or a cancelled tap, so scans and
programmatic focus never open the keyboard. Native code checks the focused
field before hiding the keyboard.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CLAUDE.md

@@ -6,23 +6,30 @@ Native Android app (Kotlin) that wraps `https://smart.joykoo.mx/` in a fullscree
 
 ## Critical Design Decision
 
-The Android soft keyboard must NEVER appear. Keyboard suppression uses multiple layers — do not remove any of them:
+The Android soft keyboard must NEVER appear for scanner fields. The only exception is a field a person taps with a finger (see Keyboard Policy below). Keyboard suppression uses multiple layers — do not remove any of them:
 
 1. `NoSoftKeyboardWebView.onCheckIsTextEditor()` → `false`
 2. `EditorInfo` flags `IME_FLAG_NO_EXTRACT_UI | IME_FLAG_NO_FULLSCREEN` in `onCreateInputConnection()`
-3. `InputMethodManager.hideSoftInputFromWindow()` posted after each InputConnection request and on page load / window focus
-4. JavaScript injection setting `inputmode="none"` on all `<input>`, `<textarea>`, and `contenteditable` elements via `MutationObserver`
+3. `InputMethodManager.hideSoftInputFromWindow()` posted after each InputConnection request and on page load / window focus — skipped only when the focused field carries `data-jk-kb="1"`
+4. JavaScript injection (`KeyboardPolicy`) setting `inputmode="none"` on every `<input>`, `<textarea>`, and `contenteditable` via `MutationObserver`, except the field currently tapped
 5. Manifest `windowSoftInputMode="stateAlwaysHidden|adjustNothing"`
 
 The real `InputConnection` from `super.onCreateInputConnection()` **must be returned** — returning `null` breaks hardware key input from the barcode scanner on devices like the Urovo CT58C.
 
+## Keyboard Policy
+
+`KeyboardPolicy.kt`: every field is suppressed (`inputmode="none"`) until a finger taps it. On `pointerdown` (also via its `<label>`) the field gets the site's own `inputmode` back — numeric fields get a numeric keypad — and `data-jk-kb="1"`, before Chromium focuses it. On focus loss, or a tap that never focuses it (scroll / `pointercancel`), it is suppressed again, so programmatic focus (scans, the site's own `.focus()`) never shows the keyboard. A field whose own `inputmode` is `none` stays suppressed even when tapped.
+
+The site reads scans with a page-wide `keydown` listener (bursts ≤ 60 ms apart), so scanning does not need a focused field. The admin "Mostrar teclado" toggle still turns all suppression off.
+
 ## Project Structure
 
 ```
 app/src/main/java/mx/joykoo/scanner/
   AppConfig.kt              — URL, allowed hosts, admin triggers, scanner broadcasts (single config point)
   MainActivity.kt           — Fullscreen kiosk activity, WebView setup, navigation, lifecycle
-  NoSoftKeyboardWebView.kt  — IME suppression via null InputConnection
+  NoSoftKeyboardWebView.kt  — IME suppression layers 1–3 (real InputConnection is returned)
+  KeyboardPolicy.kt         — Injected rule: all fields inputmode="none" except the one a finger tapped
   ScannerIntegration.kt     — Scanner lifecycle interface
   BroadcastScannerIntegration.kt — Intent-output scans → JS injection (React-safe value setter)
   KioskController.kt        — Lock Task kiosk toggle (session-only until KIOSK_PERSISTED); device-owner full lockdown + HOME alias, else screen pinning
@@ -71,7 +78,6 @@ All configurable values are in `AppConfig.kt`:
 - `ADMIN_BARCODE` — scanning this value (Intent mode) opens the admin dialog
 - `KIOSK_BARCODE` — scanning this value (Intent mode) toggles kiosk lockdown
 - `RENDERER_CRASH_LIMIT` / `RENDERER_CRASH_WINDOW_MS` — WebView crash auto-recovery limit
-- `FILE_OPEN_FALLBACK_APPS` — app launched by a download's "Abrir" when nothing opens that file type (also add it to `<queries>` in the manifest)
 
 ## Navigation Rules
 
@@ -89,7 +95,7 @@ All configurable values are in `AppConfig.kt`:
 ## Files & Permissions
 
 - Permissions are requested at first launch (camera; storage on Android ≤ 9) and again when a feature needs one.
-- Downloads: https on allowed hosts via `DownloadManager` (session cookie forwarded); `data:` decoded natively; `blob:` read in-page and returned via `evaluateJavascript` polling (no JS interface). A document-start hook keeps blobs readable if the site revokes the URL immediately, and records the `<a download="name">` file name (WebView does not pass it on; without it files save as `downloadfile.csv`). Saved to Downloads, then an "Archivo guardado" dialog offers **Abrir**: the app registered for the type, else the app in `AppConfig.FILE_OPEN_FALLBACK_APPS` (CSV → CSV Editor from F-Droid, which has no open-with support) is launched. Fallback apps must also be declared under `<queries>` in the manifest (Android 11+ package visibility).
+- Downloads: https on allowed hosts via `DownloadManager` (session cookie forwarded); `data:` decoded natively; `blob:` read in-page and returned via `evaluateJavascript` polling (no JS interface). A document-start hook keeps blobs readable if the site revokes the URL immediately. Saved to Downloads, with a toast on completion.
 - Uploads: `<input type=file>` image fields show an in-app "Tomar foto / Elegir de la galería" dialog (the system chooser hid the camera behind the gallery picker); `capture` opens the camera directly. If camera permission is denied, a dialog offers app Settings or the file picker. Photos are saved to Pictures/Joykoo.
 - In-page camera (`getUserMedia`) is granted to allowed hosts only, video only.
 

app/src/main/AndroidManifest.xml

@@ -13,12 +13,6 @@
 
     <uses-feature android:name="android.hardware.camera" android:required="false" />
 
-    <!-- Apps in AppConfig.FILE_OPEN_FALLBACK_APPS: Android 11+ hides other apps unless they
-         are declared here, so launching them would fail with ActivityNotFoundException. -->
-    <queries>
-        <package android:name="tech.brianrayburn.csv_editor" />
-    </queries>
-
     <application
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"

app/src/main/java/mx/joykoo/scanner/AppConfig.kt

@@ -60,14 +60,6 @@ object AppConfig {
         "SCAN_BARCODE1", "scannerdata", "data",
     )
 
-    /** App launched by a saved download's "Abrir" button when no installed app registers to
-     *  open that file type, keyed by extension; the user then opens the file from Descargas.
-     *  CSV Editor (F-Droid) has no "open with" support, and nothing else opens .csv here.
-     *  Each package must also be listed under <queries> in AndroidManifest.xml. */
-    val FILE_OPEN_FALLBACK_APPS = mapOf(
-        "csv" to "tech.brianrayburn.csv_editor",
-    )
-
     /** Press Enter after a broadcast scan is inserted, like the keystroke-mode suffix. */
     const val SCANNER_SEND_ENTER = true
 

app/src/main/java/mx/joykoo/scanner/FileTransfers.kt

@@ -30,7 +30,6 @@ import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.content.ContextCompat
 import org.json.JSONObject
-import org.json.JSONTokener
 import java.io.File
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -91,43 +90,21 @@ class FileTransfers(
 
     /** Wire to WebView.setDownloadListener. */
     fun onDownloadStart(url: String, userAgent: String, contentDisposition: String?, mimeType: String?) {
-        val save: (String) -> Unit = when {
-            url.startsWith("blob:") -> { name -> readBlob(url, name, mimeType) }
-            url.startsWith("data:") -> { name -> saveDataUrl(url, name) }
-            isAllowedHttps(url) -> { name -> enqueueDownload(url, userAgent, name, mimeType) }
+        val fileName = fileNameFor(url, contentDisposition, mimeType)
+        val save: () -> Unit = when {
+            url.startsWith("blob:") -> { { readBlob(url, fileName, mimeType) } }
+            url.startsWith("data:") -> { { saveDataUrl(url, fileName) } }
+            isAllowedHttps(url) -> { { enqueueDownload(url, userAgent, fileName, mimeType) } }
             else -> {
                 Log.w(TAG, "Blocked download from $url")
                 return
             }
         }
         permissions.withPermissions(Permissions.STORAGE) {
-            if (!permissions.allGranted(Permissions.STORAGE)) {
-                toast(R.string.download_permission_denied)
-                return@withPermissions
-            }
-            // WebView drops the <a download="name"> of page-made files, so ask the page
-            // (BLOB_HOOK_JS records it on click); the server's disposition is the fallback.
-            siteFileName(url) { siteName ->
-                save(siteName ?: fileNameFor(url, contentDisposition, mimeType))
+            if (permissions.allGranted(Permissions.STORAGE)) save()
+            else toast(R.string.download_permission_denied)
         }
     }
-    }
-
-    private fun siteFileName(url: String, callback: (String?) -> Unit) {
-        webView().evaluateJavascript("""
-            (function(url) {
-                var names = window.__jkDownloadNames, name = names && names[url];
-                if (names) delete names[url];
-                return name || '';
-            })(${JSONObject.quote(url)});
-        """.trimIndent()) { json ->
-            val name = (try { JSONTokener(json).nextValue() as? String } catch (_: Exception) { null })
-                ?.let(::sanitizeFileName)
-            callback(name?.takeIf { it.isNotBlank() })
-        }
-    }
-
-    private fun sanitizeFileName(name: String) = name.replace(Regex("[\\\\/:*?\"<>|]"), "_").trim()
 
     private fun enqueueDownload(url: String, userAgent: String, fileName: String, mimeType: String?) {
         try {
@@ -153,11 +130,7 @@ class FileTransfers(
             val status = c.getInt(c.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
             val title = c.getString(c.getColumnIndexOrThrow(DownloadManager.COLUMN_TITLE))
             if (status == DownloadManager.STATUS_SUCCESSFUL) {
-                showSaved(
-                    title,
-                    downloadManager.getUriForDownloadedFile(id),
-                    downloadManager.getMimeTypeForDownloadedFile(id) ?: "application/octet-stream"
-                )
+                toast(activity.getString(R.string.download_done, title))
             } else {
                 Log.e(TAG, "Download $id ended with status $status")
                 toast(R.string.download_failed)
@@ -257,67 +230,21 @@ class FileTransfers(
                 values.clear()
                 values.put(MediaStore.Downloads.IS_PENDING, 0)
                 resolver.update(uri, values, null, null)
-                // MediaStore renames duplicates ("name (1).csv"); show the name actually used.
-                showSaved(displayName(uri) ?: fileName, uri, mimeType)
             } else {
                 @Suppress("DEPRECATION")
                 val dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS)
                 dir.mkdirs()
                 val file = uniqueFile(dir, fileName)
                 file.writeBytes(bytes)
-                MediaScannerConnection.scanFile(activity, arrayOf(file.path), arrayOf(mimeType)) { _, uri ->
-                    handler.post { showSaved(file.name, uri, mimeType) }
-                }
+                MediaScannerConnection.scanFile(activity, arrayOf(file.path), arrayOf(mimeType), null)
             }
+            toast(activity.getString(R.string.download_done, fileName))
         } catch (e: Exception) {
             Log.e(TAG, "Saving $fileName failed", e)
             toast(R.string.download_failed)
         }
     }
 
-    private fun displayName(uri: Uri): String? =
-        activity.contentResolver.query(uri, arrayOf(MediaStore.Downloads.DISPLAY_NAME), null, null, null)
-            ?.use { if (it.moveToFirst()) it.getString(0) else null }
-
-    /** Tells the user where the file went and offers to open it. */
-    private fun showSaved(name: String, uri: Uri?, mimeType: String) {
-        if (activity.isFinishing) return
-        val dialog = AlertDialog.Builder(activity)
-            .setTitle(R.string.download_saved_title)
-            .setMessage(activity.getString(R.string.download_saved_message, name))
-            .setNegativeButton(R.string.download_close, null)
-        if (uri != null) dialog.setPositiveButton(R.string.download_open) { _, _ -> openFile(name, uri, mimeType) }
-        dialog.show()
-    }
-
-    /**
-     * Opens the file in whatever app handles its type. Many file types (CSV on these
-     * scanners) have no such app, so AppConfig.FILE_OPEN_FALLBACK_APPS names an app to
-     * launch instead, where the user opens the file from Descargas themselves.
-     */
-    private fun openFile(name: String, uri: Uri, mimeType: String) {
-        val view = Intent(Intent.ACTION_VIEW)
-            .setDataAndType(uri, mimeType.substringBefore(';'))
-            .addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-        try {
-            activity.startActivity(view)
-            return
-        } catch (_: ActivityNotFoundException) {
-            Log.i(TAG, "No viewer for $mimeType, trying fallback app")
-        }
-
-        // An implicit MAIN/LAUNCHER intent never matches: startActivity adds CATEGORY_DEFAULT.
-        val fallback = AppConfig.FILE_OPEN_FALLBACK_APPS[name.substringAfterLast('.', "").lowercase()]
-        val launch = fallback?.let { activity.packageManager.getLaunchIntentForPackage(it) }
-        if (launch != null) {
-            activity.startActivity(launch)
-            toast(activity.getString(R.string.download_open_manually, name))
-            return
-        }
-        Log.w(TAG, "No app opens $name (fallback ${fallback ?: "none"} not installed)")
-        toast(R.string.download_no_app)
-    }
-
     private fun uniqueFile(dir: File, name: String): File {
         var file = File(dir, name)
         var n = 1
@@ -333,9 +260,9 @@ class FileTransfers(
         // guessFileName only understands http(s); blob/data names come from the disposition.
         val name = URLUtil.guessFileName(
             if (url.startsWith("http")) url else "", contentDisposition, mimeType
-        ).let(::sanitizeFileName)
+        ).replace(Regex("[\\\\/:*?\"<>|]"), "_")
         if (name.contains('.')) return name
-        val ext = mimeType?.let { MimeTypeMap.getSingleton().getExtensionFromMimeType(it.substringBefore(';')) }
+        val ext = mimeType?.let { MimeTypeMap.getSingleton().getExtensionFromMimeType(it) }
         return if (ext != null) "$name.$ext" else name
     }
 
@@ -478,8 +405,7 @@ class FileTransfers(
         private val IMAGE_EXTENSIONS = setOf(".jpg", ".jpeg", ".png", ".webp", ".heic", ".gif")
 
         /** Injected at document start: remembers blobs behind object URLs and delays
-         *  revocation, so a download whose URL the site revokes immediately can still be read,
-         *  and records the `download` file name of clicked links. */
+         *  revocation, so a download whose URL the site revokes immediately can still be read. */
         val BLOB_HOOK_JS = """
             (function() {
                 if (window.__jkBlobs) return;
@@ -493,26 +419,6 @@ class FileTransfers(
                 URL.revokeObjectURL = function(url) {
                     setTimeout(function() { delete blobs[url]; revoke.call(URL, url); }, 60000);
                 };
-                // File names from <a download="name">, which WebView does not pass on.
-                // Covers a.click() and dispatchEvent on detached links, and real taps.
-                var names = window.__jkDownloadNames = {};
-                function remember(a) {
-                    if (a && a.hasAttribute('download') && a.href) names[a.href] = a.getAttribute('download');
-                }
-                var click = HTMLAnchorElement.prototype.click;
-                HTMLAnchorElement.prototype.click = function() {
-                    remember(this);
-                    return click.apply(this, arguments);
-                };
-                var dispatch = EventTarget.prototype.dispatchEvent;
-                HTMLAnchorElement.prototype.dispatchEvent = function(ev) {
-                    if (ev && ev.type === 'click') remember(this);
-                    return dispatch.apply(this, arguments);
-                };
-                document.addEventListener('click', function(e) {
-                    var a = e.target && e.target.closest && e.target.closest('a[download]');
-                    if (a) remember(a);
-                }, true);
             })();
         """.trimIndent()
     }

app/src/main/java/mx/joykoo/scanner/KeyboardPolicy.kt

@@ -0,0 +1,136 @@
+package mx.joykoo.scanner
+
+/**
+ * Per-field soft keyboard policy, injected into the page.
+ *
+ * Every field gets `inputmode="none"` (scanner input). A field a finger taps is the
+ * exception: on `pointerdown` it gets the site's own `inputmode` back (so numeric fields
+ * get a numeric keypad) and is marked `data-jk-kb="1"`, before Chromium focuses it and
+ * decides whether to show the keyboard. When the field loses focus it is suppressed again,
+ * so a later programmatic focus (e.g. the site focusing a field after a scan) never shows
+ * the keyboard. Native code reads the mark on the focused field ([ALLOWED_JS]) and hides
+ * the keyboard when it is missing.
+ *
+ * A field whose own `inputmode` is "none" stays keyboard-free even when tapped.
+ */
+object KeyboardPolicy {
+
+    /** Applies the policy to all current and future fields. Safe to run repeatedly. */
+    val APPLY_JS = """
+        (function() {
+            var kb = window.__jkKb;
+            if (!kb) {
+                var EDITABLE = 'input, textarea, [contenteditable]';
+                var TEXT_TYPES = /^(text|search|tel|number|email|url|password)?${'$'}/i;
+                var enabled = false;
+                var tapped = null;
+
+                function isEditable(el) {
+                    return el.isContentEditable || el.tagName === 'TEXTAREA'
+                        || (el.tagName === 'INPUT' && TEXT_TYPES.test(el.getAttribute('type') || ''));
+                }
+                // The site's inputmode, remembered before it is overwritten with "none".
+                function siteInputMode(el) {
+                    if (!el.hasAttribute('data-jk-im'))
+                        el.setAttribute('data-jk-im', el.getAttribute('inputmode') || '');
+                    return el.getAttribute('data-jk-im');
+                }
+                function suppress(el) {
+                    if (!isEditable(el)) return;
+                    siteInputMode(el);
+                    el.setAttribute('inputmode', 'none');
+                    el.setAttribute('autocomplete', 'off');
+                    el.removeAttribute('data-jk-kb');
+                }
+                function allow(el) {
+                    var im = siteInputMode(el);
+                    if (im === 'none') return;
+                    if (im) el.setAttribute('inputmode', im); else el.removeAttribute('inputmode');
+                    el.setAttribute('data-jk-kb', '1');
+                }
+                function restore(el) {
+                    var im = el.getAttribute('data-jk-im');
+                    if (im === null) return;
+                    if (im) el.setAttribute('inputmode', im); else el.removeAttribute('inputmode');
+                    el.removeAttribute('data-jk-im');
+                    el.removeAttribute('data-jk-kb');
+                }
+                function each(root, fn) {
+                    if (root.nodeType !== 1) return;
+                    fn(root);
+                    root.querySelectorAll(EDITABLE).forEach(fn);
+                }
+                // The field a tap lands on, including through its <label>.
+                function fieldFor(target) {
+                    if (!target || target.nodeType !== 1) return null;
+                    var el = target.closest(EDITABLE);
+                    if (!el) {
+                        var label = target.closest('label');
+                        el = label && (label.control || label.querySelector(EDITABLE));
+                    }
+                    return el && isEditable(el) ? el : null;
+                }
+                // A tap that never focused its field (scroll, cancelled press) must not
+                // leave it able to show the keyboard on a later programmatic focus.
+                function dropUnfocusedTap() {
+                    if (tapped && document.activeElement !== tapped) {
+                        suppress(tapped);
+                        tapped = null;
+                    }
+                }
+
+                document.addEventListener('pointerdown', function(e) {
+                    if (!enabled) return;
+                    var el = fieldFor(e.target);
+                    if (el !== tapped) dropUnfocusedTap();
+                    if (el) {
+                        allow(el);
+                        tapped = el;
+                    }
+                }, true);
+                document.addEventListener('pointercancel', function() {
+                    if (enabled) dropUnfocusedTap();
+                }, true);
+                // Any allowed field that loses focus is suppressed again — not only the
+                // latest tap, since tapping field B while A is focused moves `tapped` first.
+                document.addEventListener('focusout', function(e) {
+                    var el = e.target;
+                    if (!enabled || el.nodeType !== 1 || el.getAttribute('data-jk-kb') !== '1') return;
+                    suppress(el);
+                    if (el === tapped) tapped = null;
+                }, true);
+
+                var observer = new MutationObserver(function(muts) {
+                    muts.forEach(function(m) {
+                        m.addedNodes.forEach(function(n) { each(n, suppress); });
+                    });
+                });
+                kb = window.__jkKb = {
+                    enable: function() {
+                        enabled = true;
+                        each(document.documentElement, function(el) {
+                            if (el !== tapped) suppress(el);
+                        });
+                        observer.observe(document.documentElement, { childList: true, subtree: true });
+                    },
+                    disable: function() {
+                        enabled = false;
+                        tapped = null;
+                        observer.disconnect();
+                        each(document.documentElement, restore);
+                    }
+                };
+            }
+            kb.enable();
+        })();
+    """.trimIndent()
+
+    /** Removes the policy and gives every field back the site's own inputmode. */
+    const val DISABLE_JS = "window.__jkKb && window.__jkKb.disable();"
+
+    /** "true" when the focused field may show the soft keyboard. */
+    const val ALLOWED_JS = """(function() {
+        var el = document.activeElement;
+        return !!el && el.getAttribute('data-jk-kb') === '1';
+    })()"""
+}

app/src/main/java/mx/joykoo/scanner/MainActivity.kt

@@ -126,7 +126,7 @@ class MainActivity : AppCompatActivity() {
         super.onWindowFocusChanged(hasFocus)
         if (hasFocus) {
             enterImmersiveMode()
-            hideKeyboard()
+            enforceKeyboardPolicy()
         }
     }
 
@@ -176,6 +176,7 @@ class MainActivity : AppCompatActivity() {
 
         WebView.setWebContentsDebuggingEnabled(true)
 
+        webView.onInputConnectionRequested = ::enforceKeyboardPolicy
         webView.webViewClient = ScannerWebViewClient()
         webView.webChromeClient = ScannerWebChromeClient()
         webView.setDownloadListener { url, userAgent, contentDisposition, mimeType, _ ->
@@ -334,11 +335,11 @@ class MainActivity : AppCompatActivity() {
         webView.keyboardSuppressed = isKeyboardSuppressed
 
         if (isKeyboardSuppressed) {
-            injectKeyboardSuppression(webView)
-            hideKeyboard()
+            applyKeyboardPolicy(webView)
+            enforceKeyboardPolicy()
             Toast.makeText(this, R.string.keyboard_disabled, Toast.LENGTH_SHORT).show()
         } else {
-            removeKeyboardSuppression(webView)
+            webView.evaluateJavascript(KeyboardPolicy.DISABLE_JS, null)
             Toast.makeText(this, R.string.keyboard_enabled, Toast.LENGTH_SHORT).show()
         }
     }
@@ -471,50 +472,18 @@ class MainActivity : AppCompatActivity() {
         imm.hideSoftInputFromWindow(webView.windowToken, 0)
     }
 
-    private fun injectKeyboardSuppression(view: WebView) {
+    /** Marks which fields may show the soft keyboard (see KeyboardPolicy). */
+    private fun applyKeyboardPolicy(view: WebView) {
         if (!isKeyboardSuppressed) return
-        view.evaluateJavascript("""
-            (function() {
-                function suppress(el) {
-                    if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA'
-                        || el.isContentEditable) {
-                        el.setAttribute('inputmode', 'none');
-                        el.setAttribute('autocomplete', 'off');
-                    }
-                }
-                document.querySelectorAll('input, textarea, [contenteditable]')
-                    .forEach(suppress);
-                if (window.__jkKbObserver) window.__jkKbObserver.disconnect();
-                window.__jkKbObserver = new MutationObserver(function(muts) {
-                    muts.forEach(function(m) {
-                        m.addedNodes.forEach(function(n) {
-                            if (n.nodeType === 1) {
-                                suppress(n);
-                                if (n.querySelectorAll)
-                                    n.querySelectorAll('input, textarea, [contenteditable]')
-                                        .forEach(suppress);
-                            }
-                        });
-                    });
-                });
-                window.__jkKbObserver.observe(document.body || document.documentElement,
-                    { childList: true, subtree: true });
-            })();
-        """.trimIndent(), null)
+        view.evaluateJavascript(KeyboardPolicy.APPLY_JS, null)
     }
 
-    private fun removeKeyboardSuppression(view: WebView) {
-        view.evaluateJavascript("""
-            (function() {
-                if (window.__jkKbObserver) {
-                    window.__jkKbObserver.disconnect();
-                    window.__jkKbObserver = null;
+    /** Hides the soft keyboard unless the focused field is one the policy lets a person type in. */
+    private fun enforceKeyboardPolicy() {
+        if (!isKeyboardSuppressed) return
+        webView.evaluateJavascript(KeyboardPolicy.ALLOWED_JS) { allowed ->
+            if (allowed != "true") hideKeyboard()
         }
-                document.querySelectorAll('[inputmode="none"]').forEach(function(el) {
-                    el.removeAttribute('inputmode');
-                });
-            })();
-        """.trimIndent(), null)
     }
 
     // ── Renderer Crash Recovery ─────────────────────────────────────────
@@ -586,9 +555,9 @@ class MainActivity : AppCompatActivity() {
         override fun onPageFinished(view: WebView, url: String?) {
             super.onPageFinished(view, url)
             CookieManager.getInstance().flush()
-            injectKeyboardSuppression(view)
+            applyKeyboardPolicy(view)
             view.evaluateJavascript(FileTransfers.BLOB_HOOK_JS, null)
-            hideKeyboard()
+            enforceKeyboardPolicy()
             ensureWebViewFocus()
         }
 

app/src/main/java/mx/joykoo/scanner/NoSoftKeyboardWebView.kt

@@ -15,9 +15,10 @@ import android.webkit.WebView
  *   1. onCheckIsTextEditor() → false: first signal to the IME not to show.
  *   2. EditorInfo flags (NO_EXTRACT_UI, NO_FULLSCREEN): prevent fullscreen IME.
  *   3. InputMethodManager.hideSoftInputFromWindow posted after each
- *      InputConnection request: force-hides if the IME appears anyway.
- *   4. JavaScript inputmode="none" injection (in MainActivity): tells the
- *      Chromium renderer not to request the keyboard for HTML inputs.
+ *      InputConnection request: force-hides if the IME appears anyway, unless
+ *      [onInputConnectionRequested] decides the focused field allows typing.
+ *   4. JavaScript inputmode="none" injection (KeyboardPolicy): tells the
+ *      Chromium renderer not to request the keyboard for scan fields.
  *   5. Manifest stateAlwaysHidden|adjustNothing: system-level default.
  *
  * The real InputConnection from super is returned so that hardware key
@@ -28,6 +29,9 @@ class NoSoftKeyboardWebView : WebView {
 
     var keyboardSuppressed = true
 
+    /** Replaces the unconditional hide in layer 3 with a per-field check (MainActivity). */
+    var onInputConnectionRequested: (() -> Unit)? = null
+
     constructor(context: Context) : super(context)
     constructor(context: Context, attrs: AttributeSet?) : super(context, attrs)
     constructor(context: Context, attrs: AttributeSet?, defStyleAttr: Int) :
@@ -40,11 +44,13 @@ class NoSoftKeyboardWebView : WebView {
                     EditorInfo.IME_FLAG_NO_EXTRACT_UI or
                     EditorInfo.IME_FLAG_NO_FULLSCREEN
             post {
+                onInputConnectionRequested?.invoke() ?: run {
                     val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE)
                             as InputMethodManager
                     imm.hideSoftInputFromWindow(windowToken, 0)
                 }
             }
+        }
         return ic
     }
 

app/src/main/res/values/strings.xml

@@ -26,12 +26,7 @@
     <string name="kiosk_enabled_pinning">Modo kiosco activado (fijación de pantalla: el dispositivo no está configurado como propietario)</string>
     <string name="kiosk_disabled">Modo kiosco desactivado</string>
     <string name="download_started">Descargando %1$s…</string>
-    <string name="download_saved_title">Archivo guardado</string>
-    <string name="download_saved_message">Se guardó en la carpeta Descargas:\n%1$s</string>
-    <string name="download_open">Abrir</string>
-    <string name="download_close">Cerrar</string>
-    <string name="download_open_manually">Abra Descargas › %1$s</string>
-    <string name="download_no_app">No hay ninguna app para abrir este archivo</string>
+    <string name="download_done">Guardado en Descargas: %1$s</string>
     <string name="download_failed">No se pudo descargar el archivo</string>
     <string name="download_permission_denied">Se necesita permiso de almacenamiento para guardar archivos</string>
     <string name="upload_title">Agregar foto</string>