Merge "[flexiglass] Bouncer action button ("Emergency Call"/"Return to Call")." into main (08495046) · Commits · e / os / android_frameworks_base

packages/SystemUI/compose/features/src/com/android/systemui/bouncer/ui/composable/BouncerScene.kt

+37 −16

Original line number	Diff line number	Diff line
		@@ -25,7 +25,9 @@ import androidx.compose.animation.core.animateFloatAsState
		import androidx.compose.animation.core.snap
		import androidx.compose.animation.core.tween
		import androidx.compose.foundation.Canvas
		import androidx.compose.foundation.ExperimentalFoundationApi
		import androidx.compose.foundation.Image
		import androidx.compose.foundation.combinedClickable
		import androidx.compose.foundation.gestures.detectTapGestures
		import androidx.compose.foundation.layout.Arrangement
		import androidx.compose.foundation.layout.Box
		@@ -68,7 +70,6 @@ import androidx.compose.ui.input.pointer.pointerInput
		import androidx.compose.ui.platform.LocalConfiguration
		import androidx.compose.ui.platform.LocalContext
		import androidx.compose.ui.platform.LocalLayoutDirection
		import androidx.compose.ui.res.stringResource
		import androidx.compose.ui.text.style.TextOverflow
		import androidx.compose.ui.unit.DpOffset
		import androidx.compose.ui.unit.LayoutDirection
		@@ -77,7 +78,9 @@ import androidx.compose.ui.unit.times
		import com.android.compose.PlatformButton
		import com.android.compose.animation.scene.ElementKey
		import com.android.compose.animation.scene.SceneScope
		import com.android.compose.modifiers.thenIf
		import com.android.compose.windowsizeclass.LocalWindowSizeClass
		import com.android.systemui.bouncer.shared.model.BouncerActionButtonModel
		import com.android.systemui.bouncer.ui.viewmodel.AuthMethodBouncerViewModel
		import com.android.systemui.bouncer.ui.viewmodel.BouncerViewModel
		import com.android.systemui.bouncer.ui.viewmodel.PasswordBouncerViewModel
		@@ -195,6 +198,7 @@ private fun Bouncer(
		val message: BouncerViewModel.MessageViewModel by viewModel.message.collectAsState()
		val dialogMessage: String? by viewModel.throttlingDialogMessage.collectAsState()
		var dialog: Dialog? by remember { mutableStateOf(null) }
		val actionButton: BouncerActionButtonModel? by viewModel.actionButton.collectAsState()

		Column(
		horizontalAlignment = Alignment.CenterHorizontally,
		@@ -221,21 +225,7 @@ private fun Bouncer(
		)
		}

		if (viewModel.isEmergencyButtonVisible) {
		Button(
		onClick = viewModel::onEmergencyServicesButtonClicked,
		colors =
		ButtonDefaults.buttonColors(
		containerColor = MaterialTheme.colorScheme.tertiaryContainer,
		contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
		),
		) {
		Text(
		text = stringResource(com.android.internal.R.string.lockscreen_emergency_call),
		style = MaterialTheme.typography.bodyMedium,
		)
		}
		}
		actionButton?.let { BouncerActionButton(viewModel = it) }

		if (dialogMessage != null) {
		if (dialog == null) {
		@@ -320,6 +310,37 @@ private fun UserInputArea(
		}
		}

		/**
		* Renders the action button on the bouncer, which triggers either Return to Call or Emergency Call.
		*/
		@OptIn(ExperimentalFoundationApi::class)
		@Composable
		private fun BouncerActionButton(
		viewModel: BouncerActionButtonModel,
		modifier: Modifier = Modifier,
		) {
		Button(
		onClick = viewModel.onClick,
		modifier =
		modifier.thenIf(viewModel.onLongClick != null) {
		Modifier.combinedClickable(
		onClick = viewModel.onClick,
		onLongClick = viewModel.onLongClick,
		)
		},
		colors =
		ButtonDefaults.buttonColors(
		containerColor = MaterialTheme.colorScheme.tertiaryContainer,
		contentColor = MaterialTheme.colorScheme.onTertiaryContainer,
		),
		) {
		Text(
		text = viewModel.label,
		style = MaterialTheme.typography.bodyMedium,
		)
		}
		}

		/** Renders the UI of the user switcher that's displayed on large screens next to the bouncer UI. */
		@Composable
		private fun UserSwitcher(

packages/SystemUI/multivalentTests/src/com/android/systemui/bouncer/data/repository/EmergencyServicesRepositoryImplTest.kt

0 → 100644

+81 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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.bouncer.data.repository

		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.internal.R
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.coroutines.collectLastValue
		import com.android.systemui.scene.SceneTestUtils
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.test.TestScope
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith

		@OptIn(ExperimentalCoroutinesApi::class)
		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class EmergencyServicesRepositoryImplTest : SysuiTestCase() {

		private val utils = SceneTestUtils(this)
		private val testScope = utils.testScope

		private lateinit var underTest: EmergencyServicesRepository

		@Before
		fun setUp() {
		overrideResource(
		R.bool.config_enable_emergency_call_while_sim_locked,
		ENABLE_EMERGENCY_CALL_WHILE_SIM_LOCKED
		)

		underTest =
		EmergencyServicesRepository(
		resources = context.resources,
		applicationScope = testScope.backgroundScope,
		configurationRepository = utils.configurationRepository,
		)
		}

		@Test
		fun enableEmergencyCallWhileSimLocked() =
		testScope.runTest {
		val enableEmergencyCallWhileSimLocked by
		collectLastValue(underTest.enableEmergencyCallWhileSimLocked)

		setEmergencyCallWhileSimLocked(isEnabled = false)
		assertThat(enableEmergencyCallWhileSimLocked).isFalse()

		setEmergencyCallWhileSimLocked(isEnabled = true)
		assertThat(enableEmergencyCallWhileSimLocked).isTrue()
		}

		private fun TestScope.setEmergencyCallWhileSimLocked(isEnabled: Boolean) {
		overrideResource(R.bool.config_enable_emergency_call_while_sim_locked, isEnabled)
		utils.configurationRepository.onConfigurationChange()
		runCurrent()
		}

		companion object {
		private const val ENABLE_EMERGENCY_CALL_WHILE_SIM_LOCKED = true
		}
		}

packages/SystemUI/multivalentTests/src/com/android/systemui/bouncer/domain/interactor/BouncerActionButtonInteractorTest.kt

0 → 100644

+223 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 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.bouncer.domain.interactor

		import android.app.ActivityTaskManager
		import android.telecom.TelecomManager
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.internal.R
		import com.android.internal.logging.nano.MetricsProto
		import com.android.internal.logging.testing.FakeMetricsLogger
		import com.android.internal.util.EmergencyAffordanceManager
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.authentication.data.model.AuthenticationMethodModel
		import com.android.systemui.coroutines.collectLastValue
		import com.android.systemui.flags.Flags.REFACTOR_GETCURRENTUSER
		import com.android.systemui.log.table.TableLogBuffer
		import com.android.systemui.scene.SceneTestUtils
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.FakeMobileConnectionsRepository
		import com.android.systemui.statusbar.pipeline.mobile.util.FakeMobileMappingsProxy
		import com.android.systemui.user.domain.interactor.SelectedUserInteractor
		import com.android.systemui.util.mockito.whenever
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.ArgumentMatchers.eq
		import org.mockito.Mock
		import org.mockito.Mockito.never
		import org.mockito.Mockito.times
		import org.mockito.Mockito.verify
		import org.mockito.MockitoAnnotations

		@OptIn(ExperimentalCoroutinesApi::class)
		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class BouncerActionButtonInteractorTest : SysuiTestCase() {

		@Mock private lateinit var activityTaskManager: ActivityTaskManager
		@Mock private lateinit var emergencyAffordanceManager: EmergencyAffordanceManager
		@Mock private lateinit var selectedUserInteractor: SelectedUserInteractor
		@Mock private lateinit var tableLogger: TableLogBuffer
		@Mock private lateinit var telecomManager: TelecomManager

		private val utils = SceneTestUtils(this)
		private val testScope = utils.testScope
		private val metricsLogger = FakeMetricsLogger()
		private var currentUserId: Int = 0
		private var needsEmergencyAffordance = true

		private lateinit var mobileConnectionsRepository: FakeMobileConnectionsRepository

		private lateinit var underTest: BouncerActionButtonInteractor

		@Before
		fun setUp() {
		MockitoAnnotations.initMocks(this)
		overrideResource(R.string.lockscreen_emergency_call, MESSAGE_EMERGENCY_CALL)
		overrideResource(R.string.lockscreen_return_to_call, MESSAGE_RETURN_TO_CALL)
		overrideResource(
		R.bool.config_enable_emergency_call_while_sim_locked,
		ENABLE_EMERGENCY_CALL_WHILE_SIM_LOCKED
		)
		whenever(selectedUserInteractor.getSelectedUserId()).thenReturn(currentUserId)
		whenever(emergencyAffordanceManager.needsEmergencyAffordance())
		.thenReturn(needsEmergencyAffordance)
		whenever(telecomManager.isInCall).thenReturn(false)

		utils.featureFlags.set(REFACTOR_GETCURRENTUSER, true)

		mobileConnectionsRepository =
		FakeMobileConnectionsRepository(FakeMobileMappingsProxy(), tableLogger)

		utils.telephonyRepository.setHasTelephonyRadio(true)

		underTest =
		utils.bouncerActionButtonInteractor(
		mobileConnectionsRepository = mobileConnectionsRepository,
		activityTaskManager = activityTaskManager,
		telecomManager = telecomManager,
		emergencyAffordanceManager = emergencyAffordanceManager,
		metricsLogger = metricsLogger,
		)
		}

		@Test
		fun noTelephonyRadio_noButton() =
		testScope.runTest {
		utils.telephonyRepository.setHasTelephonyRadio(false)
		underTest =
		utils.bouncerActionButtonInteractor(
		mobileConnectionsRepository = mobileConnectionsRepository,
		activityTaskManager = activityTaskManager,
		telecomManager = telecomManager,
		)

		val actionButton by collectLastValue(underTest.actionButton)
		assertThat(actionButton).isNull()
		}

		@Test
		fun noTelecomManager_noButton() =
		testScope.runTest {
		underTest =
		utils.bouncerActionButtonInteractor(
		mobileConnectionsRepository = mobileConnectionsRepository,
		activityTaskManager = activityTaskManager,
		telecomManager = null,
		)
		val actionButton by collectLastValue(underTest.actionButton)
		assertThat(actionButton).isNull()
		}

		@Test
		fun duringCall_returnToCallButton() =
		testScope.runTest {
		val actionButton by collectLastValue(underTest.actionButton)
		utils.telephonyRepository.setIsInCall(true)

		assertThat(actionButton).isNotNull()
		assertThat(actionButton?.label).isEqualTo(MESSAGE_RETURN_TO_CALL)
		assertThat(actionButton?.onClick).isNotNull()
		assertThat(actionButton?.onLongClick).isNull()

		actionButton?.onClick?.invoke()

		assertThat(metricsLogger.logs.size).isEqualTo(1)
		assertThat(metricsLogger.logs.element().category)
		.isEqualTo(MetricsProto.MetricsEvent.ACTION_EMERGENCY_CALL)
		verify(activityTaskManager).stopSystemLockTaskMode()
		verify(telecomManager).showInCallScreen(eq(false))
		}

		@Test
		fun noCall_secureAuthMethod_emergencyCallButton() =
		testScope.runTest {
		val actionButton by collectLastValue(underTest.actionButton)
		mobileConnectionsRepository.isAnySimSecure.value = false
		utils.authenticationRepository.setAuthenticationMethod(AuthenticationMethodModel.Pin)
		utils.telephonyRepository.setIsInCall(false)

		assertThat(actionButton).isNotNull()
		assertThat(actionButton?.label).isEqualTo(MESSAGE_EMERGENCY_CALL)
		assertThat(actionButton?.onClick).isNotNull()
		assertThat(actionButton?.onLongClick).isNotNull()

		actionButton?.onClick?.invoke()

		assertThat(metricsLogger.logs.size).isEqualTo(1)
		assertThat(metricsLogger.logs.element().category)
		.isEqualTo(MetricsProto.MetricsEvent.ACTION_EMERGENCY_CALL)
		verify(activityTaskManager).stopSystemLockTaskMode()

		// TODO(b/25189994): Test the activity has been started once we switch to the
		// ActivityStarter interface here.
		verify(emergencyAffordanceManager, never()).performEmergencyCall()

		actionButton?.onLongClick?.invoke()
		verify(emergencyAffordanceManager).performEmergencyCall()
		}

		@Test
		fun noCall_insecureAuthMethodButSecureSim_emergencyCallButton() =
		testScope.runTest {
		val actionButton by collectLastValue(underTest.actionButton)
		mobileConnectionsRepository.isAnySimSecure.value = true
		utils.authenticationRepository.setAuthenticationMethod(AuthenticationMethodModel.None)
		utils.telephonyRepository.setIsInCall(false)

		assertThat(actionButton).isNotNull()
		assertThat(actionButton?.label).isEqualTo(MESSAGE_EMERGENCY_CALL)
		assertThat(actionButton?.onClick).isNotNull()
		assertThat(actionButton?.onLongClick).isNotNull()
		}

		@Test
		fun noCall_insecure_noButton() =
		testScope.runTest {
		val actionButton by collectLastValue(underTest.actionButton)
		mobileConnectionsRepository.isAnySimSecure.value = false
		utils.authenticationRepository.setAuthenticationMethod(AuthenticationMethodModel.None)
		utils.telephonyRepository.setIsInCall(false)

		assertThat(actionButton).isNull()
		}

		@Test
		fun noCall_simSecureButEmergencyNotSupported_noButton() =
		testScope.runTest {
		val actionButton by collectLastValue(underTest.actionButton)
		mobileConnectionsRepository.isAnySimSecure.value = true
		overrideResource(R.bool.config_enable_emergency_call_while_sim_locked, false)
		utils.configurationRepository.onConfigurationChange()
		utils.authenticationRepository.setAuthenticationMethod(AuthenticationMethodModel.None)
		utils.telephonyRepository.setIsInCall(false)
		runCurrent()

		assertThat(actionButton).isNull()
		}

		companion object {
		private const val MESSAGE_EMERGENCY_CALL = "Emergency"
		private const val MESSAGE_RETURN_TO_CALL = "Return to call"
		private const val ENABLE_EMERGENCY_CALL_WHILE_SIM_LOCKED = true
		}
		}

packages/SystemUI/tests/src/com/android/systemui/telephony/data/repository/TelephonyRepositoryImplTest.kt→packages/SystemUI/multivalentTests/src/com/android/systemui/telephony/data/repository/TelephonyRepositoryImplTest.kt

+41 −15

Original line number	Diff line number	Diff line
		@@ -17,48 +17,62 @@

		package com.android.systemui.telephony.data.repository

		import android.telecom.TelecomManager
		import android.telephony.TelephonyCallback
		import android.telephony.TelephonyManager
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.coroutines.collectLastValue
		import com.android.systemui.scene.SceneTestUtils
		import com.android.systemui.telephony.TelephonyListenerManager
		import com.android.systemui.util.mockito.kotlinArgumentCaptor
		import com.android.systemui.util.mockito.whenever
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.Dispatchers
		import kotlinx.coroutines.flow.launchIn
		import kotlinx.coroutines.flow.onEach
		import kotlinx.coroutines.runBlocking
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.junit.runners.JUnit4
		import org.mockito.Mock
		import org.mockito.Mockito.verify
		import org.mockito.MockitoAnnotations

		@OptIn(ExperimentalCoroutinesApi::class)
		@SmallTest
		@RunWith(JUnit4::class)
		@RunWith(AndroidJUnit4::class)
		class TelephonyRepositoryImplTest : SysuiTestCase() {

		@Mock private lateinit var manager: TelephonyListenerManager
		@Mock private lateinit var telecomManager: TelecomManager

		private val utils = SceneTestUtils(this)
		private val testScope = utils.testScope

		private lateinit var underTest: TelephonyRepositoryImpl

		@Before
		fun setUp() {
		MockitoAnnotations.initMocks(this)
		whenever(telecomManager.isInCall).thenReturn(false)

		underTest =
		TelephonyRepositoryImpl(
		applicationScope = testScope.backgroundScope,
		applicationContext = context,
		backgroundDispatcher = utils.testDispatcher,
		manager = manager,
		telecomManager = telecomManager,
		)
		}

		@Test
		fun callState() =
		runBlocking(IMMEDIATE) {
		var callState: Int? = null
		val job = underTest.callState.onEach { callState = it }.launchIn(this)
		testScope.runTest {
		val callState by collectLastValue(underTest.callState)
		runCurrent()

		val listenerCaptor = kotlinArgumentCaptor<TelephonyCallback.CallStateListener>()
		verify(manager).addCallStateListener(listenerCaptor.capture())
		val listener = listenerCaptor.value
		@@ -71,13 +85,25 @@ class TelephonyRepositoryImplTest : SysuiTestCase() {

		listener.onCallStateChanged(2)
		assertThat(callState).isEqualTo(2)
		}

		job.cancel()
		@Test
		fun isInCall() =
		testScope.runTest {
		val isInCall by collectLastValue(underTest.isInCall)
		runCurrent()

		verify(manager).removeCallStateListener(listener)
		}
		val listenerCaptor = kotlinArgumentCaptor<TelephonyCallback.CallStateListener>()
		verify(manager).addCallStateListener(listenerCaptor.capture())
		val listener = listenerCaptor.value
		whenever(telecomManager.isInCall).thenReturn(true)
		listener.onCallStateChanged(TelephonyManager.CALL_STATE_OFFHOOK)

		assertThat(isInCall).isTrue()

		whenever(telecomManager.isInCall).thenReturn(false)
		listener.onCallStateChanged(TelephonyManager.CALL_STATE_IDLE)

		companion object {
		private val IMMEDIATE = Dispatchers.Main.immediate
		assertThat(isInCall).isFalse()
		}
		}

packages/SystemUI/src/com/android/keyguard/EmergencyButtonController.java

+21 −22

File changed.

Preview size limit exceeded, changes collapsed.