ui/handheld/PermissionPreference.java

/*
 * Copyright (C) 2018 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.permissioncontroller.permission.ui.handheld;

import static com.android.permissioncontroller.permission.utils.Utils.DEFAULT_MAX_LABEL_SIZE_PX;
import static com.android.permissioncontroller.permission.utils.Utils.getRequestMessage;

import static java.lang.annotation.RetentionPolicy.SOURCE;

import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.UserHandle;
import android.text.BidiFormatter;
import android.text.TextUtils;
import android.widget.Switch;

import androidx.annotation.IntDef;
import androidx.annotation.LayoutRes;
import androidx.fragment.app.DialogFragment;
import androidx.fragment.app.Fragment;
import androidx.preference.PreferenceFragmentCompat;

import com.android.permissioncontroller.R;
import com.android.permissioncontroller.permission.model.AppPermissionGroup;
import com.android.permissioncontroller.permission.model.Permission;
import com.android.permissioncontroller.permission.utils.LocationUtils;
import com.android.permissioncontroller.permission.utils.Utils;
import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;

import java.lang.annotation.Retention;
import java.util.List;

/**
 * A preference for representing a permission group requested by an app.
 */
class PermissionPreference extends MultiTargetSwitchPreference {
    @Retention(SOURCE)
    @IntDef(value = {CHANGE_FOREGROUND, CHANGE_BACKGROUND}, flag = true)
    @interface ChangeTarget {}
    static final int CHANGE_FOREGROUND = 1;
    static final int CHANGE_BACKGROUND = 2;
    static final int CHANGE_BOTH = CHANGE_FOREGROUND | CHANGE_BACKGROUND;

    private final AppPermissionGroup mGroup;
    private final PreferenceFragmentCompat mFragment;
    private final PermissionPreferenceChangeListener mCallBacks;
    private final @LayoutRes int mOriginalWidgetLayoutRes;

    /** Callbacks for the permission to the fragment showing a list of permissions */
    interface PermissionPreferenceChangeListener {
        /**
         * Checks if the user has to confirm a revocation of a permission granted by default.
         *
         * @return {@code true} iff the user has to confirm it
         */
        boolean shouldConfirmDefaultPermissionRevoke();

        /**
         * Notify the listener that the user confirmed that she/he wants to revoke permissions that
         * were granted by default.
         */
        void hasConfirmDefaultPermissionRevoke();

        /**
         * Notify the listener that this preference has changed.
         *
         * @param key The key uniquely identifying this preference
         */
        void onPreferenceChanged(String key);
    }

    /**
     * Callbacks from dialogs to the fragment. These callbacks are supposed to directly cycle back
     * to the permission tha created the dialog.
     */
    interface PermissionPreferenceOwnerFragment {
        /**
         * The {@link DefaultDenyDialog} can only interact with the fragment, not the preference
         * that created it. Hence this call goes to the fragment, which then finds the preference an
         * calls {@link #onDenyAnyWay(int)}.
         *
         * @param key Key uniquely identifying the preference that created the default deny dialog
         * @param changeTarget Whether background or foreground permissions should be changed
         *
         * @see #showDefaultDenyDialog(int)
         */
        void onDenyAnyWay(String key, @ChangeTarget int changeTarget);

        /**
         * The {@link BackgroundAccessChooser} can only interact with the fragment, not the
         * preference that created it. Hence this call goes to the fragment, which then finds the
         * preference an calls {@link #onBackgroundAccessChosen(int)}}.
         *
         * @param key Key uniquely identifying the preference that created the background access
         *            chooser
         * @param chosenItem The index of the item selected by the user.
         *
         * @see #showBackgroundChooserDialog()
         */
        void onBackgroundAccessChosen(String key, int chosenItem);
    }

    PermissionPreference(PreferenceFragmentCompat fragment, AppPermissionGroup group,
            PermissionPreferenceChangeListener callbacks) {
        super(fragment.getPreferenceManager().getContext());

        mFragment = fragment;
        mGroup = group;
        mCallBacks = callbacks;
        mOriginalWidgetLayoutRes = getWidgetLayoutResource();

        setPersistent(false);
        updateUi();
    }

    /**
     * Are any permissions of this group fixed by the system, i.e. not changeable by the user.
     *
     * @return {@code true} iff any permission is fixed
     */
    private boolean isSystemFixed() {
        return mGroup.isSystemFixed();
    }

