Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c6432b61 authored by 1's avatar 1
Browse files

Remove ChooserSelector. 

The chooser has been selected, there's no going back.

Bug: 254512507
Test: mp sysuig
Change-Id: Ia18496020bf553e385579e5edf7ff3ce4f0ed3a2
parent 23cdcba7

packages/SystemUI/src/com/android/systemui/ChooserSelector.kt

deleted100644 → 0
+0 −81
Original line number Diff line number Diff line 
package com.android.systemui



import android.content.ComponentName

import android.content.Context

import android.content.pm.PackageManager

import android.util.Log

import com.android.internal.R

import com.android.systemui.dagger.SysUISingleton

import com.android.systemui.dagger.qualifiers.Application

import com.android.systemui.dagger.qualifiers.Background

import com.android.systemui.flags.FeatureFlags

import com.android.systemui.flags.FlagListenable

import com.android.systemui.flags.Flags

import com.android.systemui.settings.UserTracker

import kotlinx.coroutines.CoroutineDispatcher

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.launch

import kotlinx.coroutines.suspendCancellableCoroutine

import kotlinx.coroutines.withContext

import javax.inject.Inject



@SysUISingleton

class ChooserSelector @Inject constructor(

        private val context: Context,

        private val userTracker: UserTracker,

        private val featureFlags: FeatureFlags,

        @Application private val coroutineScope: CoroutineScope,

        @Background private val bgDispatcher: CoroutineDispatcher,

) : CoreStartable {



    private val chooserComponent = ComponentName.unflattenFromString(

            context.resources.getString(R.string.config_chooserActivity))



    override fun start() {

        coroutineScope.launch {

            val listener = FlagListenable.Listener { event ->

                if (event.flagName == Flags.CHOOSER_UNBUNDLED.name) {

                    launch { updateUnbundledChooserEnabled() }

                    event.requestNoRestart()

                }

            }

            featureFlags.addListener(Flags.CHOOSER_UNBUNDLED, listener)

            updateUnbundledChooserEnabled()



            awaitCancellationAndThen { featureFlags.removeListener(listener) }

        }

    }



    private suspend fun updateUnbundledChooserEnabled() {

        setUnbundledChooserEnabled(withContext(bgDispatcher) {

            featureFlags.isEnabled(Flags.CHOOSER_UNBUNDLED)

        })

    }



    private fun setUnbundledChooserEnabled(enabled: Boolean) {

        val newState = if (enabled) {

            PackageManager.COMPONENT_ENABLED_STATE_ENABLED

        } else {

            PackageManager.COMPONENT_ENABLED_STATE_DISABLED

        }

        userTracker.userProfiles.forEach {

            try {

                context.createContextAsUser(it.userHandle, /* flags = */ 0).packageManager

                        .setComponentEnabledSetting(chooserComponent, newState, /* flags = */ 0)

            } catch (e: IllegalArgumentException) {

                Log.w(

                        "ChooserSelector",

                        "Unable to set IntentResolver enabled=$enabled for user ${it.id}",

                        e,

                )

            }

        }

    }



    suspend inline fun awaitCancellation(): Nothing = suspendCancellableCoroutine { }

    suspend inline fun awaitCancellationAndThen(block: () -> Unit): Nothing = try {

        awaitCancellation()

    } finally {

        block()

    }

}

packages/SystemUI/src/com/android/systemui/dagger/SystemUICoreStartableModule.kt

+0 −7
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
package com.android.systemui.dagger



import com.android.keyguard.KeyguardBiometricLockoutLogger

import com.android.systemui.ChooserSelector

import com.android.systemui.CoreStartable

import com.android.systemui.LatencyTester

