Merge "Add transitions for the lockscreen hosted dream" into udc-qpr-dev (2e117552) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/keyguard/domain/interactor/FromDreamingLockscreenHostedTransitionInteractor.kt

0 → 100644

+169 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.keyguard.domain.interactor

		import android.animation.ValueAnimator
		import com.android.app.animation.Interpolators
		import com.android.systemui.dagger.SysUISingleton
		import com.android.systemui.dagger.qualifiers.Application
		import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepository
		import com.android.systemui.keyguard.shared.model.BiometricUnlockModel
		import com.android.systemui.keyguard.shared.model.DozeStateModel
		import com.android.systemui.keyguard.shared.model.KeyguardState
		import com.android.systemui.util.kotlin.Utils.Companion.toTriple
		import com.android.systemui.util.kotlin.sample
		import javax.inject.Inject
		import kotlin.time.Duration.Companion.milliseconds
		import kotlinx.coroutines.CoroutineScope
		import kotlinx.coroutines.delay
		import kotlinx.coroutines.flow.combine
		import kotlinx.coroutines.flow.onEach
		import kotlinx.coroutines.launch

		@SysUISingleton
		class FromDreamingLockscreenHostedTransitionInteractor
		@Inject
		constructor(
		override val transitionRepository: KeyguardTransitionRepository,
		override val transitionInteractor: KeyguardTransitionInteractor,
		@Application private val scope: CoroutineScope,
		private val keyguardInteractor: KeyguardInteractor,
		) :
		TransitionInteractor(
		fromState = KeyguardState.DREAMING_LOCKSCREEN_HOSTED,
		) {

		override fun start() {
		listenForDreamingLockscreenHostedToLockscreen()
		listenForDreamingLockscreenHostedToGone()
		listenForDreamingLockscreenHostedToDozing()
		listenForDreamingLockscreenHostedToOccluded()
		listenForDreamingLockscreenHostedToPrimaryBouncer()
		}

		private fun listenForDreamingLockscreenHostedToLockscreen() {
		scope.launch {
		keyguardInteractor.isActiveDreamLockscreenHosted
		// Add a slight delay to prevent transitioning to lockscreen from happening too soon
		// as dozing can arrive in a slight gap after the lockscreen hosted dream stops.
		.onEach { delay(50) }
		.sample(
		combine(
		keyguardInteractor.dozeTransitionModel,
		transitionInteractor.startedKeyguardTransitionStep,
		::Pair
		),
		::toTriple
		)
		.collect {
		(isActiveDreamLockscreenHosted, dozeTransitionModel, lastStartedTransition) ->
		if (
		!isActiveDreamLockscreenHosted &&
		DozeStateModel.isDozeOff(dozeTransitionModel.to) &&
		lastStartedTransition.to == KeyguardState.DREAMING_LOCKSCREEN_HOSTED
		) {
		startTransitionTo(KeyguardState.LOCKSCREEN)
		}
		}
		}
		}

		private fun listenForDreamingLockscreenHostedToOccluded() {
		scope.launch {
		keyguardInteractor.isActiveDreamLockscreenHosted
		.sample(
		combine(
		keyguardInteractor.isKeyguardOccluded,
		transitionInteractor.startedKeyguardTransitionStep,
		::Pair,
		),
		::toTriple
		)
		.collect { (isActiveDreamLockscreenHosted, isOccluded, lastStartedTransition) ->
		if (
		isOccluded &&
		!isActiveDreamLockscreenHosted &&
		lastStartedTransition.to == KeyguardState.DREAMING_LOCKSCREEN_HOSTED
		) {
		startTransitionTo(KeyguardState.OCCLUDED)
		}
		}
		}
		}

		private fun listenForDreamingLockscreenHostedToPrimaryBouncer() {
		scope.launch {
		keyguardInteractor.primaryBouncerShowing
		.sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
		.collect { (isBouncerShowing, lastStartedTransitionStep) ->
		if (
		isBouncerShowing &&
		lastStartedTransitionStep.to == KeyguardState.DREAMING_LOCKSCREEN_HOSTED
		) {
		startTransitionTo(KeyguardState.PRIMARY_BOUNCER)
		}
		}
		}
		}

		private fun listenForDreamingLockscreenHostedToGone() {
		scope.launch {
		keyguardInteractor.biometricUnlockState
		.sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
		.collect { (biometricUnlockState, lastStartedTransitionStep) ->
		if (
		lastStartedTransitionStep.to == KeyguardState.DREAMING_LOCKSCREEN_HOSTED &&
		biometricUnlockState == BiometricUnlockModel.WAKE_AND_UNLOCK_FROM_DREAM
		) {
		startTransitionTo(KeyguardState.GONE)
		}
		}
		}
		}

		private fun listenForDreamingLockscreenHostedToDozing() {
		scope.launch {
		combine(
		keyguardInteractor.dozeTransitionModel,
		transitionInteractor.startedKeyguardTransitionStep,
		::Pair
		)
		.collect { (dozeTransitionModel, lastStartedTransitionStep) ->
		if (
		dozeTransitionModel.to == DozeStateModel.DOZE &&
		lastStartedTransitionStep.to == KeyguardState.DREAMING_LOCKSCREEN_HOSTED
		) {
		startTransitionTo(KeyguardState.DOZING)
		}
		}
		}
		}

		override fun getDefaultAnimatorForTransitionsToState(toState: KeyguardState): ValueAnimator {
		return ValueAnimator().apply {
		interpolator = Interpolators.LINEAR
		duration =
		if (toState == KeyguardState.LOCKSCREEN) TO_LOCKSCREEN_DURATION.inWholeMilliseconds
		else DEFAULT_DURATION.inWholeMilliseconds
		}
		}

		companion object {
		private val DEFAULT_DURATION = 500.milliseconds
		val TO_LOCKSCREEN_DURATION = 1167.milliseconds
		}
		}

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

