Start 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 takes the following steps toward fixing this:
* Pass the list of PreferenceControllers to the search indexer
* Make the first two PrefrenceControllers set isAvailable() correctly

There are more disclosures to update, but the difficult work is done
as all others will follow the same pattern.

Bug: 32692748
Test: m RunSettingsRoboTests

Change-Id: I7d3e248b80abe72b79fce7afa11f28a822de6986

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

@@ -57,6 +57,10 @@ public abstract class AppCounter extends AsyncTask<Void, Void, Integer> {
         onCountComplete(count);
     }
 
+    void executeInForeground() {
+        onPostExecute(doInBackground());
+    }
+
     protected abstract void onCountComplete(int num);
     protected abstract List<UserInfo> getUsersToCount();
     protected abstract boolean includeInCount(ApplicationInfo info);

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

@@ -35,15 +35,17 @@ public interface ApplicationFeatureProvider {
     public static final int IGNORE_INSTALL_REASON = -1;
 
     /**
-     * Asynchronously calculates the total number of apps installed on the device, across all users
+     * Calculates the total number of apps installed on the device, across all users and managed
-     * and managed profiles.
+     * profiles.
      *
      * @param installReason Only consider apps with this install reason; may be any install reason
      *         defined in {@link android.content.pm.PackageManager} or
      *         {@link #IGNORE_INSTALL_REASON} to count all apps, irrespective of install reason.
+     * @param async Whether to count asynchronously in a background thread
      * @param callback The callback to invoke with the result
      */
-    void calculateNumberOfInstalledApps(int installReason, NumberOfAppsCallback callback);
+    void calculateNumberOfInstalledApps(int installReason, boolean async,
+            NumberOfAppsCallback callback);
 
     /**
      * Asynchronously calculates the total number of apps installed on the device, across all users

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

@@ -56,8 +56,15 @@ public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvide
     }
 
     @Override
-    public void calculateNumberOfInstalledApps(int installReason, NumberOfAppsCallback callback) {
+    public void calculateNumberOfInstalledApps(int installReason, boolean async,
-        new AllUserInstalledAppCounter(mContext, installReason, mPm, callback).execute();
+            NumberOfAppsCallback callback) {
+        final AllUserInstalledAppCounter counter = new AllUserInstalledAppCounter(mContext,
+                installReason, mPm, callback);
+        if (async) {
+            counter.execute();
+        } else {
+            counter.executeInForeground();
+        }
     }
 
     @Override

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

@@ -20,25 +20,30 @@ 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 class EnterpriseInstalledPackagesPreferenceController extends PreferenceController {
+public class EnterpriseInstalledPackagesPreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES
             = "number_enterprise_installed_packages";
     private final ApplicationFeatureProvider mFeatureProvider;
+    private final boolean mAsync;
 
-    public EnterpriseInstalledPackagesPreferenceController(Context context) {
+    public EnterpriseInstalledPackagesPreferenceController(Context context, Lifecycle lifecycle,
-        super(context);
+            boolean async) {
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getApplicationFeatureProvider(context);
+        mAsync = async;
     }
 
     @Override
     public void updateState(Preference preference) {
         mFeatureProvider.calculateNumberOfInstalledApps(
-                PackageManager.INSTALL_REASON_POLICY,
+                PackageManager.INSTALL_REASON_POLICY, true /* async */,
                 (num) -> {
                     if (num == 0) {
                         preference.setVisible(false);
@@ -52,9 +57,22 @@ public class EnterpriseInstalledPackagesPreferenceController extends PreferenceC
 
     @Override
     public boolean isAvailable() {
+        if (mAsync) {
+            // When called on the main UI thread, we must not block. Since calculating the number of
+            // enterprise-installed apps 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 there are enterprise-installed apps or not.
+        final Boolean[] haveEnterpriseInstalledPackages = { null };
+        mFeatureProvider.calculateNumberOfInstalledApps(PackageManager.INSTALL_REASON_POLICY,
+                false /* async */, (num) -> haveEnterpriseInstalledPackages[0] = num > 0);
+        return haveEnterpriseInstalledPackages[0];
+    }
+
     @Override
     public String getPreferenceKey() {
         return KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES;

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

@@ -22,6 +22,7 @@ import android.provider.SearchIndexableResource;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
 import com.android.settings.core.PreferenceController;
+import com.android.settings.core.lifecycle.Lifecycle;
 import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.search.BaseSearchIndexProvider;
@@ -51,16 +52,22 @@ public class EnterprisePrivacySettings extends DashboardFragment {
 
     @Override
     protected List<PreferenceController> getPreferenceControllers(Context context) {
+        return buildPreferenceControllers(context, getLifecycle(), true /* async */);
+    }
+
+    private static List<PreferenceController> buildPreferenceControllers(Context context,
+            Lifecycle lifecycle, boolean async) {
         final List controllers = new ArrayList<PreferenceController>();
         controllers.add(new InstalledPackagesPreferenceController(context));
         controllers.add(new NetworkLogsPreferenceController(context));
         controllers.add(new BugReportsPreferenceController(context));
         controllers.add(new SecurityLogsPreferenceController(context));
-        controllers.add(new EnterpriseInstalledPackagesPreferenceController(context));
+        controllers.add(new EnterpriseInstalledPackagesPreferenceController(context, lifecycle,
+                async));
         controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context));
         controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context));
         controllers.add(new AdminGrantedCameraPermissionPreferenceController(context));
-        controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context));
+        controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context, lifecycle));
         controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context));
         controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context));
         controllers.add(new GlobalHttpProxyPreferenceController(context));