import com.android.systemui.ScreenDecorations
@@ -84,12 +83,6 @@ abstract class SystemUICoreStartableModule { 
        service: BiometricNotificationService

    ): CoreStartable



    /** Inject into ChooserCoreStartable. */

    @Binds

    @IntoMap

    @ClassKey(ChooserSelector::class)

    abstract fun bindChooserSelector(sysui: ChooserSelector): CoreStartable



    /** Inject into ClipboardListener.  */

    @Binds

    @IntoMap

packages/SystemUI/tests/src/com/android/systemui/ChooserSelectorTest.kt

deleted100644 → 0
+0 −215
Original line number Diff line number Diff line 
package com.android.systemui



import android.content.ComponentName

import android.content.Context

import android.content.pm.PackageManager

import android.content.pm.UserInfo

import android.content.res.Resources

import android.testing.AndroidTestingRunner

import androidx.test.filters.SmallTest

import com.android.systemui.flags.FeatureFlags

import com.android.systemui.flags.Flag

import com.android.systemui.flags.FlagListenable

import com.android.systemui.flags.Flags

import com.android.systemui.flags.ReleasedFlag

import com.android.systemui.flags.UnreleasedFlag

import com.android.systemui.settings.UserTracker

import com.android.systemui.util.mockito.any

import com.android.systemui.util.mockito.eq

import com.android.systemui.util.mockito.kotlinArgumentCaptor

import com.android.systemui.util.mockito.whenever

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.ExperimentalCoroutinesApi

import kotlinx.coroutines.cancel

import kotlinx.coroutines.test.TestCoroutineDispatcher

import org.junit.After

import org.junit.Before

import org.junit.Test

import org.junit.runner.RunWith

import org.mockito.Mock

import org.mockito.Mockito.anyInt

import org.mockito.Mockito.clearInvocations

import org.mockito.Mockito.never

import org.mockito.Mockito.times

import org.mockito.Mockito.verify

import org.mockito.Mockito.verifyZeroInteractions

import org.mockito.MockitoAnnotations



@OptIn(ExperimentalCoroutinesApi::class)

@RunWith(AndroidTestingRunner::class)

@SmallTest

class ChooserSelectorTest : SysuiTestCase() {



    private val flagListener = kotlinArgumentCaptor<FlagListenable.Listener>()



    private val testDispatcher = TestCoroutineDispatcher()

    private val testScope = CoroutineScope(testDispatcher)



    private lateinit var chooserSelector: ChooserSelector



    @Mock private lateinit var mockContext: Context

    @Mock private lateinit var mockProfileContext: Context

    @Mock private lateinit var mockUserTracker: UserTracker

    @Mock private lateinit var mockPackageManager: PackageManager

    @Mock private lateinit var mockResources: Resources

    @Mock private lateinit var mockFeatureFlags: FeatureFlags



    @Before

    fun setup() {

        MockitoAnnotations.initMocks(this)



        whenever(mockContext.createContextAsUser(any(), anyInt())).thenReturn(mockProfileContext)

        whenever(mockContext.resources).thenReturn(mockResources)

        whenever(mockProfileContext.packageManager).thenReturn(mockPackageManager)

        whenever(mockResources.getString(anyInt())).thenReturn(

                ComponentName("TestPackage", "TestClass").flattenToString())

        whenever(mockUserTracker.userProfiles).thenReturn(listOf(UserInfo(), UserInfo()))



        chooserSelector = ChooserSelector(

                mockContext,

                mockUserTracker,

                mockFeatureFlags,

                testScope,

                testDispatcher,

        )

    }



    @After

    fun tearDown() {

        testDispatcher.cleanupTestCoroutines()

    }



    @Test

    fun initialize_registersFlagListenerUntilScopeCancelled() {

        // Arrange



        // Act

        chooserSelector.start()



        // Assert

        verify(mockFeatureFlags).addListener(

                eq<Flag<*>>(Flags.CHOOSER_UNBUNDLED),

                flagListener.capture(),

        )

        verify(mockFeatureFlags, never()).removeListener(any())



        // Act

        testScope.cancel()



        // Assert

        verify(mockFeatureFlags).removeListener(eq(flagListener.value))

    }



