Merge "Add TrustRepository to provide a source of truth for trust grant... (fc3114c8) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/keyguard/logging/TrustRepositoryLogger.kt

0 → 100644

+89 −0

Original line number	Original line	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.keyguard.logging

			import com.android.systemui.dagger.SysUISingleton
			import com.android.systemui.keyguard.shared.model.TrustModel
			import com.android.systemui.log.dagger.KeyguardUpdateMonitorLog
			import com.android.systemui.plugins.log.LogBuffer
			import com.android.systemui.plugins.log.LogLevel
			import javax.inject.Inject

			/** Logging helper for trust repository. */
			@SysUISingleton
			class TrustRepositoryLogger
			@Inject
			constructor(
			@KeyguardUpdateMonitorLog private val logBuffer: LogBuffer,
			) {
			fun onTrustChanged(
			enabled: Boolean,
			newlyUnlocked: Boolean,
			userId: Int,
			flags: Int,
			trustGrantedMessages: List<String>?
			) {
			logBuffer.log(
			TAG,
			LogLevel.DEBUG,
			{
			bool1 = enabled
			bool2 = newlyUnlocked
			int1 = userId
			int2 = flags
			str1 = trustGrantedMessages?.joinToString()
			},
			{
			"onTrustChanged enabled: $bool1, newlyUnlocked: $bool2, " +
			"userId: $int1, flags: $int2, grantMessages: $str1"
			}
			)
			}

			fun trustListenerRegistered() {
			logBuffer.log(TAG, LogLevel.VERBOSE, "TrustRepository#registerTrustListener")
			}

			fun trustListenerUnregistered() {
			logBuffer.log(TAG, LogLevel.VERBOSE, "TrustRepository#unregisterTrustListener")
			}

			fun trustModelEmitted(value: TrustModel) {
			logBuffer.log(
			TAG,
			LogLevel.DEBUG,
			{
			int1 = value.userId
			bool1 = value.isTrusted
			},
			{ "trustModel emitted: userId: $int1 isTrusted: $bool1" }
			)
			}

			fun isCurrentUserTrusted(isCurrentUserTrusted: Boolean) {
			logBuffer.log(
			TAG,
			LogLevel.DEBUG,
			{ bool1 = isCurrentUserTrusted },
			{ "isCurrentUserTrusted emitted: $bool1" }
			)
			}

			companion object {
			const val TAG = "TrustRepositoryLog"
			}
			}

packages/SystemUI/src/com/android/systemui/keyguard/data/repository/TrustRepository.kt

0 → 100644

+99 −0

Original line number	Original line	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.data.repository

			import android.app.trust.TrustManager
			import com.android.keyguard.logging.TrustRepositoryLogger
			import com.android.systemui.common.coroutine.ChannelExt.trySendWithFailureLogging
			import com.android.systemui.common.coroutine.ConflatedCallbackFlow.conflatedCallbackFlow
			import com.android.systemui.dagger.SysUISingleton
			import com.android.systemui.dagger.qualifiers.Application
			import com.android.systemui.keyguard.shared.model.TrustModel
			import com.android.systemui.user.data.repository.UserRepository
			import javax.inject.Inject
			import kotlinx.coroutines.CoroutineScope
			import kotlinx.coroutines.channels.awaitClose
			import kotlinx.coroutines.flow.Flow
			import kotlinx.coroutines.flow.SharingStarted
			import kotlinx.coroutines.flow.combine
			import kotlinx.coroutines.flow.distinctUntilChanged
			import kotlinx.coroutines.flow.map
			import kotlinx.coroutines.flow.onEach
			import kotlinx.coroutines.flow.onStart
			import kotlinx.coroutines.flow.shareIn

			/** Encapsulates any state relevant to trust agents and trust grants. */
			interface TrustRepository {
			/** Flow representing whether the current user is trusted. */
			val isCurrentUserTrusted: Flow<Boolean>
			}

			@SysUISingleton
			class TrustRepositoryImpl
			@Inject
			constructor(
			@Application private val applicationScope: CoroutineScope,
			private val userRepository: UserRepository,
			private val trustManager: TrustManager,
			private val logger: TrustRepositoryLogger,
			) : TrustRepository {
			private val latestTrustModelForUser = mutableMapOf<Int, TrustModel>()

			private val trust =
			conflatedCallbackFlow {
			val callback =
			object : TrustManager.TrustListener {
			override fun onTrustChanged(
			enabled: Boolean,
			newlyUnlocked: Boolean,
			userId: Int,
			flags: Int,
			grantMsgs: List<String>?
			) {
			logger.onTrustChanged(enabled, newlyUnlocked, userId, flags, grantMsgs)
			trySendWithFailureLogging(
			TrustModel(enabled, userId),
			TrustRepositoryLogger.TAG,
			"onTrustChanged"
			)
			}

			override fun onTrustError(message: CharSequence?) = Unit

			override fun onTrustManagedChanged(enabled: Boolean, userId: Int) = Unit
			}
			trustManager.registerTrustListener(callback)
			logger.trustListenerRegistered()
			awaitClose {
			logger.trustListenerUnregistered()
			trustManager.unregisterTrustListener(callback)
			}
			}
			.onEach {
			latestTrustModelForUser[it.userId] = it
			logger.trustModelEmitted(it)
			}
			.shareIn(applicationScope, started = SharingStarted.Eagerly, replay = 1)

			override val isCurrentUserTrusted: Flow<Boolean>
			get() =
			combine(trust, userRepository.selectedUserInfo, ::Pair)
			.map { latestTrustModelForUser[it.second.id]?.isTrusted ?: false }
			.distinctUntilChanged()
			.onEach { logger.isCurrentUserTrusted(it) }
			.onStart { emit(false) }
			}

