Merge "[flexiglass] Add an InputMethod module + IME switcher button to bouncer." into main (6bdba009) · Commits · e / os / android_frameworks_base

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

+30 −0

Original line number	Diff line number	Diff line
		@@ -20,6 +20,7 @@ package com.android.systemui.bouncer.ui.composable

		import androidx.compose.foundation.text.KeyboardActions
		import androidx.compose.foundation.text.KeyboardOptions
		import androidx.compose.material3.IconButtonDefaults
		import androidx.compose.material3.LocalTextStyle
		import androidx.compose.material3.MaterialTheme
		import androidx.compose.material3.TextField
		@@ -36,16 +37,21 @@ import androidx.compose.ui.focus.FocusRequester
		import androidx.compose.ui.focus.focusRequester
		import androidx.compose.ui.focus.onFocusChanged
		import androidx.compose.ui.geometry.Offset
		import androidx.compose.ui.graphics.Color
		import androidx.compose.ui.input.key.Key
		import androidx.compose.ui.input.key.key
		import androidx.compose.ui.input.key.onInterceptKeyBeforeSoftKeyboard
		import androidx.compose.ui.platform.LocalContext
		import androidx.compose.ui.platform.LocalDensity
		import androidx.compose.ui.res.stringResource
		import androidx.compose.ui.text.input.ImeAction
		import androidx.compose.ui.text.input.KeyboardType
		import androidx.compose.ui.text.input.PasswordVisualTransformation
		import androidx.compose.ui.text.style.TextAlign
		import androidx.compose.ui.unit.dp
		import com.android.compose.PlatformIconButton
		import com.android.systemui.bouncer.ui.viewmodel.PasswordBouncerViewModel
		import com.android.systemui.res.R

		/** UI for the input part of a password-requiring version of the bouncer. */
		@Composable
		@@ -64,6 +70,7 @@ internal fun PasswordBouncer(
		val password: String by viewModel.password.collectAsState()
		val isInputEnabled: Boolean by viewModel.isInputEnabled.collectAsState()
		val animateFailure: Boolean by viewModel.animateFailure.collectAsState()
		val isImeSwitcherButtonVisible by viewModel.isImeSwitcherButtonVisible.collectAsState()

		DisposableEffect(Unit) {
		viewModel.onShown()
		@@ -116,5 +123,28 @@ internal fun PasswordBouncer(
		false
		}
		},
		trailingIcon =
		if (isImeSwitcherButtonVisible) {
		{ ImeSwitcherButton(viewModel, color) }
		} else null
		)
		}

		/** Button for changing the password input method (IME). */
		@Composable
		private fun ImeSwitcherButton(
		viewModel: PasswordBouncerViewModel,
		color: Color,
		) {
		val context = LocalContext.current
		PlatformIconButton(
		onClick = { viewModel.onImeSwitcherButtonClicked(context.displayId) },
		iconResource = R.drawable.ic_lockscreen_ime,
		contentDescription = stringResource(R.string.accessibility_ime_switch_button),
		colors =
		IconButtonDefaults.filledIconButtonColors(
		contentColor = color,
		containerColor = Color.Transparent,
		)
		)
		}

packages/SystemUI/multivalentTests/src/com/android/systemui/bouncer/ui/viewmodel/PasswordBouncerViewModelTest.kt

+100 −4