    @Test

    fun initialize_enablesUnbundledChooser_whenFlagEnabled() {

        // Arrange

        setFlagMock(true)



        // Act

        chooserSelector.start()



        // Assert

        verify(mockPackageManager, times(2)).setComponentEnabledSetting(

                eq(ComponentName("TestPackage", "TestClass")),

                eq(PackageManager.COMPONENT_ENABLED_STATE_ENABLED),

                anyInt(),

        )

    }



    @Test

    fun initialize_disablesUnbundledChooser_whenFlagDisabled() {

        // Arrange

        setFlagMock(false)



        // Act

        chooserSelector.start()



        // Assert

        verify(mockPackageManager, times(2)).setComponentEnabledSetting(

                eq(ComponentName("TestPackage", "TestClass")),

                eq(PackageManager.COMPONENT_ENABLED_STATE_DISABLED),

                anyInt(),

        )

    }



    @Test

    fun enablesUnbundledChooser_whenFlagBecomesEnabled() {

        // Arrange

        setFlagMock(false)

        chooserSelector.start()

        verify(mockFeatureFlags).addListener(

                eq<Flag<*>>(Flags.CHOOSER_UNBUNDLED),

                flagListener.capture(),

        )

        verify(mockPackageManager, never()).setComponentEnabledSetting(

                any(),

                eq(PackageManager.COMPONENT_ENABLED_STATE_ENABLED),

                anyInt(),

        )



        // Act

        setFlagMock(true)

        flagListener.value.onFlagChanged(TestFlagEvent(Flags.CHOOSER_UNBUNDLED.name))



        // Assert

        verify(mockPackageManager, times(2)).setComponentEnabledSetting(

                eq(ComponentName("TestPackage", "TestClass")),

                eq(PackageManager.COMPONENT_ENABLED_STATE_ENABLED),

                anyInt(),

        )

    }



    @Test

    fun disablesUnbundledChooser_whenFlagBecomesDisabled() {

        // Arrange

        setFlagMock(true)

        chooserSelector.start()

        verify(mockFeatureFlags).addListener(

                eq<Flag<*>>(Flags.CHOOSER_UNBUNDLED),

                flagListener.capture(),

        )

        verify(mockPackageManager, never()).setComponentEnabledSetting(

                any(),

                eq(PackageManager.COMPONENT_ENABLED_STATE_DISABLED),

                anyInt(),

        )



        // Act

        setFlagMock(false)

        flagListener.value.onFlagChanged(TestFlagEvent(Flags.CHOOSER_UNBUNDLED.name))



        // Assert

        verify(mockPackageManager, times(2)).setComponentEnabledSetting(

                eq(ComponentName("TestPackage", "TestClass")),

                eq(PackageManager.COMPONENT_ENABLED_STATE_DISABLED),

                anyInt(),

        )

    }



    @Test

    fun doesNothing_whenAnotherFlagChanges() {

        // Arrange

        setFlagMock(false)

        chooserSelector.start()

        verify(mockFeatureFlags).addListener(

                eq<Flag<*>>(Flags.CHOOSER_UNBUNDLED),

                flagListener.capture(),

        )

        clearInvocations(mockPackageManager)



        // Act

        flagListener.value.onFlagChanged(TestFlagEvent("other flag"))



        // Assert

        verifyZeroInteractions(mockPackageManager)

    }



    private fun setFlagMock(enabled: Boolean) {

        whenever(mockFeatureFlags.isEnabled(any<UnreleasedFlag>())).thenReturn(enabled)

        whenever(mockFeatureFlags.isEnabled(any<ReleasedFlag>())).thenReturn(enabled)

    }



    private class TestFlagEvent(override val flagName: String) : FlagListenable.FlagEvent {

        override fun requestNoRestart() {}

    }

}