    /**
     * Is any foreground permissions of this group fixed by the policy, i.e. not changeable by the
     * user.
     *
     * @return {@code true} iff any foreground permission is fixed
     */
    private boolean isForegroundPolicyFixed() {
        return mGroup.isPolicyFixed();
    }

    /**
     * Is any background permissions of this group fixed by the policy, i.e. not changeable by the
     * user.
     *
     * @return {@code true} iff any background permission is fixed
     */
    private boolean isBackgroundPolicyFixed() {
        return mGroup.getBackgroundPermissions() != null
                && mGroup.getBackgroundPermissions().isPolicyFixed();
    }

    /**
     * Are there permissions fixed, so that the user cannot change the preference at all?
     *
     * @return {@code true} iff the permissions of this group are fixed
     */
    private boolean isPolicyFullyFixed() {
        return isForegroundPolicyFixed() && (mGroup.getBackgroundPermissions() == null
                || isBackgroundPolicyFixed());
    }

    /**
     * Is the foreground part of this group disabled. If the foreground is disabled, there is no
     * need to possible grant background access.
     *
     * @return {@code true} iff the permissions of this group are fixed
     */
    private boolean isForegroundDisabledByPolicy() {
        return isForegroundPolicyFixed() && !mGroup.areRuntimePermissionsGranted();
    }

    /**
     * Get the app that acts as admin for this profile.
     *
     * @return The admin or {@code null} if there is no admin.
     */
    private EnforcedAdmin getAdmin() {
        return RestrictedLockUtils.getProfileOrDeviceOwner(getContext(), mGroup.getUser());
    }

    /**
     * Update the preference after the state might have changed.
     */
    void updateUi() {
        boolean arePermissionsIndividuallyControlled =
                Utils.areGroupPermissionsIndividuallyControlled(getContext(), mGroup.getName());
        EnforcedAdmin admin = getAdmin();

        // Reset ui state
        setEnabled(true);
        setWidgetLayoutResource(mOriginalWidgetLayoutRes);
        setOnPreferenceClickListener(null);
        setSwitchOnClickListener(null);
        setSummary(null);

        setChecked(mGroup.areRuntimePermissionsGranted());

        if (isSystemFixed() || isPolicyFullyFixed() || isForegroundDisabledByPolicy()) {
            if (admin != null) {
                setWidgetLayoutResource(R.layout.restricted_icon);

                setOnPreferenceClickListener((v) -> {
                    RestrictedLockUtils.sendShowAdminSupportDetailsIntent(getContext(), admin);
                    return true;
                });
            } else {
                setEnabled(false);
            }

            updateSummaryForFixedByPolicyPermissionGroup();
        } else if (arePermissionsIndividuallyControlled) {
            setOnPreferenceClickListener((pref) -> {
                showAllPermissions(mGroup.getName());
                return false;
            });

            setSwitchOnClickListener(v -> {
                Switch switchView = (Switch) v;
                requestChange(switchView.isChecked(), CHANGE_BOTH);

                // Update UI as the switch widget might be in wrong state
                updateUi();
            });

            updateSummaryForIndividuallyControlledPermissionGroup();
        } else {
            if (mGroup.hasPermissionWithBackgroundMode()) {
                if (mGroup.getBackgroundPermissions() == null) {
                    // The group has background permissions but the app did not request any. I.e.
                    // The app can only switch between 'never" and "only in foreground".
                    setOnPreferenceChangeListener((pref, newValue) ->
                            requestChange((Boolean) newValue, CHANGE_FOREGROUND));

                    updateSummaryForPermissionGroupWithBackgroundPermission();
                } else {
                    if (isBackgroundPolicyFixed()) {
                        setOnPreferenceChangeListener((pref, newValue) ->
                                requestChange((Boolean) newValue, CHANGE_FOREGROUND));

                        updateSummaryForFixedByPolicyPermissionGroup();
                    } else if (isForegroundPolicyFixed()) {
                        setOnPreferenceChangeListener((pref, newValue) ->
                                requestChange((Boolean) newValue, CHANGE_BACKGROUND));

                        updateSummaryForFixedByPolicyPermissionGroup();
                    } else {
                        updateSummaryForPermissionGroupWithBackgroundPermission();

                        setOnPreferenceClickListener((pref) -> {
                            showBackgroundChooserDialog();
                            return true;
                        });

                        setSwitchOnClickListener(v -> {
                            Switch switchView = (Switch) v;

                            if (switchView.isChecked()) {
                                showBackgroundChooserDialog();
                            } else {
                                requestChange(false, CHANGE_BOTH);
                            }

                            // Update UI as the switch widget might be in wrong state
                            updateUi();
                        });
                    }
                }
            } else {
                setOnPreferenceChangeListener((pref, newValue) ->
                        requestChange((Boolean) newValue, CHANGE_BOTH));
            }
        }
    }

