Skip to content

lock: stop fingerprint scans while the display is blanked - #12420

Closed
slr01 wants to merge 1 commit into
omacom:quattrofrom
slr01:lock/fingerprint-gating
Closed

slr01 wants to merge 1 commit into
omacom:quattrofrom
slr01:lock/fingerprint-gating

Conversation

@slr01

@slr01 slr01 commented Sep 18, 2026 •

Copy link
Copy Markdown

What and why

While a display is blanked, the lock screen keeps the fingerprint reader running scan cycles against an empty pad. On fingerprint readers that thermally self-disable (Broadcom CV3 / 0a5c:5843, Goodix 27c6:533c, Elan 04f3:0c4b, all libfprint-tod), that cycles the driver into Device disabled to prevent overheating refusals: 31,534 PAM_AUTHINFO_UNAVAIL / code 9 returns in under four hours on a CV3, in a 205 s-refusing / 122 s-available cycle. Each refusal re-arms the 250 ms retry timer, so the reader stays in the storm.

This PR stops new scans while the display is blanked and re-arms on wake. With it, a CV3 logged 0 refusals across a 15-minute lock and read on the first touch after wake (measurement thread).

Changes (gating, vs quattro)

  • runBlank(): stop fingerprintRetryTimer so a blanked display is no longer re-arming scan cycles
  • startFingerprint(): return early while displaysBlank (single call site; every trigger goes through it)
  • onDisplaysBlankChanged: re-arm a scan only on the falling edge of displaysBlank, so fingerprints do not restart on every pointer move or key press on an already-awake lock
  • restartFingerprintAfterSleep(): clear displaysBlank on resume, so a lid-open that keeps the same outputs (a resume that never reaches runWake()) re-arms the reader instead of leaving it off until a key press

displaysBlank is already cleared by runWake() and onScreensChanged() on the base, so the change handler turns either of those routes into a re-arm; the resume clear covers the one route that lights the panel without going through runWake().

No abort(): an in-flight scan is allowed to finish; on readers where power/wakeup is disabled, the reader cannot wake the compositor, so aborting on blank can strand it with nothing to re-arm it.

Trade-off on healthy readers (documented)

After a lock blanks, a reader whose session is still within its verify timeout keeps working; once the in-flight session ends, no new scan starts until a wake event (pointer, unbound key press, password, panel change). On readers that never overheat this means touch-to-unlock from a fully dark lock screen stops a short time after blank where the base kept re-arming. This is the cost of the gating; the alternatives on the table for follow-up:

  • apply the backoff only after consecutive fast PamError results (the refusal signature), so healthy readers keep the base behavior while refusing readers still stop cycling
  • derive the gate from actual DPMS state (the plugin already polls hyprctl monitors -j for video wallpapers)

Both are intentionally left out of this PR to keep the validated core small; happy to take either as a follow-up.

Verified by stock A/B capture (2026-09-25)

Swapped the running lock plugin to a pristine stock build and held a blank-idle lock for 25 minutes: stock arms the reader continuously through the blank period, producing repeated Device disabled to prevent overheating storms, a real fprintd SIGSEGV in its libusb/gusb thread (auto-restarted by systemd), and a re-arm thrash where every 250 ms attempt errors instantly — which reads as a "dead reader" to the user. The gating mechanism prevents exactly this: the reader is not armed while the display is blank, so the overnight self-heating cycle that trips the thermal gate never starts. Full details: /issue/12202#issuecomment-5841664212.

Notes

@llstrk

llstrk commented Sep 25, 2026

Copy link
Copy Markdown

Automated AI review

Community review: Independent automated community review, unaffiliated with the Omarchy team, intended to help prepare PRs for their review.

Verified: the new if (displaysBlank) return in startFingerprint() blocks every new fingerprint PAM session while the lock has blanked the display. fingerprintPam.start() has a single call site, and every trigger (retry timer, completion and error handlers, secure-state change, configured-state recheck, the new runWake() call) goes through startFingerprint(). Only the session already in flight at blank time continues, so a refusing reader stops cycling right after blank, consistent with the linked measurement. Double-arming is not possible, unlock paths clear lockRequested before waking, and the patch applies cleanly to current quattro (offset 11) with no upstream changes to the fingerprint, blank or wake code.

