| package com.android.systemui.qs |
| |
| import android.content.Intent |
| import android.os.Handler |
| import android.os.UserManager |
| import android.provider.Settings |
| import android.testing.AndroidTestingRunner |
| import android.testing.TestableLooper |
| import android.testing.ViewUtils |
| import android.view.LayoutInflater |
| import android.view.View |
| import android.view.ViewGroup |
| import androidx.test.filters.SmallTest |
| import com.android.internal.logging.MetricsLogger |
| import com.android.internal.logging.UiEventLogger |
| import com.android.internal.logging.testing.FakeMetricsLogger |
| import com.android.systemui.R |
| import com.android.systemui.animation.ActivityLaunchAnimator |
| import com.android.systemui.classifier.FalsingManagerFake |
| import com.android.systemui.globalactions.GlobalActionsDialogLite |
| import com.android.systemui.plugins.ActivityStarter |
| import com.android.systemui.settings.UserTracker |
| import com.android.systemui.statusbar.phone.MultiUserSwitchController |
| import com.android.systemui.statusbar.policy.DeviceProvisionedController |
| import com.android.systemui.statusbar.policy.FakeConfigurationController |
| import com.android.systemui.statusbar.policy.UserInfoController |
| import com.android.systemui.util.mockito.capture |
| import com.android.systemui.util.settings.FakeSettings |
| import com.android.systemui.utils.leaks.LeakCheckedTest |
| import com.google.common.truth.Expect |
| import com.google.common.truth.Truth.assertThat |
| import javax.inject.Provider |
| import org.junit.After |
| import org.junit.Before |
| import org.junit.Rule |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import org.mockito.ArgumentCaptor |
| import org.mockito.ArgumentMatchers.any |
| import org.mockito.ArgumentMatchers.anyBoolean |
| import org.mockito.Captor |
| import org.mockito.Mock |
| import org.mockito.Mockito |
| import org.mockito.Mockito.atLeastOnce |
| import org.mockito.Mockito.clearInvocations |
| import org.mockito.Mockito.never |
| import org.mockito.Mockito.reset |
| import org.mockito.Mockito.verify |
| import org.mockito.Mockito.`when` as whenever |
| import org.mockito.MockitoAnnotations |
| |
| @SmallTest |
| @TestableLooper.RunWithLooper(setAsMainLooper = true) |
| @RunWith(AndroidTestingRunner::class) |
| class FooterActionsControllerTest : LeakCheckedTest() { |
| |
| @get:Rule var expect: Expect = Expect.create() |
| |
| @Mock private lateinit var userManager: UserManager |
| @Mock private lateinit var userTracker: UserTracker |
| @Mock private lateinit var activityStarter: ActivityStarter |
| @Mock private lateinit var deviceProvisionedController: DeviceProvisionedController |
| @Mock private lateinit var userInfoController: UserInfoController |
| @Mock private lateinit var multiUserSwitchControllerFactory: MultiUserSwitchController.Factory |
| @Mock private lateinit var multiUserSwitchController: MultiUserSwitchController |
| @Mock private lateinit var globalActionsDialogProvider: Provider<GlobalActionsDialogLite> |
| @Mock private lateinit var globalActionsDialog: GlobalActionsDialogLite |
| @Mock private lateinit var uiEventLogger: UiEventLogger |
| @Mock private lateinit var securityFooterController: QSSecurityFooter |
| @Mock private lateinit var fgsManagerController: QSFgsManagerFooter |
| @Captor |
| private lateinit var visibilityChangedCaptor: |
| ArgumentCaptor<VisibilityChangedDispatcher.OnVisibilityChangedListener> |
| |
| private lateinit var controller: FooterActionsController |
| |
| private val configurationController = FakeConfigurationController() |
| private val metricsLogger: MetricsLogger = FakeMetricsLogger() |
| private val falsingManager: FalsingManagerFake = FalsingManagerFake() |
| private lateinit var view: FooterActionsView |
| private lateinit var testableLooper: TestableLooper |
| private lateinit var fakeSettings: FakeSettings |
| private lateinit var securityFooter: View |
| private lateinit var fgsFooter: View |
| |
| @Before |
| fun setUp() { |
| // We want to make sure testable resources are always used |
| context.ensureTestableResources() |
| |
| MockitoAnnotations.initMocks(this) |
| testableLooper = TestableLooper.get(this) |
| fakeSettings = FakeSettings() |
| |
| whenever(multiUserSwitchControllerFactory.create(any())) |
| .thenReturn(multiUserSwitchController) |
| whenever(globalActionsDialogProvider.get()).thenReturn(globalActionsDialog) |
| |
| securityFooter = View(mContext) |
| fgsFooter = View(mContext) |
| |
| whenever(securityFooterController.view).thenReturn(securityFooter) |
| whenever(fgsManagerController.view).thenReturn(fgsFooter) |
| |
| view = inflateView() |
| |
| controller = constructFooterActionsController(view) |
| controller.init() |
| ViewUtils.attachView(view) |
| // View looper is the testable looper associated with the test |
| testableLooper.processAllMessages() |
| } |
| |
| @After |
| fun tearDown() { |
| if (view.isAttachedToWindow) { |
| ViewUtils.detachView(view) |
| } |
| } |
| |
| @Test |
| fun testInitializesControllers() { |
| verify(multiUserSwitchController).init() |
| verify(fgsManagerController).init() |
| verify(securityFooterController).init() |
| } |
| |
| @Test |
| fun testLogPowerMenuClick() { |
| controller.visible = true |
| falsingManager.setFalseTap(false) |
| |
| view.findViewById<View>(R.id.pm_lite).performClick() |
| // Verify clicks are logged |
| verify(uiEventLogger, Mockito.times(1)) |
| .log(GlobalActionsDialogLite.GlobalActionsEvent.GA_OPEN_QS) |
| } |
| |
| @Test |
| fun testSettings() { |
| val captor = ArgumentCaptor.forClass(Intent::class.java) |
| whenever(deviceProvisionedController.isCurrentUserSetup).thenReturn(true) |
| view.findViewById<View>(R.id.settings_button_container).performClick() |
| |
| verify(activityStarter) |
| .startActivity(capture(captor), anyBoolean(), any<ActivityLaunchAnimator.Controller>()) |
| |
| assertThat(captor.value.action).isEqualTo(Settings.ACTION_SETTINGS) |
| } |
| |
| @Test |
| fun testSettings_UserNotSetup() { |
| whenever(deviceProvisionedController.isCurrentUserSetup).thenReturn(false) |
| view.findViewById<View>(R.id.settings_button_container).performClick() |
| // Verify Settings wasn't launched. |
| verify(activityStarter, never()) |
| .startActivity(any(), anyBoolean(), any<ActivityLaunchAnimator.Controller>()) |
| } |
| |
| @Test |
| fun testMultiUserSwitchUpdatedWhenExpansionStarts() { |
| // When expansion starts, listening is set to true |
| val multiUserSwitch = view.requireViewById<View>(R.id.multi_user_switch) |
| |
| assertThat(multiUserSwitch.visibility).isNotEqualTo(View.VISIBLE) |
| |
| whenever(multiUserSwitchController.isMultiUserEnabled).thenReturn(true) |
| |
| controller.setListening(true) |
| testableLooper.processAllMessages() |
| |
| assertThat(multiUserSwitch.visibility).isEqualTo(View.VISIBLE) |
| } |
| |
| @Test |
| fun testMultiUserSwitchUpdatedWhenSettingChanged() { |
| // Always listening to setting while View is attached |
| testableLooper.processAllMessages() |
| |
| val multiUserSwitch = view.requireViewById<View>(R.id.multi_user_switch) |
| assertThat(multiUserSwitch.visibility).isNotEqualTo(View.VISIBLE) |
| |
| // The setting is only used as an indicator for whether the view should refresh. The actual |
| // value of the setting is ignored; isMultiUserEnabled is the source of truth |
| whenever(multiUserSwitchController.isMultiUserEnabled).thenReturn(true) |
| |
| // Changing the value of USER_SWITCHER_ENABLED should cause the view to update |
| fakeSettings.putIntForUser(Settings.Global.USER_SWITCHER_ENABLED, 1, userTracker.userId) |
| testableLooper.processAllMessages() |
| |
| assertThat(multiUserSwitch.visibility).isEqualTo(View.VISIBLE) |
| } |
| |
| @Test |
| fun testMultiUserSettingNotListenedAfterDetach() { |
| testableLooper.processAllMessages() |
| |
| val multiUserSwitch = view.requireViewById<View>(R.id.multi_user_switch) |
| assertThat(multiUserSwitch.visibility).isNotEqualTo(View.VISIBLE) |
| |
| ViewUtils.detachView(view) |
| |
| // The setting is only used as an indicator for whether the view should refresh. The actual |
| // value of the setting is ignored; isMultiUserEnabled is the source of truth |
| whenever(multiUserSwitchController.isMultiUserEnabled).thenReturn(true) |
| |
| // Changing the value of USER_SWITCHER_ENABLED should cause the view to update |
| fakeSettings.putIntForUser(Settings.Global.USER_SWITCHER_ENABLED, 1, userTracker.userId) |
| testableLooper.processAllMessages() |
| |
| assertThat(multiUserSwitch.visibility).isNotEqualTo(View.VISIBLE) |
| } |
| |
| @Test |
| fun testCleanUpGAD() { |
| reset(globalActionsDialogProvider) |
| // We are creating a new controller, so detach the views from it |
| (securityFooter.parent as ViewGroup).removeView(securityFooter) |
| (fgsFooter.parent as ViewGroup).removeView(fgsFooter) |
| |
| whenever(globalActionsDialogProvider.get()).thenReturn(globalActionsDialog) |
| val view = inflateView() |
| controller = constructFooterActionsController(view) |
| controller.init() |
| verify(globalActionsDialogProvider, never()).get() |
| |
| // GAD is constructed during attachment |
| ViewUtils.attachView(view) |
| testableLooper.processAllMessages() |
| verify(globalActionsDialogProvider).get() |
| |
| ViewUtils.detachView(view) |
| testableLooper.processAllMessages() |
| verify(globalActionsDialog).destroy() |
| } |
| |
| @Test |
| fun testSeparatorVisibility_noneVisible_gone() { |
| verify(securityFooterController) |
| .setOnVisibilityChangedListener(capture(visibilityChangedCaptor)) |
| val listener = visibilityChangedCaptor.value |
| val separator = controller.securityFootersSeparator |
| |
| setVisibilities(securityFooterVisible = false, fgsFooterVisible = false, listener) |
| assertThat(separator.visibility).isEqualTo(View.GONE) |
| } |
| |
| @Test |
| fun testSeparatorVisibility_onlySecurityFooterVisible_gone() { |
| verify(securityFooterController) |
| .setOnVisibilityChangedListener(capture(visibilityChangedCaptor)) |
| val listener = visibilityChangedCaptor.value |
| val separator = controller.securityFootersSeparator |
| |
| setVisibilities(securityFooterVisible = true, fgsFooterVisible = false, listener) |
| assertThat(separator.visibility).isEqualTo(View.GONE) |
| } |
| |
| @Test |
| fun testSeparatorVisibility_onlyFgsFooterVisible_gone() { |
| verify(securityFooterController) |
| .setOnVisibilityChangedListener(capture(visibilityChangedCaptor)) |
| val listener = visibilityChangedCaptor.value |
| val separator = controller.securityFootersSeparator |
| |
| setVisibilities(securityFooterVisible = false, fgsFooterVisible = true, listener) |
| assertThat(separator.visibility).isEqualTo(View.GONE) |
| } |
| |
| @Test |
| fun testSeparatorVisibility_bothVisible_visible() { |
| verify(securityFooterController) |
| .setOnVisibilityChangedListener(capture(visibilityChangedCaptor)) |
| val listener = visibilityChangedCaptor.value |
| val separator = controller.securityFootersSeparator |
| |
| setVisibilities(securityFooterVisible = true, fgsFooterVisible = true, listener) |
| assertThat(separator.visibility).isEqualTo(View.VISIBLE) |
| } |
| |
| @Test |
| fun testFgsFooterCollapsed() { |
| verify(securityFooterController) |
| .setOnVisibilityChangedListener(capture(visibilityChangedCaptor)) |
| val listener = visibilityChangedCaptor.value |
| |
| val booleanCaptor = ArgumentCaptor.forClass(Boolean::class.java) |
| |
| clearInvocations(fgsManagerController) |
| setVisibilities(securityFooterVisible = false, fgsFooterVisible = true, listener) |
| verify(fgsManagerController, atLeastOnce()).setCollapsed(capture(booleanCaptor)) |
| assertThat(booleanCaptor.allValues.last()).isFalse() |
| |
| clearInvocations(fgsManagerController) |
| setVisibilities(securityFooterVisible = true, fgsFooterVisible = true, listener) |
| verify(fgsManagerController, atLeastOnce()).setCollapsed(capture(booleanCaptor)) |
| assertThat(booleanCaptor.allValues.last()).isTrue() |
| } |
| |
| @Test |
| fun setExpansion_inSplitShade_alphaFollowsExpansion() { |
| enableSplitShade() |
| |
| controller.setExpansion(0f) |
| expect.that(view.alpha).isEqualTo(0f) |
| |
| controller.setExpansion(0.25f) |
| expect.that(view.alpha).isEqualTo(0.25f) |
| |
| controller.setExpansion(0.5f) |
| expect.that(view.alpha).isEqualTo(0.5f) |
| |
| controller.setExpansion(0.75f) |
| expect.that(view.alpha).isEqualTo(0.75f) |
| |
| controller.setExpansion(1f) |
| expect.that(view.alpha).isEqualTo(1f) |
| } |
| |
| @Test |
| fun setExpansion_inSplitShade_backgroundAlphaFollowsExpansion_with_0_9_delay() { |
| enableSplitShade() |
| |
| controller.setExpansion(0f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(0f) |
| |
| controller.setExpansion(0.5f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(0f) |
| |
| controller.setExpansion(0.9f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(0f) |
| |
| controller.setExpansion(0.91f) |
| expect.that(view.backgroundAlphaFraction).isWithin(FLOAT_TOLERANCE).of(0.1f) |
| |
| controller.setExpansion(0.95f) |
| expect.that(view.backgroundAlphaFraction).isWithin(FLOAT_TOLERANCE).of(0.5f) |
| |
| controller.setExpansion(1f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(1f) |
| } |
| |
| @Test |
| fun setExpansion_inSingleShade_alphaFollowsExpansion_with_0_9_delay() { |
| disableSplitShade() |
| |
| controller.setExpansion(0f) |
| expect.that(view.alpha).isEqualTo(0f) |
| |
| controller.setExpansion(0.5f) |
| expect.that(view.alpha).isEqualTo(0f) |
| |
| controller.setExpansion(0.9f) |
| expect.that(view.alpha).isEqualTo(0f) |
| |
| controller.setExpansion(0.91f) |
| expect.that(view.alpha).isWithin(FLOAT_TOLERANCE).of(0.1f) |
| |
| controller.setExpansion(0.95f) |
| expect.that(view.alpha).isWithin(FLOAT_TOLERANCE).of(0.5f) |
| |
| controller.setExpansion(1f) |
| expect.that(view.alpha).isEqualTo(1f) |
| } |
| |
| @Test |
| fun setExpansion_inSingleShade_backgroundAlphaAlways1() { |
| disableSplitShade() |
| |
| controller.setExpansion(0f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(1f) |
| |
| controller.setExpansion(0.5f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(1f) |
| |
| controller.setExpansion(1f) |
| expect.that(view.backgroundAlphaFraction).isEqualTo(1f) |
| } |
| |
| private fun setVisibilities( |
| securityFooterVisible: Boolean, |
| fgsFooterVisible: Boolean, |
| listener: VisibilityChangedDispatcher.OnVisibilityChangedListener |
| ) { |
| securityFooter.visibility = if (securityFooterVisible) View.VISIBLE else View.GONE |
| listener.onVisibilityChanged(securityFooter.visibility) |
| fgsFooter.visibility = if (fgsFooterVisible) View.VISIBLE else View.GONE |
| listener.onVisibilityChanged(fgsFooter.visibility) |
| } |
| |
| private fun inflateView(): FooterActionsView { |
| return LayoutInflater.from(context).inflate(R.layout.footer_actions, null) |
| as FooterActionsView |
| } |
| |
| private fun constructFooterActionsController(view: FooterActionsView): FooterActionsController { |
| return FooterActionsController( |
| view, |
| multiUserSwitchControllerFactory, |
| activityStarter, |
| userManager, |
| userTracker, |
| userInfoController, |
| deviceProvisionedController, |
| securityFooterController, |
| fgsManagerController, |
| falsingManager, |
| metricsLogger, |
| globalActionsDialogProvider, |
| uiEventLogger, |
| showPMLiteButton = true, |
| fakeSettings, |
| Handler(testableLooper.looper), |
| configurationController) |
| } |
| |
| private fun enableSplitShade() { |
| setSplitShadeEnabled(true) |
| } |
| |
| private fun disableSplitShade() { |
| setSplitShadeEnabled(false) |
| } |
| |
| private fun setSplitShadeEnabled(enabled: Boolean) { |
| overrideResource(R.bool.config_use_split_notification_shade, enabled) |
| configurationController.notifyConfigurationChanged() |
| } |
| } |
| |
| private const val FLOAT_TOLERANCE = 0.01f |
| |
| private val View.backgroundAlphaFraction: Float? |
| get() { |
| return if (background != null) { |
| background.alpha / 255f |
| } else { |
| null |
| } |
| } |