Original line number	Diff line number	Diff line
		@@ -16,6 +16,7 @@

		package com.android.systemui.bouncer.ui.viewmodel

		import android.content.pm.UserInfo
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.systemui.SysuiTestCase
		@@ -26,18 +27,27 @@ import com.android.systemui.bouncer.domain.interactor.bouncerInteractor
		import com.android.systemui.coroutines.collectLastValue
		import com.android.systemui.coroutines.collectValues
		import com.android.systemui.deviceentry.data.repository.fakeDeviceEntryRepository
		import com.android.systemui.inputmethod.data.model.InputMethodModel
		import com.android.systemui.inputmethod.data.repository.fakeInputMethodRepository
		import com.android.systemui.inputmethod.domain.interactor.inputMethodInteractor
		import com.android.systemui.kosmos.testScope
		import com.android.systemui.res.R
		import com.android.systemui.scene.domain.interactor.sceneInteractor
		import com.android.systemui.scene.shared.model.SceneKey
		import com.android.systemui.scene.shared.model.SceneModel
		import com.android.systemui.testKosmos
		import com.android.systemui.user.data.model.SelectedUserModel
		import com.android.systemui.user.data.model.SelectionStatus
		import com.android.systemui.user.data.repository.fakeUserRepository
		import com.android.systemui.user.domain.interactor.selectedUserInteractor
		import com.google.common.truth.Truth.assertThat
		import java.util.UUID
		import kotlin.time.Duration.Companion.seconds
		import kotlinx.coroutines.ExperimentalCoroutinesApi
		import kotlinx.coroutines.flow.MutableStateFlow
		import kotlinx.coroutines.flow.asStateFlow
		import kotlinx.coroutines.test.TestScope
		import kotlinx.coroutines.test.advanceTimeBy
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		@@ -51,19 +61,22 @@ class PasswordBouncerViewModelTest : SysuiTestCase() {

		private val kosmos = testKosmos()
		private val testScope = kosmos.testScope
		private val authenticationInteractor = kosmos.authenticationInteractor
		private val authenticationInteractor by lazy { kosmos.authenticationInteractor }
		private val sceneInteractor by lazy { kosmos.sceneInteractor }
		private val bouncerInteractor by lazy { kosmos.bouncerInteractor }
		private val selectedUserInteractor by lazy { kosmos.selectedUserInteractor }
		private val inputMethodInteractor by lazy { kosmos.inputMethodInteractor }
		private val bouncerViewModel by lazy { kosmos.bouncerViewModel }
		private val isInputEnabled = MutableStateFlow(true)

		private val underTest by lazy {
		private val underTest =
		PasswordBouncerViewModel(
		viewModelScope = testScope.backgroundScope,
		isInputEnabled = isInputEnabled.asStateFlow(),
		interactor = bouncerInteractor,
		isInputEnabled.asStateFlow(),
		inputMethodInteractor = inputMethodInteractor,
		selectedUserInteractor = selectedUserInteractor,
		)
		}

		@Before
		fun setUp() {
		@@ -270,6 +283,52 @@ class PasswordBouncerViewModelTest : SysuiTestCase() {
		assertThat(isTextFieldFocusRequested).isTrue()
		}

		@Test
		fun isImeSwitcherButtonVisible() =
		testScope.runTest {
		val selectedUserId by collectLastValue(selectedUserInteractor.selectedUser)
		selectUser(USER_INFOS.first())

		enableInputMethodsForUser(checkNotNull(selectedUserId))

		// Assert initial value, before the UI subscribes.
		assertThat(underTest.isImeSwitcherButtonVisible.value).isFalse()

		// Subscription starts; verify a fresh value is fetched.
		val isImeSwitcherButtonVisible by collectLastValue(underTest.isImeSwitcherButtonVisible)
		assertThat(isImeSwitcherButtonVisible).isTrue()

		// Change the user, verify a fresh value is fetched.
		selectUser(USER_INFOS.last())

		assertThat(
		inputMethodInteractor.hasMultipleEnabledImesOrSubtypes(
		checkNotNull(selectedUserId)
		)
		)
		.isFalse()
		assertThat(isImeSwitcherButtonVisible).isFalse()

		// Enable IMEs and add another subscriber; verify a fresh value is fetched.
		enableInputMethodsForUser(checkNotNull(selectedUserId))
		val collector2 by collectLastValue(underTest.isImeSwitcherButtonVisible)
		assertThat(collector2).isTrue()
		}

		@Test
		fun onImeSwitcherButtonClicked() =
		testScope.runTest {
		val displayId = 7
		assertThat(kosmos.fakeInputMethodRepository.inputMethodPickerShownDisplayId)
		.isNotEqualTo(displayId)

		underTest.onImeSwitcherButtonClicked(displayId)
		runCurrent()

		assertThat(kosmos.fakeInputMethodRepository.inputMethodPickerShownDisplayId)
		.isEqualTo(displayId)
		}

		private fun TestScope.switchToScene(toScene: SceneKey) {
		val currentScene by collectLastValue(sceneInteractor.desiredScene)
		val bouncerShown = currentScene?.key != SceneKey.Bouncer && toScene == SceneKey.Bouncer
		@@ -310,8 +369,45 @@ class PasswordBouncerViewModelTest : SysuiTestCase() {
		runCurrent()
		}

		private fun TestScope.selectUser(userInfo: UserInfo) {
		kosmos.fakeUserRepository.selectedUser.value =
		SelectedUserModel(
		userInfo = userInfo,
		selectionStatus = SelectionStatus.SELECTION_COMPLETE
		)
		advanceTimeBy(PasswordBouncerViewModel.DELAY_TO_FETCH_IMES)
		}

		private suspend fun enableInputMethodsForUser(userId: Int) {
		kosmos.fakeInputMethodRepository.setEnabledInputMethods(
		userId,
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 0),
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 1),
		)
		assertThat(inputMethodInteractor.hasMultipleEnabledImesOrSubtypes(userId)).isTrue()
		}

		private fun createInputMethodWithSubtypes(
		auxiliarySubtypes: Int,
		nonAuxiliarySubtypes: Int,
		): InputMethodModel {
		return InputMethodModel(
		imeId = UUID.randomUUID().toString(),
		subtypes =
		List(auxiliarySubtypes + nonAuxiliarySubtypes) {
		InputMethodModel.Subtype(subtypeId = it, isAuxiliary = it < auxiliarySubtypes)
		}
		)
		}

		companion object {
		private const val ENTER_YOUR_PASSWORD = "Enter your password"
		private const val WRONG_PASSWORD = "Wrong password"

		private val USER_INFOS =
		listOf(
		UserInfo(100, "First user", 0),
		UserInfo(101, "Second user", 0),
		)
		}
		}