The main gap: displaysBlank records what the lock asked for, not what the panels are doing. Wakes that bypass runWake() leave the reader off on a lit lock, and a screen change while blanked can restart scanning with the panels still off. The change also affects healthy readers and awake behavior in ways the description does not state.

Wakes that bypass runWake() leave the reader off on a visible lock screen

Before this PR the retry loop kept the reader armed regardless of displaysBlank. With it, re-arming depends on runWake() (or onScreensChanged clearing the flag), and two wake routes skip that:

wake route (after the in-flight session has ended)   runWake()?  displaysBlank  reader
pointer move, key that reaches the lock, password     yes         false          re-armed
volume / brightness / media / power key               no          stays true     off
monitor plug / unplug, dock / undock                  no          set false      off
  • Keys bound with { locked = true } (default/hypr/bindings/media.lua, utilities.lua) light the panel through key_press_enables_dpms = true (default/hypr/input.lua), but Hyprland consumes a claimed key before it reaches the lock surface, so LockView never emits wakeRequested.
  • onScreensChanged (shell/plugins/lock/Service.qml, around line 538) sets displaysBlank = false but does not call startFingerprint(), and runBlank() already stopped the retry timer.

Impact: fingerprint touch does nothing while the lock screen is lit and still shows the fingerprint icon. Moving the pointer, pressing an unbound key or typing the password recovers, so there is no lockout or security impact.

Suggested change: call root.startFingerprint() at the end of onScreensChanged (its own guards are sufficient). For panels woken outside the lock, derive the gate from actual DPMS state (the file already polls hyprctl monitors -j for video backgrounds) or keep a slow retry while blanked.

A screen change while blanked can restart the scan loop with the panels off

onScreensChanged also runs on screen removal and primary-screen changes, and clears displaysBlank without re-arming idleBlankTimer. Source trace:

runBlank()            displaysBlank = true, retry timer stopped, panels DPMS-off
in-flight session     still running (up to ~30 s on a healthy reader, ~250 ms if already refusing)
screen removed        e.g. docked lid close disables the internal output via hyprctl reload
onScreensChanged      displaysBlank = false; blank timer not re-armed; remaining panel stays off
session ends          fingerprintRetryTimer.restart()
retry after 250 ms    startFingerprint() passes the guard -> new session -> repeats until input

Impact: within that window the protection falls back to pre-PR behavior, including the refusal storm on affected readers, until the next input. It is not worse than the base. Qt's handling of a removed output and the physical panel state through the reload were not observed at runtime.

Suggested change: in onScreensChanged, re-arm idleBlankTimer or restore the blank state from actual DPMS status instead of clearing it unconditionally.

Touch-to-unlock from a blanked lock changes for every reader

The lock blanks about 5 s after the last input, and Omarchy's auth required pam_fprintd.so passes no arguments, so pam_fprintd's default 30 s verify timeout applies.

healthy reader, lock blanked     merge-base                          head
in-flight session (~25 s left)   touch unlocks                       touch unlocks
after that session times out     250 ms retry; touch still unlocks   retry blocked; touch ignored
                                                                     until a key or pointer wake

Impact: on readers that never overheat, touch-to-unlock from a dark lock screen stops about 25 s after blank. "Purely additive" and "no behavior change while the display is awake" do not describe this. Combined with the consumed power key above, laptops with a sensor in the power button would lose "press power, touch" unlock once that window passes (follows from source, not tested on hardware).

Suggested change: state the trade-off in the description, or apply the back-off only after consecutive fast PamError results (the refusal signature) so healthy readers keep the current behavior.

runWake() re-arms on every pointer and key event

LockView emits wakeRequested on every pointer move, key press and text change, and the new line calls startFingerprint() on each one, not only on a blank-to-awake transition. startFingerprint() does not check fingerprintRetryTimer.running, so while a 250 ms retry is pending after a fast failure, the next input event starts a session immediately.

