Merge "Refactor communal hub enablement logic" into main (9e3d8610) · Commits · e / os / android_frameworks_base

packages/SystemUI/AndroidManifest.xml

+3 −0

Original line number	Diff line number	Diff line
		@@ -312,6 +312,9 @@
		<!-- Permission necessary to change car audio volume through CarAudioManager -->
		<uses-permission android:name="android.car.permission.CAR_CONTROL_AUDIO_VOLUME" />

		<!-- To detect when projecting to Android Auto -->
		<uses-permission android:name="android.permission.READ_PROJECTION_STATE" />

		<!-- Permission to control Android Debug Bridge (ADB) -->
		<uses-permission android:name="android.permission.MANAGE_DEBUGGING" />

packages/SystemUI/multivalentTests/src/com/android/systemui/communal/CommunalOngoingContentStartableTest.kt

+4 −4

Original line number	Diff line number	Diff line
		@@ -73,12 +73,12 @@ class CommunalOngoingContentStartableTest : SysuiTestCase() {
		assertThat(fakeCommunalMediaRepository.isListening()).isFalse()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isFalse()

		kosmos.setCommunalEnabled(true)
		setCommunalEnabled(true)

		assertThat(fakeCommunalMediaRepository.isListening()).isTrue()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isTrue()

		kosmos.setCommunalEnabled(false)
		setCommunalEnabled(false)

		assertThat(fakeCommunalMediaRepository.isListening()).isFalse()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isFalse()
		@@ -93,13 +93,13 @@ class CommunalOngoingContentStartableTest : SysuiTestCase() {
		assertThat(fakeCommunalMediaRepository.isListening()).isFalse()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isFalse()

		kosmos.setCommunalEnabled(true)
		setCommunalEnabled(true)

		// Media listening does not start when UMO is disabled.
		assertThat(fakeCommunalMediaRepository.isListening()).isFalse()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isTrue()

		kosmos.setCommunalEnabled(false)
		setCommunalEnabled(false)

		assertThat(fakeCommunalMediaRepository.isListening()).isFalse()
		assertThat(fakeCommunalSmartspaceRepository.isListening()).isFalse()

packages/SystemUI/multivalentTests/src/com/android/systemui/communal/data/repository/CarProjectionRepositoryImplTest.kt

0 → 100644

+120 −0

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

		import android.app.UiModeManager
		import android.app.UiModeManager.OnProjectionStateChangedListener
		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.backgroundScope
		import com.android.systemui.kosmos.collectLastValue
		import com.android.systemui.kosmos.runTest
		import com.android.systemui.kosmos.testDispatcher
		import com.android.systemui.kosmos.useUnconfinedTestDispatcher
		import com.android.systemui.testKosmos
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.flow.launchIn
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.kotlin.any
		import org.mockito.kotlin.doAnswer
		import org.mockito.kotlin.doReturn
		import org.mockito.kotlin.eq
		import org.mockito.kotlin.mock
		import org.mockito.kotlin.stub

		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class CarProjectionRepositoryImplTest : SysuiTestCase() {
		private val kosmos = testKosmos().useUnconfinedTestDispatcher()

		private val capturedListeners = mutableListOf<OnProjectionStateChangedListener>()

		private val Kosmos.uiModeManager by
		Kosmos.Fixture<UiModeManager> {
		mock {
		on {
		addOnProjectionStateChangedListener(
		eq(UiModeManager.PROJECTION_TYPE_AUTOMOTIVE),
		any(),
		any(),
		)
		} doAnswer
		{
		val listener = it.getArgument<OnProjectionStateChangedListener>(2)
		capturedListeners.add(listener)
		Unit
		}

		on { removeOnProjectionStateChangedListener(any()) } doAnswer
		{
		val listener = it.getArgument<OnProjectionStateChangedListener>(0)
		capturedListeners.remove(listener)
		Unit
		}

		on { activeProjectionTypes } doReturn UiModeManager.PROJECTION_TYPE_NONE
		}
		}

		private val Kosmos.underTest by
		Kosmos.Fixture {
		CarProjectionRepositoryImpl(
		uiModeManager = uiModeManager,
		bgDispatcher = testDispatcher,
		)
		}

		@Test
		fun testProjectionActiveUpdatesAfterCallback() =
		kosmos.runTest {
		val projectionActive by collectLastValue(underTest.projectionActive)
		assertThat(projectionActive).isFalse()

		setActiveProjectionType(UiModeManager.PROJECTION_TYPE_AUTOMOTIVE)
		assertThat(projectionActive).isTrue()

		setActiveProjectionType(UiModeManager.PROJECTION_TYPE_NONE)
		assertThat(projectionActive).isFalse()
		}

		@Test
		fun testProjectionInitialValueTrue() =
		kosmos.runTest {
		setActiveProjectionType(UiModeManager.PROJECTION_TYPE_AUTOMOTIVE)

		val projectionActive by collectLastValue(underTest.projectionActive)
		assertThat(projectionActive).isTrue()
		}

		@Test
		fun testUnsubscribeWhenCancelled() =
		kosmos.runTest {
		val job = underTest.projectionActive.launchIn(backgroundScope)
		assertThat(capturedListeners).hasSize(1)

		job.cancel()
		assertThat(capturedListeners).isEmpty()
		}

		private fun Kosmos.setActiveProjectionType(@UiModeManager.ProjectionType projectionType: Int) {
		uiModeManager.stub { on { activeProjectionTypes } doReturn projectionType }
		capturedListeners.forEach { it.onProjectionStateChanged(projectionType, emptySet()) }
		}
		}

packages/SystemUI/multivalentTests/src/com/android/systemui/communal/data/repository/CommunalSettingsRepositoryImplTest.kt

+0 −109

Original line number	Diff line number	Diff line
		@@ -34,9 +34,7 @@ import com.android.systemui.Flags.FLAG_GLANCEABLE_HUB_BLURRED_BACKGROUND
		import com.android.systemui.Flags.FLAG_GLANCEABLE_HUB_V2
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.broadcast.broadcastDispatcher
		import com.android.systemui.communal.data.model.DisabledReason
		import com.android.systemui.communal.data.repository.CommunalSettingsRepositoryImpl.Companion.GLANCEABLE_HUB_BACKGROUND_SETTING
		import com.android.systemui.communal.domain.interactor.setCommunalV2Enabled
		import com.android.systemui.communal.shared.model.CommunalBackgroundType
		import com.android.systemui.communal.shared.model.WhenToDream
		import com.android.systemui.flags.Flags.COMMUNAL_SERVICE_ENABLED
		@@ -200,63 +198,6 @@ class CommunalSettingsRepositoryImplTest(flags: FlagsParameterization?) : SysuiT
		assertThat(underTest.getFlagEnabled()).isTrue()
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun secondaryUserIsInvalid() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getEnabledState(SECONDARY_USER))

		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState).containsExactly(DisabledReason.DISABLED_REASON_INVALID_USER)
		}

		@EnableFlags(FLAG_COMMUNAL_HUB, FLAG_GLANCEABLE_HUB_V2)
		@Test
		fun classicFlagIsDisabled() =
		kosmos.runTest {
		setCommunalV2Enabled(false)
		val enabledState by collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState).containsExactly(DisabledReason.DISABLED_REASON_FLAG)
		}

		@DisableFlags(FLAG_COMMUNAL_HUB, FLAG_GLANCEABLE_HUB_V2)
		@Test
		fun communalHubFlagIsDisabled() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState).containsExactly(DisabledReason.DISABLED_REASON_FLAG)
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun hubIsDisabledByUser() =
		kosmos.runTest {
		fakeSettings.putIntForUser(Settings.Secure.GLANCEABLE_HUB_ENABLED, 0, PRIMARY_USER.id)
		val enabledState by collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState).containsExactly(DisabledReason.DISABLED_REASON_USER_SETTING)

		fakeSettings.putIntForUser(Settings.Secure.GLANCEABLE_HUB_ENABLED, 1, SECONDARY_USER.id)
		assertThat(enabledState?.enabled).isFalse()

		fakeSettings.putIntForUser(Settings.Secure.GLANCEABLE_HUB_ENABLED, 1, PRIMARY_USER.id)
		assertThat(enabledState?.enabled).isTrue()
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun hubIsDisabledByDevicePolicy() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledState?.enabled).isTrue()

		setKeyguardFeaturesDisabled(PRIMARY_USER, KEYGUARD_DISABLE_WIDGETS_ALL)
		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState).containsExactly(DisabledReason.DISABLED_REASON_DEVICE_POLICY)
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun widgetsAllowedForWorkProfile_isFalse_whenDisallowedByDevicePolicy() =
		@@ -269,36 +210,6 @@ class CommunalSettingsRepositoryImplTest(flags: FlagsParameterization?) : SysuiT
		assertThat(widgetsAllowedForWorkProfile).isFalse()
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun hubIsEnabled_whenDisallowedByDevicePolicyForWorkProfile() =
		kosmos.runTest {
		val enabledStateForPrimaryUser by
		collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledStateForPrimaryUser?.enabled).isTrue()

		setKeyguardFeaturesDisabled(WORK_PROFILE, KEYGUARD_DISABLE_WIDGETS_ALL)
		assertThat(enabledStateForPrimaryUser?.enabled).isTrue()
		}

		@EnableFlags(FLAG_COMMUNAL_HUB)
		@Test
		fun hubIsDisabledByUserAndDevicePolicy() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getEnabledState(PRIMARY_USER))
		assertThat(enabledState?.enabled).isTrue()

		fakeSettings.putIntForUser(Settings.Secure.GLANCEABLE_HUB_ENABLED, 0, PRIMARY_USER.id)
		setKeyguardFeaturesDisabled(PRIMARY_USER, KEYGUARD_DISABLE_WIDGETS_ALL)

		assertThat(enabledState?.enabled).isFalse()
		assertThat(enabledState)
		.containsExactly(
		DisabledReason.DISABLED_REASON_DEVICE_POLICY,
		DisabledReason.DISABLED_REASON_USER_SETTING,
		)
		}

		@Test
		@DisableFlags(FLAG_GLANCEABLE_HUB_BLURRED_BACKGROUND)
		fun backgroundType_defaultValue() =
		@@ -326,26 +237,6 @@ class CommunalSettingsRepositoryImplTest(flags: FlagsParameterization?) : SysuiT
		}
		}

		@Test
		fun screensaverDisabledByUser() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getScreensaverEnabledState(PRIMARY_USER))

		fakeSettings.putIntForUser(Settings.Secure.SCREENSAVER_ENABLED, 0, PRIMARY_USER.id)

		assertThat(enabledState).isFalse()
		}

		@Test
		fun screensaverEnabledByUser() =
		kosmos.runTest {
		val enabledState by collectLastValue(underTest.getScreensaverEnabledState(PRIMARY_USER))

		fakeSettings.putIntForUser(Settings.Secure.SCREENSAVER_ENABLED, 1, PRIMARY_USER.id)

		assertThat(enabledState).isTrue()
		}

		@Test
		fun whenToDream_charging() =
		kosmos.runTest {

packages/SystemUI/multivalentTests/src/com/android/systemui/communal/domain/interactor/CommunalInteractorCommunalDisabledTest.kt→packages/SystemUI/multivalentTests/src/com/android/systemui/communal/domain/interactor/CarProjectionInteractorTest.kt

+49 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 The Android Open Source Project
		* Copyright (C) 2025 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.
		@@ -12,71 +12,38 @@
		* 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.communal.domain.interactor

		import androidx.test.ext.junit.runners.AndroidJUnit4
		import androidx.test.filters.SmallTest
		import com.android.systemui.Flags.FLAG_COMMUNAL_HUB
		import com.android.systemui.SysuiTestCase
		import com.android.systemui.communal.data.repository.FakeCommunalSceneRepository
		import com.android.systemui.communal.data.repository.FakeCommunalWidgetRepository
		import com.android.systemui.communal.data.repository.fakeCommunalSceneRepository
		import com.android.systemui.communal.data.repository.fakeCommunalWidgetRepository
		import com.android.systemui.coroutines.collectLastValue
		import com.android.systemui.keyguard.data.repository.FakeKeyguardRepository
		import com.android.systemui.keyguard.data.repository.fakeKeyguardRepository
		import com.android.systemui.kosmos.testScope
		import com.android.systemui.communal.data.repository.carProjectionRepository
		import com.android.systemui.communal.data.repository.fake
		import com.android.systemui.kosmos.Kosmos
		import com.android.systemui.kosmos.collectLastValue
		import com.android.systemui.kosmos.runTest
		import com.android.systemui.kosmos.useUnconfinedTestDispatcher
		import com.android.systemui.testKosmos
		import com.google.common.truth.Truth.assertThat
		import kotlinx.coroutines.test.runCurrent
		import kotlinx.coroutines.test.runTest
		import org.junit.Before
		import org.junit.Test
		import org.junit.runner.RunWith

		/**
		* This class is a variation of the [CommunalInteractorTest] for cases where communal is disabled.
		*/
		@SmallTest
		@RunWith(AndroidJUnit4::class)
		class CommunalInteractorCommunalDisabledTest : SysuiTestCase() {
		private val kosmos = testKosmos()
		private val testScope = kosmos.testScope

		private lateinit var communalRepository: FakeCommunalSceneRepository
		private lateinit var widgetRepository: FakeCommunalWidgetRepository
		private lateinit var keyguardRepository: FakeKeyguardRepository
		class CarProjectionInteractorTest : SysuiTestCase() {
		private val kosmos = testKosmos().useUnconfinedTestDispatcher()

		private lateinit var underTest: CommunalInteractor

		@Before
		fun setUp() {
		communalRepository = kosmos.fakeCommunalSceneRepository
		widgetRepository = kosmos.fakeCommunalWidgetRepository
		keyguardRepository = kosmos.fakeKeyguardRepository

		mSetFlagsRule.disableFlags(FLAG_COMMUNAL_HUB)

		underTest = kosmos.communalInteractor
		}

		@Test
		fun isCommunalEnabled_false() =
		testScope.runTest { assertThat(underTest.isCommunalEnabled.value).isFalse() }
		private val Kosmos.underTest by Kosmos.Fixture { carProjectionInteractor }

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

		assertThat(isCommunalAvailable).isFalse()

		keyguardRepository.setIsEncryptedOrLockdown(false)
		runCurrent()
		fun testProjectionActive() =
		kosmos.runTest {
		val projectionActive by collectLastValue(underTest.projectionActive)
		assertThat(projectionActive).isFalse()

		assertThat(isCommunalAvailable).isFalse()
		carProjectionRepository.fake.setProjectionActive(true)
		assertThat(projectionActive).isTrue()
		}
		}