tree af83d8f6c63237f56fe3da52a0cd3fc7372e184b
parent b5508fff1f099fa155ced5170fec299ac55971d5
author Beverly <beverlyt@google.com> 1723816703 +0000
committer Beverly <beverlyt@google.com> 1724093115 +0000

[flexiglass] hide and cancel AlternateBouncer when device sleeps

After the device goes to sleep, the alternate bouncer should
immediately hide and any dismiss actions should be reset and
dismiss callbacks should receive an onDismissCancelled call.

Previously, the dismiss registry callbacks would miss success
and cancelled calls. This CL will call onDismissCancelled
when the device goes to sleep from the alternate or
primary bouncer and will call onDismissSucceeded when the
device becomes unlocked.

Fixes: 353955910
Flag: com.android.systemui.scene_container
Test: atest SceneContainerStartableTest
KeyguardDismissActionInteractorTest
Test: look at DismissCallbackRegistry logs from logcat and observe
the cancellation and success calls from the alt/primary bouncer
on AlternateBouncer => sleeping, PrimaryBouncer => sleeping,
AlternateBouncer => Primary Bouncer
Test: Tap on a notification with an intent to bring up the alternate
bouncer. Press the power button to put the device to sleep. Wake
the device and use the FP sensor to authenticate. Observe that the
device enters and does NOT open the stale notification intent.

Change-Id: Ifd6c1a1a1c36da584eaa8a96e73a3848bf943244
