Replace ECM AppOps call with service

A new ECM service was introcuded in changeId
I831391e4437b51b3312b5273a2360bd029a3d8ee.

We begin calling it, and update/cleanup method signatures to match.

Note: There are two feature flags:

1. enhancedConfirmationModeApisEnabled - read only, protects the
   mainline API.

2. extendEcmToAllSettings - runtime - gates calls to the above APIs.

We use both so we can ramp up in teamfood as needed.

Bug: 297372999
Test: Tested on device
Test: atest SpaPrivilegedLibTests
Test: atest com.android.settings.applications.specialaccess.notificationaccess
Test: atest com.android.settings.datausage
Test: atest PremiumSmsAccessTest
Test: atest RestrictedPreferenceHelperTest
Change-Id: I945ec51df5cd63de548a8ffdd1acc4f09f2301e5

src/com/android/settings/ActionDisabledByAppOpsDialog.java

@@ -21,7 +21,6 @@ import android.app.AppOpsManager;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.os.Bundle;
-import android.util.Log;
 
 public class ActionDisabledByAppOpsDialog extends Activity
         implements DialogInterface.OnDismissListener {

src/com/android/settings/accessibility/AccessibilityDetailsSettingsFragment.java

@@ -43,6 +43,7 @@ import com.android.settings.R;
 import com.android.settings.core.InstrumentedFragment;
 import com.android.settings.core.SubSettingLauncher;
 import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.RestrictedLockUtilsInternal;
 import com.android.settingslib.accessibility.AccessibilityUtils;
 
 import java.util.List;
@@ -164,16 +165,9 @@ public class AccessibilityDetailsSettingsFragment extends InstrumentedFragment {
         if (permittedServices != null && !permittedServices.contains(packageName)) {
             return false;
         }
-        try {
+
-            final int mode = mAppOps.noteOpNoThrow(AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
+        return !RestrictedLockUtilsInternal.isEnhancedConfirmationRestricted(getContext(),
-                    uid, packageName);
+                packageName, AppOpsManager.OPSTR_BIND_ACCESSIBILITY_SERVICE);
-            final boolean ecmEnabled = getContext().getResources().getBoolean(
-                    com.android.internal.R.bool.config_enhancedConfirmationModeEnabled);
-            return !ecmEnabled || mode == AppOpsManager.MODE_ALLOWED;
-        } catch (Exception e) {
-            // Fallback in case if app ops is not available in testing.
-            return true;
-        }
     }
 
     private AccessibilityServiceInfo getAccessibilityServiceInfo(ComponentName componentName) {

src/com/android/settings/accessibility/RestrictedPreferenceHelper.java

@@ -235,10 +235,11 @@ public class RestrictedPreferenceHelper {
         boolean serviceAllowed = permittedServices == null || permittedServices.contains(
                 preference.getPackageName());
 
-        if (android.security.Flags.extendEcmToAllSettings()) {
+        if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
+                && android.security.Flags.extendEcmToAllSettings()) {
             preference.checkEcmRestrictionAndSetDisabled(
                     AppOpsManager.OPSTR_BIND_ACCESSIBILITY_SERVICE,
-                    preference.getPackageName(), preference.getUid());
+                    preference.getPackageName());
             if (preference.isDisabledByEcm()) {
                 serviceAllowed = false;
             }
@@ -257,40 +258,39 @@ public class RestrictedPreferenceHelper {
                     preference.setEnabled(false);
                 }
             }
-            return;
-        }
-
-        boolean appOpsAllowed;
-        if (serviceAllowed) {
-            try {
-                final int mode = mAppOps.noteOpNoThrow(
-                        AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
-                        preference.getUid(), preference.getPackageName());
-                final boolean ecmEnabled = mContext.getResources().getBoolean(
-                        com.android.internal.R.bool.config_enhancedConfirmationModeEnabled);
-                appOpsAllowed = !ecmEnabled || mode == AppOpsManager.MODE_ALLOWED;
-                serviceAllowed = appOpsAllowed;
-            } catch (Exception e) {
-                // Allow service in case if app ops is not available in testing.
-                appOpsAllowed = true;
-            }
         } else {
-            appOpsAllowed = false;
+            boolean appOpsAllowed;
-        }
+            if (serviceAllowed) {
-        if (serviceAllowed || serviceEnabled) {
+                try {
-            preference.setEnabled(true);
+                    final int mode = mAppOps.noteOpNoThrow(
-        } else {
+                            AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
-            // Disable accessibility service that are not permitted.
+                            preference.getUid(), preference.getPackageName());
-            final RestrictedLockUtils.EnforcedAdmin admin =
+                    final boolean ecmEnabled = mContext.getResources().getBoolean(
-                    RestrictedLockUtilsInternal.checkIfAccessibilityServiceDisallowed(
+                            com.android.internal.R.bool.config_enhancedConfirmationModeEnabled);
-                            mContext, preference.getPackageName(), UserHandle.myUserId());
+                    appOpsAllowed = !ecmEnabled || mode == AppOpsManager.MODE_ALLOWED;
-
+                    serviceAllowed = appOpsAllowed;
-            if (admin != null) {
+                } catch (Exception e) {
-                preference.setDisabledByAdmin(admin);
+                    // Allow service in case if app ops is not available in testing.
-            } else if (!appOpsAllowed) {
+                    appOpsAllowed = true;
-                preference.setDisabledByAppOps(true);
+                }
             } else {
-                preference.setEnabled(false);
+                appOpsAllowed = false;
+            }
+            if (serviceAllowed || serviceEnabled) {
+                preference.setEnabled(true);
+            } else {
+                // Disable accessibility service that are not permitted.
+                final RestrictedLockUtils.EnforcedAdmin admin =
+                        RestrictedLockUtilsInternal.checkIfAccessibilityServiceDisallowed(
+                                mContext, preference.getPackageName(), UserHandle.myUserId());
+
+                if (admin != null) {
+                    preference.setDisabledByAdmin(admin);
+                } else if (!appOpsAllowed) {
+                    preference.setDisabledByAppOps(true);
+                } else {
+                    preference.setEnabled(false);
+                }
             }
         }
     }

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

@@ -174,7 +174,7 @@ public class UsageAccessDetails extends AppInfoWithHeader implements OnPreferenc
 
         if (shouldEnable && !hasAccess) {
             mSwitchPref.checkEcmRestrictionAndSetDisabled(AppOpsManager.OPSTR_GET_USAGE_STATS,
-                    mPackageName, mPackageInfo.applicationInfo.uid);
+                    mPackageName);
             shouldEnable = !mSwitchPref.isDisabledByEcm();
         }
 

