Finish removing N/A DO disclosures from search index

DO disclosures referring to actions that the admin did not actually
take are hidden in the UI, but still show up in the search index. This
CL switches the remaining PreferenceControllers from setting visibility
to implementing isAvailable() instead.

Bug: 32692748
Test: m RunSettingsRoboTests

Change-Id: I54360698f28b549b18cdc230e3b9087cf4e9ff4a

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

@@ -54,9 +54,10 @@ public interface ApplicationFeatureProvider {
      *
      * @param permissions Only consider apps that have been granted one or more of these permissions
      *        by the admin, either at run-time or install-time
+     * @param async Whether to count asynchronously in a background thread
      * @param callback The callback to invoke with the result
      */
-    void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
+    void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions, boolean async,
             NumberOfAppsCallback callback);
 
     /**

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

@@ -69,9 +69,15 @@ public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvide
 
     @Override
     public void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions,
-            NumberOfAppsCallback callback) {
+            boolean async, NumberOfAppsCallback callback) {
-        new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms, mDpm,
+        final AllUserAppWithAdminGrantedPermissionsCounter counter =
-                callback).execute();
+                new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms,
+                        mDpm, callback);
+        if (async) {
+            counter.execute();
+        } else {
+            counter.executeInForeground();
+        }
     }
 
     @Override

src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java

@@ -17,14 +17,18 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedCameraPermissionPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_CAMERA_ACCESS_PACKAGES
             = "enterprise_privacy_number_camera_access_packages";
 
-    public AdminGrantedCameraPermissionPreferenceController(Context context) {
+    public AdminGrantedCameraPermissionPreferenceController(Context context, Lifecycle lifecycle,
-        super(context, new String[] {Manifest.permission.CAMERA}, Manifest.permission_group.CAMERA);
+            boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.CAMERA},
+                Manifest.permission_group.CAMERA);
     }
 
     @Override

src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java

@@ -17,14 +17,17 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedLocationPermissionsPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_LOCATION_ACCESS_PACKAGES
             = "enterprise_privacy_number_location_access_packages";
 
-    public AdminGrantedLocationPermissionsPreferenceController(Context context) {
+    public AdminGrantedLocationPermissionsPreferenceController(Context context, Lifecycle lifecycle,
-        super(context, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
+            boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
                 Manifest.permission.ACCESS_FINE_LOCATION}, Manifest.permission_group.LOCATION);
     }
 

src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java

@@ -17,14 +17,17 @@ package com.android.settings.enterprise;
 import android.Manifest;
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class AdminGrantedMicrophonePermissionPreferenceController extends
         AdminGrantedPermissionsPreferenceControllerBase {
 
     private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_MICROPHONE_ACCESS_PACKAGES
             = "enterprise_privacy_number_microphone_access_packages";
 
-    public AdminGrantedMicrophonePermissionPreferenceController(Context context) {
+    public AdminGrantedMicrophonePermissionPreferenceController(Context context,
-        super(context, new String[] {Manifest.permission.RECORD_AUDIO},
+            Lifecycle lifecycle, boolean async) {
+        super(context, lifecycle, async, new String[] {Manifest.permission.RECORD_AUDIO},
                 Manifest.permission_group.MICROPHONE);
     }
 

src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java

@@ -1,3 +1,4 @@
+
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -20,28 +21,32 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
 import com.android.settings.applications.ApplicationFeatureProvider;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public abstract class AdminGrantedPermissionsPreferenceControllerBase extends PreferenceController {
+public abstract class AdminGrantedPermissionsPreferenceControllerBase
+        extends DynamicAvailabilityPreferenceController {
 
     private final String[] mPermissions;
     private final String mPermissionGroup;
     private final ApplicationFeatureProvider mFeatureProvider;
+    private final boolean mAsync;
 
-    public AdminGrantedPermissionsPreferenceControllerBase(Context context,
+    public AdminGrantedPermissionsPreferenceControllerBase(Context context, Lifecycle lifecycle,
-                                                           String[] permissions,
+            boolean async, String[] permissions, String permissionGroup) {
-                                                           String permissionGroup) {
+        super(context, lifecycle);
-        super(context);
         mPermissions = permissions;
         mPermissionGroup = permissionGroup;
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getApplicationFeatureProvider(context);
+        mAsync = async;
     }
 
     @Override
     public void updateState(Preference preference) {
         mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
+                true /* async */,
                 (num) -> {
                     if (num == 0) {
                         preference.setVisible(false);
@@ -55,9 +60,24 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase extends Pr
 
     @Override
     public boolean isAvailable() {
+        if (mAsync) {
+            // When called on the main UI thread, we must not block. Since calculating the number of
+            // apps that the admin has granted a given permissions takes a bit of time, we always
+            // return true here and determine the pref's actual visibility asynchronously in
+            // updateState().
             return true;
         }
 
+        // When called by the search indexer, we are on a background thread that we can block. Also,
+        // changes to the pref's visibility made in updateState() would not be seen by the indexer.
+        // We block and return synchronously whether the admin has granted the given permissions to
+        // any apps or not.
+        final Boolean[] haveAppsWithAdminGrantedPermissions = { null };
+        mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
+                false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0);
+        return haveAppsWithAdminGrantedPermissions[0];
+    }
+
     @Override
     public boolean handlePreferenceTreeClick(Preference preference) {
         if (!getPreferenceKey().equals(preference.getKey())) {

src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java

@@ -14,30 +14,26 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
-import android.support.v7.preference.Preference;
 
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class AlwaysOnVpnManagedProfilePreferenceController extends PreferenceController {
+public class AlwaysOnVpnManagedProfilePreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public AlwaysOnVpnManagedProfilePreferenceController(Context context) {
+    public AlwaysOnVpnManagedProfilePreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
-    @Override
-    public void updateState(Preference preference) {
-        preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInManagedProfile());
-    }
-
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
     }
 
     @Override

src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java

@@ -17,16 +17,18 @@ import android.content.Context;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceController {
+public class AlwaysOnVpnPrimaryUserPreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public AlwaysOnVpnPrimaryUserPreferenceController(Context context) {
+    public AlwaysOnVpnPrimaryUserPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
@@ -36,12 +38,11 @@ public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceContro
         preference.setTitle(mFeatureProvider.isInCompMode()
                 ? R.string.enterprise_privacy_always_on_vpn_personal
                 : R.string.enterprise_privacy_always_on_vpn_device);
-        preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser());
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser();
     }
 
     @Override

src/com/android/settings/enterprise/CaCertsPreferenceController.java

@@ -19,16 +19,17 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class CaCertsPreferenceController extends PreferenceController {
+public class CaCertsPreferenceController extends DynamicAvailabilityPreferenceController {
 
     private static final String CA_CERTS = "ca_certs";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public CaCertsPreferenceController(Context context) {
+    public CaCertsPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
@@ -37,18 +38,14 @@ public class CaCertsPreferenceController extends PreferenceController {
     public void updateState(Preference preference) {
         final int certs =
                 mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile();
-        if (certs == 0) {
-            preference.setVisible(false);
-            return;
-        }
         preference.setSummary(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_ca_certs, certs, certs));
-        preference.setVisible(true);
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()
+                > 0;
     }
 
     @Override

src/com/android/settings/enterprise/EnterprisePrivacySettings.java

@@ -64,17 +64,21 @@ public class EnterprisePrivacySettings extends DashboardFragment {
         controllers.add(new SecurityLogsPreferenceController(context));
         controllers.add(new EnterpriseInstalledPackagesPreferenceController(context, lifecycle,
                 async));
-        controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context));
+        controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle,
-        controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context));
+                async));
-        controllers.add(new AdminGrantedCameraPermissionPreferenceController(context));
+        controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle,
+                async));
+        controllers.add(new AdminGrantedCameraPermissionPreferenceController(context, lifecycle,
+                async));
         controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context, lifecycle));