Impact: on a reader whose sessions fail quickly, moving the pointer or typing on an awake lock can start attempts faster than the retry timer allows. The merge-base runWake() never started fingerprint.

Suggested change: re-arm only when the display was blank (sketch, untested):

function runWake() {
  const wasBlank = root.displaysBlank
  root.displaysBlank = false
  // ...existing lines...
  if (wasBlank && lockRequested && fingerprintConfigured && !authenticatingPassword) root.startFingerprint()
}

Note: the new !authenticatingPassword condition does not act on password submit, because submitPassword() calls runWake() before setting authenticatingPassword = true. Concurrent fingerprint and password PAM already occurred on the base, so this is harmless but does not do what it appears to.

Documentation: the comment at shell/plugins/lock/Service.qml:496-498 ("The fingerprint PAM stays armed for the whole lock") is no longer accurate with this change.


Review information

Test scope: Source review of head 939ab0b6 against merge-base d174d4aa and current quattro c3e67f5d, including upstream Quickshell PamContext, fprintd pam_fprintd, and Hyprland key and DPMS handling at releases or commits near the PR date, plus a clean git apply onto current quattro. No QML, PAM, fprintd, lock screen or fingerprint hardware was run. Timings come from source defaults (30 s pam_fprintd timeout, 5 s blank delay), not measurements. Omarchy does not pin its Hyprland or Quickshell versions.

AI process: Opus 5.5 Medium coordination and synthesis, independent Opus 5.5 Xhigh and GPT 6 Sol Xhigh technical assessments with targeted cross-checks of each other's single-sourced points, Opus 5.5 Medium editorial check.

Opt out: To stop receiving these reviews, reply to this comment saying so.

@llstrk

llstrk commented Sep 27, 2026

Copy link
Copy Markdown

Automated AI review

Community review: Independent automated community review, unaffiliated with the Omarchy team, intended to help prepare PRs for their review.

Follow-up on head d54116f9, reassessing the previous review of 939ab0b6.

Verified: the new commit fixes the per-event re-arm, re-arms the reader and the blank timer on screen changes, and the description now documents the healthy-reader trade-off. It also breaks an existing repository test (new finding below). The wake route through locked key binds is still open.

Previous finding Status at d54116f9
Wakes that bypass runWake() leave the reader off Screen-change route resolved (onScreensChanged now calls startFingerprint()). Locked-key route still present, see below
Screen change while blanked restarts scanning with panels off Resolved: armBlankTimer() re-blanks about 5 s after a screen change. Scanning resumes until that re-blank, and screen-change signals repeating faster than every 5 s keep postponing it, so it ends about 5 s after the last one. For scanning this is no worse than the base, which scans throughout
Touch-to-unlock from a blanked lock changes for every reader Resolved as suggested: stated in the new "Trade-off on healthy readers" section
runWake() re-arms on every pointer and key event Resolved: the wasBlank gate re-arms only on a blank-to-awake transition
Stale comment at Service.qml:496-498 Resolved: rewritten. Nit: the new text says the reader is "paused" while blanked, but a session already in flight keeps running

Verified: the opening points of the previous review still hold at this head: fingerprintPam.start() has one call site, every trigger (now including onScreensChanged) goes through startFingerprint(), an in-flight session continues after blank, and unlock paths clear lockRequested before waking. The PR merges cleanly onto current quattro (c231097d), and the quattro commits since the merge-base do not touch the fingerprint, blank or wake code.

New: test/shell.d/video-background-test.sh fails at this head

The assertion "the lock screen stops playback once displays go dark or power-saver is active" (lines 165-173) matches root.displaysBlank = false as the first statement of runWake():