+9 −4

Original line number	Diff line number	Diff line
		@@ -94,8 +94,13 @@ constructor(

		private fun listenForDreamingToGone() {
		scope.launch {
		keyguardInteractor.biometricUnlockState.collect { biometricUnlockState ->
		if (biometricUnlockState == BiometricUnlockModel.WAKE_AND_UNLOCK_FROM_DREAM) {
		keyguardInteractor.biometricUnlockState
		.sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
		.collect { (biometricUnlockState, lastStartedTransitionStep) ->
		if (
		lastStartedTransitionStep.to == KeyguardState.DREAMING &&
		biometricUnlockState == BiometricUnlockModel.WAKE_AND_UNLOCK_FROM_DREAM
		) {
		startTransitionTo(KeyguardState.GONE)
		}
		}

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

+27 −3

Original line number	Diff line number	Diff line
		@@ -48,6 +48,7 @@ constructor(
		listenForGoneToAodOrDozing()
		listenForGoneToDreaming()
		listenForGoneToLockscreen()
		listenForGoneToDreamingLockscreenHosted()
		}

		// Primarily for when the user chooses to lock down the device
		@@ -63,12 +64,35 @@ constructor(
		}
		}

		private fun listenForGoneToDreamingLockscreenHosted() {
		scope.launch {
		keyguardInteractor.isActiveDreamLockscreenHosted
		.sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
		.collect { (isActiveDreamLockscreenHosted, lastStartedStep) ->
		if (isActiveDreamLockscreenHosted && lastStartedStep.to == KeyguardState.GONE) {
		startTransitionTo(KeyguardState.DREAMING_LOCKSCREEN_HOSTED)
		}
		}
		}
		}

		private fun listenForGoneToDreaming() {
		scope.launch {
		keyguardInteractor.isAbleToDream
		.sample(transitionInteractor.startedKeyguardTransitionStep, ::Pair)
		.collect { (isAbleToDream, lastStartedStep) ->
		if (isAbleToDream && lastStartedStep.to == KeyguardState.GONE) {
		.sample(
		combine(
		transitionInteractor.startedKeyguardTransitionStep,
		keyguardInteractor.isActiveDreamLockscreenHosted,
		::Pair
		),
		::toTriple
		)
		.collect { (isAbleToDream, lastStartedStep, isActiveDreamLockscreenHosted) ->
		if (
		isAbleToDream &&
		lastStartedStep.to == KeyguardState.GONE &&
		!isActiveDreamLockscreenHosted
		) {
		startTransitionTo(KeyguardState.DREAMING)
		}
		}

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

+14 −4

Original line number	Diff line number	Diff line
		@@ -70,21 +70,31 @@ constructor(
		combine(
		transitionInteractor.startedKeyguardTransitionStep,
		transitionInteractor.finishedKeyguardState,
		::Pair
		keyguardInteractor.isActiveDreamLockscreenHosted,
		::Triple
		),
		::toTriple
		::toQuad
		)
		.collect { (isAbleToDream, lastStartedTransition, finishedKeyguardState) ->
		.collect {
		(
		isAbleToDream,
		lastStartedTransition,
		finishedKeyguardState,
		isActiveDreamLockscreenHosted) ->
		val isOnLockscreen = finishedKeyguardState == KeyguardState.LOCKSCREEN
		val isTransitionInterruptible =
		lastStartedTransition.to == KeyguardState.LOCKSCREEN &&
		!invalidFromStates.contains(lastStartedTransition.from)
		if (isAbleToDream && (isOnLockscreen \|\| isTransitionInterruptible)) {
		if (isActiveDreamLockscreenHosted) {
		startTransitionTo(KeyguardState.DREAMING_LOCKSCREEN_HOSTED)
		} else {
		startTransitionTo(KeyguardState.DREAMING)
		}
		}
		}
		}
		}

		private fun listenForLockscreenToPrimaryBouncer() {
		scope.launch {

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

+39 −5

Original line number	Diff line number	Diff line
		@@ -27,6 +27,8 @@ import com.android.systemui.keyguard.data.repository.KeyguardTransitionRepositor
		import com.android.systemui.keyguard.shared.model.KeyguardState
		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.toQuint
		import com.android.systemui.util.kotlin.Utils.Companion.toTriple
		import com.android.systemui.util.kotlin.sample
		import javax.inject.Inject
		import kotlin.time.Duration.Companion.milliseconds
		@@ -52,6 +54,7 @@ constructor(
		listenForPrimaryBouncerToGone()
		listenForPrimaryBouncerToAodOrDozing()
		listenForPrimaryBouncerToLockscreenOrOccluded()
		listenForPrimaryBouncerToDreamingLockscreenHosted()
		}

		private fun listenForPrimaryBouncerToLockscreenOrOccluded() {
		@@ -62,17 +65,24 @@ constructor(
		keyguardInteractor.wakefulnessModel,
		transitionInteractor.startedKeyguardTransitionStep,
		keyguardInteractor.isKeyguardOccluded,
		::Triple
		),
		keyguardInteractor.isActiveDreamLockscreenHosted,
		::toQuad
		),
		::toQuint
		)
		.collect { (isBouncerShowing, wakefulnessState, lastStartedTransitionStep, occluded)
		->
		.collect {
		(
		isBouncerShowing,
		wakefulnessState,
		lastStartedTransitionStep,
		occluded,
		isActiveDreamLockscreenHosted) ->
		if (
		!isBouncerShowing &&
		lastStartedTransitionStep.to == KeyguardState.PRIMARY_BOUNCER &&
		(wakefulnessState.state == WakefulnessState.AWAKE \|\|
		wakefulnessState.state == WakefulnessState.STARTING_TO_WAKE)
		wakefulnessState.state == WakefulnessState.STARTING_TO_WAKE) &&
		!isActiveDreamLockscreenHosted
		) {
		startTransitionTo(
		if (occluded) KeyguardState.OCCLUDED else KeyguardState.LOCKSCREEN
		@@ -111,6 +121,30 @@ constructor(
		}
		}

		private fun listenForPrimaryBouncerToDreamingLockscreenHosted() {
		scope.launch {
		keyguardInteractor.primaryBouncerShowing
		.sample(
		combine(
		keyguardInteractor.isActiveDreamLockscreenHosted,
		transitionInteractor.startedKeyguardTransitionStep,
		::Pair
		),
		::toTriple
		)
		.collect {
		(isBouncerShowing, isActiveDreamLockscreenHosted, lastStartedTransitionStep) ->
		if (
		!isBouncerShowing &&
		isActiveDreamLockscreenHosted &&
		lastStartedTransitionStep.to == KeyguardState.PRIMARY_BOUNCER
		) {
		startTransitionTo(KeyguardState.DREAMING_LOCKSCREEN_HOSTED)
		}
		}
		}
		}

		private fun listenForPrimaryBouncerToGone() {
		scope.launch {
		keyguardInteractor.isKeyguardGoingAway