packages/SystemUI/multivalentTests/src/com/android/systemui/inputmethod/data/repository/InputMethodRepositoryTest.kt

0 → 100644

+124 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.inputmethod.data.repository

		import android.os.UserHandle
		import android.view.inputmethod.InputMethodInfo
		import android.view.inputmethod.InputMethodManager
		import android.view.inputmethod.InputMethodSubtype
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.kosmos.Kosmos
		import com.android.systemui.kosmos.testDispatcher
		import com.android.systemui.kosmos.testScope
		import com.android.systemui.util.mockito.any
		import com.android.systemui.util.mockito.eq
		import com.android.systemui.util.mockito.mock
		import com.android.systemui.util.mockito.whenever
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.flow.count
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.ArgumentMatchers.anyBoolean
		import org.mockito.Mock
		import org.mockito.Mockito.verify
		import org.mockito.MockitoAnnotations

		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class InputMethodRepositoryTest : SysuiTestCase() {

		@Mock private lateinit var inputMethodManager: InputMethodManager

		private val kosmos = Kosmos()
		private val testScope = kosmos.testScope

		private lateinit var underTest: InputMethodRepository

		@Before
		fun setUp() {
		MockitoAnnotations.initMocks(this)

		whenever(inputMethodManager.getEnabledInputMethodSubtypeList(eq(null), anyBoolean()))
		.thenReturn(listOf())

		underTest =
		InputMethodRepositoryImpl(
		backgroundDispatcher = kosmos.testDispatcher,
		inputMethodManager = inputMethodManager,
		)
		}

		@Test
		fun enabledInputMethods_noImes_emptyFlow() =
		testScope.runTest {
		whenever(inputMethodManager.getEnabledInputMethodListAsUser(eq(USER_HANDLE)))
		.thenReturn(listOf())
		whenever(inputMethodManager.getEnabledInputMethodSubtypeList(any(), anyBoolean()))
		.thenReturn(listOf())

		assertThat(underTest.enabledInputMethods(USER_ID, fetchSubtypes = true).count())
		.isEqualTo(0)
		}

		@Test
		fun selectedInputMethodSubtypes_returnsSubtypeList() =
		testScope.runTest {
		val subtypeId = 123
		val isAuxiliary = true
		whenever(inputMethodManager.getEnabledInputMethodListAsUser(eq(USER_HANDLE)))
		.thenReturn(listOf(mock<InputMethodInfo>()))
		whenever(inputMethodManager.getEnabledInputMethodSubtypeList(any(), anyBoolean()))
		.thenReturn(listOf())
		whenever(inputMethodManager.getEnabledInputMethodSubtypeList(eq(null), anyBoolean()))
		.thenReturn(
		listOf(
		InputMethodSubtype.InputMethodSubtypeBuilder()
		.setSubtypeId(subtypeId)
		.setIsAuxiliary(isAuxiliary)
		.build()
		)
		)

		val result = underTest.selectedInputMethodSubtypes()
		assertThat(result).hasSize(1)
		assertThat(result.first().subtypeId).isEqualTo(subtypeId)
		assertThat(result.first().isAuxiliary).isEqualTo(isAuxiliary)
		}

		@Test
		fun showImePicker_forwardsDisplayId() =
		testScope.runTest {
		val displayId = 7

		underTest.showInputMethodPicker(displayId, /* showAuxiliarySubtypes = */ true)

		verify(inputMethodManager)
		.showInputMethodPickerFromSystem(
		/* showAuxiliarySubtypes = */ eq(true),
		/* displayId = */ eq(displayId)
		)
		}

		companion object {
		private const val USER_ID = 100
		private val USER_HANDLE = UserHandle.of(USER_ID)
		}
		}

packages/SystemUI/multivalentTests/src/com/android/systemui/inputmethod/domain/interactor/InputMethodInteractorTest.kt

0 → 100644

