Add HibernationSwitchPreference for Spa (af97082f) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/spa/app/appinfo/AppInfoSettings.kt

+4 −0

Original line number	Diff line number	Diff line
		@@ -100,6 +100,10 @@ private fun AppInfoSettings(packageInfoPresenter: PackageInfoPresenter) {
		AppOpenByDefaultPreference(app)
		DefaultAppShortcuts(app)

		Category(title = stringResource(R.string.unused_apps_category)) {
		HibernationSwitchPreference(app)
		}

		Category(title = stringResource(R.string.advanced_apps)) {
		DisplayOverOtherAppsAppListProvider.InfoPageEntryItem(app)
		ModifySystemSettingsAppListProvider.InfoPageEntryItem(app)

src/com/android/settings/spa/app/appinfo/HibernationSwitchPreference.kt

0 → 100644

+136 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.settings.spa.app.appinfo

		import android.app.AppOpsManager.MODE_ALLOWED
		import android.app.AppOpsManager.MODE_DEFAULT
		import android.app.AppOpsManager.MODE_IGNORED
		import android.app.AppOpsManager.OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED
		import android.content.Context
		import android.content.pm.ApplicationInfo
		import android.os.Build
		import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_EXEMPT_BY_SYSTEM
		import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_UNKNOWN
		import android.provider.DeviceConfig
		import android.provider.DeviceConfig.NAMESPACE_APP_HIBERNATION
		import androidx.compose.runtime.Composable
		import androidx.compose.runtime.derivedStateOf
		import androidx.compose.runtime.remember
		import androidx.compose.ui.platform.LocalContext
		import com.android.settings.R
		import com.android.settings.Utils.PROPERTY_APP_HIBERNATION_ENABLED
		import com.android.settings.Utils.PROPERTY_HIBERNATION_TARGETS_PRE_S_APPS
		import com.android.settingslib.spa.framework.compose.OverridableFlow
		import com.android.settingslib.spa.framework.compose.collectAsStateWithLifecycle
		import com.android.settingslib.spa.framework.compose.stateOf
		import com.android.settingslib.spa.widget.preference.SwitchPreference
		import com.android.settingslib.spa.widget.preference.SwitchPreferenceModel
		import com.android.settingslib.spaprivileged.framework.common.appHibernationManager
		import com.android.settingslib.spaprivileged.framework.common.appOpsManager
		import com.android.settingslib.spaprivileged.framework.common.asUser
		import com.android.settingslib.spaprivileged.framework.common.permissionControllerManager
		import com.android.settingslib.spaprivileged.model.app.userHandle
		import kotlinx.coroutines.Dispatchers
		import kotlinx.coroutines.asExecutor
		import kotlinx.coroutines.flow.flow
		import kotlinx.coroutines.withContext
		import kotlin.coroutines.resume
		import kotlin.coroutines.suspendCoroutine

		@Composable
		fun HibernationSwitchPreference(app: ApplicationInfo) {
		val context = LocalContext.current
		val presenter = remember { HibernationSwitchPresenter(context, app) }
		if (!presenter.isAvailable()) return

		val isEligibleState = presenter.isEligibleFlow.collectAsStateWithLifecycle(initialValue = false)
		val isCheckedState = presenter.isCheckedFlow.collectAsStateWithLifecycle(initialValue = null)
		SwitchPreference(remember {
		object : SwitchPreferenceModel {
		override val title = context.getString(R.string.unused_apps_switch)
		override val summary = stateOf(context.getString(R.string.unused_apps_switch_summary))
		override val changeable = isEligibleState

		override val checked = derivedStateOf {
		if (!changeable.value) false else isCheckedState.value
		}

		override val onCheckedChange = presenter::onCheckedChange
		}
		})
		}

		private class HibernationSwitchPresenter(context: Context, private val app: ApplicationInfo) {
		private val appOpsManager = context.appOpsManager
		private val permissionControllerManager =
		context.asUser(app.userHandle).permissionControllerManager
		private val appHibernationManager = context.appHibernationManager
		private val executor = Dispatchers.IO.asExecutor()

		fun isAvailable() =
		DeviceConfig.getBoolean(NAMESPACE_APP_HIBERNATION, PROPERTY_APP_HIBERNATION_ENABLED, true)

		val isEligibleFlow = flow {
		val eligibility = getEligibility()
		emit(
		eligibility != HIBERNATION_ELIGIBILITY_EXEMPT_BY_SYSTEM &&
		eligibility != HIBERNATION_ELIGIBILITY_UNKNOWN
		)
		}

		private suspend fun getEligibility(): Int = suspendCoroutine { continuation ->
		permissionControllerManager.getHibernationEligibility(app.packageName, executor) {
		continuation.resume(it)
		}
		}

		private val isChecked = OverridableFlow(flow {
		emit(!isExempt())
		})

		val isCheckedFlow = isChecked.flow

		private suspend fun isExempt(): Boolean = withContext(Dispatchers.IO) {
		val mode = appOpsManager.checkOpNoThrow(
		OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED, app.uid, app.packageName
		)
		if (mode == MODE_DEFAULT) isExemptByDefault() else mode != MODE_ALLOWED
		}

		private fun isExemptByDefault() =
		!hibernationTargetsPreSApps() && app.targetSdkVersion <= Build.VERSION_CODES.Q

		private fun hibernationTargetsPreSApps() = DeviceConfig.getBoolean(
		NAMESPACE_APP_HIBERNATION, PROPERTY_HIBERNATION_TARGETS_PRE_S_APPS, false
		)

		fun onCheckedChange(newChecked: Boolean) {
		try {
		appOpsManager.setUidMode(
		OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED,
		app.uid,
		if (newChecked) MODE_ALLOWED else MODE_IGNORED,
		)
		if (!newChecked) {
		appHibernationManager.setHibernatingForUser(app.packageName, false)
		appHibernationManager.setHibernatingGlobally(app.packageName, false)
		}
		isChecked.override(newChecked)
		} catch (_: RuntimeException) {
		}
		}
		}

src/com/android/settings/spa/app/specialaccess/AlarmsAndRemindersController.kt

+5 −7

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

		package com.android.settings.spa.app.specialaccess

		import android.app.AlarmManager
		import android.app.AppOpsManager
		import android.app.AppOpsManager.MODE_ALLOWED
		import android.app.AppOpsManager.MODE_ERRORED
		@@ -24,21 +23,23 @@ import android.content.Context
		import android.content.pm.ApplicationInfo
		import androidx.lifecycle.LiveData
		import androidx.lifecycle.MutableLiveData
		import com.android.settingslib.spaprivileged.framework.common.alarmManager
		import com.android.settingslib.spaprivileged.framework.common.appOpsManager
		import com.android.settingslib.spaprivileged.model.app.userId

		class AlarmsAndRemindersController(
		context: Context,
		private val app: ApplicationInfo,
		) {
		private val alarmManager = context.getSystemService(AlarmManager::class.java)!!
		private val appOpsManager = context.getSystemService(AppOpsManager::class.java)!!
		private val alarmManager = context.alarmManager
		private val appOpsManager = context.appOpsManager

		val isAllowed: LiveData<Boolean>
		get() = _allowed

		fun setAllowed(allowed: Boolean) {
		val mode = if (allowed) MODE_ALLOWED else MODE_ERRORED
		appOpsManager.setUidMode(AppOpsManager.OPSTR_SCHEDULE_EXACT_ALARM, app.uid, mode)
		appOpsManager.setUidMode(AppOpsManager.OP_SCHEDULE_EXACT_ALARM, app.uid, mode)
		_allowed.postValue(allowed)
		}

		@@ -46,8 +47,5 @@ class AlarmsAndRemindersController(
		override fun onActive() {
		postValue(alarmManager.hasScheduleExactAlarm(app.packageName, app.userId))
		}

		override fun onInactive() {
		}
		}
		}

tests/spa_unit/AndroidManifest.xml

+2 −0

Original line number	Diff line number	Diff line
		@@ -19,6 +19,8 @@
		xmlns:tools="http://schemas.android.com/tools"
		package="com.android.settings.tests.spa_unit">

		<uses-permission android:name="android.permission.WRITE_DEVICE_CONFIG" />

		<application android:debuggable="true">
		<provider android:name="com.android.settings.slices.SettingsSliceProvider"
		android:authorities="${applicationId}.slices"

tests/spa_unit/src/com/android/settings/spa/app/appinfo/HibernationSwitchPreferenceTest.kt

0 → 100644

+251 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2022 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.settings.spa.app.appinfo

		import android.app.AppOpsManager
		import android.app.AppOpsManager.MODE_ALLOWED
		import android.app.AppOpsManager.MODE_DEFAULT
		import android.app.AppOpsManager.MODE_IGNORED
		import android.app.AppOpsManager.OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED
		import android.apphibernation.AppHibernationManager
		import android.content.Context
		import android.content.pm.ApplicationInfo
		import android.os.Build
		import android.os.UserHandle
		import android.permission.PermissionControllerManager
		import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_ELIGIBLE
		import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_EXEMPT_BY_SYSTEM
		import android.provider.DeviceConfig.NAMESPACE_APP_HIBERNATION
		import androidx.compose.runtime.CompositionLocalProvider
		import androidx.compose.ui.platform.LocalContext
		import androidx.compose.ui.test.assertIsDisplayed
		import androidx.compose.ui.test.assertIsEnabled
		import androidx.compose.ui.test.assertIsNotDisplayed
		import androidx.compose.ui.test.assertIsNotEnabled
		import androidx.compose.ui.test.assertIsOff
		import androidx.compose.ui.test.assertIsOn
		import androidx.compose.ui.test.isToggleable
		import androidx.compose.ui.test.junit4.createComposeRule
		import androidx.compose.ui.test.onNodeWithText
		import androidx.compose.ui.test.onRoot
		import androidx.compose.ui.test.performClick
		import androidx.test.core.app.ApplicationProvider
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.android.settings.R
		import com.android.settings.Utils.PROPERTY_APP_HIBERNATION_ENABLED
		import com.android.settings.Utils.PROPERTY_HIBERNATION_TARGETS_PRE_S_APPS
		import com.android.settings.testutils.TestDeviceConfig
		import com.android.settingslib.spaprivileged.framework.common.appHibernationManager
		import com.android.settingslib.spaprivileged.framework.common.appOpsManager
		import com.android.settingslib.spaprivileged.framework.common.permissionControllerManager
		import org.junit.After
		import org.junit.Before
		import org.junit.Rule
		import org.junit.Test
		import org.junit.runner.RunWith
		import org.mockito.Mock
		import org.mockito.Mockito.any
		import org.mockito.Mockito.anyBoolean
		import org.mockito.Mockito.anyString
		import org.mockito.Mockito.doAnswer
		import org.mockito.Mockito.doReturn
		import org.mockito.Mockito.eq
		import org.mockito.Mockito.never
		import org.mockito.Mockito.verify
		import org.mockito.Spy
		import org.mockito.junit.MockitoJUnit
		import org.mockito.junit.MockitoRule
		import java.util.function.IntConsumer
		import org.mockito.Mockito.`when` as whenever

		@RunWith(AndroidJUnit4::class)
		class HibernationSwitchPreferenceTest {

		@JvmField
		@Rule
		val mockito: MockitoRule = MockitoJUnit.rule()

		@get:Rule
		val composeTestRule = createComposeRule()

		@Spy
		private val context: Context = ApplicationProvider.getApplicationContext()

		@Mock
		private lateinit var permissionControllerManager: PermissionControllerManager

		@Mock
		private lateinit var appOpsManager: AppOpsManager

		@Mock
		private lateinit var appHibernationManager: AppHibernationManager

		private val hibernationEnabledConfig =
		TestDeviceConfig(NAMESPACE_APP_HIBERNATION, PROPERTY_APP_HIBERNATION_ENABLED)

		private val hibernationTargetsPreSConfig =
		TestDeviceConfig(NAMESPACE_APP_HIBERNATION, PROPERTY_HIBERNATION_TARGETS_PRE_S_APPS)

		@Before
		fun setUp() {
		hibernationEnabledConfig.override(true)
		hibernationTargetsPreSConfig.override(false)
		doReturn(context)
		.`when`(context).createContextAsUser(UserHandle.getUserHandleForUid(UID), 0)
		whenever(context.permissionControllerManager).thenReturn(permissionControllerManager)
		whenever(context.appOpsManager).thenReturn(appOpsManager)
		whenever(context.appHibernationManager).thenReturn(appHibernationManager)
		mockHibernationEligibility(HIBERNATION_ELIGIBILITY_ELIGIBLE)
		}

		@After
		fun cleanUp() {
		hibernationEnabledConfig.reset()
		hibernationTargetsPreSConfig.reset()
		}

		private fun mockHibernationEligibility(eligibility: Int) {
		doAnswer {
		@Suppress("UNCHECKED_CAST")
		(it.arguments[2] as IntConsumer).accept(eligibility)
		}.`when`(permissionControllerManager).getHibernationEligibility(
		eq(PACKAGE_NAME), any(), any()
		)
		}

		private fun mockOpsMode(mode: Int) {
		whenever(
		appOpsManager.checkOpNoThrow(OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED, UID, PACKAGE_NAME)
		).thenReturn(mode)
		}

		@Test
		fun `Hibernation disabled - not display`() {
		hibernationEnabledConfig.override(false)

		setContent()

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun `Not eligible - displayed but disabled`() {
		mockHibernationEligibility(HIBERNATION_ELIGIBILITY_EXEMPT_BY_SYSTEM)

		setContent()

		composeTestRule.onNodeWithText(context.getString(R.string.unused_apps_switch))
		.assertIsDisplayed()
		.assertIsNotEnabled()
		.assertIsOff()
		}

		@Test
		fun `An app targets Q with ops mode default when hibernation targets pre S - not exempted`() {
		mockOpsMode(MODE_DEFAULT)
		hibernationTargetsPreSConfig.override(true)

		setContent(TARGET_Q_APP)

		composeTestRule.onNode(isToggleable()).assertIsEnabled().assertIsOn()
		}

		@Test
		fun `An app targets Q with ops mode default when hibernation targets R - exempted`() {
		mockOpsMode(MODE_DEFAULT)
		hibernationTargetsPreSConfig.override(false)

		setContent(TARGET_Q_APP)

		composeTestRule.onNode(isToggleable()).assertIsEnabled().assertIsOff()
		}

		@Test
		fun `An app targets R with ops mode default - not exempted`() {
		mockOpsMode(MODE_DEFAULT)

		setContent(TARGET_R_APP)

		composeTestRule.onNode(isToggleable()).assertIsEnabled().assertIsOn()
		}

		@Test
		fun `An app with ops mode allowed - not exempted`() {
		mockOpsMode(MODE_ALLOWED)

		setContent()

		composeTestRule.onNode(isToggleable()).assertIsEnabled().assertIsOn()
		}

		@Test
		fun `An app with ops mode ignored - exempted`() {
		mockOpsMode(MODE_IGNORED)

		setContent()

		composeTestRule.onNode(isToggleable()).assertIsEnabled().assertIsOff()
		}

		@Test
		fun `An app is exempted - on click`() {
		mockOpsMode(MODE_IGNORED)

		setContent()
		composeTestRule.onRoot().performClick()

		verify(appOpsManager).setUidMode(OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED, UID, MODE_ALLOWED)
		verify(appHibernationManager, never()).setHibernatingForUser(anyString(), anyBoolean())
		verify(appHibernationManager, never()).setHibernatingGlobally(anyString(), anyBoolean())
		}

		@Test
		fun `An app is not exempted - on click`() {
		mockOpsMode(MODE_ALLOWED)

		setContent()
		composeTestRule.onRoot().performClick()

		verify(appOpsManager).setUidMode(OP_AUTO_REVOKE_PERMISSIONS_IF_UNUSED, UID, MODE_IGNORED)
		verify(appHibernationManager).setHibernatingForUser(PACKAGE_NAME, false)
		verify(appHibernationManager).setHibernatingGlobally(PACKAGE_NAME, false)
		}

		private fun setContent(app: ApplicationInfo = TARGET_R_APP) {
		composeTestRule.setContent {
		CompositionLocalProvider(LocalContext provides context) {
		HibernationSwitchPreference(app)
		}
		}
		}

		private companion object {
		const val PACKAGE_NAME = "package name"
		const val UID = 123

		val TARGET_R_APP = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		uid = UID
		targetSdkVersion = Build.VERSION_CODES.R
		}
		val TARGET_Q_APP = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		uid = UID
		targetSdkVersion = Build.VERSION_CODES.Q
		}
		}
		}