src/com/android/settings/applications/appinfo/AppInfoDashboardFragment.java

@@ -24,6 +24,7 @@ import android.app.Activity;
 import android.app.AppOpsManager;
 import android.app.KeyguardManager;
 import android.app.admin.DevicePolicyManager;
+import android.app.ecm.EnhancedConfirmationManager;
 import android.app.settings.SettingsEnums;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -490,12 +491,23 @@ public class AppInfoDashboardFragment extends DashboardFragment
                 return true;
             case ACCESS_RESTRICTED_SETTINGS:
                 showLockScreen(getContext(), () -> {
-                    final AppOpsManager appOpsManager = getContext().getSystemService(
+                    if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
-                            AppOpsManager.class);
+                            && android.security.Flags.extendEcmToAllSettings()) {
-                    appOpsManager.setMode(AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
+                        EnhancedConfirmationManager manager = getContext().getSystemService(
-                            getUid(),
+                                EnhancedConfirmationManager.class);
-                            getPackageName(),
+                        try {
-                            AppOpsManager.MODE_ALLOWED);
+                            manager.clearRestriction(getPackageName());
+                        } catch (NameNotFoundException e) {
+                            Log.e(TAG, "Exception when retrieving package:" + getPackageName(), e);
+                        }
+                    } else {
+                        final AppOpsManager appOpsManager = getContext().getSystemService(
+                                AppOpsManager.class);
+                        appOpsManager.setMode(AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
+                                getUid(),
+                                getPackageName(),
+                                AppOpsManager.MODE_ALLOWED);
+                    }
                     getActivity().invalidateOptionsMenu();
                     final String toastString = getContext().getString(
                             R.string.toast_allows_restricted_settings_successfully,
@@ -527,14 +539,25 @@ public class AppInfoDashboardFragment extends DashboardFragment
     }
 
     private boolean shouldShowAccessRestrictedSettings() {
-        try {
+        if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
-            final int mode = getSystemService(AppOpsManager.class).noteOpNoThrow(
+                && android.security.Flags.extendEcmToAllSettings()) {
-                    AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS, getUid(),
+            try {
-                    getPackageName());
+                return getSystemService(EnhancedConfirmationManager.class)
-            return mode == AppOpsManager.MODE_IGNORED;
+                        .isClearRestrictionAllowed(getPackageName());
-        } catch (Exception e) {
+            } catch (NameNotFoundException e) {
-            // Fallback in case if app ops is not available in testing.
+                Log.e(TAG, "Exception when retrieving package:" + getPackageName(), e);
-            return false;
+                return false;
+            }
+        } else {
+            try {
+                final int mode = getSystemService(AppOpsManager.class).noteOpNoThrow(
+                        AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS, getUid(),
+                        getPackageName());
+                return mode == AppOpsManager.MODE_IGNORED;
+            } catch (Exception e) {
+                // Fallback in case if app ops is not available in testing.
+                return false;
+            }
         }
     }
 

src/com/android/settings/applications/specialaccess/deviceadmin/DeviceAdminListPreferenceController.java

@@ -210,7 +210,7 @@ public class DeviceAdminListPreferenceController extends BasePreferenceControlle
         pref.setOnPreferenceChangeListener((preference, newValue) -> false);
         pref.setSingleLineTitle(true);
         pref.checkEcmRestrictionAndSetDisabled(Manifest.permission.BIND_DEVICE_ADMIN,
-                item.getPackageName(), item.getUid());
+                item.getPackageName());
     }
 
     /**

src/com/android/settings/applications/specialaccess/notificationaccess/ApprovalPreferenceController.java

@@ -24,6 +24,7 @@ import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.os.AsyncTask;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceFragmentCompat;
@@ -42,7 +43,7 @@ public class ApprovalPreferenceController extends BasePreferenceController {
     private NotificationManager mNm;
     private PackageManager mPm;
     // The appOp representing this preference
-    private String mAppOpStr;
+    private String mSettingIdentifier;
 
     public ApprovalPreferenceController(Context context, String key) {
         super(context, key);
@@ -76,8 +77,9 @@ public class ApprovalPreferenceController extends BasePreferenceController {
     /**
      * Set the associated appOp for the Setting
      */
