Merge "Add AppTimeSpentPreference for Spa" (cf26d6ba) · Commits · e / os / android_packages_apps_Settings

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

+1 −0

Original line number	Diff line number	Diff line
		@@ -92,6 +92,7 @@ private fun AppInfoSettings(packageInfoPresenter: PackageInfoPresenter) {

		AppPermissionPreference(app)
		AppStoragePreference(app)
		AppTimeSpentPreference(app)

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

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

0 → 100644

+81 −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.content.Context
		import android.content.Intent
		import android.content.pm.ApplicationInfo
		import android.content.pm.PackageManager.ResolveInfoFlags
		import android.provider.Settings
		import androidx.compose.runtime.Composable
		import androidx.compose.runtime.livedata.observeAsState
		import androidx.compose.runtime.remember
		import androidx.compose.ui.platform.LocalContext
		import androidx.compose.ui.res.stringResource
		import androidx.lifecycle.liveData
		import com.android.settings.R
		import com.android.settings.overlay.FeatureFactory
		import com.android.settingslib.spa.framework.compose.stateOf
		import com.android.settingslib.spa.widget.preference.Preference
		import com.android.settingslib.spa.widget.preference.PreferenceModel
		import com.android.settingslib.spaprivileged.model.app.hasFlag
		import com.android.settingslib.spaprivileged.model.app.userHandle
		import com.android.settingslib.spaprivileged.model.app.userId
		import kotlinx.coroutines.Dispatchers

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

		Preference(object : PreferenceModel {
		override val title = stringResource(R.string.time_spent_in_app_pref_title)
		override val summary = presenter.summaryLiveData.observeAsState(
		initial = stringResource(R.string.summary_placeholder),
		)
		override val enabled = stateOf(presenter.isEnabled())
		override val onClick = presenter::startActivity
		})
		}

		private class AppTimeSpentPresenter(
		private val context: Context,
		private val app: ApplicationInfo,
		) {
		private val intent = Intent(Settings.ACTION_APP_USAGE_SETTINGS).apply {
		putExtra(Intent.EXTRA_PACKAGE_NAME, app.packageName)
		}
		private val appFeatureProvider = FeatureFactory.getFactory(context)
		.getApplicationFeatureProvider(context)

		fun isAvailable() = context.packageManager.queryIntentActivitiesAsUser(
		intent, ResolveInfoFlags.of(0), app.userId
		).any { resolveInfo ->
		resolveInfo?.activityInfo?.applicationInfo?.isSystemApp == true
		}

		fun isEnabled() = app.hasFlag(ApplicationInfo.FLAG_INSTALLED)

		val summaryLiveData = liveData(Dispatchers.IO) {
		emit(appFeatureProvider.getTimeSpentInApp(app.packageName).toString())
		}

		fun startActivity() {
		context.startActivityAsUser(intent, app.userHandle)
		}
		}

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -54,7 +54,7 @@ class AppStoragePreferenceTest {
		val composeTestRule = createComposeRule()

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

		@Mock
		private lateinit var storageStatsManager: StorageStatsManager

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

0 → 100644

+158 −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.content.Context
		import android.content.pm.ActivityInfo
		import android.content.pm.ApplicationInfo
		import android.content.pm.PackageManager
		import android.content.pm.PackageManager.ResolveInfoFlags
		import android.content.pm.ResolveInfo
		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.junit4.createComposeRule
		import androidx.compose.ui.test.onNodeWithText
		import androidx.compose.ui.test.onRoot
		import androidx.test.core.app.ApplicationProvider
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.android.settings.R
		import com.android.settings.testutils.FakeFeatureFactory
		import com.android.settingslib.spaprivileged.framework.common.storageStatsManager
		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
		import org.mockito.Mockito.any
		import org.mockito.Mockito.anyInt
		import org.mockito.Spy
		import org.mockito.junit.MockitoJUnit
		import org.mockito.junit.MockitoRule
		import org.mockito.Mockito.`when` as whenever

		@RunWith(AndroidJUnit4::class)
		class AppTimeSpentPreferenceTest {
		@JvmField
		@Rule
		val mockito: MockitoRule = MockitoJUnit.rule()

		@get:Rule
		val composeTestRule = createComposeRule()

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

		@Mock
		private lateinit var packageManager: PackageManager

		private val fakeFeatureFactory = FakeFeatureFactory()
		private val appFeatureProvider = fakeFeatureFactory.applicationFeatureProvider

		@Before
		fun setUp() {
		whenever(context.packageManager).thenReturn(packageManager)
		whenever(appFeatureProvider.getTimeSpentInApp(PACKAGE_NAME)).thenReturn(TIME_SPENT)
		}

		private fun mockActivitiesQueryResult(resolveInfos: List<ResolveInfo>) {
		whenever(
		packageManager.queryIntentActivitiesAsUser(any(), any<ResolveInfoFlags>(), anyInt())
		).thenReturn(resolveInfos)
		}

		@Test
		fun noIntentHandler_notDisplay() {
		mockActivitiesQueryResult(emptyList())

		composeTestRule.setContent {
		CompositionLocalProvider(LocalContext provides context) {
		AppTimeSpentPreference(INSTALLED_APP)
		}
		}

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun hasIntentHandler_notSystemApp_notDisplay() {
		mockActivitiesQueryResult(listOf(ResolveInfo()))

		composeTestRule.setContent {
		CompositionLocalProvider(LocalContext provides context) {
		AppTimeSpentPreference(INSTALLED_APP)
		}
		}

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun installedApp_enabled() {
		mockActivitiesQueryResult(listOf(MATCHED_RESOLVE_INFO))

		composeTestRule.setContent {
		CompositionLocalProvider(LocalContext provides context) {
		AppTimeSpentPreference(INSTALLED_APP)
		}
		}

		composeTestRule.onNodeWithText(context.getString(R.string.time_spent_in_app_pref_title))
		.assertIsDisplayed()
		.assertIsEnabled()
		composeTestRule.onNodeWithText(TIME_SPENT).assertIsDisplayed()
		}

		@Test
		fun uninstalledApp_disabled() {
		mockActivitiesQueryResult(listOf(MATCHED_RESOLVE_INFO))
		val uninstalledApp = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		}

		composeTestRule.setContent {
		CompositionLocalProvider(LocalContext provides context) {
		AppTimeSpentPreference(uninstalledApp)
		}
		}

		composeTestRule.onNodeWithText(context.getString(R.string.time_spent_in_app_pref_title))
		.assertIsNotEnabled()
		}

		companion object {
		private const val PACKAGE_NAME = "package name"
		private const val TIME_SPENT = "15 minutes"

		private val INSTALLED_APP = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		flags = ApplicationInfo.FLAG_INSTALLED
		}

		private val MATCHED_RESOLVE_INFO = ResolveInfo().apply {
		activityInfo = ActivityInfo().apply {
		applicationInfo = ApplicationInfo().apply {
		flags = ApplicationInfo.FLAG_SYSTEM
		}
		}
		}
		}
		}

tests/spa_unit/src/com/android/settings/testutils/FakeFeatureFactory.kt

0 → 100644

+175 −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.testutils

		import android.content.Context
		import com.android.settings.accessibility.AccessibilityMetricsFeatureProvider
		import com.android.settings.accessibility.AccessibilitySearchFeatureProvider
		import com.android.settings.accounts.AccountFeatureProvider
		import com.android.settings.applications.ApplicationFeatureProvider
		import com.android.settings.aware.AwareFeatureProvider
		import com.android.settings.biometrics.face.FaceFeatureProvider
		import com.android.settings.bluetooth.BluetoothFeatureProvider
		import com.android.settings.dashboard.DashboardFeatureProvider
		import com.android.settings.dashboard.suggestions.SuggestionFeatureProvider
		import com.android.settings.enterprise.EnterprisePrivacyFeatureProvider
		import com.android.settings.fuelgauge.BatterySettingsFeatureProvider
		import com.android.settings.fuelgauge.BatteryStatusFeatureProvider
		import com.android.settings.fuelgauge.PowerUsageFeatureProvider
		import com.android.settings.gestures.AssistGestureFeatureProvider
		import com.android.settings.homepage.contextualcards.ContextualCardFeatureProvider
		import com.android.settings.localepicker.LocaleFeatureProvider
		import com.android.settings.overlay.DockUpdaterFeatureProvider
		import com.android.settings.overlay.FeatureFactory
		import com.android.settings.overlay.SupportFeatureProvider
		import com.android.settings.overlay.SurveyFeatureProvider
		import com.android.settings.panel.PanelFeatureProvider
		import com.android.settings.search.SearchFeatureProvider
		import com.android.settings.security.SecurityFeatureProvider
		import com.android.settings.security.SecuritySettingsFeatureProvider
		import com.android.settings.slices.SlicesFeatureProvider
		import com.android.settings.users.UserFeatureProvider
		import com.android.settings.vpn2.AdvancedVpnFeatureProvider
		import com.android.settings.wifi.WifiTrackerLibProvider
		import com.android.settingslib.core.instrumentation.MetricsFeatureProvider
		import org.mockito.Mockito.mock

		class FakeFeatureFactory : FeatureFactory() {

		val applicationFeatureProvider: ApplicationFeatureProvider =
		mock(ApplicationFeatureProvider::class.java)

		init {
		sFactory = this
		}

		override fun getAssistGestureFeatureProvider(): AssistGestureFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSuggestionFeatureProvider(): SuggestionFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSupportFeatureProvider(context: Context?): SupportFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getMetricsFeatureProvider(): MetricsFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getPowerUsageFeatureProvider(context: Context?): PowerUsageFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getBatteryStatusFeatureProvider(context: Context?): BatteryStatusFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getBatterySettingsFeatureProvider(
		context: Context?,
		): BatterySettingsFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getDashboardFeatureProvider(context: Context?): DashboardFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getDockUpdaterFeatureProvider(): DockUpdaterFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getApplicationFeatureProvider(context: Context?) = applicationFeatureProvider

		override fun getLocaleFeatureProvider(): LocaleFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getEnterprisePrivacyFeatureProvider(
		context: Context?,
		): EnterprisePrivacyFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSearchFeatureProvider(): SearchFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSurveyFeatureProvider(context: Context?): SurveyFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSecurityFeatureProvider(): SecurityFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getUserFeatureProvider(context: Context?): UserFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getSlicesFeatureProvider(): SlicesFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getAccountFeatureProvider(): AccountFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getPanelFeatureProvider(): PanelFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getContextualCardFeatureProvider(
		context: Context?,
		): ContextualCardFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getBluetoothFeatureProvider(): BluetoothFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getAwareFeatureProvider(): AwareFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getFaceFeatureProvider(): FaceFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getWifiTrackerLibProvider(): WifiTrackerLibProvider {
		TODO("Not yet implemented")
		}

		override fun getSecuritySettingsFeatureProvider(): SecuritySettingsFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getAccessibilitySearchFeatureProvider(): AccessibilitySearchFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getAccessibilityMetricsFeatureProvider(): AccessibilityMetricsFeatureProvider {
		TODO("Not yet implemented")
		}

		override fun getAdvancedVpnFeatureProvider(): AdvancedVpnFeatureProvider {
		TODO("Not yet implemented")
		}
		}