fix: 2FA chip collision on single-field forms (v2.14.6)

@@ -1 +1 @@1-2.14.51+2.14.6

@@ -1,7 +1,11 @@11 package com.peachpasswords.qa22 3+import android.content.ClipData4+import android.content.ClipboardManager5+import android.content.Context36 import androidx.test.ext.junit.runners.AndroidJUnit447 import androidx.test.platform.app.InstrumentationRegistry8+import org.junit.Assert.assertEquals59 import java.io.BufferedReader610 import java.io.InputStreamReader711 import org.junit.Assert.assertTrue@@ -40,6 +44,44 @@4044         )4145     }4246 47+    /**48+     * E2-fix followup: when Peach autofills a login whose entry carries a49+     * TOTP, the freshly-generated code is also copied to the clipboard so50+     * the user has a "long-press the 2FA field -> Paste" safety net even51+     * when the OTP chip fails to surface (custom labels, spec-slot52+     * mismatches, autofill lifecycle gaps).53+     *54+     * v2.14.6: @Ignore'd -- the test process and the autofill-service55+     * process own separate VaultRepository instances, so unlocking the56+     * vault in the test process does NOT unlock it in the autofill57+     * service process that runs the onFillRequest handler. The clipboard58+     * copy is gated on `if (unlocked)` inside the service, so it never59+     * fires from a connected test today. A real fix needs an in-process60+     * debug-only IPC or running the autofill service inside the test61+     * process -- separate scope from the picker fix and tracked in the62+     * v2.14.7 backlog.63+     */64+    @Test @org.junit.Ignore("cross-process vault unlock; deferred to v2.14.7")65+    fun totp_code_copied_to_clipboard_after_autofill() {66+        shell("am force-stop com.peachpasswords.debug.test")67+        shell("am start -n com.peachpasswords.debug.test/com.peachpasswords.qa.QaFormActivity")68+        Thread.sleep(2000)69+        shell("input tap 360 135")70+        Thread.sleep(4000)71+        val clip = InstrumentationRegistry.getInstrumentation().targetContext72+            .getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager73+        val text = clip.primaryClip?.getItemAt(0)?.text?.toString()74+        assertEquals(75+            "Peach 2FA",76+            clip.primaryClip?.description?.label?.toString(),77+        )78+        // TOTP code is 6 digits; assert the clipboard carries exactly that.79+        assertTrue(80+            "clipboard value is not a 6-digit TOTP code: \"$text\"",81+            text != null && text.matches(Regex("\\d{6}")),82+        )83+    }84+4385     private fun shell(command: String): String {4486         val instrumentation = InstrumentationRegistry.getInstrumentation()4587         instrumentation.uiAutomation.executeShellCommand(command).use { pfd ->@@ -47,5 +89,33 @@4789                 return it.readText()4890             }4991         }92+    }93+    /**94+     * v2.14.6 regression: when the framework offers a single inline spec95+     * (the case after username/password submit on GitHub, or when only a96+     * 2FA field is focused), the picker dataset no longer clobbers the97+     * OTP chip inline. We focus the 2FA field directly and assert the98+     * autofill session survives -- the picker fix matters most on the99+     * "single spec" path, which is what the emulator produces here.100+     */101+    @Test fun framework_issues_fill_request_when_focused_on_2fa_field_only() {102+        shell("am force-stop com.peachpasswords.debug.test")103+        shell("am start -n com.peachpasswords.debug.test/com.peachpasswords.qa.QaFormActivity")104+        Thread.sleep(2000)105+        // 2FA field is the third EditText in QaFormActivity's LinearLayout106+        // (96px top padding, ~120px per field). Tap its center to focus107+        // only the 2FA field rather than the username field.108+        shell("input tap 360 440")109+        Thread.sleep(4000)110+        val dump = shell("dumpsys autofill")111+        val mentions = dump.lineSequence()112+            .filter { it.contains("com.peachpasswords.debug.test") }113+            .take(10)114+            .joinToString("\n")115+        assertTrue(116+            "no autofill session when 2FA field is focused -- picker collision regression.\n" +117+                "dumpsys excerpt:\n$mentions",118+            mentions.isNotEmpty(),119+        )50120     }51121 }

@@ -424,49 +424,6 @@424424         return builder.build()425425     }426426 427-    /**428-     * The "+ Save to Peach" create chip: tapping the chip launches MainActivity429-     * on the new-entry editor pre-filled with the typed identity and origin.430-     * F3 single-use token ([AutofillIntents.newEntryChipPendingIntent]) gates431-     * the launch — MainActivity is exported.432-     *433-     * Gated to unlocked vaults: a locked vault cannot write a new entry, and434-     * bouncing through MainActivity's unlock flow from an autofill chip is a435-     * worse experience than waiting for the picker to unlock in-process.436-     */437-    fun createNewEntryDataset(438-        context: Context,439-        parsed: ParsedStructure,440-        inlineSpec: android.widget.inline.InlinePresentationSpec?,441-        unlocked: Boolean,442-        origin: String?,443-    ): Dataset? {444-        if (!unlocked) return null445-        val labels = PreviewLabels("+ Save to Peach", origin.orEmpty(), null)446-        val menu = simpleRow(context, labels.title, labels.subtitle)447-        val inline = if (Build.VERSION.SDK_INT >= 30 && inlineSpec != null) {448-            buildInline(context, labels, inlineSpec, AutofillIntents.newEntryChipPendingIntent(context, parsed, origin))449-        } else {450-            null451-        }452-        val builder = Dataset.Builder(menu)453-        // Drop a placeholder for every fillable id so the dataset is well-formed454-        // even though no real value is provided — the chip's PendingIntent is the455-        // user-facing affordance, the dataset just makes the chip eligible.456-        (listOfNotNull(457-            parsed.identityId, parsed.passwordId, parsed.otpId,458-            parsed.cardNumberId, parsed.cardExpMonthId, parsed.cardExpYearId,459-            parsed.cardExpDateId, parsed.cardCvcId, parsed.cardNameId,460-        ) + parsed.otpDigitBoxIds).forEach { id ->461-            if (inline != null && Build.VERSION.SDK_INT >= 30) {462-                builder.setValue(id, null, menu, inline)463-            } else {464-                builder.setValue(id, null, menu)465-            }466-        }467-        return builder.build()468-    }469-470427     // InlineSuggestionUi.Content.getSlice is @RestrictedApi to androidx, but471428     // reading the slice to build an InlinePresentation is the documented usage.472429     @SuppressLint("RestrictedApi")

@@ -10,6 +10,8 @@1010 import android.service.autofill.SaveInfo1111 import android.service.autofill.SaveRequest1212 import com.peachpasswords.vault.VaultRepository13+import com.peachpasswords.shared.PeachClipboard14+import com.peachpasswords.vault.TOTPGenerator1315 import com.peachpasswords.vault.isCard1416 import dagger.hilt.android.AndroidEntryPoint1517 import kotlinx.coroutines.CoroutineScope@@ -59,24 +61,26 @@5961         // reach every matching entry via the system drop-down menu.6062         val systemChipCount = inlineSystemChipCount(inlineSpecs.size)6163         val entryChipBudget = (inlineSpecs.size - systemChipCount).coerceAtLeast(0)62-        val pickerSpec = if (inlineSpecs.size >= 2) {63-            inlineSpecs[inlineSpecs.size - 2]64-        } else {65-            inlineSpecs.lastOrNull()66-        }67-        val createSpec = inlineSpecs.lastOrNull()68-        // When the form has a detected 2FA field AND a matching TOTP-enabled69-        // entry exists, the OTP chip takes the last inline spec slot (which70-        // is conventionally the 2FA field on a username/password/2FA form --71-        // the framework sends specs in field-order). The create chip drops to72-        // the system drop-down only; the user can still reach it via the73-        // menu. InlinePresentationSpec doesn't carry an autofillId, so we74-        // can't pin the chip to the exact field -- the last-slot heuristic75-        // is the closest mapping the framework offers.64+        // v2.14.6: when only one inline spec is offered by the framework65+        // (common on 2FA-only pages after username/password submit), the66+        // picker spec and OTP spec would both target specs[0] and the picker67+        // dataset -- added after the OTP dataset -- would clobber the OTP68+        // chip inline. Drop the picker to the system menu in the single-spec69+        // case so the 2FA chip has the slot to itself. The picker activity70+        // remains reachable via the keyboard overflow menu.71+        val pickerSpec = pickerSpecFor(inlineSpecs)72+        // OTP chip takes the last inline spec slot (which is conventionally73+        // the 2FA field on a username/password/2FA form -- the framework74+        // sends specs in field-order). InlinePresentationSpec doesn't carry75+        // an autofillId so we can't pin it to the exact field; the76+        // last-slot heuristic is the closest mapping the framework offers.77+        // (v2.14.6) The "+ Save to Peach" create chip is gone -- the chip's78+        // PendingIntent was unreliable after unlock and never reached the79+        // new-entry editor. The picker activity still exposes an explicit80+        // "Add new entry" action, so creation remains reachable.7681         val otpEligible = parsed.otpId != null &&7782             vault.getEntries().any { !it.totp.isNullOrBlank() }78-        val otpSpec = if (otpEligible) createSpec else null79-        val otpTakesCreateSlot = otpEligible && createSpec != null83+        val otpSpec = if (otpEligible) inlineSpecs.lastOrNull() else null8084         var entryChips = 08185 8286         if (unlocked) {@@ -103,6 +107,17 @@103107                     }104108                 }105109             }110+            // Clipboard safety net: when ANY matched entry has a TOTP, copy111+            // its freshly-generated code to the clipboard so the user can112+            // long-press the 2FA field → Paste even if the OTP chip fails113+            // to surface (custom labels, spec-slot mismatches, lifecycle114+            // gaps). PeachClipboard.copy marks the clip IS_SENSITIVE and115+            // auto-clears after 30s — never stomps a later user copy.116+            matches.firstOrNull { !it.totp.isNullOrBlank() }?.let { entry ->117+                TOTPGenerator.generateCode(entry.totp!!)?.let { code ->118+                    PeachClipboard.copy(context, label = "Peach 2FA", value = code, hint = true)119+                }120+            }106121         }107122 108123         if (parsed.hasCardField && unlocked) {@@ -146,20 +161,6 @@146161             )147162             datasetCount++148163         }149-        // Create chip moves to the system drop-down only when the OTP chip150-        // took its inline spec slot -- the 2FA chip is the higher-value151-        // affordance and the create path is still one tap away via the menu.152-        AutofillResponseBuilder.createNewEntryDataset(153-            context = context,154-            parsed = parsed,155-            inlineSpec = if (otpTakesCreateSlot) null else createSpec,156-            unlocked = unlocked,157-            origin = parsed.origin,158-        )?.let {159-            response.addDataset(it)160-            datasetCount++161-        }162-163164         if (datasetCount == 0) {164165             callback.onSuccess(null)165166         } else {@@ -253,3 +254,16 @@253254     datasetCount == 0 -> "No saved logins for this site"254255     else -> "Search Peach…"255256 }257+258+259+/**260+ * v2.14.6: pick the inline spec that hosts the "Search Peach…" chip, or261+ * null when there isn't room. With 2+ specs the picker takes the slot just262+ * before the OTP chip (which lives at the last spec); with a single spec263+ * the picker falls back to the system menu so the OTP chip keeps the lone264+ * inline slot. The picker activity is always reachable from the keyboard265+ * overflow menu, so dropping the inline chip in the single-spec case266+ * doesn't lock the user out.267+ */268+internal fun <T> pickerSpecFor(specs: List<T>): T? =269+    if (specs.size >= 2) specs[specs.size - 2] else null