-        controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context));
+        controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context, lifecycle));
-        controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context));
+        controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context, lifecycle));
-        controllers.add(new GlobalHttpProxyPreferenceController(context));
+        controllers.add(new GlobalHttpProxyPreferenceController(context, lifecycle));
-        controllers.add(new CaCertsPreferenceController(context));
+        controllers.add(new CaCertsPreferenceController(context, lifecycle));
-        controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context));
+        controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context, lifecycle));
-        controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context));
+        controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context,
-        controllers.add(new ImePreferenceController(context));
+                lifecycle));
+        controllers.add(new ImePreferenceController(context, lifecycle));
         return controllers;
     }
 

src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java

@@ -14,6 +14,7 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
+import com.android.settings.core.lifecycle.Lifecycle;
 
 public class FailedPasswordWipeManagedProfilePreferenceController
         extends FailedPasswordWipePreferenceControllerBase {
@@ -21,8 +22,9 @@ public class FailedPasswordWipeManagedProfilePreferenceController
     private static final String KEY_FAILED_PASSWORD_WIPE_MANAGED_PROFILE
             = "failed_password_wipe_managed_profile";
 
-    public FailedPasswordWipeManagedProfilePreferenceController(Context context) {
+    public FailedPasswordWipeManagedProfilePreferenceController(Context context,
-        super(context);
+            Lifecycle lifecycle) {
+        super(context, lifecycle);
     }
 
     @Override

src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java

@@ -19,15 +19,17 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public abstract class FailedPasswordWipePreferenceControllerBase extends PreferenceController {
+public abstract class FailedPasswordWipePreferenceControllerBase
+        extends DynamicAvailabilityPreferenceController {
 
     protected final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public FailedPasswordWipePreferenceControllerBase(Context context) {
+    public FailedPasswordWipePreferenceControllerBase(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
@@ -37,18 +39,13 @@ public abstract class FailedPasswordWipePreferenceControllerBase extends Prefere
     @Override
     public void updateState(Preference preference) {
         final int failedPasswordsBeforeWipe = getMaximumFailedPasswordsBeforeWipe();
-        if (failedPasswordsBeforeWipe == 0) {
-            preference.setVisible(false);
-        } else {
-            preference.setVisible(true);
         preference.setSummary(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_failed_password_wipe,
                 failedPasswordsBeforeWipe, failedPasswordsBeforeWipe));
     }
-    }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return getMaximumFailedPasswordsBeforeWipe() > 0;
     }
 }

src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java

@@ -15,14 +15,16 @@ package com.android.settings.enterprise;
 
 import android.content.Context;
 
+import com.android.settings.core.lifecycle.Lifecycle;
+
 public class FailedPasswordWipePrimaryUserPreferenceController
         extends FailedPasswordWipePreferenceControllerBase {
 
     private static final String KEY_FAILED_PASSWORD_WIPE_PRIMARY_USER
             = "failed_password_wipe_primary_user";
 
-    public FailedPasswordWipePrimaryUserPreferenceController(Context context) {
+    public FailedPasswordWipePrimaryUserPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
     }
 
     @Override

src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java

@@ -14,30 +14,25 @@
 package com.android.settings.enterprise;
 
 import android.content.Context;
-import android.support.v7.preference.Preference;
 
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class GlobalHttpProxyPreferenceController extends PreferenceController {
+public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public GlobalHttpProxyPreferenceController(Context context) {
+    public GlobalHttpProxyPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
-    @Override
-    public void updateState(Preference preference) {
-        preference.setVisible(mFeatureProvider.isGlobalHttpProxySet());
-    }
-
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.isGlobalHttpProxySet();
     }
 
     @Override

src/com/android/settings/enterprise/ImePreferenceController.java

@@ -19,35 +19,31 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
-import com.android.settings.core.PreferenceController;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.overlay.FeatureFactory;
 
-public class ImePreferenceController extends PreferenceController {
+public class ImePreferenceController extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_INPUT_METHOD = "input_method";
     private final EnterprisePrivacyFeatureProvider mFeatureProvider;
 
-    public ImePreferenceController(Context context) {
+    public ImePreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getEnterprisePrivacyFeatureProvider(context);
     }
 
     @Override
     public void updateState(Preference preference) {
-        final String ownerSetIme = mFeatureProvider.getImeLabelIfOwnerSet();
-        if (ownerSetIme == null) {
-            preference.setVisible(false);
-            return;
-        }
         preference.setSummary(mContext.getResources().getString(
-            R.string.enterprise_privacy_input_method_name, ownerSetIme));
+            R.string.enterprise_privacy_input_method_name,
-        preference.setVisible(true);
+            mFeatureProvider.getImeLabelIfOwnerSet()));
     }
 
     @Override
     public boolean isAvailable() {
-        return true;
+        return mFeatureProvider.getImeLabelIfOwnerSet() != null;
     }
 
     @Override

tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java

@@ -89,8 +89,7 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
         MockitoAnnotations.initMocks(this);
     }
 
-    @Test
+    private void verifyCountInstalledAppsAcrossAllUsers(boolean async) throws Exception {
-    public void testCountInstalledAppsAcrossAllUsers() throws Exception {
         // There are two users.
         mUsersToCount = Arrays.asList(
                 new UserInfo(MAIN_USER_ID, "main", UserInfo.FLAG_ADMIN),
@@ -181,10 +180,14 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
                 .thenReturn(PackageManager.INSTALL_REASON_UNKNOWN);
 
         // Count the number of all apps installed that were granted on or more permissions by the
-        // admin.  Wait for the background task to finish.
+        // admin.
+        if (async) {
             (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).execute();
+            // Wait for the background task to finish.
             ShadowApplication.runBackgroundTasks();
-
+        } else {
+            (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).executeInForeground();
+        }
         assertThat(mAppCount).isEqualTo(3);
 
         // Verify that installed packages were retrieved for the users returned by
@@ -194,7 +197,16 @@ public final class AppWithAdminGrantedPermissionsCounterTest {
                 eq(MANAGED_PROFILE_ID));
         verify(mPackageManager, atLeast(0)).getInstallReason(anyObject(), anyObject());
         verifyNoMoreInteractions(mPackageManager);
+    }
 
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersSync() throws Exception {
+        verifyCountInstalledAppsAcrossAllUsers(false /* async */);
+    }
+
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersAync() throws Exception {
+        verifyCountInstalledAppsAcrossAllUsers(true /* async */);
     }
 
     private class AppWithAdminGrantedPermissionsCounterTestable extends

tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java

@@ -88,7 +88,7 @@ public final class ApplicationFeatureProviderImplTest {
                 mPackageManagerService, mDevicePolicyManager);
     }
 
-    private void testCalculateNumberOfInstalledApps(boolean async) {
+    private void verifyCalculateNumberOfInstalledApps(boolean async) {
         setUpUsersAndInstalledApps();
 
         when(mPackageManager.getInstallReason(APP_1, new UserHandle(MAIN_USER_ID)))
@@ -117,16 +117,16 @@ public final class ApplicationFeatureProviderImplTest {
 
     @Test
     public void testCalculateNumberOfInstalledAppsSync() {
-        testCalculateNumberOfInstalledApps(false /* async */);
+        verifyCalculateNumberOfInstalledApps(false /* async */);
     }
 
     @Test
     public void testCalculateNumberOfInstalledAppsAsync() {
-        testCalculateNumberOfInstalledApps(true /* async */);
+        verifyCalculateNumberOfInstalledApps(true /* async */);
     }
 
-    @Test
+    private void verifyCalculateNumberOfAppsWithAdminGrantedPermissions(boolean async)
-    public void testCalculateNumberOfAppsWithAdminGrantedPermissions() throws Exception {
+            throws Exception {
         setUpUsersAndInstalledApps();
 
         when(mDevicePolicyManager.getPermissionGrantState(null, APP_1, PERMISSION))
@@ -143,15 +143,25 @@ public final class ApplicationFeatureProviderImplTest {
                 .thenReturn(PackageManager.INSTALL_REASON_POLICY);
 
         mAppCount = -1;
-        mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION},
+        mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION}, async,
-                (num) -> {
+                (num) -> mAppCount = num);
-                    mAppCount = num;
+        if (async) {
-                });
             ShadowApplication.runBackgroundTasks();
+        }
         assertThat(mAppCount).isEqualTo(2);
 
     }
 
+    @Test
+    public void testCalculateNumberOfAppsWithAdminGrantedPermissionsSync() throws Exception {
+        verifyCalculateNumberOfAppsWithAdminGrantedPermissions(false /* async */);
+    }
+
+    @Test
+    public void testCalculateNumberOfAppsWithAdminGrantedPermissionsAsync() throws Exception {
+        verifyCalculateNumberOfAppsWithAdminGrantedPermissions(true /* async */);
+    }
+
     @Test
     public void testFindPersistentPreferredActivities() throws Exception {
         when(mUserManager.getUserProfiles()).thenReturn(Arrays.asList(new UserHandle(MAIN_USER_ID),

tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java

@@ -39,8 +39,8 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */,
-        mController = new AdminGrantedCameraPermissionPreferenceController(mContext);
+                async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java

@@ -40,8 +40,8 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedLocationPermissionsPreferenceController(mContext,
-        mController = new AdminGrantedLocationPermissionsPreferenceController(mContext);
+                null /* lifecycle */, async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java

@@ -39,8 +39,8 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedMicrophonePermissionPreferenceController(mContext,
-        mController = new AdminGrantedMicrophonePermissionPreferenceController(mContext);
+                null /* lifecycle */, async);
     }
 }

tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java

@@ -40,17 +40,16 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
     }
 
     @Override
-    public void setUp() {
+    protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
-        super.setUp();
+        return new AdminGrantedPermissionsPreferenceControllerBaseTestable(async);
-        mController = new AdminGrantedPermissionsPreferenceControllerBaseTestable();
     }
 
     private class AdminGrantedPermissionsPreferenceControllerBaseTestable extends
             AdminGrantedPermissionsPreferenceControllerBase {
 
-        AdminGrantedPermissionsPreferenceControllerBaseTestable() {
+        AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) {
-            super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext, mPermissions,
+            super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext,
-                    mPermissionGroup);
+                    null /* lifecycle */, async, mPermissions, mPermissionGroup);
         }
 
         @Override

tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java

@@ -68,39 +68,56 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
+        mController = createController(true /* async */);
     }
 
-    private void setNumberOfPackagesWithAdminGrantedPermissions(int number) {
+    private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) {
         doAnswer(new Answer() {
             public Object answer(InvocationOnMock invocation) {
                 ((ApplicationFeatureProvider.NumberOfAppsCallback)
-                        invocation.getArguments()[1]).onNumberOfAppsResult(number);
+                        invocation.getArguments()[2]).onNumberOfAppsResult(number);
                 return null;
             }}).when(mFeatureFactory.applicationFeatureProvider)
                     .calculateNumberOfAppsWithAdminGrantedPermissions(eq(mPermissions),
-                            anyObject());
+                            eq(async), anyObject());
     }
 
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(false);
+        preference.setVisible(true);
 
-        setNumberOfPackagesWithAdminGrantedPermissions(20);
+        setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
+        mController.updateState(preference);
+        assertThat(preference.isVisible()).isFalse();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         when(mContext.getResources().getQuantityString(
                 R.plurals.enterprise_privacy_number_packages_actionable,20, 20))
                 .thenReturn("20 packages");
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("20 packages");
         assertThat(preference.isVisible()).isTrue();
-
-        setNumberOfPackagesWithAdminGrantedPermissions(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
     }
 
     @Test
-    public void testIsAvailable() {
+    public void testIsAvailableSync() {
+        final AdminGrantedPermissionsPreferenceControllerBase controller
+                = createController(false /* async */);
+
+        setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */);
+        assertThat(controller.isAvailable()).isFalse();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */);
+        assertThat(controller.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailableAsync() {
+        setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
+        assertThat(mController.isAvailable()).isTrue();
+
+        setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
     }
 
@@ -125,4 +142,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
     public void testGetPreferenceKey() {
         assertThat(mController.getPreferenceKey()).isEqualTo(mKey);
     }
+
+    protected abstract AdminGrantedPermissionsPreferenceControllerBase createController(
+            boolean async);
 }

tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java

@@ -52,27 +52,18 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext);
+        mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
-    }
+                null /* lifecycle */);
-
-    @Test
-    public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java