/function runWake\(\) \{\s*\n\s*root\.displaysBlank = false/.test(lockService)

The new first line var wasBlank = root.displaysBlank (Service.qml:178) breaks that match.

revision                          video-background-test.sh
merge-base d174d4aa               ok
previous head 939ab0b6            runWake first-line check passes
head d54116f9                     not ok
head merged into quattro          not ok

In a full test/shell run (244 files), the base and the head fail the same 7 unrelated files. The head fails only this one in addition.

Impact: ./test/shell reports a new failure. The check is a text pattern: runWake() still clears displaysBlank (Service.qml:179), so the playback behaviour it guards is unchanged.

Suggested change: update the test's runWake pattern to allow the wasBlank line. Alternatively, keep root.displaysBlank = false as the first statement and move the re-arm into an onDisplaysBlankChanged handler for the true-to-false transition, which also covers the onScreensChanged route in one place. A copy of the head with that handler passes this test and the other lock-source text tests that ran in the sandbox (compositor-dependent tests skipped). Its QML behaviour was not run.

Still present: panels lit by locked key binds leave the reader off

Keys bound with { locked = true } (volume, brightness and media keys in default/hypr/bindings/media.lua, the power key in utilities.lua:9) light the panels through key_press_enables_dpms = true (default/hypr/input.lua:72). Hyprland claims a bound key, so it never reaches the lock surface:

locked-bind key on a blanked lock, after the session in flight at blank has ended
  Hyprland: DPMS on, key consumed by the bind
  LockView: no key event -> no wakeRequested -> runWake() not called
  displaysBlank stays true -> startFingerprint() returns early
  result: lit lock showing the fingerprint icon, touch ignored
          until pointer motion or an unbound key

The session in flight at blank is not aborted and can run up to 30 s (pam_fprintd's default timeout), so this applies once it has ended.

Omarchy's own notes (commit 41b6cc69 and the comment at Service.qml:35-38) say a resume that keeps the same outputs also lights panels without runWake(). The same state would follow after resuming from a lock that had already blanked. If the outputs are re-created instead, onScreensChanged re-arms the reader. This resume route follows from source and was not observed on hardware.

Impact: once the in-flight session has ended, "press power, touch" on laptops with a sensor in the power button stops working until other input. "Open lid, touch" after a blanked lock would likely behave the same when the resume keeps the same outputs (not observed). No lockout or security impact. The trade-off section describes a "fully dark lock screen", and the note "no behavior change while the display is awake" does not hold for these routes.

Suggested change: mention the lit-lock case in the trade-off section, or gate on actual DPMS state as already listed for follow-up. Open PR #10130 adds an IdleMonitor whose handleActivityResumed() also sees this input but only calls armBlankTimer(). Combined with this PR, the lock would light for about 5 s with the reader off, then blank again. Routing that handler through runWake() while displaysBlank is set would re-arm the reader for locked-bind keys (not for resume), at the cost of running omarchy-system-wake on that input too.

Related open PRs: #11273 ("keep fingerprint idle while the display is blanked") targets the same behaviour with abort-on-blank semantics and conflicts textually with this PR in runWake, the startFingerprint guard and the blank-timer comment. The description's "libfprint#7179" refers to Omarchy PR #7179.


Review information

Test scope: Source review of d54116f9 against the previous head 939ab0b6, merge-base d174d4aa and current quattro c231097d, with upstream Hyprland (9a1ea292), Quickshell (41651d7d) and fprintd (b10251ea) read at recent tips, since Omarchy does not pin them. The full test/shell suite ran in an isolated sandbox on base and head, and the lock-related test files also on the head merged into quattro. No QML runtime, PAM, fprintd, Hyprland, suspend/resume or fingerprint hardware was run. Timings come from source defaults, and the #10130 interaction is a source trace of the two diffs combined.

AI process: Opus 5.5 Medium coordination and synthesis, Opus 5.5 Xhigh technical review and final fact check, GPT 6 Sol Xhigh search for related issues, Opus 5.5 Medium editorial check.

Opt out: To stop receiving these reviews, reply to this comment saying so.

@omarchybot omarchybot added bug Something isn't working compatibility Make Omarchy work better on everything! labels Sep 27, 2026
@omarchybot

Copy link
Copy Markdown
Collaborator

Reviewed by Claude Opus 5.5, with a second opinion from Codex Medium. I pushed one fix, and the head is now 4ac18089043c31d93c3ee05d2e8d6ccf8b4b6473.

Pushed: 4ac18089 moves the fingerprint re-arm out of runWake() and into an onDisplaysBlankChanged handler. The var wasBlank = root.displaysBlank line in runWake() broke test/shell.d/video-background-test.sh. That test asserts runWake() opens with root.displaysBlank = false, and quattro still asserts it. I checked that the test fails at d54116f9 and passes at 4ac18089. Changing the test instead would have conflicted with quattro, which rewrote the lines around that assertion. The behaviour is the same: a scan restarts only when the display goes from blank to awake, never on more input to an awake lock.

What ran, on a worker built from the Omarchy ISO and linked onto the branch:

  • The full suite (./test/cli and every test/shell.d file) on this branch merged into current quattro (8b4eae66). It fails the same four tests as quattro alone, and nothing else (a vscode theme test, linux-omarchy headers, the network portal fixture, a pre_remove status).
  • The lock tests: video-background-test.sh, lock-blank-fingerprint-test.sh, lock-stranded-recovery-test.sh, monitor-recovery-test.sh, lock-fingerprint-indicator-test.sh and lock-password-overflow-test.sh all pass.
  • A probe that drives Service.qml's own runBlank, runWake, startFingerprint and handleFingerprintFinished against a stubbed PAM context. It ran 20 failed scans after the lock blanks:
    • quattro starts 20 new PAM sessions while the display is blank.
    • This branch starts none, and starts one when the display wakes.
    • Removing the new displaysBlank guard brings the 20 sessions back, and removing the handler stops the re-arm on wake.

That shows the logic, not the hardware. No fingerprint reader was run, so nothing here confirms the thermal behaviour on a CV3, Goodix or Elan reader. The PR's author can't give that confirmation either; it has to come from someone else seeing the overheating, against 4ac18089.

Second opinion: Codex Medium found nothing further at 4ac18089 and judged the change proportionate. The two trade-offs below were already in front of it, so its agreement on them is not independent. It did add two things I had not checked:

Still open, for the maintainer:

  • Readers that never overheat lose touch-to-unlock from a dark lock once the scan in flight at blank ends (up to pam_fprintd's 30 s timeout). The description states this.
  • A panel lit by a key Hyprland consumes under a locked = true bind leaves displaysBlank true and the reader off on a lit lock. Those keys are volume, brightness, media and the power key in default/hypr/bindings/utilities.lua:9, lit through key_press_enables_dpms in default/hypr/input.lua:72. On a power-button sensor, "press power, touch" stops working once the in-flight scan ends; moving the pointer or pressing an unbound key brings the reader back. The trade-off section covers a dark lock but not this lit-lock case.

Related: several open pull requests fix the same overheating differently: #11918, #11273, #7179, #12461, #12544, #13819, #10653 and #10393. This one stops the reader from being armed while the display is dark. #11918, which is already marked ready, backs off retries that fail instantly, which covers the awake lock this one leaves alone. They look complementary rather than alternatives. Which to take, and whether to accept the healthy-reader trade-off, is the maintainer's decision, so this is waiting on them.

@greptile-apps

greptile-apps Bot commented Oct 1, 2026 •

Copy link
Copy Markdown
Contributor

RetriggerConfidence Score: 3/5

[Medium impact] Adds fingerprint reader gating while the lock screen is blanked.

The PR does not appear safe to merge until screen-change and resume rearming also restore the blank timeout.

Findings

  1. P1 Screen changes restart dark scans ▶
  2. P1 Resume leaves scans running ▶

Summary

The PR stops new fingerprint scans when the lock blanks and restarts them when the blank flag clears. It adds source-level tests for the gate and wake routes.

  • Screen-set changes and same-output resume can restart scanning without restoring the blank timer.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[Blank timer fires] --> B[runBlank stops retry timer]
  B --> C{Blank flag cleared}
  C -->|Input wake| D[runWake rearms blank timer]
  C -->|Screen change or resume| E[Change handler restarts scan]
  E --> F[No fresh blank timer]
Loading

Reviews (3) · Last reviewed commit: "lock: pause fingerprint scans while the ..." · Reviewed by Greptile

Comment thread shell/plugins/lock/Service.qml Resolved
@omarchybot omarchybot removed bug Something isn't working compatibility Make Omarchy work better on everything! labels Oct 1, 2026
@omarchybot

Copy link
Copy Markdown
Collaborator

I took bug and compatibility off this pull request because, at 4ac18089, the two models classifying it no longer agree. Claude Opus 5.5 classified it as a compatibility bug: it stops readers that thermally self-disable (Broadcom CV3, Goodix, Elan on libfprint-tod) from overheating while the lock is blanked. Codex Medium, reading the item on its own without that answer, classified it as an enhancement. That reading holds up too, because the change affects every reader on purpose: readers that never overheat lose touch-to-unlock on a dark lock once the scan running at blank ends, and the description presents that as the trade-off. Whether this fixes a hardware fault or deliberately changes lock behaviour for everyone is the maintainer's call, so I've left it without a class label.

Nothing else has changed since my last comment. The review, the worker results and the open points listed there still stand at 4ac18089. Greptile's note on the comment at Service.qml:496 is accurate: runBlank() stops the retries, but a scan already running finishes. llstrk made the same point earlier. It's a one-line wording fix and changes no behaviour, and I haven't pushed it. This is waiting on the maintainer.

@omarchybot

Copy link
Copy Markdown
Collaborator

Merged #7158 covers the immediate-error backoff alternative mentioned here. Pausing new scans while the display is blank remains unmerged: the landed code keeps healthy readers listening through normal scan timeouts. Keeping this open for that distinct arming-policy change.

GPT-6 in Codex and Claude Opus 5.5 Medium checked the coverage against the landed source; Claude's agreement does not guarantee independence. This closure review was read-only and did not rerun runtime tests.

A scan window that ends without a finger counts as a usable attempt, so
with the panel blanked the reader re-arms every 250 ms for as long as the
screen is off, self-heating thermal-limited readers into a cutoff. Stop the
retry loop in runBlank() and refuse new scans in startFingerprint() while
displaysBlank is set.

Re-arm on every route the panel can come back: runWake() and
onScreensChanged() already clear the flag, and a resume that keeps the same
outputs (and so never reaches runWake()) now clears it from
restartFingerprintAfterSleep(). A falling displaysBlank re-arms scanning
from the change handler rather than on every input to an awake lock.
@slr01
slr01 force-pushed the lock/fingerprint-gating branch from de40367 to d82f5c1 Compare October 12, 2026 15:35
// restartFingerprintAfterSleep() clears it for the resume route, which lights
// the panel without either.
onDisplaysBlankChanged: {
if (!displaysBlank && lockRequested && fingerprintConfigured && !authenticatingPassword) startFingerprint()

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P1 Screen changes restart dark scans

If the screen set changes while the lock is blanked and the remaining panels are still dark, onScreensChanged() clears displaysBlank, and this handler starts fingerprint scanning. The blank timer has already fired and is not restarted on this route, so retries can continue on the dark lock instead of stopping after a fresh blank interval.

// keypress. Defer the clear so this function has settled any orphaned
// attempt first; the falling flag re-arms scanning through the
// displaysBlank change handler (runBlank stopped the retry timer).
Qt.callLater(function() { root.displaysBlank = false })

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P1 Resume leaves scans running

When a blanked lock resumes with the same outputs, this deferred clear restarts fingerprint scanning without restarting the blank timer. That single-shot timer was consumed when the lock blanked, so if the display stays awake without further input, scans continue indefinitely.

@slr01

slr01 commented Oct 12, 2026

Copy link
Copy Markdown
Author

Addressed the resume gap (from the omarchybot read on #12202): read against current quattro (4c1b4cb3), restartFingerprintAfterSleep() now clears displaysBlank, so a resume that keeps the same outputs and never reaches runWake() re-arms through the displaysBlank change handler instead of leaving the reader off until a key press. The clear is deferred with Qt.callLater so the resume handler settles any orphaned attempt before the falling flag starts a new scan.

Rebased onto current quattro. Net change is four points: runBlank() stops fingerprintRetryTimer, startFingerprint() returns while displaysBlank, the onDisplaysBlankChanged handler re-arms on the falling edge, and the resume clear above. test/shell.d/lock-fingerprint-blank-gating-test.sh pins all three wake routes. ./test/shell is green apart from the 9 environment-only failures also present on a clean quattro worktree (missing omarchy-pkgs checkout, etc.).

@jandrusk

Copy link
Copy Markdown

Pausing new fingerprint scans while displaysBlank (and re-arming on wake / panel change) is the right fix for thermal self-disable readers.

Same feature as CONFLICTING #11273 — prefer this MERGEABLE head. Related cluster: lid-closed gate #14280/#14251, retry-storm reports #13944/#13748/#12461. #7158's merged backoff is complementary, not a substitute for the blank gate.

@omarchybot

Copy link
Copy Markdown
Collaborator

Since this head (d82f5c1b) was pushed, quattro merged #15294 (76557733), which pauses fingerprint scans while the lock has the displays off. It covers what this pull request does, and the two now conflict in shell/plugins/lock/Service.qml.

Read against quattro at 41d2f9d9, every behaviour here is already there:

  • Retry loop stopped on blank: runBlank() calls pauseFingerprint(), which stops fingerprintRetryTimer (Service.qml:364, :276-280), and armFingerprintRetry() will not restart it while paused (:337).
  • No new scans while blank: startFingerprint() returns while fingerprintPaused (:426).
  • An in-flight scan finishes: pausing aborts nothing.
  • Re-armed on wake: runWake() calls resumeFingerprint() (:270). A screen change resumes it when an output arrives (:891-895). A resume that keeps the same outputs is caught by the pre-suspend lock request arming fingerprintResumeTimer, which resumes the reader when it sees the sleep gap (:944, :708-712).

There is one literal difference. Here, any screen change that clears the blank re-arms the reader. On quattro, only an output being added does, so unplugging a monitor while the panel is blank keeps the reader paused. That is on purpose in #15294. It is not a gap in the fix for the overheating this pull request describes. Porting this change on top would also fight #15294. fingerprintResumeTimer resumes the reader without clearing displaysBlank, so the new guard in startFingerprint() would keep it off. The onDisplaysBlankChanged handler would also skip the remaining backoff that resumeFingerprint() applies.

This was checked by reading the source only. Nothing ran on a worker, because there is nothing left to verify on this branch. Codex Medium reviewed the same question separately and reached the same answer with the same line references. I checked those references against quattro. It can read this session's work, so its agreement is not guaranteed to be independent.

The classification is still unsettled. Claude Opus 5.5 reads this as a compatibility bug, because it targets readers that thermally self-disable. Codex Medium reads it as an enhancement, because it changes arming for every reader on purpose. So this pull request carries no class label.

This now waits on the maintainer. Since quattro already does this, I recommend closing this pull request in favour of #15294.

@slr01

slr01 commented Oct 15, 2026

Copy link
Copy Markdown
Author

Superseded by #15294 (76557733, "Leave the fingerprint reader alone while the lock has the displays off"), which landed the same fix on quattro more completely: pauseFingerprint()/resumeFingerprint() gating on fingerprintPaused, the sleep-gap fingerprintResumeTimer covering the resume-with-same-outputs route, and the retry backoff preserved across the pause - plus tests and the manual entry. This branch now conflicts with quattro and adding ours on top would fight that design (our displaysBlank guard vs fingerprintPaused, and the change handler would skip their backoff), so there is nothing left to port.

Closing in favour of #15294. Thanks to omarchybot and jandrusk for the reads that pinned this down.

@slr01 slr01 closed this Oct 15, 2026
@slr01
slr01 deleted the lock/fingerprint-gating branch October 15, 2026 02:15
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants