Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Move common From*TransitionInteractor logic into the superclass." into udc-qpr-dev

Browse Source
This commit is contained in:
Josh Tsuji
2023-06-26 15:00:14 +00:00
committed by Android (Google) Code Review
parent 848b73fe14 9c9d951846
commit 816823390a
11 changed files with 301 additions and 459 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromAlternateBouncerTransitionInteractor.kt
View File

@@ -22,7 +22,6 @@ import com.android.systemui.dagger.SysUISingleton
import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.dagger.qualifiers.Application
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.keyguard.shared.model.WakefulnessState import com.android.systemui.keyguard.shared.model.WakefulnessState
import com.android.systemui.util.kotlin.Utils.Companion.toQuad import com.android.systemui.util.kotlin.Utils.Companion.toQuad
import com.android.systemui.util.kotlin.Utils.Companion.toQuint import com.android.systemui.util.kotlin.Utils.Companion.toQuint
@@ -38,11 +37,14 @@ import kotlinx.coroutines.launch
class FromAlternateBouncerTransitionInteractor class FromAlternateBouncerTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromAlternateBouncerTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.ALTERNATE_BOUNCER,
) {
override fun start() { override fun start() {
listenForAlternateBouncerToGone() listenForAlternateBouncerToGone()
@@ -60,7 +62,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.primaryBouncerShowing, keyguardInteractor.primaryBouncerShowing,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.wakefulnessModel, keyguardInteractor.wakefulnessModel,
keyguardInteractor.isAodAvailable, keyguardInteractor.isAodAvailable,
::toQuad ::toQuad
@@ -92,14 +94,7 @@ constructor(
} else { } else {
KeyguardState.LOCKSCREEN KeyguardState.LOCKSCREEN
} }
keyguardTransitionRepository.startTransition( startTransitionTo(to)
TransitionInfo(
ownerName = name,
from = KeyguardState.ALTERNATE_BOUNCER,
to = to,
animator = getAnimator(),
)
)
} }
} }
} }
@@ -108,17 +103,10 @@ constructor(
private fun listenForAlternateBouncerToGone() { private fun listenForAlternateBouncerToGone() {
scope.launch { scope.launch {
keyguardInteractor.isKeyguardGoingAway keyguardInteractor.isKeyguardGoingAway
.sample(keyguardTransitionInteractor.finishedKeyguardState, ::Pair) .sample(transitionInteractor.finishedKeyguardState, ::Pair)
.collect { (isKeyguardGoingAway, keyguardState) -> .collect { (isKeyguardGoingAway, keyguardState) ->
if (isKeyguardGoingAway && keyguardState == KeyguardState.ALTERNATE_BOUNCER) { if (isKeyguardGoingAway && keyguardState == KeyguardState.ALTERNATE_BOUNCER) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
ownerName = name,
from = KeyguardState.ALTERNATE_BOUNCER,
to = KeyguardState.GONE,
animator = getAnimator(),
)
)
} }
} }
} }
@@ -127,26 +115,19 @@ constructor(
private fun listenForAlternateBouncerToPrimaryBouncer() { private fun listenForAlternateBouncerToPrimaryBouncer() {
scope.launch { scope.launch {
keyguardInteractor.primaryBouncerShowing keyguardInteractor.primaryBouncerShowing
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (isPrimaryBouncerShowing, startedKeyguardState) -> .collect { (isPrimaryBouncerShowing, startedKeyguardState) ->
if ( if (
isPrimaryBouncerShowing && isPrimaryBouncerShowing &&
startedKeyguardState.to == KeyguardState.ALTERNATE_BOUNCER startedKeyguardState.to == KeyguardState.ALTERNATE_BOUNCER
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.PRIMARY_BOUNCER)
TransitionInfo(
ownerName = name,
from = KeyguardState.ALTERNATE_BOUNCER,
to = KeyguardState.PRIMARY_BOUNCER,
animator = getAnimator(),
)
)
} }
} }
} }
} }
private fun getAnimator(): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
interpolator = Interpolators.LINEAR interpolator = Interpolators.LINEAR
duration = TRANSITION_DURATION_MS duration = TRANSITION_DURATION_MS

38
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromAodTransitionInteractor.kt
View File

@@ -24,7 +24,6 @@ import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepositor
import com.android.systemui.keyguard.shared.model.BiometricUnlockModel.Companion.isWakeAndUnlock import com.android.systemui.keyguard.shared.model.BiometricUnlockModel.Companion.isWakeAndUnlock
import com.android.systemui.keyguard.shared.model.DozeStateModel import com.android.systemui.keyguard.shared.model.DozeStateModel
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
@@ -34,11 +33,14 @@ import kotlinx.coroutines.launch
class FromAodTransitionInteractor class FromAodTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromAodTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.AOD,
) {
override fun start() { override fun start() {
listenForAodToLockscreen() listenForAodToLockscreen()
@@ -49,18 +51,11 @@ constructor(
scope.launch { scope.launch {
keyguardInteractor keyguardInteractor
.dozeTransitionTo(DozeStateModel.FINISH) .dozeTransitionTo(DozeStateModel.FINISH)
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { pair -> .collect { pair ->
val (dozeToAod, lastStartedStep) = pair val (dozeToAod, lastStartedStep) = pair
if (lastStartedStep.to == KeyguardState.AOD) { if (lastStartedStep.to == KeyguardState.AOD) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.LOCKSCREEN)
TransitionInfo(
name,
KeyguardState.AOD,
KeyguardState.LOCKSCREEN,
getAnimator(),
)
)
} }
} }
} }
@@ -69,29 +64,22 @@ constructor(
private fun listenForAodToGone() { private fun listenForAodToGone() {
scope.launch { scope.launch {
keyguardInteractor.biometricUnlockState keyguardInteractor.biometricUnlockState
.sample(keyguardTransitionInteractor.finishedKeyguardState, ::Pair) .sample(transitionInteractor.finishedKeyguardState, ::Pair)
.collect { pair -> .collect { pair ->
val (biometricUnlockState, keyguardState) = pair val (biometricUnlockState, keyguardState) = pair
if ( if (
keyguardState == KeyguardState.AOD && isWakeAndUnlock(biometricUnlockState) keyguardState == KeyguardState.AOD && isWakeAndUnlock(biometricUnlockState)
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
name,
KeyguardState.AOD,
KeyguardState.GONE,
getAnimator(),
)
)
} }
} }
} }
} }
private fun getAnimator(): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(TRANSITION_DURATION_MS) duration = TRANSITION_DURATION_MS
} }
} }

39
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromDozingTransitionInteractor.kt
View File

@@ -23,10 +23,8 @@ import com.android.systemui.dagger.qualifiers.Application
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.BiometricUnlockModel.Companion.isWakeAndUnlock import com.android.systemui.keyguard.shared.model.BiometricUnlockModel.Companion.isWakeAndUnlock
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
@@ -35,11 +33,14 @@ import kotlinx.coroutines.launch
class FromDozingTransitionInteractor class FromDozingTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromDozingTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.DOZING,
) {
override fun start() { override fun start() {
listenForDozingToLockscreen() listenForDozingToLockscreen()
@@ -49,20 +50,13 @@ constructor(
private fun listenForDozingToLockscreen() { private fun listenForDozingToLockscreen() {
scope.launch { scope.launch {
keyguardInteractor.wakefulnessModel keyguardInteractor.wakefulnessModel
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (wakefulnessModel, lastStartedTransition) -> .collect { (wakefulnessModel, lastStartedTransition) ->
if ( if (
wakefulnessModel.isStartingToWakeOrAwake() && wakefulnessModel.isStartingToWakeOrAwake() &&
lastStartedTransition.to == KeyguardState.DOZING lastStartedTransition.to == KeyguardState.DOZING
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.LOCKSCREEN)
TransitionInfo(
name,
KeyguardState.DOZING,
KeyguardState.LOCKSCREEN,
getAnimator(),
)
)
} }
} }
} }
@@ -71,29 +65,22 @@ constructor(
private fun listenForDozingToGone() { private fun listenForDozingToGone() {
scope.launch { scope.launch {
keyguardInteractor.biometricUnlockState keyguardInteractor.biometricUnlockState
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (biometricUnlockState, lastStartedTransition) -> .collect { (biometricUnlockState, lastStartedTransition) ->
if ( if (
lastStartedTransition.to == KeyguardState.DOZING && lastStartedTransition.to == KeyguardState.DOZING &&
isWakeAndUnlock(biometricUnlockState) isWakeAndUnlock(biometricUnlockState)
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
name,
KeyguardState.DOZING,
KeyguardState.GONE,
getAnimator(),
)
)
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration = DEFAULT_DURATION.inWholeMilliseconds
} }
} }

61
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromDreamingTransitionInteractor.kt
View File

@@ -24,11 +24,9 @@ import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepositor
import com.android.systemui.keyguard.shared.model.BiometricUnlockModel import com.android.systemui.keyguard.shared.model.BiometricUnlockModel
import com.android.systemui.keyguard.shared.model.DozeStateModel import com.android.systemui.keyguard.shared.model.DozeStateModel
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.util.kotlin.Utils.Companion.toTriple import com.android.systemui.util.kotlin.Utils.Companion.toTriple
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.delay import kotlinx.coroutines.delay
@@ -40,11 +38,14 @@ import kotlinx.coroutines.launch
class FromDreamingTransitionInteractor class FromDreamingTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromDreamingTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.DREAMING,
) {
override fun start() { override fun start() {
listenForDreamingToOccluded() listenForDreamingToOccluded()
@@ -54,15 +55,8 @@ constructor(
fun startToLockscreenTransition() { fun startToLockscreenTransition() {
scope.launch { scope.launch {
if (keyguardTransitionInteractor.startedKeyguardState.value == KeyguardState.DREAMING) { if (transitionInteractor.startedKeyguardState.value == KeyguardState.DREAMING) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.LOCKSCREEN)
TransitionInfo(
name,
KeyguardState.DREAMING,
KeyguardState.LOCKSCREEN,
getAnimator(TO_LOCKSCREEN_DURATION),
)
)
} }
} }
} }
@@ -76,7 +70,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.isKeyguardOccluded, keyguardInteractor.isKeyguardOccluded,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
::Pair, ::Pair,
), ),
::toTriple ::toTriple
@@ -92,14 +86,7 @@ constructor(
// action. There's no great signal to determine when the dream is ending // action. There's no great signal to determine when the dream is ending
// and a transition to OCCLUDED is beginning directly. For now, the solution // and a transition to OCCLUDED is beginning directly. For now, the solution
// is DREAMING->LOCKSCREEN->OCCLUDED // is DREAMING->LOCKSCREEN->OCCLUDED
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.OCCLUDED)
TransitionInfo(
name,
lastStartedTransition.to,
KeyguardState.OCCLUDED,
getAnimator(),
)
)
} }
} }
} }
@@ -109,14 +96,7 @@ constructor(
scope.launch { scope.launch {
keyguardInteractor.biometricUnlockState.collect { biometricUnlockState -> keyguardInteractor.biometricUnlockState.collect { biometricUnlockState ->
if (biometricUnlockState == BiometricUnlockModel.WAKE_AND_UNLOCK_FROM_DREAM) { if (biometricUnlockState == BiometricUnlockModel.WAKE_AND_UNLOCK_FROM_DREAM) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
name,
KeyguardState.DREAMING,
KeyguardState.GONE,
getAnimator(),
)
)
} }
} }
} }
@@ -126,7 +106,7 @@ constructor(
scope.launch { scope.launch {
combine( combine(
keyguardInteractor.dozeTransitionModel, keyguardInteractor.dozeTransitionModel,
keyguardTransitionInteractor.finishedKeyguardState, transitionInteractor.finishedKeyguardState,
::Pair ::Pair
) )
.collect { (dozeTransitionModel, keyguardState) -> .collect { (dozeTransitionModel, keyguardState) ->
@@ -134,23 +114,18 @@ constructor(
dozeTransitionModel.to == DozeStateModel.DOZE && dozeTransitionModel.to == DozeStateModel.DOZE &&
keyguardState == KeyguardState.DREAMING keyguardState == KeyguardState.DREAMING
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.DOZING)
TransitionInfo(
name,
KeyguardState.DREAMING,
KeyguardState.DOZING,
getAnimator(),
)
)
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration =
if (toState == KeyguardState.LOCKSCREEN) TO_LOCKSCREEN_DURATION.inWholeMilliseconds
else DEFAULT_DURATION.inWholeMilliseconds
} }
} }

59
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromGoneTransitionInteractor.kt
View File

@@ -22,12 +22,10 @@ import com.android.systemui.dagger.SysUISingleton
import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.dagger.qualifiers.Application
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.keyguard.shared.model.WakefulnessState import com.android.systemui.keyguard.shared.model.WakefulnessState
import com.android.systemui.util.kotlin.Utils.Companion.toTriple import com.android.systemui.util.kotlin.Utils.Companion.toTriple
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.combine
@@ -37,11 +35,14 @@ import kotlinx.coroutines.launch
class FromGoneTransitionInteractor class FromGoneTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromGoneTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.GONE,
) {
override fun start() { override fun start() {
listenForGoneToAodOrDozing() listenForGoneToAodOrDozing()
@@ -53,17 +54,10 @@ constructor(
private fun listenForGoneToLockscreen() { private fun listenForGoneToLockscreen() {
scope.launch { scope.launch {
keyguardInteractor.isKeyguardShowing keyguardInteractor.isKeyguardShowing
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (isKeyguardShowing, lastStartedStep) -> .collect { (isKeyguardShowing, lastStartedStep) ->
if (isKeyguardShowing && lastStartedStep.to == KeyguardState.GONE) { if (isKeyguardShowing && lastStartedStep.to == KeyguardState.GONE) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.LOCKSCREEN)
TransitionInfo(
name,
KeyguardState.GONE,
KeyguardState.LOCKSCREEN,
getAnimator(),
)
)
} }
} }
} }
@@ -72,17 +66,10 @@ constructor(
private fun listenForGoneToDreaming() { private fun listenForGoneToDreaming() {
scope.launch { scope.launch {
keyguardInteractor.isAbleToDream keyguardInteractor.isAbleToDream
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (isAbleToDream, lastStartedStep) -> .collect { (isAbleToDream, lastStartedStep) ->
if (isAbleToDream && lastStartedStep.to == KeyguardState.GONE) { if (isAbleToDream && lastStartedStep.to == KeyguardState.GONE) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.DREAMING)
TransitionInfo(
name,
KeyguardState.GONE,
KeyguardState.DREAMING,
getAnimator(TO_DREAMING_DURATION),
)
)
} }
} }
} }
@@ -93,7 +80,7 @@ constructor(
keyguardInteractor.wakefulnessModel keyguardInteractor.wakefulnessModel
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.isAodAvailable, keyguardInteractor.isAodAvailable,
::Pair ::Pair
), ),
@@ -104,30 +91,24 @@ constructor(
lastStartedStep.to == KeyguardState.GONE && lastStartedStep.to == KeyguardState.GONE &&
wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(
TransitionInfo( if (isAodAvailable) KeyguardState.AOD else KeyguardState.DOZING
name,
KeyguardState.GONE,
if (isAodAvailable) {
KeyguardState.AOD
} else {
KeyguardState.DOZING
},
getAnimator(),
)
) )
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration =
when (toState) {
KeyguardState.DREAMING -> TO_DREAMING_DURATION
else -> DEFAULT_DURATION
}.inWholeMilliseconds
} }
} }
companion object { companion object {
private val DEFAULT_DURATION = 500.milliseconds private val DEFAULT_DURATION = 500.milliseconds
val TO_DREAMING_DURATION = 933.milliseconds val TO_DREAMING_DURATION = 933.milliseconds

126
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromLockscreenTransitionInteractor.kt
View File

@@ -32,7 +32,6 @@ import com.android.systemui.util.kotlin.Utils.Companion.toTriple
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import java.util.UUID import java.util.UUID
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.combine
@@ -42,12 +41,15 @@ import kotlinx.coroutines.launch
class FromLockscreenTransitionInteractor class FromLockscreenTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val shadeRepository: ShadeRepository, private val shadeRepository: ShadeRepository,
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, ) :
private val keyguardTransitionRepository: KeyguardTransitionRepository, TransitionInteractor(
) : TransitionInteractor(FromLockscreenTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.LOCKSCREEN,
) {
override fun start() { override fun start() {
listenForLockscreenToGone() listenForLockscreenToGone()
@@ -66,8 +68,8 @@ constructor(
keyguardInteractor.isAbleToDream keyguardInteractor.isAbleToDream
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardTransitionInteractor.finishedKeyguardState, transitionInteractor.finishedKeyguardState,
::Pair ::Pair
), ),
::toTriple ::toTriple
@@ -78,14 +80,7 @@ constructor(
lastStartedTransition.to == KeyguardState.LOCKSCREEN && lastStartedTransition.to == KeyguardState.LOCKSCREEN &&
!invalidFromStates.contains(lastStartedTransition.from) !invalidFromStates.contains(lastStartedTransition.from)
if (isAbleToDream && (isOnLockscreen || isTransitionInterruptible)) { if (isAbleToDream && (isOnLockscreen || isTransitionInterruptible)) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.DREAMING)
TransitionInfo(
name,
KeyguardState.LOCKSCREEN,
KeyguardState.DREAMING,
getAnimator(TO_DREAMING_DURATION),
)
)
} }
} }
} }
@@ -94,20 +89,13 @@ constructor(
private fun listenForLockscreenToPrimaryBouncer() { private fun listenForLockscreenToPrimaryBouncer() {
scope.launch { scope.launch {
keyguardInteractor.primaryBouncerShowing keyguardInteractor.primaryBouncerShowing
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { pair -> .collect { pair ->
val (isBouncerShowing, lastStartedTransitionStep) = pair val (isBouncerShowing, lastStartedTransitionStep) = pair
if ( if (
isBouncerShowing && lastStartedTransitionStep.to == KeyguardState.LOCKSCREEN isBouncerShowing && lastStartedTransitionStep.to == KeyguardState.LOCKSCREEN
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.PRIMARY_BOUNCER)
TransitionInfo(
ownerName = name,
from = KeyguardState.LOCKSCREEN,
to = KeyguardState.PRIMARY_BOUNCER,
animator = getAnimator(),
)
)
} }
} }
} }
@@ -116,21 +104,14 @@ constructor(
private fun listenForLockscreenToAlternateBouncer() { private fun listenForLockscreenToAlternateBouncer() {
scope.launch { scope.launch {
keyguardInteractor.alternateBouncerShowing keyguardInteractor.alternateBouncerShowing
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { pair -> .collect { pair ->
val (isAlternateBouncerShowing, lastStartedTransitionStep) = pair val (isAlternateBouncerShowing, lastStartedTransitionStep) = pair
if ( if (
isAlternateBouncerShowing && isAlternateBouncerShowing &&
lastStartedTransitionStep.to == KeyguardState.LOCKSCREEN lastStartedTransitionStep.to == KeyguardState.LOCKSCREEN
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.ALTERNATE_BOUNCER)
TransitionInfo(
ownerName = name,
from = KeyguardState.LOCKSCREEN,
to = KeyguardState.ALTERNATE_BOUNCER,
animator = getAnimator(),
)
)
} }
} }
} }
@@ -143,7 +124,7 @@ constructor(
shadeRepository.shadeModel shadeRepository.shadeModel
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.statusBarState, keyguardInteractor.statusBarState,
keyguardInteractor.isKeyguardUnlocked, keyguardInteractor.isKeyguardUnlocked,
::Triple ::Triple
@@ -164,7 +145,7 @@ constructor(
} else { } else {
TransitionState.RUNNING TransitionState.RUNNING
} }
keyguardTransitionRepository.updateTransition( transitionRepository.updateTransition(
id, id,
1f - shadeModel.expansionAmount, 1f - shadeModel.expansionAmount,
nextState, nextState,
@@ -178,13 +159,17 @@ constructor(
} }
// If canceled, just put the state back // If canceled, just put the state back
// TODO: This logic should happen in FromPrimaryBouncerInteractor.
if (nextState == TransitionState.CANCELED) { if (nextState == TransitionState.CANCELED) {
keyguardTransitionRepository.startTransition( transitionRepository.startTransition(
TransitionInfo( TransitionInfo(
ownerName = name, ownerName = name,
from = KeyguardState.PRIMARY_BOUNCER, from = KeyguardState.PRIMARY_BOUNCER,
to = KeyguardState.LOCKSCREEN, to = KeyguardState.LOCKSCREEN,
animator = getAnimator(0.milliseconds) animator =
getDefaultAnimatorForTransitionsToState(KeyguardState.LOCKSCREEN).apply {
duration = 0
}
) )
) )
} }
@@ -198,15 +183,7 @@ constructor(
!isKeyguardUnlocked && !isKeyguardUnlocked &&
statusBarState == KEYGUARD statusBarState == KEYGUARD
) { ) {
transitionId = transitionId = startTransitionTo(KeyguardState.PRIMARY_BOUNCER)
keyguardTransitionRepository.startTransition(
TransitionInfo(
ownerName = name,
from = KeyguardState.LOCKSCREEN,
to = KeyguardState.PRIMARY_BOUNCER,
animator = null,
)
)
} }
} }
} }
@@ -216,18 +193,11 @@ constructor(
private fun listenForLockscreenToGone() { private fun listenForLockscreenToGone() {
scope.launch { scope.launch {
keyguardInteractor.isKeyguardGoingAway keyguardInteractor.isKeyguardGoingAway
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { pair -> .collect { pair ->
val (isKeyguardGoingAway, lastStartedStep) = pair val (isKeyguardGoingAway, lastStartedStep) = pair
if (isKeyguardGoingAway && lastStartedStep.to == KeyguardState.LOCKSCREEN) { if (isKeyguardGoingAway && lastStartedStep.to == KeyguardState.LOCKSCREEN) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
name,
KeyguardState.LOCKSCREEN,
KeyguardState.GONE,
getAnimator(),
)
)
} }
} }
} }
@@ -238,7 +208,7 @@ constructor(
keyguardInteractor.isKeyguardOccluded keyguardInteractor.isKeyguardOccluded
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.finishedKeyguardState, transitionInteractor.finishedKeyguardState,
keyguardInteractor.isDreaming, keyguardInteractor.isDreaming,
::Pair ::Pair
), ),
@@ -246,14 +216,7 @@ constructor(
) )
.collect { (isOccluded, keyguardState, isDreaming) -> .collect { (isOccluded, keyguardState, isDreaming) ->
if (isOccluded && !isDreaming && keyguardState == KeyguardState.LOCKSCREEN) { if (isOccluded && !isDreaming && keyguardState == KeyguardState.LOCKSCREEN) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.OCCLUDED)
TransitionInfo(
name,
keyguardState,
KeyguardState.OCCLUDED,
getAnimator(TO_OCCLUDED_DURATION),
)
)
} }
} }
} }
@@ -263,7 +226,7 @@ constructor(
private fun listenForLockscreenToCamera() { private fun listenForLockscreenToCamera() {
scope.launch { scope.launch {
keyguardInteractor.onCameraLaunchDetected keyguardInteractor.onCameraLaunchDetected
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (_, lastStartedStep) -> .collect { (_, lastStartedStep) ->
// DREAMING/AOD/OFF may trigger on the first power button push, so include this // DREAMING/AOD/OFF may trigger on the first power button push, so include this
// state in order to cancel and correct the transition // state in order to cancel and correct the transition
@@ -274,14 +237,7 @@ constructor(
lastStartedStep.to == KeyguardState.AOD || lastStartedStep.to == KeyguardState.AOD ||
lastStartedStep.to == KeyguardState.OFF lastStartedStep.to == KeyguardState.OFF
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.OCCLUDED)
TransitionInfo(
name,
KeyguardState.LOCKSCREEN,
KeyguardState.OCCLUDED,
getAnimator(TO_OCCLUDED_DURATION),
)
)
} }
} }
} }
@@ -292,7 +248,7 @@ constructor(
keyguardInteractor.wakefulnessModel keyguardInteractor.wakefulnessModel
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.isAodAvailable, keyguardInteractor.isAodAvailable,
::Pair ::Pair
), ),
@@ -303,27 +259,23 @@ constructor(
lastStartedStep.to == KeyguardState.LOCKSCREEN && lastStartedStep.to == KeyguardState.LOCKSCREEN &&
wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(
TransitionInfo( if (isAodAvailable) KeyguardState.AOD else KeyguardState.DOZING
name,
KeyguardState.LOCKSCREEN,
if (isAodAvailable) {
KeyguardState.AOD
} else {
KeyguardState.DOZING
},
getAnimator(),
)
) )
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration =
when (toState) {
KeyguardState.DREAMING -> TO_DREAMING_DURATION
KeyguardState.OCCLUDED -> TO_OCCLUDED_DURATION
else -> DEFAULT_DURATION
}.inWholeMilliseconds
} }
} }

80
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromOccludedTransitionInteractor.kt
View File

@@ -22,12 +22,10 @@ import com.android.systemui.dagger.SysUISingleton
import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.dagger.qualifiers.Application
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.keyguard.shared.model.WakefulnessState import com.android.systemui.keyguard.shared.model.WakefulnessState
import com.android.systemui.util.kotlin.Utils.Companion.toTriple import com.android.systemui.util.kotlin.Utils.Companion.toTriple
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.combine
@@ -37,11 +35,14 @@ import kotlinx.coroutines.launch
class FromOccludedTransitionInteractor class FromOccludedTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository, ) :
private val keyguardTransitionInteractor: KeyguardTransitionInteractor, TransitionInteractor(
) : TransitionInteractor(FromOccludedTransitionInteractor::class.simpleName!!) { fromState = KeyguardState.OCCLUDED,
) {
override fun start() { override fun start() {
listenForOccludedToLockscreen() listenForOccludedToLockscreen()
@@ -54,18 +55,11 @@ constructor(
private fun listenForOccludedToDreaming() { private fun listenForOccludedToDreaming() {
scope.launch { scope.launch {
keyguardInteractor.isAbleToDream keyguardInteractor.isAbleToDream
.sample(keyguardTransitionInteractor.finishedKeyguardState, ::Pair) .sample(transitionInteractor.finishedKeyguardState, ::Pair)
.collect { pair -> .collect { pair ->
val (isAbleToDream, keyguardState) = pair val (isAbleToDream, keyguardState) = pair
if (isAbleToDream && keyguardState == KeyguardState.OCCLUDED) { if (isAbleToDream && keyguardState == KeyguardState.OCCLUDED) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.DREAMING)
TransitionInfo(
name,
KeyguardState.OCCLUDED,
KeyguardState.DREAMING,
getAnimator(),
)
)
} }
} }
} }
@@ -77,7 +71,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.isKeyguardShowing, keyguardInteractor.isKeyguardShowing,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
::Pair ::Pair
), ),
::toTriple ::toTriple
@@ -90,14 +84,7 @@ constructor(
isShowing && isShowing &&
lastStartedKeyguardState.to == KeyguardState.OCCLUDED lastStartedKeyguardState.to == KeyguardState.OCCLUDED
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.LOCKSCREEN)
TransitionInfo(
name,
KeyguardState.OCCLUDED,
KeyguardState.LOCKSCREEN,
getAnimator(TO_LOCKSCREEN_DURATION),
)
)
} }
} }
} }
@@ -109,7 +96,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.isKeyguardShowing, keyguardInteractor.isKeyguardShowing,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
::Pair ::Pair
), ),
::toTriple ::toTriple
@@ -122,14 +109,7 @@ constructor(
!isShowing && !isShowing &&
lastStartedKeyguardState.to == KeyguardState.OCCLUDED lastStartedKeyguardState.to == KeyguardState.OCCLUDED
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.GONE)
TransitionInfo(
name,
KeyguardState.OCCLUDED,
KeyguardState.GONE,
getAnimator(),
)
)
} }
} }
} }
@@ -140,7 +120,7 @@ constructor(
keyguardInteractor.wakefulnessModel keyguardInteractor.wakefulnessModel
.sample( .sample(
combine( combine(
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.isAodAvailable, keyguardInteractor.isAodAvailable,
::Pair ::Pair
), ),
@@ -151,17 +131,8 @@ constructor(
lastStartedStep.to == KeyguardState.OCCLUDED && lastStartedStep.to == KeyguardState.OCCLUDED &&
wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(
TransitionInfo( if (isAodAvailable) KeyguardState.AOD else KeyguardState.DOZING
name,
KeyguardState.OCCLUDED,
if (isAodAvailable) {
KeyguardState.AOD
} else {
KeyguardState.DOZING
},
getAnimator(),
)
) )
} }
} }
@@ -171,29 +142,26 @@ constructor(
private fun listenForOccludedToAlternateBouncer() { private fun listenForOccludedToAlternateBouncer() {
scope.launch { scope.launch {
keyguardInteractor.alternateBouncerShowing keyguardInteractor.alternateBouncerShowing
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (isAlternateBouncerShowing, lastStartedTransitionStep) -> .collect { (isAlternateBouncerShowing, lastStartedTransitionStep) ->
if ( if (
isAlternateBouncerShowing && isAlternateBouncerShowing &&
lastStartedTransitionStep.to == KeyguardState.OCCLUDED lastStartedTransitionStep.to == KeyguardState.OCCLUDED
) { ) {
keyguardTransitionRepository.startTransition( startTransitionTo(KeyguardState.ALTERNATE_BOUNCER)
TransitionInfo(
ownerName = name,
from = KeyguardState.OCCLUDED,
to = KeyguardState.ALTERNATE_BOUNCER,
animator = getAnimator(),
)
)
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration =
when (toState) {
KeyguardState.LOCKSCREEN -> TO_LOCKSCREEN_DURATION
else -> DEFAULT_DURATION
}.inWholeMilliseconds
} }
} }

71
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromPrimaryBouncerTransitionInteractor.kt
View File

@@ -25,12 +25,10 @@ import com.android.systemui.dagger.SysUISingleton
import com.android.systemui.dagger.qualifiers.Application import com.android.systemui.dagger.qualifiers.Application
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.KeyguardState import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import com.android.systemui.keyguard.shared.model.WakefulnessState import com.android.systemui.keyguard.shared.model.WakefulnessState
import com.android.systemui.util.kotlin.Utils.Companion.toQuad import com.android.systemui.util.kotlin.Utils.Companion.toQuad
import com.android.systemui.util.kotlin.sample import com.android.systemui.util.kotlin.sample
import javax.inject.Inject import javax.inject.Inject
import kotlin.time.Duration
import kotlin.time.Duration.Companion.milliseconds import kotlin.time.Duration.Companion.milliseconds
import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.flow.combine import kotlinx.coroutines.flow.combine
@@ -40,12 +38,15 @@ import kotlinx.coroutines.launch
class FromPrimaryBouncerTransitionInteractor class FromPrimaryBouncerTransitionInteractor
@Inject @Inject
constructor( constructor(
override val transitionRepository: KeyguardTransitionRepository,
override val transitionInteractor: KeyguardTransitionInteractor,
@Application private val scope: CoroutineScope, @Application private val scope: CoroutineScope,
private val keyguardInteractor: KeyguardInteractor, private val keyguardInteractor: KeyguardInteractor,
private val keyguardTransitionRepository: KeyguardTransitionRepository,
private val keyguardTransitionInteractor: KeyguardTransitionInteractor,
private val keyguardSecurityModel: KeyguardSecurityModel, private val keyguardSecurityModel: KeyguardSecurityModel,
) : TransitionInteractor(FromPrimaryBouncerTransitionInteractor::class.simpleName!!) { ) :
TransitionInteractor(
fromState = KeyguardState.PRIMARY_BOUNCER,
) {
override fun start() { override fun start() {
listenForPrimaryBouncerToGone() listenForPrimaryBouncerToGone()
@@ -59,7 +60,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.wakefulnessModel, keyguardInteractor.wakefulnessModel,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.isKeyguardOccluded, keyguardInteractor.isKeyguardOccluded,
::Triple ::Triple
), ),
@@ -73,20 +74,8 @@ constructor(
(wakefulnessState.state == WakefulnessState.AWAKE || (wakefulnessState.state == WakefulnessState.AWAKE ||
wakefulnessState.state == WakefulnessState.STARTING_TO_WAKE) wakefulnessState.state == WakefulnessState.STARTING_TO_WAKE)
) { ) {
val to = startTransitionTo(
if (occluded) { if (occluded) KeyguardState.OCCLUDED else KeyguardState.LOCKSCREEN
KeyguardState.OCCLUDED
} else {
KeyguardState.LOCKSCREEN
}
keyguardTransitionRepository.startTransition(
TransitionInfo(
ownerName = name,
from = KeyguardState.PRIMARY_BOUNCER,
to = to,
animator = getAnimator(),
)
) )
} }
} }
@@ -99,7 +88,7 @@ constructor(
.sample( .sample(
combine( combine(
keyguardInteractor.wakefulnessModel, keyguardInteractor.wakefulnessModel,
keyguardTransitionInteractor.startedKeyguardTransitionStep, transitionInteractor.startedKeyguardTransitionStep,
keyguardInteractor.isAodAvailable, keyguardInteractor.isAodAvailable,
::Triple ::Triple
), ),
@@ -114,20 +103,8 @@ constructor(
(wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP || (wakefulnessState.state == WakefulnessState.STARTING_TO_SLEEP ||
wakefulnessState.state == WakefulnessState.ASLEEP) wakefulnessState.state == WakefulnessState.ASLEEP)
) { ) {
val to = startTransitionTo(
if (isAodAvailable) { if (isAodAvailable) KeyguardState.AOD else KeyguardState.DOZING
KeyguardState.AOD
} else {
KeyguardState.DOZING
}
keyguardTransitionRepository.startTransition(
TransitionInfo(
ownerName = name,
from = KeyguardState.PRIMARY_BOUNCER,
to = to,
animator = getAnimator(),
)
) )
} }
} }
@@ -137,7 +114,7 @@ constructor(
private fun listenForPrimaryBouncerToGone() { private fun listenForPrimaryBouncerToGone() {
scope.launch { scope.launch {
keyguardInteractor.isKeyguardGoingAway keyguardInteractor.isKeyguardGoingAway
.sample(keyguardTransitionInteractor.startedKeyguardTransitionStep, ::Pair) .sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
.collect { (isKeyguardGoingAway, lastStartedTransitionStep) -> .collect { (isKeyguardGoingAway, lastStartedTransitionStep) ->
if ( if (
isKeyguardGoingAway && isKeyguardGoingAway &&
@@ -154,24 +131,24 @@ constructor(
} else { } else {
TO_GONE_DURATION TO_GONE_DURATION
} }
keyguardTransitionRepository.startTransition(
TransitionInfo( startTransitionTo(
ownerName = name, toState = KeyguardState.GONE,
from = KeyguardState.PRIMARY_BOUNCER, animator =
to = KeyguardState.GONE, getDefaultAnimatorForTransitionsToState(KeyguardState.GONE).apply {
animator = getAnimator(duration), this.duration = duration.inWholeMilliseconds
), },
resetIfCanceled = true, resetIfCancelled = true
) )
} }
} }
} }
} }
private fun getAnimator(duration: Duration = DEFAULT_DURATION): ValueAnimator { override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
return ValueAnimator().apply { return ValueAnimator().apply {
setInterpolator(Interpolators.LINEAR) interpolator = Interpolators.LINEAR
setDuration(duration.inWholeMilliseconds) duration = DEFAULT_DURATION.inWholeMilliseconds
} }
} }

2
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/KeyguardTransitionInteractor.kt
View File

@@ -47,6 +47,8 @@ constructor(
private val repository: KeyguardTransitionRepository, private val repository: KeyguardTransitionRepository,
@Application val scope: CoroutineScope, @Application val scope: CoroutineScope,
) { ) {
private val TAG = this::class.simpleName
/** (any)->GONE transition information */ /** (any)->GONE transition information */
val anyStateToGoneTransition: Flow<TransitionStep> = val anyStateToGoneTransition: Flow<TransitionStep> =
repository.transitions.filter { step -> step.to == KeyguardState.GONE } repository.transitions.filter { step -> step.to == KeyguardState.GONE }

54
packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/TransitionInteractor.kt
View File

@@ -15,6 +15,14 @@
*/ */
package com.android.systemui.keyguard.domain.interactor package com.android.systemui.keyguard.domain.interactor
import android.animation.ValueAnimator
import android.util.Log
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.KeyguardState
import com.android.systemui.keyguard.shared.model.TransitionInfo
import java.util.UUID
/** /**
* Each TransitionInteractor is responsible for determining under which conditions to notify * Each TransitionInteractor is responsible for determining under which conditions to notify
* [KeyguardTransitionRepository] to signal a transition. When (and if) the transition occurs is * [KeyguardTransitionRepository] to signal a transition. When (and if) the transition occurs is
@@ -26,6 +34,50 @@ package com.android.systemui.keyguard.domain.interactor
* MUST list implementing classes in dagger module [StartKeyguardTransitionModule] and also in the * MUST list implementing classes in dagger module [StartKeyguardTransitionModule] and also in the
* 'when' clause of [KeyguardTransitionCoreStartable] * 'when' clause of [KeyguardTransitionCoreStartable]
*/ */
sealed class TransitionInteractor(val name: String) { sealed class TransitionInteractor(
val fromState: KeyguardState,
) {
val name = this::class.simpleName ?: "UnknownTransitionInteractor"
abstract val transitionRepository: KeyguardTransitionRepository
abstract val transitionInteractor: KeyguardTransitionInteractor
abstract fun start() abstract fun start()
fun startTransitionTo(
toState: KeyguardState,
animator: ValueAnimator? = getDefaultAnimatorForTransitionsToState(toState),
resetIfCancelled: Boolean = false
): UUID? {
if (
fromState != transitionInteractor.startedKeyguardState.value &&
fromState != transitionInteractor.finishedKeyguardState.value
) {
Log.e(
name,
"startTransition: We were asked to transition from " +
"$fromState to $toState, however we last finished a transition to " +
"${transitionInteractor.finishedKeyguardState.value}, " +
"and last started a transition to " +
"${transitionInteractor.startedKeyguardState.value}. " +
"Ignoring startTransition, but this should never happen."
)
return null
}
return transitionRepository.startTransition(
TransitionInfo(
name,
fromState,
toState,
animator,
),
resetIfCancelled
)
}
/**
* Returns a ValueAnimator to be used for transitions to [toState], if one is not explicitly
* passed to [startTransitionTo].
*/
abstract fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator?
} }

185
packages/SystemUI/tests/src/com/android/systemui/keyguard/domain/interactor/KeyguardTransitionScenariosTest.kt
View File

@@ -25,7 +25,6 @@ import com.android.systemui.flags.FakeFeatureFlags
import com.android.systemui.flags.Flags import com.android.systemui.flags.Flags
import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository
import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository import com.android.systemui.keyguard.data.repository.FakeKeyguardTransitionRepository
import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
import com.android.systemui.keyguard.shared.model.BiometricUnlockModel import com.android.systemui.keyguard.shared.model.BiometricUnlockModel
import com.android.systemui.keyguard.shared.model.DozeStateModel import com.android.systemui.keyguard.shared.model.DozeStateModel
import com.android.systemui.keyguard.shared.model.DozeTransitionModel import com.android.systemui.keyguard.shared.model.DozeTransitionModel
@@ -56,6 +55,7 @@ import org.mockito.ArgumentMatchers.anyInt
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito.never import org.mockito.Mockito.never
import org.mockito.Mockito.reset import org.mockito.Mockito.reset
import org.mockito.Mockito.spy
import org.mockito.Mockito.verify import org.mockito.Mockito.verify
import org.mockito.MockitoAnnotations import org.mockito.MockitoAnnotations
@@ -72,10 +72,10 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
private lateinit var bouncerRepository: FakeKeyguardBouncerRepository private lateinit var bouncerRepository: FakeKeyguardBouncerRepository
private lateinit var shadeRepository: ShadeRepository private lateinit var shadeRepository: ShadeRepository
private lateinit var transitionRepository: FakeKeyguardTransitionRepository private lateinit var transitionRepository: FakeKeyguardTransitionRepository
private lateinit var transitionInteractor: KeyguardTransitionInteractor
private lateinit var featureFlags: FakeFeatureFlags private lateinit var featureFlags: FakeFeatureFlags
// Used to verify transition requests for test output // Used to verify transition requests for test output
@Mock private lateinit var mockTransitionRepository: KeyguardTransitionRepository
@Mock private lateinit var keyguardSecurityModel: KeyguardSecurityModel @Mock private lateinit var keyguardSecurityModel: KeyguardSecurityModel
private lateinit var fromLockscreenTransitionInteractor: FromLockscreenTransitionInteractor private lateinit var fromLockscreenTransitionInteractor: FromLockscreenTransitionInteractor
@@ -97,92 +97,71 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
keyguardRepository = FakeKeyguardRepository() keyguardRepository = FakeKeyguardRepository()
bouncerRepository = FakeKeyguardBouncerRepository() bouncerRepository = FakeKeyguardBouncerRepository()
shadeRepository = FakeShadeRepository() shadeRepository = FakeShadeRepository()
transitionRepository = FakeKeyguardTransitionRepository() transitionRepository = spy(FakeKeyguardTransitionRepository())
transitionInteractor = KeyguardTransitionInteractor(
transitionRepository, testScope.backgroundScope)
whenever(keyguardSecurityModel.getSecurityMode(anyInt())).thenReturn(PIN) whenever(keyguardSecurityModel.getSecurityMode(anyInt())).thenReturn(PIN)
featureFlags = FakeFeatureFlags().apply { set(Flags.FACE_AUTH_REFACTOR, true) } featureFlags = FakeFeatureFlags().apply { set(Flags.FACE_AUTH_REFACTOR, true) }
fromLockscreenTransitionInteractor =
FromLockscreenTransitionInteractor( fromLockscreenTransitionInteractor = FromLockscreenTransitionInteractor(
scope = testScope, scope = testScope,
keyguardInteractor = createKeyguardInteractor(), keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
shadeRepository = shadeRepository, shadeRepository = shadeRepository,
keyguardTransitionRepository = mockTransitionRepository, ).apply { start() }
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromLockscreenTransitionInteractor.start()
fromDreamingTransitionInteractor = fromPrimaryBouncerTransitionInteractor = FromPrimaryBouncerTransitionInteractor(
FromDreamingTransitionInteractor(
scope = testScope, scope = testScope,
keyguardInteractor = createKeyguardInteractor(), keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository, transitionRepository = transitionRepository,
keyguardTransitionInteractor = transitionInteractor = transitionInteractor,
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromDreamingTransitionInteractor.start()
fromAodTransitionInteractor =
FromAodTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromAodTransitionInteractor.start()
fromGoneTransitionInteractor =
FromGoneTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromGoneTransitionInteractor.start()
fromDozingTransitionInteractor =
FromDozingTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromDozingTransitionInteractor.start()
fromOccludedTransitionInteractor =
FromOccludedTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromOccludedTransitionInteractor.start()
fromAlternateBouncerTransitionInteractor =
FromAlternateBouncerTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
)
fromAlternateBouncerTransitionInteractor.start()
fromPrimaryBouncerTransitionInteractor =
FromPrimaryBouncerTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
keyguardTransitionRepository = mockTransitionRepository,
keyguardTransitionInteractor =
KeyguardTransitionInteractor(transitionRepository, testScope.backgroundScope),
keyguardSecurityModel = keyguardSecurityModel, keyguardSecurityModel = keyguardSecurityModel,
) ).apply { start() }
fromPrimaryBouncerTransitionInteractor.start()
fromDreamingTransitionInteractor = FromDreamingTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
fromAodTransitionInteractor = FromAodTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
fromGoneTransitionInteractor = FromGoneTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
fromDozingTransitionInteractor = FromDozingTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
fromOccludedTransitionInteractor = FromOccludedTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
fromAlternateBouncerTransitionInteractor = FromAlternateBouncerTransitionInteractor(
scope = testScope,
keyguardInteractor = createKeyguardInteractor(),
transitionRepository = transitionRepository,
transitionInteractor = transitionInteractor,
).apply { start() }
} }
@Test @Test
@@ -201,7 +180,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to PRIMARY_BOUNCER should occur // THEN a transition to PRIMARY_BOUNCER should occur
assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor")
@@ -228,7 +207,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor")
@@ -255,7 +234,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor")
@@ -286,7 +265,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DREAMING should occur // THEN a transition to DREAMING should occur
assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor")
@@ -313,7 +292,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor")
@@ -340,7 +319,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromLockscreenTransitionInteractor")
@@ -363,7 +342,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromDozingTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromDozingTransitionInteractor")
@@ -388,14 +367,14 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
) )
) )
runCurrent() runCurrent()
reset(mockTransitionRepository) reset(transitionRepository)
// WHEN a signal comes that dreaming is enabled // WHEN a signal comes that dreaming is enabled
keyguardRepository.setDreamingWithOverlay(true) keyguardRepository.setDreamingWithOverlay(true)
advanceUntilIdle() advanceUntilIdle()
// THEN the transition is ignored // THEN the transition is ignored
verify(mockTransitionRepository, never()).startTransition(any(), anyBoolean()) verify(transitionRepository, never()).startTransition(any(), anyBoolean())
coroutineContext.cancelChildren() coroutineContext.cancelChildren()
} }
@@ -412,7 +391,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromDozingTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromDozingTransitionInteractor")
@@ -439,7 +418,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor")
@@ -466,7 +445,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AOD should occur // THEN a transition to AOD should occur
assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor")
@@ -489,7 +468,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AOD should occur // THEN a transition to AOD should occur
assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor")
@@ -520,7 +499,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DREAMING should occur // THEN a transition to DREAMING should occur
assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromGoneTransitionInteractor")
@@ -543,7 +522,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to PRIMARY_BOUNCER should occur // THEN a transition to PRIMARY_BOUNCER should occur
assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor")
@@ -572,7 +551,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AOD should occur // THEN a transition to AOD should occur
assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor")
@@ -602,7 +581,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor")
@@ -630,7 +609,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to LOCKSCREEN should occur // THEN a transition to LOCKSCREEN should occur
assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromAlternateBouncerTransitionInteractor")
@@ -658,7 +637,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AOD should occur // THEN a transition to AOD should occur
assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor")
@@ -686,7 +665,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to DOZING should occur // THEN a transition to DOZING should occur
assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor")
@@ -713,7 +692,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to LOCKSCREEN should occur // THEN a transition to LOCKSCREEN should occur
assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor")
@@ -744,7 +723,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to GONE should occur // THEN a transition to GONE should occur
assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor")
@@ -773,7 +752,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to LOCKSCREEN should occur // THEN a transition to LOCKSCREEN should occur
assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor")
@@ -799,7 +778,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AlternateBouncer should occur // THEN a transition to AlternateBouncer should occur
assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromOccludedTransitionInteractor")
@@ -828,7 +807,7 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
val info = val info =
withArgCaptor<TransitionInfo> { withArgCaptor<TransitionInfo> {
verify(mockTransitionRepository).startTransition(capture(), anyBoolean()) verify(transitionRepository).startTransition(capture(), anyBoolean())
} }
// THEN a transition to AlternateBouncer should occur // THEN a transition to AlternateBouncer should occur
assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor") assertThat(info.ownerName).isEqualTo("FromPrimaryBouncerTransitionInteractor")
@@ -890,6 +869,6 @@ class KeyguardTransitionScenariosTest : SysuiTestCase() {
) )
) )
runCurrent() runCurrent()
reset(mockTransitionRepository) reset(transitionRepository)
} }
} }