Use SettingsAlertDialog for app button dialogs

Use the spa standard widget SettingsAlertDialog to unify the dialog style. Bug: 236346018 Test: Manually with Settings Test: Unit test Change-Id: Idb231600e38ec7b0244baa5101da912ed2b9fd3c
2023-01-31 17:42:18 +08:00
parent 7acbaf2d13
commit 750c6072b9
6 changed files with 222 additions and 134 deletions
--- a/src/com/android/settings/spa/app/appinfo/AppButtons.kt
+++ b/src/com/android/settings/spa/app/appinfo/AppButtons.kt
@@ -24,14 +24,12 @@ import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.android.settingslib.applications.AppUtils
 import com.android.settingslib.spa.widget.button.ActionButton
 import com.android.settingslib.spa.widget.button.ActionButtons
-import kotlinx.coroutines.flow.map

@Composable
 fun AppButtons(packageInfoPresenter: PackageInfoPresenter) {
    if (remember(packageInfoPresenter) { packageInfoPresenter.isMainlineModule() }) return
    val presenter = remember { AppButtonsPresenter(packageInfoPresenter) }
-    presenter.Dialogs()
-    ActionButtons(actionButtons = presenter.rememberActionsButtons().value)
+    ActionButtons(actionButtons = presenter.getActionButtons())
 }

 private fun PackageInfoPresenter.isMainlineModule(): Boolean =