packages/SystemUI/src/com/android/systemui/keyguard/shared/model/TrustModel.kt

0 → 100644

+25 −0

Original line number	Original line	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.shared.model

			/** Represents the trust state */
			data class TrustModel(
			/** If true, the system believes the environment to be trusted. */
			val isTrusted: Boolean,
			/** The user, for which the trust changed. */
			val userId: Int,
			)

packages/SystemUI/tests/src/com/android/systemui/keyguard/data/repository/TrustRepositoryTest.kt

0 → 100644

+163 −0

Original line number	Original line	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.data.repository

			import android.app.trust.TrustManager
			import android.content.pm.UserInfo
			import androidx.test.filters.SmallTest
			import com.android.keyguard.logging.TrustRepositoryLogger
			import com.android.systemui.SysuiTestCase
			import com.android.systemui.coroutines.collectLastValue
			import com.android.systemui.plugins.log.LogBuffer
			import com.android.systemui.plugins.log.LogcatEchoTracker
			import com.android.systemui.user.data.repository.FakeUserRepository
			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
			import org.junit.runners.JUnit4
			import org.mockito.ArgumentCaptor
			import org.mockito.Captor
			import org.mockito.Mock
			import org.mockito.Mockito.mock
			import org.mockito.Mockito.verify
			import org.mockito.MockitoAnnotations

			@OptIn(ExperimentalCoroutinesApi::class)
			@SmallTest
			@RunWith(JUnit4::class)
			class TrustRepositoryTest : SysuiTestCase() {
			@Mock private lateinit var trustManager: TrustManager
			@Captor private lateinit var listenerCaptor: ArgumentCaptor<TrustManager.TrustListener>
			private lateinit var userRepository: FakeUserRepository
			private lateinit var testScope: TestScope
			private val users = listOf(UserInfo(1, "user 1", 0), UserInfo(2, "user 1", 0))

			private lateinit var underTest: TrustRepository

			@Before
			fun setUp() {
			MockitoAnnotations.initMocks(this)
			testScope = TestScope()
			userRepository = FakeUserRepository()
			userRepository.setUserInfos(users)

			val logger =
			TrustRepositoryLogger(
			LogBuffer("TestBuffer", 1, mock(LogcatEchoTracker::class.java), false)
			)
			underTest =
			TrustRepositoryImpl(testScope.backgroundScope, userRepository, trustManager, logger)
			}

			@Test
			fun isCurrentUserTrusted_whenTrustChanges_emitsLatestValue() =
			testScope.runTest {
			runCurrent()
			verify(trustManager).registerTrustListener(listenerCaptor.capture())
			val listener = listenerCaptor.value

			val currentUserId = users[0].id
			userRepository.setSelectedUserInfo(users[0])
			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)

			listener.onTrustChanged(true, false, currentUserId, 0, emptyList())
			assertThat(isCurrentUserTrusted()).isTrue()

			listener.onTrustChanged(false, false, currentUserId, 0, emptyList())

			assertThat(isCurrentUserTrusted()).isFalse()
			}

			@Test
			fun isCurrentUserTrusted_isFalse_byDefault() =
			testScope.runTest {
			runCurrent()

			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)

			assertThat(isCurrentUserTrusted()).isFalse()
			}

			@Test
			fun isCurrentUserTrusted_whenTrustChangesForDifferentUser_noop() =
			testScope.runTest {
			runCurrent()
			verify(trustManager).registerTrustListener(listenerCaptor.capture())
			userRepository.setSelectedUserInfo(users[0])
			val listener = listenerCaptor.value

			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)
			// current user is trusted.
			listener.onTrustChanged(true, true, users[0].id, 0, emptyList())
			// some other user is not trusted.
			listener.onTrustChanged(false, false, users[1].id, 0, emptyList())

			assertThat(isCurrentUserTrusted()).isTrue()
			}

			@Test
			fun isCurrentUserTrusted_whenTrustChangesForCurrentUser_emitsNewValue() =
			testScope.runTest {
			runCurrent()
			verify(trustManager).registerTrustListener(listenerCaptor.capture())
			val listener = listenerCaptor.value
			userRepository.setSelectedUserInfo(users[0])

			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)
			listener.onTrustChanged(true, true, users[0].id, 0, emptyList())
			assertThat(isCurrentUserTrusted()).isTrue()

			listener.onTrustChanged(false, true, users[0].id, 0, emptyList())
			assertThat(isCurrentUserTrusted()).isFalse()
			}

			@Test
			fun isCurrentUserTrusted_whenUserChangesWithoutRecentTrustChange_defaultsToFalse() =
			testScope.runTest {
			runCurrent()
			verify(trustManager).registerTrustListener(listenerCaptor.capture())
			val listener = listenerCaptor.value
			userRepository.setSelectedUserInfo(users[0])
			listener.onTrustChanged(true, true, users[0].id, 0, emptyList())

			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)
			userRepository.setSelectedUserInfo(users[1])

			assertThat(isCurrentUserTrusted()).isFalse()
			}

			@Test
			fun isCurrentUserTrusted_trustChangesFirstBeforeUserInfoChanges_emitsCorrectValue() =
			testScope.runTest {
			runCurrent()
			verify(trustManager).registerTrustListener(listenerCaptor.capture())
			val listener = listenerCaptor.value
			val isCurrentUserTrusted = collectLastValue(underTest.isCurrentUserTrusted)

			listener.onTrustChanged(true, true, users[0].id, 0, emptyList())
			assertThat(isCurrentUserTrusted()).isFalse()

			userRepository.setSelectedUserInfo(users[0])

			assertThat(isCurrentUserTrusted()).isTrue()
			}
			}