Fix VOSK minification bug

Author: adam-weber

app/proguard-rules.pro

@@ -1,2 +1,12 @@
 # InputMethodService is referenced from the manifest; keep it.
 -keep class app.lightphonekeyboard.** { *; }
+
+# Vosk (voice dictation) calls its native library through JNA, which the native code resolves by
+# class/field NAME (e.g. com.sun.jna.Pointer.peer). R8 must not strip or rename JNA or Vosk, or the
+# release build throws "UnsatisfiedLinkError: Can't obtain peer field ID for class com.sun.jna.Pointer".
+-keep class com.sun.jna.** { *; }
+-keep class * implements com.sun.jna.Library { *; }
+-keepclassmembers class * extends com.sun.jna.Structure { *; }
+-keep class org.vosk.** { *; }
+# JNA references java.awt (desktop-only, absent on Android); silence the resulting R8 warnings.
+-dontwarn java.awt.**

app/src/main/java/app/lightphonekeyboard/LightImeService.kt

@@ -228,11 +228,10 @@ class LightImeService : InputMethodService(), LightKeyboardView.Listener, SpellC
         if (dictation.ready) {
             dictation.listen(
                 onPartial = { kb.setListeningStatus(it) },
-                onResult = { text ->
-                    micActive = false
+                // Each finished segment commits to the field; dictation keeps going across pauses.
+                onSegment = { text ->
                     clearUndo()
                     currentInputConnection?.commitText(spacedDictation(text), 1)
-                    kb.stopListeningUi()
                 },
                 onError = { msg ->
                     micActive = false
@@ -253,9 +252,11 @@ class LightImeService : InputMethodService(), LightKeyboardView.Listener, SpellC
         kb.postDelayed({ startDictationWhenReady(kb, attempts + 1) }, 300)
     }
 
+    /** Tap on the listening surface = "I'm done": flush the trailing words, then close it. */
     override fun onMicCancel() {
+        if (!micActive) return
         micActive = false
-        dictation.destroy()
+        dictation.stop()
         keyboard?.stopListeningUi()
     }
 
@@ -271,6 +272,7 @@ class LightImeService : InputMethodService(), LightKeyboardView.Listener, SpellC
     override fun onWindowHidden() { super.onWindowHidden(); broadcastImeVisible(false) }
     override fun onFinishInputView(finishingInput: Boolean) {
         super.onFinishInputView(finishingInput)
+        if (micActive) { micActive = false; dictation.destroy(); keyboard?.stopListeningUi() }
         broadcastImeVisible(false)
     }
 

app/src/main/java/app/lightphonekeyboard/LightKeyboardView.kt

@@ -316,10 +316,31 @@ class LightKeyboardView @JvmOverloads constructor(
         d.setBounds(left, top, (left + size).toInt(), (top + size).toInt())
         d.draw(canvas)
         textPaint.textSize = spf(18)
-        val baseY = midY + dpf(22) - (textPaint.descent() + textPaint.ascent()) / 2f
-        canvas.drawText(listeningStatus, cx, baseY, textPaint)
+        // Wrap the live text so a long phrase stacks into lines instead of running off the screen.
+        drawWrappedCentered(canvas, listeningStatus, cx, midY + dpf(22), width - dpf(48), textPaint)
         textPaint.textSize = spf(12)
-        canvas.drawText("Tap to cancel", cx, height - dpf(18), textPaint)
+        canvas.drawText("Tap when done", cx, height - dpf(18), textPaint)
+    }
+
+    /** Draw [text] centered on ([cx],[centerY]), wrapping at word boundaries to fit [maxWidth]. */
+    private fun drawWrappedCentered(
+        canvas: Canvas, text: String, cx: Float, centerY: Float, maxWidth: Float, paint: Paint,
+    ) {
+        if (text.isEmpty()) return
+        val lines = ArrayList<String>()
+        var line = ""
+        for (word in text.split(' ')) {
+            val candidate = if (line.isEmpty()) word else "$line $word"
+            if (line.isEmpty() || paint.measureText(candidate) <= maxWidth) {
+                line = candidate
+            } else {
+                lines.add(line); line = word
+            }
+        }
+        if (line.isNotEmpty()) lines.add(line)
+        val lineH = paint.descent() - paint.ascent()
+        var baseline = centerY - lines.size * lineH / 2f - paint.ascent()
+        for (l in lines) { canvas.drawText(l, cx, baseline, paint); baseline += lineH }
     }
 
     private fun drawKey(canvas: Canvas, pk: PlacedKey) {

app/src/main/java/app/lightphonekeyboard/VoiceDictation.kt

@@ -39,9 +39,14 @@ class VoiceDictation(private val context: Context) {
         }.start()
     }
 
+    /**
+     * Continuous dictation: a pause ends one *segment* (delivered via [onSegment]) but keeps listening,
+     * so a mid-sentence pause no longer stops you. Call [stop] when you're done; the trailing words
+     * since the last pause then arrive through [onSegment] too. [onPartial] is the live, in-progress text.
+     */
     fun listen(
         onPartial: (String) -> Unit,
-        onResult: (String) -> Unit,
+        onSegment: (String) -> Unit,
         onError: (String) -> Unit,
     ) {
         val m = model
@@ -51,13 +56,6 @@ class VoiceDictation(private val context: Context) {
             return
         }
         destroy()
-        var done = false
-        fun finish(text: String) {
-            if (done) return
-            done = true
-            if (text.isBlank()) onError("Didn't catch that.") else onResult(text)
-            destroy()
-        }
         try {
             val rec = Recognizer(m, SAMPLE_RATE)
             recognizer = rec
@@ -67,19 +65,32 @@ class VoiceDictation(private val context: Context) {
                 override fun onPartialResult(hypothesis: String?) {
                     field(hypothesis, "partial")?.let { if (it.isNotBlank()) onPartial(it) }
                 }
-                override fun onResult(hypothesis: String?) = finish(field(hypothesis, "text").orEmpty())
-                override fun onFinalResult(hypothesis: String?) = finish(field(hypothesis, "text").orEmpty())
-                override fun onError(e: Exception?) {
-                    if (!done) { done = true; onError("Voice error."); destroy() }
+                // A pause ends a segment but NOT the whole dictation — emit it and keep listening.
+                override fun onResult(hypothesis: String?) {
+                    field(hypothesis, "text")?.let { if (it.isNotBlank()) onSegment(it) }
+                }
+                // Fires once when we stop(): the trailing words since the last pause.
+                override fun onFinalResult(hypothesis: String?) {
+                    field(hypothesis, "text")?.let { if (it.isNotBlank()) onSegment(it) }
                 }
-                override fun onTimeout() { if (!done) { done = true; destroy() } }
+                override fun onError(e: Exception?) { onError("Voice error.") }
+                override fun onTimeout() {}
             })
         } catch (e: Throwable) {
             Log.e(TAG, "listen failed", e)
             onError("Voice error."); destroy()
         }
     }
 
+    /** Finish dictating: flush the words since the last pause (via onSegment), then tear down. */
+    fun stop() {
+        val s = speech ?: return destroy()
+        runCatching { s.stop() }
+        // Give the final result a moment to arrive before closing the recognizer; skip if a new
+        // session has since replaced this one.
+        main.postDelayed({ if (speech === s) destroy() }, 350)
+    }
+
     fun destroy() {
         speech?.let { runCatching { it.stop() }; runCatching { it.shutdown() } }
         speech = null