+157 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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.inputmethod.domain.interactor

		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.inputmethod.data.model.InputMethodModel
		import com.android.systemui.inputmethod.data.repository.fakeInputMethodRepository
		import com.android.systemui.inputmethod.data.repository.inputMethodRepository
		import com.android.systemui.kosmos.Kosmos
		import com.android.systemui.kosmos.testScope
		import com.google.common.truth.Truth.assertThat
		import java.util.UUID
		import kotlinx.coroutines.test.runTest
		import org.junit.Test
		import org.junit.runner.RunWith

		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class InputMethodInteractorTest : SysuiTestCase() {

		private val kosmos = Kosmos()
		private val testScope = kosmos.testScope
		private val fakeInputMethodRepository = kosmos.fakeInputMethodRepository

		private val underTest = InputMethodInteractor(repository = kosmos.inputMethodRepository)

		@Test
		fun hasMultipleEnabledImesOrSubtypes_noImes_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(USER_ID)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_noMatches_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(
		USER_ID,
		createInputMethodWithSubtypes(auxiliarySubtypes = 1, nonAuxiliarySubtypes = 0),
		createInputMethodWithSubtypes(auxiliarySubtypes = 3, nonAuxiliarySubtypes = 0),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_oneMatch_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(
		USER_ID,
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 0),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_twoMatches_returnsTrue() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(
		USER_ID,
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 1),
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 0),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isTrue()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_oneWithNonAux_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(
		USER_ID,
		createInputMethodWithSubtypes(auxiliarySubtypes = 0, nonAuxiliarySubtypes = 2),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_twoWithAux_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.setEnabledInputMethods(
		USER_ID,
		createInputMethodWithSubtypes(auxiliarySubtypes = 3, nonAuxiliarySubtypes = 0),
		createInputMethodWithSubtypes(auxiliarySubtypes = 5, nonAuxiliarySubtypes = 0),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_selectedHasOneSubtype_returnsFalse() =
		testScope.runTest {
		fakeInputMethodRepository.selectedInputMethodSubtypes =
		listOf(InputMethodModel.Subtype(1, isAuxiliary = false))

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isFalse()
		}

		@Test
		fun hasMultipleEnabledImesOrSubtypes_selectedHasTwoSubtypes_returnsTrue() =
		testScope.runTest {
		fakeInputMethodRepository.selectedInputMethodSubtypes =
		listOf(
		InputMethodModel.Subtype(subtypeId = 1, isAuxiliary = false),
		InputMethodModel.Subtype(subtypeId = 2, isAuxiliary = false),
		)

		assertThat(underTest.hasMultipleEnabledImesOrSubtypes(USER_ID)).isTrue()
		}

		@Test
		fun showImePicker_shownOnCorrectId() =
		testScope.runTest {
		val displayId = 7

		underTest.showInputMethodPicker(displayId, showAuxiliarySubtypes = false)

		assertThat(fakeInputMethodRepository.inputMethodPickerShownDisplayId)
		.isEqualTo(displayId)
		}

		private fun createInputMethodWithSubtypes(
		auxiliarySubtypes: Int,
		nonAuxiliarySubtypes: Int,
		): InputMethodModel {
		return InputMethodModel(
		imeId = UUID.randomUUID().toString(),
		subtypes =
		List(auxiliarySubtypes + nonAuxiliarySubtypes) {
		InputMethodModel.Subtype(subtypeId = it, isAuxiliary = it < auxiliarySubtypes)
		}
		)
		}

		companion object {
		private const val USER_ID = 100
		}
		}

packages/SystemUI/src/com/android/systemui/authentication/data/repository/AuthenticationRepository.kt

+2 −6

Original line number	Diff line number	Diff line
		@@ -39,7 +39,7 @@ import com.android.systemui.dagger.qualifiers.Background
		import com.android.systemui.scene.shared.flag.SceneContainerFlags
		import com.android.systemui.statusbar.pipeline.mobile.data.repository.MobileConnectionsRepository
		import com.android.systemui.user.data.repository.UserRepository
		import com.android.systemui.util.kotlin.pairwise
		import com.android.systemui.util.kotlin.onSubscriberAdded
		import com.android.systemui.util.time.SystemClock
		import dagger.Binds
		import dagger.Module
		@@ -54,7 +54,6 @@ import kotlinx.coroutines.flow.StateFlow
		import kotlinx.coroutines.flow.asStateFlow
		import kotlinx.coroutines.flow.combine
		import kotlinx.coroutines.flow.distinctUntilChanged
		import kotlinx.coroutines.flow.filter
		import kotlinx.coroutines.flow.flatMapLatest
		import kotlinx.coroutines.flow.map
		import kotlinx.coroutines.flow.onStart
		@@ -355,10 +354,7 @@ constructor(
		userRepository.selectedUserInfo.map { it.id }.distinctUntilChanged(),
		// Emits a value only when the number of downstream subscribers of this flow
		// increases.
		flow.subscriptionCount.pairwise(initialValue = 0).filter { (previous, current)
		->
		current > previous
		},
		flow.onSubscriberAdded(),
		) { selectedUserId, _ ->
		selectedUserId
		}