    /**
     * Update the summary in the case the permission group has individually controlled permissions.
     */
    private void updateSummaryForIndividuallyControlledPermissionGroup() {
        int revokedCount = 0;
        List<Permission> permissions = mGroup.getPermissions();
        final int permissionCount = permissions.size();
        for (int i = 0; i < permissionCount; i++) {
            Permission permission = permissions.get(i);
            if (!permission.isGrantedIncludingAppOp()) {
                revokedCount++;
            }
        }

        final int resId;
        if (revokedCount == 0) {
            resId = R.string.permission_revoked_none;
        } else if (revokedCount == permissionCount) {
            resId = R.string.permission_revoked_all;
        } else {
            resId = R.string.permission_revoked_count;
        }

        String summary = getContext().getString(resId, revokedCount);
        setSummary(summary);
    }

    /**
     * Update the summary of a permission group that has background permission.
     *
     * <p>This does not apply to permission groups that are fixed by policy</p>
     */
    private void updateSummaryForPermissionGroupWithBackgroundPermission() {
        AppPermissionGroup backgroundGroup = mGroup.getBackgroundPermissions();

        if (mGroup.areRuntimePermissionsGranted()) {
            if (backgroundGroup == null) {
                setSummary(R.string.permission_access_only_foreground);
            } else {
                if (backgroundGroup.areRuntimePermissionsGranted()) {
                    setSummary(R.string.permission_access_always);
                } else {
                    setSummary(R.string.permission_access_only_foreground);
                }
            }
        } else {
            setSummary(R.string.permission_access_never);
        }
    }

    /**
     * Update the summary of a permission group that is at least partially fixed by policy.
     */
    private void updateSummaryForFixedByPolicyPermissionGroup() {
        EnforcedAdmin admin = getAdmin();
        AppPermissionGroup backgroundGroup = mGroup.getBackgroundPermissions();

        boolean hasAdmin = admin != null;

        if (isSystemFixed()) {
            // Permission is fully controlled by the system and cannot be switched

            setSummary(R.string.permission_summary_enabled_system_fixed);
        } else if (isForegroundDisabledByPolicy()) {
            // Permission is fully controlled by policy and cannot be switched

            if (hasAdmin) {
                setSummary(R.string.disabled_by_admin);
            } else {
                // Disabled state will be displayed by switch, so no need to add text for that
                setSummary(R.string.permission_summary_enforced_by_policy);
            }
        } else if (isPolicyFullyFixed()) {
            // Permission is fully controlled by policy and cannot be switched

            if (backgroundGroup == null) {
                if (hasAdmin) {
                    setSummary(R.string.enabled_by_admin);
                } else {
                    // Enabled state will be displayed by switch, so no need to add text for
                    // that
                    setSummary(R.string.permission_summary_enforced_by_policy);
                }
            } else {
                if (backgroundGroup.areRuntimePermissionsGranted()) {
                    if (hasAdmin) {
                        setSummary(R.string.enabled_by_admin);
                    } else {
                        // Enabled state will be displayed by switch, so no need to add text for
                        // that
                        setSummary(R.string.permission_summary_enforced_by_policy);
                    }
                } else {
                    if (hasAdmin) {
                        setSummary(
                                R.string.permission_summary_enabled_by_admin_foreground_only);
                    } else {
                        setSummary(
                                R.string.permission_summary_enabled_by_policy_foreground_only);
                    }
                }
            }
        } else {
            // Part of the permission group can still be switched

            if (isBackgroundPolicyFixed()) {
                if (backgroundGroup.areRuntimePermissionsGranted()) {
                    if (hasAdmin) {
                        setSummary(R.string.permission_summary_enabled_by_admin_background_only);
                    } else {
                        setSummary(R.string.permission_summary_enabled_by_policy_background_only);
                    }
                } else {
                    if (hasAdmin) {
                        setSummary(R.string.permission_summary_disabled_by_admin_background_only);
                    } else {
                        setSummary(R.string.permission_summary_disabled_by_policy_background_only);
                    }
                }
            } else if (isForegroundPolicyFixed()) {
                if (hasAdmin) {
                    setSummary(R.string.permission_summary_enabled_by_admin_foreground_only);
                } else {
                    setSummary(R.string.permission_summary_enabled_by_policy_foreground_only);
                }
            }
        }
    }