@@ -92,5 +99,10 @@ public class EnterprisePrivacySettings extends DashboardFragment {
                     sir.xmlResId = R.xml.enterprise_privacy_settings;
                     return Arrays.asList(sir);
             }
+
+            @Override
+            public List<PreferenceController> getPreferenceControllers(Context context) {
+                return buildPreferenceControllers(context, null /* lifecycle */, false /* async */);
+                }
             };
 }

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

@@ -22,22 +22,40 @@ 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 class EnterpriseSetDefaultAppsPreferenceController extends PreferenceController {
+public class EnterpriseSetDefaultAppsPreferenceController
+        extends DynamicAvailabilityPreferenceController {
 
     private static final String KEY_DEFAULT_APPS = "number_enterprise_set_default_apps";
     private final ApplicationFeatureProvider mFeatureProvider;
 
-    public EnterpriseSetDefaultAppsPreferenceController(Context context) {
+    public EnterpriseSetDefaultAppsPreferenceController(Context context, Lifecycle lifecycle) {
-        super(context);
+        super(context, lifecycle);
         mFeatureProvider = FeatureFactory.getFactory(context)
                 .getApplicationFeatureProvider(context);
     }
 
     @Override
     public void updateState(Preference preference) {
+        final int num = getNumberOfEnterpriseSetDefaultApps();
+        preference.setSummary(mContext.getResources().getQuantityString(
+                R.plurals.enterprise_privacy_number_packages, num, num));
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return getNumberOfEnterpriseSetDefaultApps() > 0;
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_DEFAULT_APPS;
+    }
+
+    private int getNumberOfEnterpriseSetDefaultApps() {
         // Browser
         int num = mFeatureProvider.findPersistentPreferredActivities(new Intent[] {
                 buildIntent(Intent.ACTION_VIEW, Intent.CATEGORY_BROWSABLE, "http:", null)}).size();
@@ -64,23 +82,7 @@ public class EnterpriseSetDefaultAppsPreferenceController extends PreferenceCont
         num += mFeatureProvider.findPersistentPreferredActivities(new Intent[] {
                 new Intent(Intent.ACTION_DIAL), new Intent(Intent.ACTION_CALL)}).size();
 
-        if (num == 0) {
+        return num;
-            preference.setVisible(false);
-        } else {
-            preference.setVisible(true);
-            preference.setSummary(mContext.getResources().getQuantityString(
-                    R.plurals.enterprise_privacy_number_packages, num, num));
-        }
-    }
-
-    @Override
-    public boolean isAvailable() {
-        return true;
-    }
-
-    @Override
-    public String getPreferenceKey() {
-        return KEY_DEFAULT_APPS;
     }
 
     private static Intent buildIntent(String action, String category, String protocol,

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

@@ -36,7 +36,7 @@ public class InstalledPackagesPreferenceController extends PreferenceController
     @Override
     public void updateState(Preference preference) {
         mFeatureProvider.calculateNumberOfInstalledApps(
-                ApplicationFeatureProvider.IGNORE_INSTALL_REASON,
+                ApplicationFeatureProvider.IGNORE_INSTALL_REASON, true /* async */,
                 (num) -> {
                     if (num == 0) {
                         preference.setSummary("");

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

@@ -88,8 +88,7 @@ public final class ApplicationFeatureProviderImplTest {
                 mPackageManagerService, mDevicePolicyManager);
     }
 
-    @Test
+    private void testCalculateNumberOfInstalledApps(boolean async) {
-    public void testCalculateNumberOfInstalledApps() {
         setUpUsersAndInstalledApps();
 
         when(mPackageManager.getInstallReason(APP_1, new UserHandle(MAIN_USER_ID)))
@@ -100,22 +99,32 @@ public final class ApplicationFeatureProviderImplTest {
         // Count all installed apps.
         mAppCount = -1;
         mProvider.calculateNumberOfInstalledApps(ApplicationFeatureProvider.IGNORE_INSTALL_REASON,
-                (num) -> {
+                async, (num) -> mAppCount = num);
-                    mAppCount = num;
+        if (async) {
-                });
             ShadowApplication.runBackgroundTasks();
+        }
         assertThat(mAppCount).isEqualTo(2);
 
         // Count apps with specific install reason only.
         mAppCount = -1;
-        mProvider.calculateNumberOfInstalledApps(PackageManager.INSTALL_REASON_POLICY,
+        mProvider.calculateNumberOfInstalledApps(PackageManager.INSTALL_REASON_POLICY, async,
-                (num) -> {
+                (num) -> mAppCount = num);
-                    mAppCount = num;
+        if (async) {
-                });
             ShadowApplication.runBackgroundTasks();
+        }
         assertThat(mAppCount).isEqualTo(1);
     }
 
+    @Test
+    public void testCalculateNumberOfInstalledAppsSync() {
+        testCalculateNumberOfInstalledApps(false /* async */);
+    }
+
+    @Test
+    public void testCalculateNumberOfInstalledAppsAsync() {
+        testCalculateNumberOfInstalledApps(true /* async */);
+    }
+
     @Test
     public void testCalculateNumberOfAppsWithAdminGrantedPermissions() throws Exception {
         setUpUsersAndInstalledApps();

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

@@ -97,8 +97,7 @@ public final class InstalledAppCounterTest {
                         : new ArrayList<ResolveInfo>());
     }
 
-    @Test
+    private void testCountInstalledAppsAcrossAllUsers(boolean async) {
-    public void testCountInstalledAppsAcrossAllUsers() {
         // There are two users.
         mUsersToCount = Arrays.asList(
                 new UserInfo(MAIN_USER_ID, "main", UserInfo.FLAG_ADMIN),
@@ -156,12 +155,8 @@ public final class InstalledAppCounterTest {
         when(mPackageManager.getInstallReason(APP_6, managedProfileUser))
                 .thenReturn(PackageManager.INSTALL_REASON_UNKNOWN);
 
-        // Count the number of all apps installed, irrespective of install reason. Wait for the
+        // Count the number of all apps installed, irrespective of install reason.
-        // background task to finish.
+        count(ApplicationFeatureProvider.IGNORE_INSTALL_REASON, async);
-        (new InstalledAppCounterTestable(ApplicationFeatureProvider.IGNORE_INSTALL_REASON))
-                .execute();
-        ShadowApplication.runBackgroundTasks();
-
         assertThat(mInstalledAppCount).isEqualTo(5);
 
         // Verify that installed packages were retrieved for the users returned by
@@ -173,15 +168,34 @@ public final class InstalledAppCounterTest {
                 anyInt());
         verifyNoMoreInteractions(mPackageManager);
 
-        // Count once more, considering apps installed by enterprise policy only. Wait for the
+        // Count once more, considering apps installed by enterprise policy only.
-        // background task to finish.
+        count(PackageManager.INSTALL_REASON_POLICY, async);
-        mInstalledAppCount = -1;
-        (new InstalledAppCounterTestable(PackageManager.INSTALL_REASON_POLICY)).execute();
-        ShadowApplication.runBackgroundTasks();
-
         assertThat(mInstalledAppCount).isEqualTo(3);
     }
 
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersSync() {
+        testCountInstalledAppsAcrossAllUsers(false /* async */);
+    }
+
+    @Test
+    public void testCountInstalledAppsAcrossAllUsersAsync() {
+        testCountInstalledAppsAcrossAllUsers(true /* async */);
+    }
+
+    private void count(int installReason, boolean async) {
+        mInstalledAppCount = -1;
+        final InstalledAppCounterTestable counter = new InstalledAppCounterTestable(installReason);
+        if (async) {
+            counter.execute();
+            // Wait for the background task to finish.
+            ShadowApplication.runBackgroundTasks();
+        } else {
+            counter.executeInForeground();
+        }
+    }
+
+
     private class InstalledAppCounterTestable extends InstalledAppCounter {
         public InstalledAppCounterTestable(int installReason) {
             super(mContext, installReason, mPackageManager);

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

@@ -62,18 +62,19 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new EnterpriseInstalledPackagesPreferenceController(mContext);
+        mController = new EnterpriseInstalledPackagesPreferenceController(mContext,
+                null /* lifecycle */, true /* async */);
     }
 
-    private void setNumberOfEnterpriseInstalledPackages(int number) {
+    private void setNumberOfEnterpriseInstalledPackages(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)
                     .calculateNumberOfInstalledApps(eq(PackageManager.INSTALL_REASON_POLICY),
-                            anyObject());
+                            eq(async), anyObject());
     }
 
     @Test
@@ -81,11 +82,11 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         final Preference preference = new Preference(mContext, null, 0, 0);
         preference.setVisible(true);
 
-        setNumberOfEnterpriseInstalledPackages(0);
+        setNumberOfEnterpriseInstalledPackages(0, true /* async */);
         mController.updateState(preference);
         assertThat(preference.isVisible()).isFalse();
 
-        setNumberOfEnterpriseInstalledPackages(20);
+        setNumberOfEnterpriseInstalledPackages(20, true /* async */);
         when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_packages,
                 20, 20)).thenReturn("20 packages");
         mController.updateState(preference);
@@ -94,7 +95,24 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
     }
 
     @Test
-    public void testIsAvailable() {
+    public void testIsAvailableSync() {
+        EnterpriseInstalledPackagesPreferenceController controller
+                = new EnterpriseInstalledPackagesPreferenceController(mContext,
+                        null /* lifecycle */, false /* async */);
+
+        setNumberOfEnterpriseInstalledPackages(0, false /* async */);
+        assertThat(controller.isAvailable()).isFalse();
+
+        setNumberOfEnterpriseInstalledPackages(20, false /* async */);
+        assertThat(controller.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailableAsync() {
+        setNumberOfEnterpriseInstalledPackages(0, true /* async */);
+        assertThat(mController.isAvailable()).isTrue();
+
+        setNumberOfEnterpriseInstalledPackages(20, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
     }
 

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

@@ -104,6 +104,18 @@ public final class EnterprisePrivacySettingsTest {
     public void getPreferenceControllers() {
         final List<PreferenceController> controllers = mSettings.getPreferenceControllers(
                 ShadowApplication.getInstance().getApplicationContext());
+        verifyPreferenceControllers(controllers);
+    }
+
+    @Test
+    public void getSearchIndexProviderPreferenceControllers() {
+        final List<PreferenceController> controllers
+                = EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers(
+                        ShadowApplication.getInstance().getApplicationContext());
+        verifyPreferenceControllers(controllers);
+    }
+
+    private void verifyPreferenceControllers(List<PreferenceController> controllers) {
         assertThat(controllers).isNotNull();
         assertThat(controllers.size()).isEqualTo(17);
         assertThat(controllers.get(0)).isInstanceOf(InstalledPackagesPreferenceController.class);

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

@@ -65,7 +65,8 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mController = new EnterpriseSetDefaultAppsPreferenceController(mContext);
+        mController = new EnterpriseSetDefaultAppsPreferenceController(mContext,
+                null /* lifecycle */);
     }
 
     private static Intent buildIntent(String action, String category, String protocol,
@@ -95,15 +96,6 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
 
     @Test
     public void testUpdateState() {
-        final Preference preference = new Preference(mContext, null, 0, 0);
-        preference.setVisible(true);
-
-        when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(
-                anyObject())).thenReturn(
-                        new ArraySet<ApplicationFeatureProvider.PersistentPreferredActivityInfo>());
-        mController.updateState(preference);
-        assertThat(preference.isVisible()).isFalse();
-
         setEnterpriseSetDefaultApps(new Intent[] {buildIntent(Intent.ACTION_VIEW,
                 Intent.CATEGORY_BROWSABLE, "http:", null)}, 1);
         setEnterpriseSetDefaultApps(new Intent[] {new Intent(MediaStore.ACTION_IMAGE_CAPTURE),
@@ -120,13 +112,21 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
                 new Intent(Intent.ACTION_CALL)}, 64);
         when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_packages,
                 127, 127)).thenReturn("127 apps");
+
+        final Preference preference = new Preference(mContext, null, 0, 0);
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("127 apps");
-        assertThat(preference.isVisible()).isTrue();
     }
 
     @Test
     public void testIsAvailable() {
+        when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(
+                anyObject())).thenReturn(
+                        new ArraySet<ApplicationFeatureProvider.PersistentPreferredActivityInfo>());
+        assertThat(mController.isAvailable()).isFalse();
+
+        setEnterpriseSetDefaultApps(new Intent[] {buildIntent(Intent.ACTION_VIEW,
+                Intent.CATEGORY_BROWSABLE, "http:", null)}, 1);
         assertThat(mController.isAvailable()).isTrue();
     }
 

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

@@ -68,11 +68,10 @@ public final class InstalledPackagesPreferenceControllerTest {
         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)
+            }}).when(mFeatureFactory.applicationFeatureProvider).calculateNumberOfInstalledApps(
-                    .calculateNumberOfInstalledApps(
+                    eq(ApplicationFeatureProvider.IGNORE_INSTALL_REASON), eq(true), anyObject());
-                            eq(ApplicationFeatureProvider.IGNORE_INSTALL_REASON), anyObject());
     }
 
     @Test