@@ -47,12 +45,12 @@ private class AppButtonsPresenter(private val packageInfoPresenter: PackageInfoP

    @OptIn(ExperimentalLifecycleComposeApi::class)
    @Composable
-    fun rememberActionsButtons() = remember {
-        packageInfoPresenter.flow.map { packageInfo ->
-            if (packageInfo != null) getActionButtons(packageInfo.applicationInfo) else emptyList()
-        }
-    }.collectAsStateWithLifecycle(initialValue = emptyList())
+    fun getActionButtons() =
+        packageInfoPresenter.flow.collectAsStateWithLifecycle(initialValue = null).value?.let {
+            getActionButtons(it.applicationInfo)
+        } ?: emptyList()

+    @Composable
    private fun getActionButtons(app: ApplicationInfo): List<ActionButton> = listOfNotNull(
        appLaunchButton.getActionButton(app),
        appInstallButton.getActionButton(app),
@@ -61,11 +59,4 @@ private class AppButtonsPresenter(private val packageInfoPresenter: PackageInfoP
        appClearButton.getActionButton(app),
        appForceStopButton.getActionButton(app),
    )
-
-    @Composable
-    fun Dialogs() {
-        appDisableButton.DisableConfirmDialog()
-        appClearButton.ClearConfirmDialog()
-        appForceStopButton.ForceStopConfirmDialog()
-    }
 }
--- a/src/com/android/settings/spa/app/appinfo/AppClearButton.kt
+++ b/src/com/android/settings/spa/app/appinfo/AppClearButton.kt
@@ -19,61 +19,44 @@ package com.android.settings.spa.app.appinfo
 import android.content.pm.ApplicationInfo
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.Delete
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.res.stringResource
 import com.android.settings.R
 import com.android.settingslib.spa.widget.button.ActionButton
+import com.android.settingslib.spa.widget.dialog.AlertDialogButton
+import com.android.settingslib.spa.widget.dialog.rememberAlertDialogPresenter

 class AppClearButton(
    private val packageInfoPresenter: PackageInfoPresenter,
 ) {
    private val context = packageInfoPresenter.context

-    private var openConfirmDialog by mutableStateOf(false)
-
+    @Composable
    fun getActionButton(app: ApplicationInfo): ActionButton? {
        if (!app.isInstantApp) return null

        return clearButton()
    }

-    private fun clearButton() = ActionButton(
-        text = context.getString(R.string.clear_instant_app_data),
-        imageVector = Icons.Outlined.Delete,
-    ) { openConfirmDialog = true }
-
    @Composable
-    fun ClearConfirmDialog() {
-        if (!openConfirmDialog) return
-        AlertDialog(
-            onDismissRequest = { openConfirmDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
-                        openConfirmDialog = false
-                        packageInfoPresenter.clearInstantApp()
-                    },
-                ) {
-                    Text(stringResource(R.string.clear_instant_app_data))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { openConfirmDialog = false }) {
-                    Text(stringResource(R.string.cancel))
-                }
-            },
-            title = {
-                Text(stringResource(R.string.clear_instant_app_data))
-            },
-            text = {
-                Text(stringResource(R.string.clear_instant_app_confirmation))
-            },
+    private fun clearButton(): ActionButton {
+        val dialogPresenter = confirmDialogPresenter()
+        return ActionButton(
+            text = context.getString(R.string.clear_instant_app_data),
+            imageVector = Icons.Outlined.Delete,
+            onClick = dialogPresenter::open,
        )
    }
+
+    @Composable
+    private fun confirmDialogPresenter() = rememberAlertDialogPresenter(
+        confirmButton = AlertDialogButton(
+            text = stringResource(R.string.clear_instant_app_data),
+            onClick = packageInfoPresenter::clearInstantApp,
+        ),
+        dismissButton = AlertDialogButton(stringResource(R.string.cancel)),
+        title = stringResource(R.string.clear_instant_app_data),
+        text = { Text(stringResource(R.string.clear_instant_app_confirmation)) },
+    )
 }
--- a/src/com/android/settings/spa/app/appinfo/AppDisableButton.kt
+++ b/src/com/android/settings/spa/app/appinfo/AppDisableButton.kt
@@ -20,18 +20,15 @@ import android.content.pm.ApplicationInfo
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.ArrowCircleDown
 import androidx.compose.material.icons.outlined.HideSource
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.res.stringResource
 import com.android.settings.R
 import com.android.settings.Utils
 import com.android.settings.overlay.FeatureFactory
 import com.android.settingslib.spa.widget.button.ActionButton
+import com.android.settingslib.spa.widget.dialog.AlertDialogButton
+import com.android.settingslib.spa.widget.dialog.rememberAlertDialogPresenter
 import com.android.settingslib.spaprivileged.framework.common.devicePolicyManager
 import com.android.settingslib.spaprivileged.framework.common.userManager
 import com.android.settingslib.spaprivileged.model.app.isDisabledUntilUsed
@@ -49,8 +46,7 @@ class AppDisableButton(
    private val applicationFeatureProvider =
        FeatureFactory.getFactory(context).getApplicationFeatureProvider(context)

-    private var openConfirmDialog by mutableStateOf(false)
-
+    @Composable
    fun getActionButton(app: ApplicationInfo): ActionButton? {
        if (!app.isSystemApp) return null

@@ -92,14 +88,19 @@ class AppDisableButton(
        else -> true
    }

-    private fun disableButton(app: ApplicationInfo) = ActionButton(
-        text = context.getString(R.string.disable_text),
-        imageVector = Icons.Outlined.HideSource,
-        enabled = app.canBeDisabled(),
-    ) {
-        // Currently we apply the same device policy for both the uninstallation and disable button.
-        if (!appButtonRepository.isUninstallBlockedByAdmin(app)) {
-            openConfirmDialog = true
+    @Composable
+    private fun disableButton(app: ApplicationInfo): ActionButton {
+        val dialogPresenter = confirmDialogPresenter()
+        return ActionButton(
+            text = context.getString(R.string.disable_text),
+            imageVector = Icons.Outlined.HideSource,
+            enabled = app.canBeDisabled(),
+        ) {
+            // Currently we apply the same device policy for both the uninstallation and disable
+            // button.
+            if (!appButtonRepository.isUninstallBlockedByAdmin(app)) {
+                dialogPresenter.open()
+            }
        }
    }

@@ -109,28 +110,13 @@ class AppDisableButton(
    ) { packageInfoPresenter.enable() }

    @Composable
-    fun DisableConfirmDialog() {
-        if (!openConfirmDialog) return
-        AlertDialog(
-            onDismissRequest = { openConfirmDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
-                        openConfirmDialog = false
-                        packageInfoPresenter.disable()
-                    },
-                ) {
-                    Text(stringResource(R.string.app_disable_dlg_positive))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { openConfirmDialog = false }) {
-                    Text(stringResource(R.string.cancel))
-                }
-            },
-            text = {
-                Text(stringResource(R.string.app_disable_dlg_text))
-            },
-        )
-    }
+    private fun confirmDialogPresenter() = rememberAlertDialogPresenter(
+        confirmButton = AlertDialogButton(
+            text = stringResource(R.string.reset_app_preferences_button),
+            onClick = packageInfoPresenter::disable,
+        ),
+        dismissButton = AlertDialogButton(stringResource(R.string.cancel)),
+        title = stringResource(R.string.app_disable_dlg_positive),
+        text = { Text(stringResource(R.string.app_disable_dlg_text)) },
+    )
 }
--- a/src/com/android/settings/spa/app/appinfo/AppForceStopButton.kt
+++ b/src/com/android/settings/spa/app/appinfo/AppForceStopButton.kt
@@ -21,19 +21,17 @@ import android.content.pm.ApplicationInfo
 import android.os.UserManager
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.WarningAmber
-import androidx.compose.material3.AlertDialog
 import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.setValue
 import androidx.compose.ui.res.stringResource
 import com.android.settings.R
 import com.android.settingslib.RestrictedLockUtils
 import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin
 import com.android.settingslib.RestrictedLockUtilsInternal
 import com.android.settingslib.spa.widget.button.ActionButton
+import com.android.settingslib.spa.widget.dialog.AlertDialogButton
+import com.android.settingslib.spa.widget.dialog.AlertDialogPresenter
+import com.android.settingslib.spa.widget.dialog.rememberAlertDialogPresenter
 import com.android.settingslib.spaprivileged.model.app.hasFlag
 import com.android.settingslib.spaprivileged.model.app.isActiveAdmin
 import com.android.settingslib.spaprivileged.model.app.userId
@@ -45,14 +43,14 @@ class AppForceStopButton(
    private val appButtonRepository = AppButtonRepository(context)
    private val packageManager = context.packageManager

-    private var openConfirmDialog by mutableStateOf(false)
-
+    @Composable
    fun getActionButton(app: ApplicationInfo): ActionButton {
+        val dialogPresenter = confirmDialogPresenter()
        return ActionButton(
            text = context.getString(R.string.force_stop),
            imageVector = Icons.Outlined.WarningAmber,
            enabled = isForceStopButtonEnable(app),
-        ) { onForceStopButtonClicked(app) }
+        ) { onForceStopButtonClicked(app, dialogPresenter) }
    }

    /**
@@ -68,13 +66,16 @@ class AppForceStopButton(
        else -> !app.hasFlag(ApplicationInfo.FLAG_STOPPED)
    }

-    private fun onForceStopButtonClicked(app: ApplicationInfo) {
+    private fun onForceStopButtonClicked(
+        app: ApplicationInfo,
+        dialogPresenter: AlertDialogPresenter,
+    ) {
        packageInfoPresenter.logAction(SettingsEnums.ACTION_APP_INFO_FORCE_STOP)
        getAdminRestriction(app)?.let { admin ->
            RestrictedLockUtils.sendShowAdminSupportDetailsIntent(context, admin)
            return
        }
-        openConfirmDialog = true
+        dialogPresenter.open()
    }

    private fun getAdminRestriction(app: ApplicationInfo): EnforcedAdmin? = when {
@@ -88,31 +89,13 @@ class AppForceStopButton(
    }

    @Composable
-    fun ForceStopConfirmDialog() {
-        if (!openConfirmDialog) return
-        AlertDialog(
-            onDismissRequest = { openConfirmDialog = false },
-            confirmButton = {
-                TextButton(
-                    onClick = {
-                        openConfirmDialog = false
-                        packageInfoPresenter.forceStop()
-                    },
-                ) {
-                    Text(stringResource(R.string.okay))
-                }
-            },
-            dismissButton = {
-                TextButton(onClick = { openConfirmDialog = false }) {
-                    Text(stringResource(R.string.cancel))
-                }
-            },
-            title = {
-                Text(stringResource(R.string.force_stop_dlg_title))
-            },
-            text = {
-                Text(stringResource(R.string.force_stop_dlg_text))
-            },
-        )
-    }
+    private fun confirmDialogPresenter() = rememberAlertDialogPresenter(
+        confirmButton = AlertDialogButton(
+            text = stringResource(R.string.okay),
+            onClick = packageInfoPresenter::forceStop,
+        ),
+        dismissButton = AlertDialogButton(stringResource(R.string.cancel)),
+        title = stringResource(R.string.force_stop_dlg_title),
+        text = { Text(stringResource(R.string.force_stop_dlg_text)) },
+    )
 }