    /**
     * Show all individual permissions in this group in a new fragment.
     */
    private void showAllPermissions(String filterGroup) {
        Fragment frag = AllAppPermissionsFragment.newInstance(mGroup.getApp().packageName,
                filterGroup, UserHandle.getUserHandleForUid(mGroup.getApp().applicationInfo.uid));
        mFragment.getFragmentManager().beginTransaction()
                .replace(android.R.id.content, frag)
                .addToBackStack("AllPerms")
                .commit();
    }

    /**
     * Get the label of the app the permission group belongs to. (App permission groups are all
     * permissions of a group an app has requested.)
     *
     * @return The label of the app
     */
    private String getAppLabel() {
        return BidiFormatter.getInstance().unicodeWrap(
                mGroup.getApp().applicationInfo.loadSafeLabel(getContext().getPackageManager(),
                        DEFAULT_MAX_LABEL_SIZE_PX,
                        TextUtils.SAFE_STRING_FLAG_TRIM
                                | TextUtils.SAFE_STRING_FLAG_FIRST_LINE)
                        .toString());
    }

    /**
     * Request to grant/revoke permissions group.
     *
     * <p>Does <u>not</u> handle:
     * <ul>
     * <li>Individually granted permissions</li>
     * <li>Permission groups with background permissions</li>
     * </ul>
     * <p><u>Does</u> handle:
     * <ul>
     * <li>Default grant permissions</li>
     * </ul>
     *
     * @param requestGrant If this group should be granted
     * @param changeTarget Which permission group (foreground/background/both) should be changed
     * @return If the request was processed.
     */
    private boolean requestChange(boolean requestGrant, @ChangeTarget int changeTarget) {
        if (LocationUtils.isLocationGroupAndProvider(getContext(), mGroup.getName(),
                mGroup.getApp().packageName)) {
            LocationUtils.showLocationDialog(getContext(), getAppLabel());
            return false;
        }
        if (requestGrant) {
            mCallBacks.onPreferenceChanged(getKey());

            if ((changeTarget & CHANGE_FOREGROUND) != 0) {
                mGroup.grantRuntimePermissions(true, false);
            }
            if ((changeTarget & CHANGE_BACKGROUND) != 0) {
                if (mGroup.getBackgroundPermissions() != null) {
                    mGroup.getBackgroundPermissions().grantRuntimePermissions(true, false);
                }
            }
        } else {
            boolean requestToRevokeGrantedByDefault = false;
            if ((changeTarget & CHANGE_FOREGROUND) != 0) {
                requestToRevokeGrantedByDefault = mGroup.hasGrantedByDefaultPermission();
            }
            if ((changeTarget & CHANGE_BACKGROUND) != 0) {
                if (mGroup.getBackgroundPermissions() != null) {
                    requestToRevokeGrantedByDefault |=
                            mGroup.getBackgroundPermissions().hasGrantedByDefaultPermission();
                }
            }

            if ((requestToRevokeGrantedByDefault || !mGroup.doesSupportRuntimePermissions())
                    && mCallBacks.shouldConfirmDefaultPermissionRevoke()) {
                showDefaultDenyDialog(changeTarget);
                return false;
            } else {
                mCallBacks.onPreferenceChanged(getKey());

                if ((changeTarget & CHANGE_FOREGROUND) != 0) {
                    mGroup.revokeRuntimePermissions(false);
                }
                if ((changeTarget & CHANGE_BACKGROUND) != 0) {
                    if (mGroup.getBackgroundPermissions() != null) {
                        mGroup.getBackgroundPermissions().revokeRuntimePermissions(false);
                    }
                }
            }
        }

        updateUi();

        return true;
    }