-    public ApprovalPreferenceController setAppOpStr(String appOpStr) {
+    @NonNull
-        mAppOpStr = appOpStr;
+    public ApprovalPreferenceController setSettingIdentifier(@NonNull String settingIdentifier) {
+        mSettingIdentifier = settingIdentifier;
         return this;
     }
 
@@ -118,14 +120,15 @@ public class ApprovalPreferenceController extends BasePreferenceController {
             }
         });
 
-        if (android.security.Flags.extendEcmToAllSettings()) {
+        if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
+                && android.security.Flags.extendEcmToAllSettings()) {
             if (!isAllowedCn && !isEnabled) {
                 preference.setEnabled(false);
             } else if (isEnabled) {
                 preference.setEnabled(true);
             } else {
-                preference.checkEcmRestrictionAndSetDisabled(mAppOpStr,
+                preference.checkEcmRestrictionAndSetDisabled(mSettingIdentifier,
-                        mCn.getPackageName(), mPkgInfo.applicationInfo.uid);
+                        mCn.getPackageName());
             }
         } else {
             preference.updateState(

src/com/android/settings/applications/specialaccess/notificationaccess/NotificationAccessDetails.java

@@ -103,7 +103,7 @@ public class NotificationAccessDetails extends DashboardFragment {
                 .setCn(mComponentName)
                 .setNm(context.getSystemService(NotificationManager.class))
                 .setPm(mPm)
-                .setAppOpStr(AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS)
+                .setSettingIdentifier(AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS)
                 .setParent(this);
         use(HeaderPreferenceController.class)
                 .setFragment(this)

src/com/android/settings/applications/specialaccess/premiumsms/PremiumSmsAccess.java

@@ -226,8 +226,7 @@ public class PremiumSmsAccess extends EmptyTextSettings
             });
             setValue(String.valueOf(getCurrentValue()));
             setSummary("%s");
-            this.checkEcmRestrictionAndSetDisabled(ECM_RESTRICTION_KEY, appEntry.info.packageName,
+            this.checkEcmRestrictionAndSetDisabled(ECM_RESTRICTION_KEY, appEntry.info.packageName);
-                    appEntry.info.uid);
         }
 
         private int getCurrentValue() {

src/com/android/settings/datausage/UnrestrictedDataAccessPreference.java

@@ -20,6 +20,7 @@ import android.graphics.drawable.Drawable;
 import android.os.UserHandle;
 import android.view.View;
 
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import androidx.preference.PreferenceViewHolder;
@@ -37,7 +38,7 @@ import com.android.settingslib.widget.AppSwitchPreference;
 
 public class UnrestrictedDataAccessPreference extends AppSwitchPreference implements
         DataSaverBackend.Listener {
-    private static final String ECM_RESTRICTION_KEY = "android:unrestricted_data_access";
+    private static final String ECM_SETTING_IDENTIFIER = "android:unrestricted_data_access";
 
     private final ApplicationsState mApplicationsState;
     private final AppEntry mEntry;
@@ -60,8 +61,7 @@ public class UnrestrictedDataAccessPreference extends AppSwitchPreference implem
         mParentFragment = parentFragment;
         setDisabledByAdmin(checkIfMeteredDataUsageUserControlDisabled(
                 context, entry.info.packageName, UserHandle.getUserId(entry.info.uid)));
-        mHelper.checkEcmRestrictionAndSetDisabled(ECM_RESTRICTION_KEY, entry.info.packageName,
+        mHelper.checkEcmRestrictionAndSetDisabled(ECM_SETTING_IDENTIFIER, entry.info.packageName);
-                entry.info.uid);
         updateState();
         setKey(generateKey(mEntry));
 
@@ -183,10 +183,9 @@ public class UnrestrictedDataAccessPreference extends AppSwitchPreference implem
      * Checks if the given setting is subject to Enhanced Confirmation Mode restrictions for this
      * package. Marks the preference as disabled if so.
      * @param packageName the package to check the restriction for
-     * @param uid the uid of the package
      */
-    public void checkEcmRestrictionAndSetDisabled(@Nullable String packageName, int uid) {
+    public void checkEcmRestrictionAndSetDisabled(@NonNull String packageName) {
-        mHelper.checkEcmRestrictionAndSetDisabled(ECM_RESTRICTION_KEY, packageName, uid);
+        mHelper.checkEcmRestrictionAndSetDisabled(ECM_SETTING_IDENTIFIER, packageName);
     }
 
     // Sets UI state based on allowlist/denylist status.

src/com/android/settings/datausage/UnrestrictedDataAccessPreferenceController.java

@@ -151,8 +151,7 @@ public class UnrestrictedDataAccessPreferenceController extends BasePreferenceCo
             } else {
                 preference.setDisabledByAdmin(checkIfMeteredDataUsageUserControlDisabled(mContext,
                         entry.info.packageName, UserHandle.getUserId(entry.info.uid)));
-                preference.checkEcmRestrictionAndSetDisabled(entry.info.packageName,
+                preference.checkEcmRestrictionAndSetDisabled(entry.info.packageName);
-                        entry.info.uid);
                 preference.updateState();
             }
             preference.setOrder(i);

src/com/android/settings/notification/zen/ZenAccessSettings.java

@@ -134,7 +134,7 @@ public class ZenAccessSettings extends EmptyTextSettings implements
                 // Not auto approved, update summary according to notification backend.
                 pref.setSummary(getPreferenceSummary(pkg));
                 pref.checkEcmRestrictionAndSetDisabled(
-                        android.Manifest.permission.MANAGE_NOTIFICATIONS, app.packageName, app.uid);
+                        android.Manifest.permission.MANAGE_NOTIFICATIONS, app.packageName);
             }
             pref.setOnPreferenceClickListener(preference -> {
                 AppInfoBase.startAppInfoFragment(

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

@@ -17,6 +17,7 @@
 package com.android.settings.spa.app.appinfo
 
 import android.app.AppOpsManager
+import android.app.ecm.EnhancedConfirmationManager
 import android.content.Context
 import android.content.pm.ApplicationInfo
 import android.os.UserManager
@@ -90,12 +91,18 @@ fun AppInfoSettingsMoreOptions(
 
 private fun ApplicationInfo.allowRestrictedSettings(context: Context, onSuccess: () -> Unit) {
     AppInfoDashboardFragment.showLockScreen(context) {
-        context.appOpsManager.setMode(
+        if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
-            AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
+                && android.security.Flags.extendEcmToAllSettings()) {
-            uid,
+            val manager = context.getSystemService(EnhancedConfirmationManager::class.java)!!
-            packageName,
+            manager.clearRestriction(packageName)
-            AppOpsManager.MODE_ALLOWED,
+        } else {
-        )
+            context.appOpsManager.setMode(
+                AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS,
+                uid,
+                packageName,
+                AppOpsManager.MODE_ALLOWED,
+            )
+        }
         onSuccess()
         val toastString = context.getString(
             R.string.toast_allows_restricted_settings_successfully,
@@ -137,7 +144,7 @@ private suspend fun ApplicationInfo.getMoreOptionsState(
         )
     }
     val shouldShowAccessRestrictedSettingsDeferred = async {
-        shouldShowAccessRestrictedSettings(context.appOpsManager)
+        shouldShowAccessRestrictedSettings(context)
     }
     val isProfileOrDeviceOwner =
         Utils.isProfileOrDeviceOwner(context.userManager, context.devicePolicyManager, packageName)
@@ -169,7 +176,14 @@ private fun ApplicationInfo.isOtherUserHasInstallPackage(
     .filter { it.id != userId }
     .any { packageManagers.isPackageInstalledAsUser(packageName, it.id) }
 
-private fun ApplicationInfo.shouldShowAccessRestrictedSettings(appOpsManager: AppOpsManager) =
+private fun ApplicationInfo.shouldShowAccessRestrictedSettings(context: Context): Boolean {
-    appOpsManager.noteOpNoThrow(
+    return if (android.permission.flags.Flags.enhancedConfirmationModeApisEnabled()
-        AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS, uid, packageName, null, null
+            && android.security.Flags.extendEcmToAllSettings()) {
-    ) == AppOpsManager.MODE_IGNORED
+        val manager = context.getSystemService(EnhancedConfirmationManager::class.java)!!
+        manager.isClearRestrictionAllowed(packageName)
+    } else {
+        context.appOpsManager.noteOpNoThrow(
+            AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS, uid, packageName, null, null
+        ) == AppOpsManager.MODE_IGNORED
+    }
+}

src/com/android/settings/utils/ManagedServiceSettings.java

@@ -153,8 +153,7 @@ public abstract class ManagedServiceSettings extends EmptyTextSettings {
             });
             pref.setKey(cn.flattenToString());
             if (!pref.isChecked()) {
-                pref.checkEcmRestrictionAndSetDisabled(mConfig.permission, service.packageName,
+                pref.checkEcmRestrictionAndSetDisabled(mConfig.permission, service.packageName);
-                        service.applicationInfo.uid);
             }
             screen.addPreference(pref);
         }

src/com/android/settings/widget/RestrictedAppPreference.java

@@ -21,6 +21,7 @@ import android.os.UserHandle;
 import android.text.TextUtils;
 import android.util.AttributeSet;
 
+import androidx.annotation.NonNull;
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceViewHolder;
 
@@ -128,11 +129,11 @@ public class RestrictedAppPreference extends AppPreference {
     /**
      * Checks if the given setting is subject to Enhanced Confirmation Mode restrictions for this
      * package. Marks the preference as disabled if so.
-     * @param restriction The key identifying the setting
+     * @param settingIdentifier The key identifying the setting
-     * @param packageName the package to check the restriction for
+     * @param packageName the package to check the settingIdentifier for
-     * @param uid the uid of the package
      */
-    public void checkEcmRestrictionAndSetDisabled(String restriction, String packageName, int uid) {
+    public void checkEcmRestrictionAndSetDisabled(@NonNull String settingIdentifier,
-        mHelper.checkEcmRestrictionAndSetDisabled(restriction, packageName, uid);
+                                                  @NonNull String packageName) {
+        mHelper.checkEcmRestrictionAndSetDisabled(settingIdentifier, packageName);
     }
 }

tests/robotests/src/com/android/settings/accessibility/AccessibilityDetailsSettingsFragmentTest.java

@@ -38,6 +38,7 @@ import androidx.test.core.app.ApplicationProvider;
 
 import com.android.settings.SettingsActivity;
 import com.android.settings.testutils.shadow.ShadowDevicePolicyManager;
+import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
 
 import com.google.common.collect.ImmutableList;
 
@@ -57,7 +58,10 @@ import java.util.ArrayList;
 import java.util.List;
 
 /** Tests for {@link AccessibilityDetailsSettingsFragment}. */
-@Config(shadows = ShadowDevicePolicyManager.class)
+@Config(shadows = {
+        ShadowDevicePolicyManager.class,
+        ShadowRestrictedLockUtilsInternal.class
+})
 @RunWith(RobolectricTestRunner.class)
 public class AccessibilityDetailsSettingsFragmentTest {
     private static final String PACKAGE_NAME = "com.foo.bar";

tests/robotests/src/com/android/settings/accessibility/AccessibilitySettingsTest.java

@@ -52,6 +52,7 @@ import com.android.settings.testutils.XmlTestUtils;
 import com.android.settings.testutils.shadow.ShadowApplicationPackageManager;
 import com.android.settings.testutils.shadow.ShadowBluetoothAdapter;
 import com.android.settings.testutils.shadow.ShadowBluetoothUtils;
+import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
 import com.android.settings.testutils.shadow.ShadowUserManager;
 import com.android.settingslib.RestrictedPreference;
 import com.android.settingslib.bluetooth.LocalBluetoothManager;
@@ -87,6 +88,7 @@ import java.util.List;
         ShadowUserManager.class,
         ShadowColorDisplayManager.class,
         ShadowApplicationPackageManager.class,
+        ShadowRestrictedLockUtilsInternal.class,
 })
 public class AccessibilitySettingsTest {
     private static final String PACKAGE_NAME = "com.android.test";

tests/robotests/src/com/android/settings/accessibility/RestrictedPreferenceHelperTest.java

@@ -31,8 +31,10 @@ import android.content.pm.ActivityInfo;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 import android.platform.test.flag.junit.SetFlagsRule;
-import android.security.Flags;
 
 import androidx.test.core.app.ApplicationProvider;
 
@@ -81,6 +83,8 @@ public class RestrictedPreferenceHelperTest {
 
     @Rule
     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
 
     @Test
     public void createAccessibilityServicePreferenceList_hasOneInfo_containsSameKey() {
@@ -96,8 +100,9 @@ public class RestrictedPreferenceHelperTest {
     }
 
     @Test
+    @RequiresFlagsEnabled(value = {android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS,
+            android.permission.flags.Flags.FLAG_ENHANCED_CONFIRMATION_MODE_APIS_ENABLED})
     public void createAccessibilityServicePreferenceList_ecmRestricted_prefIsEcmRestricted() {
-        mSetFlagsRule.enableFlags(Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS);
         ShadowRestrictedLockUtilsInternal.setEcmRestrictedPkgs(
                 mServiceInfo.getResolveInfo().serviceInfo.packageName);
         final List<AccessibilityServiceInfo> infoList = new ArrayList<>(
@@ -111,8 +116,9 @@ public class RestrictedPreferenceHelperTest {
     }
 
     @Test
+    @RequiresFlagsEnabled(value = {android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS,
+            android.permission.flags.Flags.FLAG_ENHANCED_CONFIRMATION_MODE_APIS_ENABLED})
     public void createAccessibilityServicePreferenceList_ecmNotRestricted_prefIsNotEcmRestricted() {
-        mSetFlagsRule.enableFlags(Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS);
         ShadowRestrictedLockUtilsInternal.setEcmRestrictedPkgs();
         final List<AccessibilityServiceInfo> infoList = new ArrayList<>(
                 singletonList(mServiceInfo));

tests/robotests/src/com/android/settings/applications/specialaccess/premiumsms/PremiumSmsAccessTest.java

@@ -124,8 +124,6 @@ public class PremiumSmsAccessTest {
 
         doAnswer((invocation) -> {
             final RestrictedDropDownPreference preference = invocation.getArgument(0);
-            final ApplicationsState.AppEntry entry = ReflectionHelpers
-                    .getField(preference, "mAppEntry");
             // Verify preference is disabled by ecm and the summary is changed accordingly.
             assertThat(preference.isDisabledByEcm()).isTrue();
             assertThat(preference.getSummary().toString()).isEqualTo(
@@ -156,13 +154,11 @@ public class PremiumSmsAccessTest {
         doReturn(preferenceManager).when(mFragment).getPreferenceManager();
         doReturn(preferenceScreen).when(mFragment).getPreferenceScreen();
         final String testPkg = "com.example.enabled";
-        doNothing().when(mContext).startActivity(any());
         ShadowRestrictedLockUtilsInternal.setEcmRestrictedPkgs();
 
+
         doAnswer((invocation) -> {
             final RestrictedDropDownPreference preference = invocation.getArgument(0);
-            final ApplicationsState.AppEntry entry = ReflectionHelpers
-                    .getField(preference, "mAppEntry");
             assertThat(preference.isDisabledByEcm()).isFalse();
             assertThat(preference.getSummary().toString()).isEqualTo("");
             preference.onBindViewHolder(holder);
@@ -195,4 +191,3 @@ public class PremiumSmsAccessTest {
         return appEntries;
     }
 }
-

tests/robotests/src/com/android/settings/datausage/UnrestrictedDataAccessPreferenceControllerTest.java

@@ -167,11 +167,11 @@ public class UnrestrictedDataAccessPreferenceControllerTest {
     @Test
     public void onRebuildComplete_ecmRestricted_shouldBeDisabled() {
         mFragment = spy(new UnrestrictedDataAccess());
+        mContext = spy(mContext);
         doNothing().when(mFragment).setLoading(anyBoolean(), anyBoolean());
         mController.setParentFragment(mFragment);
-        final Context context = spy(mContext);
+        mPreferenceManager = new PreferenceManager(mContext);
-        mPreferenceManager = new PreferenceManager(context);
+        mPreferenceScreen = spy(mPreferenceManager.createPreferenceScreen(mContext));
-        mPreferenceScreen = spy(mPreferenceManager.createPreferenceScreen(context));
         doReturn(mPreferenceManager).when(mFragment).getPreferenceManager();
         doReturn(mPreferenceScreen).when(mFragment).getPreferenceScreen();
         doReturn(0).when(mPreferenceScreen).getPreferenceCount();
@@ -180,12 +180,11 @@ public class UnrestrictedDataAccessPreferenceControllerTest {
         ReflectionHelpers.setField(mController, "mScreen", mPreferenceScreen);
 
         final String testPkg = "com.example.disabled";
-        doNothing().when(context).startActivity(any());
+        doNothing().when(mContext).startActivity(any());
         ShadowRestrictedLockUtilsInternal.setEcmRestrictedPkgs(testPkg);
 
         doAnswer((invocation) -> {
             final UnrestrictedDataAccessPreference preference = invocation.getArgument(0);
-            final AppEntry entry = preference.getEntry();
             // Verify preference is disabled by ecm and the summary is changed accordingly.
             assertThat(preference.isDisabledByEcm()).isTrue();
             assertThat(preference.getSummary().toString()).isEqualTo(
@@ -195,7 +194,7 @@ public class UnrestrictedDataAccessPreferenceControllerTest {
             preference.performClick();
             // Verify that when the preference is clicked, ecm details intent is launched
             assertThat(preference.isChecked()).isFalse();
-            verify(context).startActivity(any());
+            verify(mContext).startActivity(any());
 
             return null;
         }).when(mPreferenceScreen).addPreference(any(UnrestrictedDataAccessPreference.class));
@@ -207,11 +206,11 @@ public class UnrestrictedDataAccessPreferenceControllerTest {
     @Test
     public void onRebuildComplete_ecmNotRestricted_notDisabled() {
         mFragment = spy(new UnrestrictedDataAccess());
+        mContext = spy(mContext);
         doNothing().when(mFragment).setLoading(anyBoolean(), anyBoolean());
         mController.setParentFragment(mFragment);
-        final Context context = spy(mContext);
+        mPreferenceManager = new PreferenceManager(mContext);
-        mPreferenceManager = new PreferenceManager(context);
+        mPreferenceScreen = spy(mPreferenceManager.createPreferenceScreen(mContext));
-        mPreferenceScreen = spy(mPreferenceManager.createPreferenceScreen(context));
         doReturn(mPreferenceManager).when(mFragment).getPreferenceManager();
         doReturn(mPreferenceScreen).when(mFragment).getPreferenceScreen();
         doReturn(0).when(mPreferenceScreen).getPreferenceCount();
@@ -220,19 +219,18 @@ public class UnrestrictedDataAccessPreferenceControllerTest {
         ReflectionHelpers.setField(mController, "mScreen", mPreferenceScreen);
 
         final String testPkg = "com.example.enabled";
-        doNothing().when(context).startActivity(any());
+        doNothing().when(mContext).startActivity(any());
         ShadowRestrictedLockUtilsInternal.setEcmRestrictedPkgs();
 
         doAnswer((invocation) -> {
             final UnrestrictedDataAccessPreference preference = invocation.getArgument(0);
-            final AppEntry entry = preference.getEntry();
             assertThat(preference.isDisabledByEcm()).isFalse();
             assertThat(preference.getSummary()).isEqualTo("");
             assertThat(preference.isChecked()).isFalse();
             preference.performClick();
             // Verify that when the preference is clicked, ecm details intent is not launched
             assertThat(preference.isChecked()).isTrue();
-            verify(context, never()).startActivity(any());
+            verify(mContext, never()).startActivity(any());
 
             return null;
         }).when(mPreferenceScreen).addPreference(any(UnrestrictedDataAccessPreference.class));

tests/robotests/src/com/android/settings/testutils/shadow/ShadowRestrictedLockUtilsInternal.java

@@ -16,7 +16,6 @@
 package com.android.settings.testutils.shadow;
 
 import android.annotation.NonNull;
-import android.annotation.Nullable;
 import android.annotation.UserIdInt;
 import android.app.admin.DevicePolicyManager;
 import android.content.Context;
@@ -122,9 +121,7 @@ public class ShadowRestrictedLockUtilsInternal {
 
     @Implementation
     public static Intent checkIfRequiresEnhancedConfirmation(@NonNull Context context,
-            @NonNull String restriction,
+            @NonNull String settingIdentifier, @NonNull String packageName) {
-            int uid,
-            @Nullable String packageName) {
         if (ArrayUtils.contains(sEcmRestrictedPkgs, packageName)) {
             return new Intent();
         }
@@ -132,6 +129,12 @@ public class ShadowRestrictedLockUtilsInternal {
         return null;
     }
 
+    @Implementation
+    public static boolean isEnhancedConfirmationRestricted(@NonNull Context context,
+            @NonNull String settingIdentifier, @NonNull String packageName) {
+        return false;
+    }
+
     public static void setRestricted(boolean restricted) {
         sIsRestricted = restricted;
     }

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

@@ -19,11 +19,16 @@ package com.android.settings.spa.app.appinfo
 import android.app.AppOpsManager
 import android.app.KeyguardManager
 import android.app.admin.DevicePolicyManager
+import android.app.ecm.EnhancedConfirmationManager
 import android.content.Context
 import android.content.pm.ApplicationInfo
 import android.content.pm.PackageManager
 import android.content.pm.UserInfo
 import android.os.UserManager
+import android.platform.test.annotations.RequiresFlagsDisabled
+import android.platform.test.annotations.RequiresFlagsEnabled
+import android.platform.test.flag.junit.CheckFlagsRule
+import android.platform.test.flag.junit.DeviceFlagsValueProvider
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.test.assertIsNotDisplayed
@@ -61,6 +66,9 @@ class AppInfoSettingsMoreOptionsTest {
     @get:Rule
     val composeTestRule = createComposeRule()
 
+    @get:Rule
+    val checkFlagsRule: CheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
     private lateinit var mockSession: MockitoSession
 
     @Spy
@@ -81,6 +89,9 @@ class AppInfoSettingsMoreOptionsTest {
     @Mock
     private lateinit var appOpsManager: AppOpsManager
 
+    @Mock
+    private lateinit var enhancedConfirmationManager: EnhancedConfirmationManager
+
     @Mock
     private lateinit var keyguardManager: KeyguardManager
 
@@ -103,6 +114,8 @@ class AppInfoSettingsMoreOptionsTest {
         whenever(context.devicePolicyManager).thenReturn(devicePolicyManager)
         whenever(context.appOpsManager).thenReturn(appOpsManager)
         whenever(context.getSystemService(KeyguardManager::class.java)).thenReturn(keyguardManager)
+        whenever(context.getSystemService(EnhancedConfirmationManager::class.java))
+                .thenReturn(enhancedConfirmationManager)
         whenever(keyguardManager.isKeyguardSecure).thenReturn(false)
         whenever(Utils.isProfileOrDeviceOwner(userManager, devicePolicyManager, PACKAGE_NAME))
             .thenReturn(false)
@@ -158,7 +171,9 @@ class AppInfoSettingsMoreOptionsTest {
     }
 
     @Test
-    fun shouldShowAccessRestrictedSettings() {
+    @RequiresFlagsDisabled(android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS,
+        android.permission.flags.Flags.FLAG_ENHANCED_CONFIRMATION_MODE_APIS_ENABLED)
+    fun shouldShowAccessRestrictedSettings_appOp() {
         whenever(
             appOpsManager.noteOpNoThrow(
                 AppOpsManager.OP_ACCESS_RESTRICTED_SETTINGS, UID, PACKAGE_NAME, null, null
@@ -186,6 +201,31 @@ class AppInfoSettingsMoreOptionsTest {
         )
     }
 
+    @Test
+    @RequiresFlagsEnabled(android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS,
+        android.permission.flags.Flags.FLAG_ENHANCED_CONFIRMATION_MODE_APIS_ENABLED)
+    fun shouldShowAccessRestrictedSettings() {
+        whenever(
+            enhancedConfirmationManager.isClearRestrictionAllowed(PACKAGE_NAME)
+        ).thenReturn(true)
+        val app = ApplicationInfo().apply {
+            packageName = PACKAGE_NAME
+            uid = UID
+        }
+
+        setContent(app)
+        composeTestRule.onRoot().performClick()
+
+        composeTestRule.waitUntilExists(
+            hasText(context.getString(R.string.app_restricted_settings_lockscreen_title))
+        )
+        composeTestRule
+            .onNodeWithText(context
+                .getString(R.string.app_restricted_settings_lockscreen_title))
+            .performClick()
+        verify(enhancedConfirmationManager).clearRestriction(PACKAGE_NAME)
+    }
+
     private fun setContent(app: ApplicationInfo) {
         composeTestRule.setContent {
             CompositionLocalProvider(LocalContext provides context) {

tests/unit/src/com/android/settings/applications/specialaccess/notificationaccess/ApprovalPreferenceControllerTest.java

@@ -21,7 +21,6 @@ import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
@@ -37,6 +36,9 @@ import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.platform.test.annotations.EnableFlags;
+import android.platform.test.annotations.RequiresFlagsDisabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 import android.platform.test.flag.junit.SetFlagsRule;
 
 import androidx.test.core.app.ApplicationProvider;
@@ -46,6 +48,7 @@ import com.android.internal.logging.nano.MetricsProto;
 import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settingslib.RestrictedSwitchPreference;
 
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -59,6 +62,8 @@ public class ApprovalPreferenceControllerTest {
     @Rule
     public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(
             SetFlagsRule.DefaultInitValueType.DEVICE_DEFAULT);
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
 
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
@@ -123,6 +128,7 @@ public class ApprovalPreferenceControllerTest {
     }
 
     @Test
+    @RequiresFlagsDisabled(android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS)
     public void updateState_checked() {
         when(mAppOpsManager.noteOpNoThrow(anyInt(), anyInt(), anyString())).thenReturn(
                 AppOpsManager.MODE_ALLOWED);
@@ -137,24 +143,26 @@ public class ApprovalPreferenceControllerTest {
     }
 
     @Test
+    @RequiresFlagsDisabled(android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS)
     public void restrictedSettings_appOpsDisabled() {
-        when(mAppOpsManager.noteOpNoThrow(anyInt(), anyInt(), anyString(), isNull(), isNull()))
+        Assert.assertFalse(android.security.Flags.extendEcmToAllSettings());
+        when(mAppOpsManager.noteOpNoThrow(anyInt(), anyInt(), anyString()))
                 .thenReturn(AppOpsManager.MODE_ERRORED);
         doReturn(mAppOpsManager).when(mContext).getSystemService(Context.APP_OPS_SERVICE);
         when(mNm.isNotificationListenerAccessGranted(mCn)).thenReturn(false);
         RestrictedSwitchPreference pref = new RestrictedSwitchPreference(
                 mContext);
         pref.setAppOps(mAppOpsManager);
-        mController.setAppOpStr(AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS);
+        mController.setSettingIdentifier(AppOpsManager.OPSTR_ACCESS_NOTIFICATIONS);
 
         mController.updateState(pref);
 
-        verify(mContext).getSystemService(Context.APP_OPS_SERVICE);
+        verify(mAppOpsManager).noteOpNoThrow(anyInt(), anyInt(), anyString());
-        verify(mAppOpsManager).noteOpNoThrow(anyInt(), anyInt(), anyString(), isNull(), isNull());
         assertThat(pref.isEnabled()).isFalse();
     }
 
     @Test
+    @RequiresFlagsDisabled(android.security.Flags.FLAG_EXTEND_ECM_TO_ALL_SETTINGS)
     public void restrictedSettings_serviceAlreadyEnabled() {
         when(mAppOpsManager.noteOpNoThrow(anyInt(), anyInt(), anyString())).thenReturn(
                 AppOpsManager.MODE_ERRORED);