@@ -56,7 +56,8 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext);
+        mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext,
+                null /* lifecycle */);
         when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device))
                 .thenReturn(VPN_SET_DEVICE);
         when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal))
@@ -66,37 +67,27 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
                 .thenReturn(true);
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getTitle()).isEqualTo(VPN_SET_DEVICE);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(false);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getTitle()).isEqualTo(VPN_SET_PERSONAL);
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java

@@ -54,32 +54,29 @@ public final class CaCertsPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new CaCertsPreferenceController(mContext);
+        mController = new CaCertsPreferenceController(mContext, null /* lifecycle */);
-
-        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                10, 10)).thenReturn("10 certs");
     }
 
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
 
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider
+        when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs,
-                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0);
+                10, 10)).thenReturn("10 certs");
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        preference.setVisible(false);
         when(mFeatureFactory.enterprisePrivacyFeatureProvider
                 .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getSummary()).isEqualTo("10 certs");
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider
+                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider
+                .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java

@@ -96,7 +96,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
 
     @Test
     public void testIsAvailableSync() {
-        EnterpriseInstalledPackagesPreferenceController controller
+        final EnterpriseInstalledPackagesPreferenceController controller
                 = new EnterpriseInstalledPackagesPreferenceController(mContext,
                         null /* lifecycle */, false /* async */);
 

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java

@@ -43,7 +43,8 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte
     @Override
     public void setUp() {
         super.setUp();
-        mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext);
+        mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext,
+                null /* lifecycle */);
     }
 
     @Override

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java