    /**
     * Show a dialog that warns the user that she/he is about to revoke permissions that were
     * granted by default.
     *
     * <p>The order of operation to revoke a permission granted by default is:
     * <ol>
     *     <li>{@code showDefaultDenyDialog}</li>
     *     <li>{@link DefaultDenyDialog#onCreateDialog}</li>
     *     <li>{@link PermissionPreferenceOwnerFragment#onDenyAnyWay}</li>
     *     <li>{@link PermissionPreference#onDenyAnyWay}</li>
     * </ol>
     *
     * @param changeTarget Whether background or foreground should be changed
     */
    private void showDefaultDenyDialog(@ChangeTarget int changeTarget) {
        if (!mFragment.isResumed()) {
            return;
        }

        Bundle args = new Bundle();

        boolean showGrantedByDefaultWarning = false;
        if ((changeTarget & CHANGE_FOREGROUND) != 0) {
            showGrantedByDefaultWarning = mGroup.hasGrantedByDefaultPermission();
        }
        if ((changeTarget & CHANGE_BACKGROUND) != 0) {
            if (mGroup.getBackgroundPermissions() != null) {
                showGrantedByDefaultWarning |=
                        mGroup.getBackgroundPermissions().hasGrantedByDefaultPermission();
            }
        }

        args.putInt(DefaultDenyDialog.MSG, showGrantedByDefaultWarning ? R.string.system_warning
                : R.string.old_sdk_deny_warning);
        args.putString(DefaultDenyDialog.KEY, getKey());
        args.putInt(DefaultDenyDialog.CHANGE_TARGET, changeTarget);

        DefaultDenyDialog deaultDenyDialog = new DefaultDenyDialog();
        deaultDenyDialog.setArguments(args);
        deaultDenyDialog.show(mFragment.getChildFragmentManager().beginTransaction(),
                "denyDefault");
    }

    /**
     * Show a dialog that asks the user if foreground/background/none access should be enabled.
     *
     * <p>The order of operation to grant foreground/background/none access is:
     * <ol>
     *     <li>{@code showBackgroundChooserDialog}</li>
     *     <li>{@link BackgroundAccessChooser#onCreateDialog}</li>
     *     <li>{@link PermissionPreferenceOwnerFragment#onBackgroundAccessChosen}</li>
     *     <li>{@link PermissionPreference#onBackgroundAccessChosen}</li>
     * </ol>
     */
    private void showBackgroundChooserDialog() {
        if (!mFragment.isResumed()) {
            return;
        }

        if (LocationUtils.isLocationGroupAndProvider(getContext(), mGroup.getName(),
                mGroup.getApp().packageName)) {
            LocationUtils.showLocationDialog(getContext(), getAppLabel());
            return;
        }

        Bundle args = new Bundle();
        args.putCharSequence(BackgroundAccessChooser.TITLE,
                getRequestMessage(getAppLabel(), mGroup, getContext(), mGroup.getRequest()));
        args.putString(BackgroundAccessChooser.KEY, getKey());


        if (mGroup.areRuntimePermissionsGranted()) {
            if (mGroup.getBackgroundPermissions().areRuntimePermissionsGranted()) {
                args.putInt(BackgroundAccessChooser.SELECTION,
                        BackgroundAccessChooser.ALWAYS_OPTION);
            } else {
                args.putInt(BackgroundAccessChooser.SELECTION,
                        BackgroundAccessChooser.FOREGROUND_ONLY_OPTION);
            }
        } else {
            args.putInt(BackgroundAccessChooser.SELECTION, BackgroundAccessChooser.NEVER_OPTION);
        }

        BackgroundAccessChooser chooserDialog = new BackgroundAccessChooser();
        chooserDialog.setArguments(args);
        chooserDialog.show(mFragment.getChildFragmentManager().beginTransaction(),
                "backgroundChooser");
    }

