Merge "Add AppInstallerInfoPreference for Spa" (ca7eca14) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/Utils.java

+4 −2

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@ import static android.content.Intent.EXTRA_USER_ID;
		import static android.text.format.DateUtils.FORMAT_ABBREV_MONTH;
		import static android.text.format.DateUtils.FORMAT_SHOW_DATE;

		import android.annotation.Nullable;
		import android.app.ActionBar;
		import android.app.Activity;
		import android.app.ActivityManager;
		@@ -96,6 +95,7 @@ import android.widget.TabWidget;

		import androidx.annotation.ColorInt;
		import androidx.annotation.NonNull;
		import androidx.annotation.Nullable;
		import androidx.annotation.StringRes;
		import androidx.core.graphics.drawable.IconCompat;
		import androidx.core.graphics.drawable.RoundedBitmapDrawable;
		@@ -799,7 +799,9 @@ public final class Utils extends com.android.settingslib.Utils {
		}
		}

		public static CharSequence getApplicationLabel(Context context, String packageName) {
		/** Gets the application label of the given package name. */
		@Nullable
		public static CharSequence getApplicationLabel(Context context, @NonNull String packageName) {
		try {
		final ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
		packageName,

src/com/android/settings/applications/AppStoreUtil.java

+11 −5

Original line number	Diff line number	Diff line
		@@ -24,7 +24,9 @@ import android.content.pm.PackageManager.NameNotFoundException;
		import android.content.pm.ResolveInfo;
		import android.util.Log;

		// This class provides methods that help dealing with app stores.
		import androidx.annotation.Nullable;

		/** This class provides methods that help dealing with app stores. */
		public class AppStoreUtil {
		private static final String LOG_TAG = "AppStoreUtil";

		@@ -34,8 +36,11 @@ public class AppStoreUtil {
		.setClassName(result.activityInfo.packageName, result.activityInfo.name) : null;
		}

		// Returns the package name of the app that we consider to be the user-visible 'installer'
		// of given packageName, if one is available.
		/**
		* Returns the package name of the app that we consider to be the user-visible 'installer'
		* of given packageName, if one is available.
		*/
		@Nullable
		public static String getInstallerPackageName(Context context, String packageName) {
		String installerPackageName;
		try {
		@@ -62,7 +67,8 @@ public class AppStoreUtil {
		return installerPackageName;
		}

		// Returns a link to the installer app store for a given package name.
		/** Returns a link to the installer app store for a given package name. */
		@Nullable
		public static Intent getAppStoreLink(Context context, String installerPackageName,
		String packageName) {
		Intent intent = new Intent(Intent.ACTION_SHOW_APP_INFO)
		@@ -75,7 +81,7 @@ public class AppStoreUtil {
		return null;
		}

		// Convenience method that looks up the installerPackageName for you.
		/** Convenience method that looks up the installerPackageName for you. */
		public static Intent getAppStoreLink(Context context, String packageName) {
		String installerPackageName = getInstallerPackageName(context, packageName);
		return getAppStoreLink(context, installerPackageName, packageName);

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

+3 −1

Original line number	Diff line number	Diff line
		@@ -113,7 +113,9 @@ private fun AppInfoSettings(packageInfoPresenter: PackageInfoPresenter) {
		AlarmsAndRemindersAppListProvider.InfoPageEntryItem(app)
		}

		// TODO: app_installer
		Category(title = stringResource(R.string.app_install_details_group_title)) {
		AppInstallerInfoPreference(app)
		}
		appInfoProvider.FooterAppVersion()
		}
		}

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

0 → 100644

+123 −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.ApplicationInfo
		import androidx.compose.runtime.Composable
		import androidx.compose.runtime.remember
		import androidx.compose.runtime.rememberCoroutineScope
		import androidx.compose.ui.platform.LocalContext
		import androidx.compose.ui.res.stringResource
		import com.android.settings.R
		import com.android.settings.Utils
		import com.android.settings.applications.AppStoreUtil
		import com.android.settingslib.applications.AppUtils
		import com.android.settingslib.spa.framework.compose.collectAsStateWithLifecycle
		import com.android.settingslib.spa.widget.preference.Preference
		import com.android.settingslib.spa.widget.preference.PreferenceModel
		import com.android.settingslib.spaprivileged.framework.common.asUser
		import com.android.settingslib.spaprivileged.framework.common.userManager
		import com.android.settingslib.spaprivileged.model.app.userHandle
		import com.android.settingslib.spaprivileged.model.app.userId
		import kotlinx.coroutines.CoroutineScope
		import kotlinx.coroutines.Dispatchers
		import kotlinx.coroutines.flow.Flow
		import kotlinx.coroutines.flow.SharingStarted
		import kotlinx.coroutines.flow.flow
		import kotlinx.coroutines.flow.map
		import kotlinx.coroutines.flow.shareIn
		import kotlinx.coroutines.launch
		import kotlinx.coroutines.withContext

		@Composable
		fun AppInstallerInfoPreference(app: ApplicationInfo) {
		val context = LocalContext.current
		val coroutineScope = rememberCoroutineScope()
		val presenter = remember { AppInstallerInfoPresenter(context, app, coroutineScope) }
		if (!presenter.isAvailableFlow.collectAsStateWithLifecycle(initialValue = false).value) return

		Preference(object : PreferenceModel {
		override val title = stringResource(R.string.app_install_details_title)
		override val summary = presenter.summaryFlow.collectAsStateWithLifecycle(
		initialValue = stringResource(R.string.summary_placeholder),
		)
		override val enabled =
		presenter.enabledFlow.collectAsStateWithLifecycle(initialValue = false)
		override val onClick = presenter::startActivity
		})
		}

		private class AppInstallerInfoPresenter(
		private val context: Context,
		private val app: ApplicationInfo,
		private val coroutineScope: CoroutineScope,
		) {
		private val userContext = context.asUser(app.userHandle)
		private val packageManager = userContext.packageManager
		private val userManager = context.userManager

		private val installerPackageFlow = flow {
		emit(withContext(Dispatchers.IO) {
		AppStoreUtil.getInstallerPackageName(userContext, app.packageName)
		})
		}.sharedFlow()

		private val installerLabelFlow = installerPackageFlow.map { installerPackage ->
		installerPackage ?: return@map null
		withContext(Dispatchers.IO) {
		Utils.getApplicationLabel(context, installerPackage)
		}
		}.sharedFlow()

		val isAvailableFlow = installerLabelFlow.map { installerLabel ->
		withContext(Dispatchers.IO) {
		!userManager.isManagedProfile(app.userId) &&
		!AppUtils.isMainlineModule(packageManager, app.packageName) &&
		installerLabel != null
		}
		}

		val summaryFlow = installerLabelFlow.map { installerLabel ->
		val detailsStringId = when {
		app.isInstantApp -> R.string.instant_app_details_summary
		else -> R.string.app_install_details_summary
		}
		context.getString(detailsStringId, installerLabel)
		}

		private val intentFlow = installerPackageFlow.map { installerPackage ->
		withContext(Dispatchers.IO) {
		AppStoreUtil.getAppStoreLink(context, installerPackage, app.packageName)
		}
		}.sharedFlow()

		val enabledFlow = intentFlow.map { it != null }

		fun startActivity() {
		coroutineScope.launch {
		intentFlow.collect { intent ->
		if (intent != null) {
		context.startActivityAsUser(intent, app.userHandle)
		}
		}
		}
		}

		private fun <T> Flow<T>.sharedFlow() =
		shareIn(coroutineScope, SharingStarted.WhileSubscribed(), 1)
		}

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

0 → 100644

+208 −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.os.UserManager
		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.hasText
		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.compose.ui.test.printToLog
		import androidx.test.core.app.ApplicationProvider
		import androidx.test.ext.junit.runners.AndroidJUnit4
		import com.android.dx.mockito.inline.extended.ExtendedMockito.mockitoSession
		import com.android.settings.R
		import com.android.settings.Utils
		import com.android.settings.applications.AppStoreUtil
		import com.android.settings.testutils.waitUntilExists
		import com.android.settingslib.applications.AppUtils
		import com.android.settingslib.spaprivileged.framework.common.userManager
		import com.android.settingslib.spaprivileged.model.app.userHandle
		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.anyInt
		import org.mockito.Mockito.eq
		import org.mockito.Mockito.verify
		import org.mockito.MockitoSession
		import org.mockito.Spy
		import org.mockito.quality.Strictness
		import org.mockito.Mockito.`when` as whenever

		@RunWith(AndroidJUnit4::class)
		class AppInstallerInfoPreferenceTest {
		@get:Rule
		val composeTestRule = createComposeRule()

		private lateinit var mockSession: MockitoSession

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

		@Mock
		private lateinit var userManager: UserManager

		@Before
		fun setUp() {
		mockSession = mockitoSession()
		.initMocks(this)
		.mockStatic(AppStoreUtil::class.java)
		.mockStatic(Utils::class.java)
		.mockStatic(AppUtils::class.java)
		.strictness(Strictness.LENIENT)
		.startMocking()
		whenever(context.userManager).thenReturn(userManager)
		whenever(userManager.isManagedProfile(anyInt())).thenReturn(false)
		whenever(AppStoreUtil.getInstallerPackageName(any(), eq(PACKAGE_NAME)))
		.thenReturn(INSTALLER_PACKAGE_NAME)
		whenever(AppStoreUtil.getAppStoreLink(context, INSTALLER_PACKAGE_NAME, PACKAGE_NAME))
		.thenReturn(STORE_LINK)
		whenever(Utils.getApplicationLabel(context, INSTALLER_PACKAGE_NAME))
		.thenReturn(INSTALLER_PACKAGE_LABEL)
		whenever(AppUtils.isMainlineModule(any(), eq(PACKAGE_NAME)))
		.thenReturn(false)
		}

		@After
		fun tearDown() {
		mockSession.finishMocking()
		}

		@Test
		fun whenNoInstaller_notDisplayed() {
		whenever(AppStoreUtil.getInstallerPackageName(any(), eq(PACKAGE_NAME))).thenReturn(null)

		setContent()

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun whenInstallerLabelIsNull_notDisplayed() {
		whenever(Utils.getApplicationLabel(context, INSTALLER_PACKAGE_NAME)).thenReturn(null)

		setContent()

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun whenIsManagedProfile_notDisplayed() {
		whenever(userManager.isManagedProfile(anyInt())).thenReturn(true)

		setContent()

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun whenIsMainlineModule_notDisplayed() {
		whenever(AppUtils.isMainlineModule(any(), eq(PACKAGE_NAME))).thenReturn(true)

		setContent()

		composeTestRule.onRoot().assertIsNotDisplayed()
		}

		@Test
		fun whenStoreLinkIsNull_disabled() {
		whenever(AppStoreUtil.getAppStoreLink(context, INSTALLER_PACKAGE_NAME, PACKAGE_NAME))
		.thenReturn(null)

		setContent()
		waitUntilDisplayed()

		composeTestRule.onNode(preferenceNode).assertIsNotEnabled()
		}

		@Test
		fun whenIsInstantApp_hasSummaryForInstant() {
		val instantApp = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		uid = UID
		privateFlags = ApplicationInfo.PRIVATE_FLAG_INSTANT
		}

		setContent(instantApp)
		waitUntilDisplayed()

		composeTestRule.onRoot().printToLog("AAA")
		composeTestRule.onNodeWithText("More info on installer label")
		.assertIsDisplayed()
		.assertIsEnabled()
		}

		@Test
		fun whenNotInstantApp() {
		setContent()
		waitUntilDisplayed()

		composeTestRule.onRoot().printToLog("AAA")
		composeTestRule.onNodeWithText("App installed from installer label")
		.assertIsDisplayed()
		.assertIsEnabled()
		}

		@Test
		fun whenClick_startActivity() {
		setContent()
		waitUntilDisplayed()
		composeTestRule.onRoot().performClick()

		verify(context).startActivityAsUser(STORE_LINK, APP.userHandle)
		}

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

		private fun waitUntilDisplayed() {
		composeTestRule.waitUntilExists(preferenceNode)
		}

		private val preferenceNode = hasText(context.getString(R.string.app_install_details_title))

		private companion object {
		const val PACKAGE_NAME = "packageName"
		const val INSTALLER_PACKAGE_NAME = "installer"
		const val INSTALLER_PACKAGE_LABEL = "installer label"
		val STORE_LINK = Intent("store/link")
		const val UID = 123
		val APP = ApplicationInfo().apply {
		packageName = PACKAGE_NAME
		uid = UID
		}
		}
		}