@@ -50,7 +50,8 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends
     private class FailedPasswordWipePreferenceControllerBaseTestable extends
             FailedPasswordWipePreferenceControllerBase {
         FailedPasswordWipePreferenceControllerBaseTestable() {
-            super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext);
+            super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext,
+                    null /* lifecycle */);
         }
 
         @Override

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java

@@ -61,7 +61,6 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(false);
 
         setMaximumFailedPasswordsBeforeWipe(10);
         when(mContext.getResources().getQuantityString(
@@ -69,14 +68,14 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
                 .thenReturn("10 attempts");
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("10 attempts");
-
-        setMaximumFailedPasswordsBeforeWipe(0);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
     }
 
     @Test
     public void testIsAvailable() {
+        setMaximumFailedPasswordsBeforeWipe(0);
+        assertThat(mController.isAvailable()).isFalse();
+
+        setMaximumFailedPasswordsBeforeWipe(10);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java

@@ -43,7 +43,8 @@ public final class FailedPasswordWipePrimaryUserPreferenceControllerTest extends
     @Override
     public void setUp() {
         super.setUp();
-        mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext);
+        mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext,
+                null /* lifecycle */);
     }
 
     @Override

tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java

@@ -51,27 +51,17 @@ public final class GlobalHttpProxyPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new GlobalHttpProxyPreferenceController(mContext);
+        mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */);
-    }
-
-    @Test
-    public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
-                .thenReturn(false);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
-                .thenReturn(true);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
+                .thenReturn(false);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
+                .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
     }
 

tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java

@@ -57,7 +57,7 @@ public final class ImePreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new ImePreferenceController(mContext);
+        mController = new ImePreferenceController(mContext, null /* lifecycle */);
         when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name,
                 DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT);
     }
@@ -65,22 +65,21 @@ public final class ImePreferenceControllerTest {
     @Test
     public void testUpdateState() {
         final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
-            .thenReturn(null);
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
             .thenReturn(DEFAULT_IME_LABEL);
         mController.updateState(preference);
-        assertThat(preference.isVisible()).isTrue();
         assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT);
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
+            .thenReturn(null);
+        assertThat(mController.isAvailable()).isFalse();
+
+        when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
+            .thenReturn(DEFAULT_IME_LABEL);
         assertThat(mController.isAvailable()).isTrue();
     }