    /**
     * Once we user has confirmed that he/she wants to revoke a permission that was granted by
     * default, actually revoke the permissions.
     *
     * @see #showDefaultDenyDialog(int)
     */
    void onDenyAnyWay(@ChangeTarget int changeTarget) {
        mCallBacks.onPreferenceChanged(getKey());

        boolean hasDefaultPermissions = false;
        if ((changeTarget & CHANGE_FOREGROUND) != 0) {
            mGroup.revokeRuntimePermissions(false);
            hasDefaultPermissions = mGroup.hasGrantedByDefaultPermission();
        }
        if ((changeTarget & CHANGE_BACKGROUND) != 0) {
            if (mGroup.getBackgroundPermissions() != null) {
                mGroup.getBackgroundPermissions().revokeRuntimePermissions(false);
                hasDefaultPermissions |=
                        mGroup.getBackgroundPermissions().hasGrantedByDefaultPermission();
            }
        }

        if (hasDefaultPermissions || !mGroup.doesSupportRuntimePermissions()) {
            mCallBacks.hasConfirmDefaultPermissionRevoke();
        }
        updateUi();
    }

    /**
     * Process the return from a {@link BackgroundAccessChooser} dialog.
     *
     * <p>These dialog are started when the user want to grant a permission group that has
     * background permissions.
     *
     * @param choosenItem The item that the user chose
     */
    void onBackgroundAccessChosen(int choosenItem) {
        AppPermissionGroup backgroundGroup = mGroup.getBackgroundPermissions();

        switch (choosenItem) {
            case BackgroundAccessChooser.ALWAYS_OPTION:
                requestChange(true, CHANGE_BOTH);
                break;
            case BackgroundAccessChooser.FOREGROUND_ONLY_OPTION:
                if (backgroundGroup.areRuntimePermissionsGranted()) {
                    requestChange(false, CHANGE_BACKGROUND);
                }
                requestChange(true, CHANGE_FOREGROUND);
                break;
            case BackgroundAccessChooser.NEVER_OPTION:
                if (mGroup.areRuntimePermissionsGranted()
                        || mGroup.getBackgroundPermissions().areRuntimePermissionsGranted()) {
                    requestChange(false, CHANGE_BOTH);
                }
                break;
        }
    }

    /**
     * A dialog warning the user that she/he is about to deny a permission that was granted by
     * default.
     *
     * @see #showDefaultDenyDialog(int)
     */
    public static class DefaultDenyDialog extends DialogFragment {
        private static final String MSG = DefaultDenyDialog.class.getName() + ".arg.msg";
        private static final String CHANGE_TARGET = DefaultDenyDialog.class.getName()
                + ".arg.changeTarget";
        private static final String KEY = DefaultDenyDialog.class.getName() + ".arg.key";

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            AlertDialog.Builder b = new AlertDialog.Builder(getContext())
                    .setMessage(getArguments().getInt(MSG))
                    .setNegativeButton(R.string.cancel, null)
                    .setPositiveButton(R.string.grant_dialog_button_deny_anyway,
                            (DialogInterface dialog, int which) -> (
                                    (PermissionPreferenceOwnerFragment) getParentFragment())
                                    .onDenyAnyWay(getArguments().getString(KEY),
                                            getArguments().getInt(CHANGE_TARGET)));

            return b.create();
        }
    }

    /**
     * If a permission group has background permission this chooser is used to let the user
     * choose how the permission group should be granted.
     *
     * @see #showBackgroundChooserDialog()
     */
    public static class BackgroundAccessChooser extends DialogFragment {
        private static final String TITLE = BackgroundAccessChooser.class.getName() + ".arg.title";
        private static final String KEY = BackgroundAccessChooser.class.getName() + ".arg.key";
        private static final String SELECTION = BackgroundAccessChooser.class.getName()
                + ".arg.selection";

        // Needs to match the entries in R.array.background_access_chooser_dialog_choices
        static final int ALWAYS_OPTION = 0;
        static final int FOREGROUND_ONLY_OPTION = 1;
        static final int NEVER_OPTION = 2;

        @Override
        public Dialog onCreateDialog(Bundle savedInstanceState) {
            AlertDialog.Builder b = new AlertDialog.Builder(getActivity())
                    .setTitle(getArguments().getCharSequence(TITLE))
                    .setSingleChoiceItems(R.array.background_access_chooser_dialog_choices,
                            getArguments().getInt(SELECTION),
                            (dialog, which) -> {
                                dismissAllowingStateLoss();
                                ((PermissionPreferenceOwnerFragment) getParentFragment())
                                        .onBackgroundAccessChosen(getArguments().getString(KEY),
                                                which);
                            }
                    );

            return b.create();
        }
    }
}