Hide "Changes made by your organization's admin" when empty

The admin of a manged device can take a number actions that will be
listed in the "Changes made by your organization's admin" section of
Settings. If the admin has not taken any such actions, the section
will be empty and should be hidden. This is accomplished by having a
PreferenceController for the section that observes the state of the
PreferenceControllers inside it.

Bug: 35912953
Test: m RunSettingsRoboTests

Change-Id: Ia95754493ee6c5a19b4aa9731fd56fd558e61849

res/xml/enterprise_privacy_settings.xml

@@ -45,7 +45,8 @@
                     android:selectable="false"/>
     </PreferenceCategory>
 
-    <PreferenceCategory android:title="@string/enterprise_privacy_exposure_changes_category">
+    <PreferenceCategory android:title="@string/enterprise_privacy_exposure_changes_category"
+                        android:key="exposure_changes_category">
         <Preference android:fragment="com.android.settings.enterprise.ApplicationListFragment$EnterpriseInstalledPackages"
                     android:key="number_enterprise_installed_packages"
                     android:title="@string/enterprise_privacy_enterprise_installed_packages"/>

src/com/android/settings/core/DynamicAvailabilityPreferenceController.java

@@ -29,6 +29,7 @@ public abstract class DynamicAvailabilityPreferenceController extends Preference
 
     private Preference mPreference;
     private PreferenceScreen mScreen;
+    private PreferenceAvailabilityObserver mAvailabilityObserver = null;
 
     public DynamicAvailabilityPreferenceController(Context context, Lifecycle lifecycle) {
         super(context);
@@ -37,6 +38,14 @@ public abstract class DynamicAvailabilityPreferenceController extends Preference
         }
     }
 
+    public void setAvailabilityObserver(PreferenceAvailabilityObserver observer) {
+        mAvailabilityObserver = observer;
+    }
+
+    public PreferenceAvailabilityObserver getAvailabilityObserver() {
+        return mAvailabilityObserver;
+    }
+
     @Override
     public void displayPreference(PreferenceScreen screen) {
         mScreen = screen;
@@ -56,4 +65,10 @@ public abstract class DynamicAvailabilityPreferenceController extends Preference
             mScreen.addPreference(mPreference);
         }
     }
+
+    protected void notifyOnAvailabilityUpdate(boolean available) {
+        if (mAvailabilityObserver != null) {
+            mAvailabilityObserver.onPreferenceAvailabilityUpdated(getPreferenceKey(), available);
+        }
+    }
 }

src/com/android/settings/core/PreferenceAvailabilityObserver.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.core;
+
+/**
+ * @deprecated This interface allows a {@link android.support.v7.preference.PreferenceGroup}'s
+ * controller to observe the availability of the {@link android.support.v7.preference.Preference}s
+ * inside it, hiding the group when all preferences become unavailable. In the future,
+ * {@link android.support.v7.preference.PreferenceGroup} will have native support for that
+ * functionality, removing the need for this interface.
+ */
+public interface PreferenceAvailabilityObserver {
+
+    /**
+     * Notifies the observer that the availability of the preference identified by {@code key} has
+     * been updated.
+     */
+    void onPreferenceAvailabilityUpdated(String key, boolean available);
+}

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

@@ -50,15 +50,15 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase
                 true /* async */,
                 (num) -> {
                     if (num == 0) {
-                        preference.setVisible(false);
                         mHasApps = false;
                     } else {
-                        preference.setVisible(true);
                         preference.setSummary(mContext.getResources().getQuantityString(
                                 R.plurals.enterprise_privacy_number_packages_lower_bound,
                                 num, num));
                         mHasApps = true;
                     }
+                    preference.setVisible(mHasApps);
+                    notifyOnAvailabilityUpdate(mHasApps);
                 });
     }
 
@@ -80,6 +80,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase
         mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
                 false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0);
         mHasApps = haveAppsWithAdminGrantedPermissions[0];
+        notifyOnAvailabilityUpdate(mHasApps);
         return mHasApps;
     }
 

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

@@ -42,7 +42,9 @@ public class AlwaysOnVpnCurrentUserPreferenceController
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.isAlwaysOnVpnSetInCurrentUser();
+        final boolean available = mFeatureProvider.isAlwaysOnVpnSetInCurrentUser();
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -33,7 +33,9 @@ public class AlwaysOnVpnManagedProfilePreferenceController
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
+        final boolean available = mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -44,8 +44,11 @@ public class CaCertsPreferenceController extends DynamicAvailabilityPreferenceCo
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()
+        final boolean available =
-                > 0;
+                mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()
+                        > 0;
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -42,14 +42,18 @@ public class EnterpriseInstalledPackagesPreferenceController
     public void updateState(Preference preference) {
         mFeatureProvider.calculateNumberOfPolicyInstalledApps(true /* async */,
                 (num) -> {
+                    final boolean available;
                     if (num == 0) {
-                        preference.setVisible(false);
+                        available = false;
                     } else {
-                        preference.setVisible(true);
+                        available = true;
                         preference.setSummary(mContext.getResources().getQuantityString(
                                 R.plurals.enterprise_privacy_number_packages_lower_bound, num,
                                 num));
+
                     }
+                    preference.setVisible(available);
+                    notifyOnAvailabilityUpdate(available);
                 });
     }
 
@@ -68,7 +72,9 @@ public class EnterpriseInstalledPackagesPreferenceController
         final Boolean[] haveEnterpriseInstalledPackages = { null };
         mFeatureProvider.calculateNumberOfPolicyInstalledApps(false /* async */,
                 (num) -> haveEnterpriseInstalledPackages[0] = num > 0);
-        return haveEnterpriseInstalledPackages[0];
+        final boolean available = haveEnterpriseInstalledPackages[0];
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -45,7 +45,9 @@ public class EnterprisePrivacyPreferenceController extends DynamicAvailabilityPr
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.hasDeviceOwner();
+        final boolean available = mFeatureProvider.hasDeviceOwner();
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -61,23 +61,32 @@ public class EnterprisePrivacySettings extends DashboardFragment {
         controllers.add(new NetworkLogsPreferenceController(context));
         controllers.add(new BugReportsPreferenceController(context));
         controllers.add(new SecurityLogsPreferenceController(context));
-        controllers.add(new EnterpriseInstalledPackagesPreferenceController(context, lifecycle,
+        final List exposureChangesCategoryControllers = new ArrayList<PreferenceController>();
-                async));
+        exposureChangesCategoryControllers.add(new EnterpriseInstalledPackagesPreferenceController(
-        controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle,
+                context, lifecycle, async));
-                async));
+        exposureChangesCategoryControllers.add(
-        controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle,
+                new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle, async));
-                async));
+        exposureChangesCategoryControllers.add(
-        controllers.add(new AdminGrantedCameraPermissionPreferenceController(context, lifecycle,
+                new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle,
-                async));
+                        async));
-        controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context, lifecycle));
+        exposureChangesCategoryControllers.add(new AdminGrantedCameraPermissionPreferenceController(
-        controllers.add(new AlwaysOnVpnCurrentUserPreferenceController(context, lifecycle));
+                context, lifecycle, async));
-        controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context, lifecycle));
+        exposureChangesCategoryControllers.add(new EnterpriseSetDefaultAppsPreferenceController(
-        controllers.add(new GlobalHttpProxyPreferenceController(context, lifecycle));
+                context, lifecycle));
-        controllers.add(new CaCertsPreferenceController(context, lifecycle));
+        exposureChangesCategoryControllers.add(new AlwaysOnVpnCurrentUserPreferenceController(
+                context, lifecycle));
+        exposureChangesCategoryControllers.add(new AlwaysOnVpnManagedProfilePreferenceController(
+                context, lifecycle));
+        exposureChangesCategoryControllers.add(new ImePreferenceController(context, lifecycle));
+        exposureChangesCategoryControllers.add(new GlobalHttpProxyPreferenceController(context,
+                lifecycle));
+        exposureChangesCategoryControllers.add(new CaCertsPreferenceController(context, lifecycle));
+        controllers.addAll(exposureChangesCategoryControllers);
+        controllers.add(new ExposureChangesCategoryPreferenceController(context, lifecycle,
+                exposureChangesCategoryControllers, async));
         controllers.add(new FailedPasswordWipeCurrentUserPreferenceController(context, lifecycle));
         controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context,
                 lifecycle));
-        controllers.add(new ImePreferenceController(context, lifecycle));
         return controllers;
     }
 

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

@@ -1,3 +1,4 @@
+
 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
@@ -48,7 +49,9 @@ public class EnterpriseSetDefaultAppsPreferenceController
 
     @Override
     public boolean isAvailable() {
-        return getNumberOfEnterpriseSetDefaultApps() > 0;
+        final boolean available = getNumberOfEnterpriseSetDefaultApps() > 0;
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -0,0 +1,111 @@
+
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+package com.android.settings.enterprise;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.PreferenceAvailabilityObserver;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * A controller that hides a {@link android.support.v7.preference.PreferenceGroup} when none of the
+ * {@link Preference}s inside it are visible.
+ *
+ * TODO(b/62051162): Use {@link android.support.v7.preference.PreferenceGroup}'s native ability to
+ * hide itself when all {@link Preference}s inside it are invisible when that functionality becomes
+ * available. This custom controller will still be needed to remove the
+ * {@link android.support.v7.preference.PreferenceGroup} from the search index as required (by
+ * having {@link #isAvailable()} return {@code false} if the method returns {@code false} for all
+ * {@link Preference}s in the {@link android.support.v7.preference.PreferenceGroup}).
+ */
+public class ExposureChangesCategoryPreferenceController
+        extends DynamicAvailabilityPreferenceController implements PreferenceAvailabilityObserver {
+
+    private static final String KEY_EXPOSURE_CHANGES_CATEGORY = "exposure_changes_category";
+    private final Set<String> mAvailablePrefs = new HashSet<String>();
+    private Preference mPreference = null;
+    private boolean mControllingUi;
+
+    /**
+     * When {@code controllingUi} is {@code true}, some of the preferences may have their visibility
+     * determined asynchronously. In this case, {@link #isAvailable()} must always return {@code
+     * true} and the group should be hidden using {@link Preference#setVisible()} if all preferences
+     * report that they are invisible.
+     * When {@code controllingUi} is {@code false}, we are running on the search indexer thread and
+     * visibility must be determined synchronously. {@link #isAvailable()} can rely on all
+     * preferences having their visibility determined already and should return whether the group is
+     * visible or not.
+     */
+    public ExposureChangesCategoryPreferenceController(Context context, Lifecycle lifecycle,
+            List<DynamicAvailabilityPreferenceController> controllers, boolean controllingUi) {
+        super(context, lifecycle);
+        mControllingUi = controllingUi;
+        for (final DynamicAvailabilityPreferenceController controller : controllers) {
+            controller.setAvailabilityObserver(this);
+        }
+    }
+
+    @Override
+    public void onPreferenceAvailabilityUpdated(String key, boolean available) {
+        if (available) {
+            mAvailablePrefs.add(key);
+        } else {
+            mAvailablePrefs.remove(key);
+        }
+        available = haveAnyVisiblePreferences();
+        if (mControllingUi) {
+            notifyOnAvailabilityUpdate(available);
+        }
+        if (mPreference != null) {
+            mPreference.setVisible(available);
+        }
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        mPreference = preference;
+        mPreference.setVisible(haveAnyVisiblePreferences());
+    }
+
+    @Override
+    public boolean isAvailable() {
+        if (mControllingUi) {
+            // When running on the main UI thread, some preferences determine their visibility
+            // asynchronously. Always return true here and determine the pref group's actual
+            // visibility as the other preferences report their visibility asynchronously via
+            // onPreferenceAvailabilityUpdated().
+            return true;
+        }
+        final boolean available = haveAnyVisiblePreferences();
+        notifyOnAvailabilityUpdate(available);
+        return available;
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_EXPOSURE_CHANGES_CATEGORY;
+    }
+
+    private boolean haveAnyVisiblePreferences() {
+        return mAvailablePrefs.size() > 0;
+    }
+}

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

@@ -46,6 +46,8 @@ public abstract class FailedPasswordWipePreferenceControllerBase
 
     @Override
     public boolean isAvailable() {
-        return getMaximumFailedPasswordsBeforeWipe() > 0;
+        final boolean available = getMaximumFailedPasswordsBeforeWipe() > 0;
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 }

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

@@ -32,7 +32,9 @@ public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPref
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.isGlobalHttpProxySet();
+        final boolean available = mFeatureProvider.isGlobalHttpProxySet();
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

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

@@ -43,7 +43,9 @@ public class ImePreferenceController extends DynamicAvailabilityPreferenceContro
 
     @Override
     public boolean isAvailable() {
-        return mFeatureProvider.getImeLabelIfOwnerSet() != null;
+        final boolean available = mFeatureProvider.getImeLabelIfOwnerSet() != null;
+        notifyOnAvailabilityUpdate(available);
+        return available;
     }
 
     @Override

tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java

@@ -22,6 +22,7 @@ import android.support.v7.preference.PreferenceScreen;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 import org.junit.Before;
@@ -50,6 +51,7 @@ public final class DynamicAvailabilityPreferenceControllerTest {
     private @Mock Preference mPreference;
     private @Mock PreferenceScreen mScreen;
     private @Mock Lifecycle mLifecycle;
+    private @Mock PreferenceAvailabilityObserver mObserver;
 
     private boolean mIsAvailable;
     private Preference mUpdatedPreference = null;
@@ -115,6 +117,21 @@ public final class DynamicAvailabilityPreferenceControllerTest {
         assertThat(mUpdatedPreference).isEqualTo(mPreference);
     }
 
+    @Test
+    public void testNotifyOnAvailabilityUpdate() {
+        final DynamicAvailabilityPreferenceController controller
+                = new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
+        controller.setAvailabilityObserver(mObserver);
+        assertThat(controller.getAvailabilityObserver()).isEqualTo(mObserver);
+
+        mIsAvailable = false;
+        controller.isAvailable();
+        verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, false);
+
+        mIsAvailable = true;
+        controller.isAvailable();
+        verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, true);
+    }
 
     private class DynamicAvailabilityPreferenceControllerTestable
             extends DynamicAvailabilityPreferenceController {
@@ -124,6 +141,7 @@ public final class DynamicAvailabilityPreferenceControllerTest {
 
         @Override
         public boolean isAvailable() {
+            notifyOnAvailabilityUpdate(mIsAvailable);
             return mIsAvailable;
         }
 

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

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
 import com.android.settings.applications.ApplicationFeatureProvider;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -32,9 +33,12 @@ import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyObject;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -48,6 +52,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     protected Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     protected AdminGrantedPermissionsPreferenceControllerBase mController;
 
@@ -64,6 +69,12 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = createController(true /* async */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) {
@@ -85,6 +96,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
         setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
         mController.updateState(preference);
         assertThat(preference.isVisible()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
 
         setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         when(mContext.getResources().getQuantityString(
@@ -93,27 +105,33 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
         assertThat(preference.isVisible()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
     }
 
     @Test
     public void testIsAvailableSync() {
         final AdminGrantedPermissionsPreferenceControllerBase controller
                 = createController(false /* async */);
+        controller.setAvailabilityObserver(mObserver);
 
         setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */);
         assertThat(controller.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
 
         setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */);
         assertThat(controller.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
     }
 
     @Test
     public void testIsAvailableAsync() {
         setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
 
         setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
     }
 
     @Test

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

@@ -22,6 +22,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -33,6 +34,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -42,12 +44,14 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
 
-    private final String VPN_SET_DEVICE = "VPN set";
+    private static final String VPN_SET_DEVICE = "VPN set";
-    private final String VPN_SET_PERSONAL = "VPN set in personal profile";
+    private static final String VPN_SET_PERSONAL = "VPN set in personal profile";
+    private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private AlwaysOnVpnCurrentUserPreferenceController mController;
 
@@ -62,6 +66,12 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
                 .thenReturn(VPN_SET_DEVICE);
         when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal))
                 .thenReturn(VPN_SET_PERSONAL);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -85,10 +95,12 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
                 .thenReturn(false);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
                 .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, true);
     }
 
     @Test
@@ -99,6 +111,6 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("always_on_vpn_primary_user");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ALWAYS_ON_VPN_PRIMARY_USER);
     }
 }

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

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -32,6 +33,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -41,9 +43,12 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
 
+    private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private AlwaysOnVpnManagedProfilePreferenceController mController;
 
@@ -54,6 +59,12 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
                 null /* lifecycle */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -61,10 +72,12 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
                 .thenReturn(false);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
                 .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, true);
     }
 
     @Test
@@ -75,6 +88,6 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("always_on_vpn_managed_profile");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE);
     }
 }

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

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -43,9 +45,12 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class CaCertsPreferenceControllerTest {
 
+    private static final String KEY_CA_CERTS = "ca_certs";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private CaCertsPreferenceController mController;
 
@@ -55,6 +60,12 @@ public final class CaCertsPreferenceControllerTest {
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new CaCertsPreferenceController(mContext, null /* lifecycle */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -74,10 +85,12 @@ public final class CaCertsPreferenceControllerTest {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider
                 .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_CA_CERTS, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider
                 .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_CA_CERTS, true);
     }
 
     @Test
@@ -88,6 +101,6 @@ public final class CaCertsPreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_CA_CERTS);
     }
 }

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

@@ -24,6 +24,7 @@ import com.android.settings.R;
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
 import com.android.settings.applications.ApplicationFeatureProvider;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -37,9 +38,12 @@ import org.mockito.stubbing.Answer;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.anyBoolean;
 import static org.mockito.Mockito.anyObject;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -49,9 +53,13 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class EnterpriseInstalledPackagesPreferenceControllerTest {
 
+    private static final String KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES
+            = "number_enterprise_installed_packages";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private EnterpriseInstalledPackagesPreferenceController mController;
 
@@ -62,6 +70,12 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new EnterpriseInstalledPackagesPreferenceController(mContext,
                 null /* lifecycle */, true /* async */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     private void setNumberOfEnterpriseInstalledPackages(int number, boolean async) {
@@ -82,6 +96,8 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         setNumberOfEnterpriseInstalledPackages(0, true /* async */);
         mController.updateState(preference);
         assertThat(preference.isVisible()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
+                false);
 
         setNumberOfEnterpriseInstalledPackages(20, true /* async */);
         when(mContext.getResources().getQuantityString(
@@ -90,6 +106,8 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         mController.updateState(preference);
         assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
         assertThat(preference.isVisible()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
+                true);
     }
 
     @Test
@@ -97,21 +115,30 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
         final EnterpriseInstalledPackagesPreferenceController controller
                 = new EnterpriseInstalledPackagesPreferenceController(mContext,
                         null /* lifecycle */, false /* async */);
+        controller.setAvailabilityObserver(mObserver);
 
         setNumberOfEnterpriseInstalledPackages(0, false /* async */);
         assertThat(controller.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(
+                KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, false);
 
         setNumberOfEnterpriseInstalledPackages(20, false /* async */);
         assertThat(controller.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(
+                KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, true);
     }
 
     @Test
     public void testIsAvailableAsync() {
         setNumberOfEnterpriseInstalledPackages(0, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
 
         setNumberOfEnterpriseInstalledPackages(20, true /* async */);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
     }
 
     @Test
@@ -123,6 +150,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
     @Test
     public void testGetPreferenceKey() {
         assertThat(mController.getPreferenceKey())
-                .isEqualTo("number_enterprise_installed_packages");
+                .isEqualTo(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES);
     }
 }

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

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
 import com.android.settings.R;
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -43,13 +45,15 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class EnterprisePrivacyPreferenceControllerTest {
 
-    private final String MANAGED_GENERIC = "managed by organization";
+    private static final String MANAGED_GENERIC = "managed by organization";
-    private final String MANAGED_WITH_NAME = "managed by Foo, Inc.";
+    private static final String MANAGED_WITH_NAME = "managed by Foo, Inc.";
-    private final String MANAGING_ORGANIZATION = "Foo, Inc.";
+    private static final String MANAGING_ORGANIZATION = "Foo, Inc.";
+    private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private EnterprisePrivacyPreferenceController mController;
 
@@ -59,6 +63,12 @@ public final class EnterprisePrivacyPreferenceControllerTest {
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new EnterprisePrivacyPreferenceController(mContext, null /* lifecycle */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -85,10 +95,11 @@ public final class EnterprisePrivacyPreferenceControllerTest {
     public void testIsAvailable() {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
-
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, true);
     }
 
     @Test
@@ -99,6 +110,6 @@ public final class EnterprisePrivacyPreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("enterprise_privacy");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_ENTERPRISE_PRIVACY);
     }
 }

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

@@ -16,12 +16,16 @@
 
 package com.android.settings.enterprise;
 
+import android.app.Application;
 import android.content.Context;
+import android.content.res.Resources;
+import android.content.res.XmlResourceParser;
 
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
 import com.android.settings.core.PreferenceController;
 import com.android.settings.testutils.FakeFeatureFactory;
 
@@ -31,10 +35,14 @@ import org.junit.runner.RunWith;
 import org.mockito.Answers;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 import org.robolectric.shadows.ShadowApplication;
+import org.xmlpull.v1.XmlPullParser;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
 
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.when;
@@ -46,6 +54,9 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class EnterprisePrivacySettingsTest {
 
+    private final static String RESOURCES_NAMESPACE = "http://schemas.android.com/apk/res/android";
+    private final static String ATTR_KEY = "key";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
@@ -101,23 +112,24 @@ public final class EnterprisePrivacySettingsTest {
     }
 
     @Test
-    public void getPreferenceControllers() {
+    public void getPreferenceControllers() throws Exception {
         final List<PreferenceController> controllers = mSettings.getPreferenceControllers(
                 ShadowApplication.getInstance().getApplicationContext());
         verifyPreferenceControllers(controllers);
     }
 
     @Test
-    public void getSearchIndexProviderPreferenceControllers() {
+    public void getSearchIndexProviderPreferenceControllers() throws Exception {
         final List<PreferenceController> controllers
                 = EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers(
                         ShadowApplication.getInstance().getApplicationContext());
         verifyPreferenceControllers(controllers);
     }
 
-    private void verifyPreferenceControllers(List<PreferenceController> controllers) {
+    private void verifyPreferenceControllers(List<PreferenceController> controllers)
+            throws Exception {
         assertThat(controllers).isNotNull();
-        assertThat(controllers.size()).isEqualTo(15);
+        assertThat(controllers.size()).isEqualTo(16);
         int position = 0;
         assertThat(controllers.get(position++)).isInstanceOf(NetworkLogsPreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(BugReportsPreferenceController.class);
@@ -137,14 +149,71 @@ public final class EnterprisePrivacySettingsTest {
                 AlwaysOnVpnCurrentUserPreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(
                 AlwaysOnVpnManagedProfilePreferenceController.class);
+        assertThat(controllers.get(position++)).isInstanceOf(ImePreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(
                 GlobalHttpProxyPreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(
                 CaCertsPreferenceController.class);
+        final PreferenceController exposureChangesCategoryController = controllers.get(position);
+        final int exposureChangesCategoryControllerIndex = position;
+        assertThat(controllers.get(position++)).isInstanceOf(
+                ExposureChangesCategoryPreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(
                 FailedPasswordWipeCurrentUserPreferenceController.class);
         assertThat(controllers.get(position++)).isInstanceOf(
                 FailedPasswordWipeManagedProfilePreferenceController.class);
-        assertThat(controllers.get(position++)).isInstanceOf(ImePreferenceController.class);
+
+        // The "Changes made by your organization's admin" category is hidden when all Preferences
+        // inside it become unavailable. To do this correctly, the category's controller must:
+        // a) Observe the availability of all Preferences in the category and
+        // b) Be listed after those Preferences' controllers, so that availability is updated in
+        //    the correct order
+
+        // Find all Preferences in the category.
+        final XmlResourceParser parser = RuntimeEnvironment.application.getResources().getXml(
+                R.xml.enterprise_privacy_settings);
+        boolean done = false;
+        int type;
+        final Set<String> expectedObserved = new HashSet<>();
+        while (!done && (type = parser.next()) != XmlPullParser.END_DOCUMENT) {
+            if (type != XmlPullParser.START_TAG || !"exposure_changes_category".equals(
+                    parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY))) {
+                continue;
+            }
+            int depth = 1;
+            while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
+                if (type == XmlPullParser.START_TAG) {
+                    final String key = parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY);
+                    if (key != null) {
+                        expectedObserved.add(key);
+                    }
+                    depth++;
+                } else if (type == XmlPullParser.END_TAG) {
+                    depth--;
+                    if (depth == 0) {
+                        done = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Find all Preferences the category's controller is observing.
+        final Set<String> actualObserved = new HashSet<>();
+        int maxObservedIndex = -1;
+        for (int i = 0; i < controllers.size(); i++) {
+            final PreferenceController controller = controllers.get(i);
+            if (controller instanceof DynamicAvailabilityPreferenceController &&
+                    ((DynamicAvailabilityPreferenceController) controller).getAvailabilityObserver()
+                            == exposureChangesCategoryController) {
+                actualObserved.add(controller.getPreferenceKey());
+                maxObservedIndex = i;
+            }
+        }
+
+        // Verify that the category's controller is observing the Preferences inside it.
+        assertThat(actualObserved).isEqualTo(expectedObserved);
+        // Verify that the category's controller is listed after the Preferences' controllers.
+        assertThat(maxObservedIndex).isLessThan(exposureChangesCategoryControllerIndex);
     }
 }

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

@@ -37,6 +37,7 @@ import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
 import com.android.settings.applications.EnterpriseDefaultApps;
 import com.android.settings.applications.UserAppInfo;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -51,6 +52,7 @@ import org.robolectric.annotation.Config;
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.mockito.Mockito.verify;
 /**
  * Tests for {@link EnterpriseSetDefaultAppsPreferenceController}.
  */
@@ -58,11 +60,14 @@ import java.util.List;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
 
+    private static final String KEY_DEFAULT_APPS = "number_enterprise_set_default_apps";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private UserManager mUm;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private EnterpriseSetDefaultAppsPreferenceController mController;
 
@@ -73,6 +78,12 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new EnterpriseSetDefaultAppsPreferenceController(mContext,
                 null /* lifecycle */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     private void setEnterpriseSetDefaultApps(Intent[] intents, int number) {
@@ -119,10 +130,12 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
         when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(anyInt(),
                 any(Intent[].class))).thenReturn(new ArrayList<>());
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, false);
 
         setEnterpriseSetDefaultApps(EnterpriseDefaultApps.BROWSER.getIntents(), 1);
         configureUsers(1);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, true);
     }
 
     @Test
@@ -133,8 +146,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey())
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_DEFAULT_APPS);
-                .isEqualTo("number_enterprise_set_default_apps");
     }
 
     private ArgumentMatcher<Intent[]> matchesIntents(Intent[] intents) {

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

@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.settings.enterprise;
+
+import android.content.Context;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.SettingsRobolectricTestRunner;
+import com.android.settings.TestConfig;
+import com.android.settings.core.DynamicAvailabilityPreferenceController;
+import com.android.settings.core.PreferenceAvailabilityObserver;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.annotation.Config;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.anyBoolean;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Tests for {@link ExposureChangesCategoryPreferenceController}.
+ */
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public final class ExposureChangesCategoryPreferenceControllerTest {
+
+    private static final String KEY_1 = "key_1";
+    private static final String KEY_2 = "key_2";
+    private static final String KEY_EXPOSURE_CHANGES_CATEGORY = "exposure_changes_category";
+
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+    private Context mContext;
+    private List<DynamicAvailabilityPreferenceController> mControllers;
+    private ExposureChangesCategoryPreferenceController mController;
+    @Mock private PreferenceAvailabilityObserver mObserver;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mControllers = Arrays.asList(mock(DynamicAvailabilityPreferenceController.class),
+                mock(DynamicAvailabilityPreferenceController.class));
+        mController = new ExposureChangesCategoryPreferenceController(mContext,
+                null /* lifecycle */, mControllers, true /* controllingUi */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testInitialization() {
+        verify(mControllers.get(0)).setAvailabilityObserver(mController);
+        verify(mControllers.get(1)).setAvailabilityObserver(mController);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
+    }
+
+    @Test
+    public void testOnPreferenceAvailabilityUpdated() {
+        final Preference preference = new Preference(mContext, null, 0, 0);
+        preference.setVisible(true);
+
+        mController.updateState(preference);
+        assertThat(preference.isVisible()).isFalse();
+
+        mController.onPreferenceAvailabilityUpdated(KEY_1, true);
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        assertThat(preference.isVisible()).isTrue();
+        reset(mObserver);
+
+        mController.onPreferenceAvailabilityUpdated(KEY_2, true);
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        assertThat(preference.isVisible()).isTrue();
+        reset(mObserver);
+
+        mController.onPreferenceAvailabilityUpdated(KEY_1, false);
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        assertThat(preference.isVisible()).isTrue();
+        reset(mObserver);
+
+        mController.onPreferenceAvailabilityUpdated(KEY_2, false);
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
+        assertThat(preference.isVisible()).isFalse();
+    }
+
+    @Test
+    public void testUpdateState() {
+        final Preference preference = new Preference(mContext, null, 0, 0);
+        preference.setVisible(false);
+
+        mController.onPreferenceAvailabilityUpdated(KEY_1, true);
+        mController.updateState(preference);
+        assertThat(preference.isVisible()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailableForUi() {
+        assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+
+        mController.onPreferenceAvailabilityUpdated(KEY_1, true);
+        reset(mObserver);
+        assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+
+        mController.onPreferenceAvailabilityUpdated(KEY_1, false);
+        reset(mObserver);
+        assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+    }
+
+    @Test
+    public void testIsAvailableForSearch() {
+        final ExposureChangesCategoryPreferenceController controller
+                = new ExposureChangesCategoryPreferenceController(mContext, null /* lifecycle */,
+                        mControllers, false /* controllingUi */);
+        controller.setAvailabilityObserver(mObserver);
+        verify(mControllers.get(0)).setAvailabilityObserver(controller);
+        verify(mControllers.get(1)).setAvailabilityObserver(controller);
+
+        assertThat(controller.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
+        reset(mObserver);
+
+        controller.onPreferenceAvailabilityUpdated(KEY_1, true);
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+        assertThat(controller.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        reset(mObserver);
+
+        controller.onPreferenceAvailabilityUpdated(KEY_2, true);
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+        assertThat(controller.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        reset(mObserver);
+
+        controller.onPreferenceAvailabilityUpdated(KEY_1, false);
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+        assertThat(controller.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, true);
+        reset(mObserver);
+
+        controller.onPreferenceAvailabilityUpdated(KEY_2, false);
+        verify(mObserver, never()).onPreferenceAvailabilityUpdated(
+                eq(KEY_EXPOSURE_CHANGES_CATEGORY), anyBoolean());
+        assertThat(controller.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_EXPOSURE_CHANGES_CATEGORY, false);
+    }
+
+    @Test
+    public void testHandlePreferenceTreeClick() {
+        assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0)))
+                .isFalse();
+    }
+
+    @Test
+    public void testGetPreferenceKey() {
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_EXPOSURE_CHANGES_CATEGORY);
+    }
+}

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

@@ -21,6 +21,7 @@ import android.content.res.Resources;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -30,6 +31,7 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -42,6 +44,7 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     protected Context mContext;
     protected FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     protected FailedPasswordWipePreferenceControllerBase mController;
 
@@ -56,6 +59,12 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
     }
 
+    @Test
+    public void testGetAvailabilityObserver() {
+        mController.setAvailabilityObserver(mObserver);
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
+    }
+
     public abstract void setMaximumFailedPasswordsBeforeWipe(int maximum);
 
     @Test
@@ -72,11 +81,15 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase {
 
     @Test
     public void testIsAvailable() {
+        mController.setAvailabilityObserver(mObserver);
+
         setMaximumFailedPasswordsBeforeWipe(0);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
 
         setMaximumFailedPasswordsBeforeWipe(10);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
     }
 
     @Test

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

@@ -21,6 +21,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -32,6 +33,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -40,9 +42,13 @@ import static org.mockito.Mockito.when;
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class GlobalHttpProxyPreferenceControllerTest {
+
+    private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy";
+
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private GlobalHttpProxyPreferenceController mController;
 
@@ -52,6 +58,12 @@ public final class GlobalHttpProxyPreferenceControllerTest {
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
         mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -59,10 +71,12 @@ public final class GlobalHttpProxyPreferenceControllerTest {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
                 .thenReturn(false);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
                 .thenReturn(true);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, true);
     }
 
     @Test
@@ -73,6 +87,6 @@ public final class GlobalHttpProxyPreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("global_http_proxy");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_GLOBAL_HTTP_PROXY);
     }
 }

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

@@ -23,6 +23,7 @@ import android.support.v7.preference.Preference;
 
 import com.android.settings.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
+import com.android.settings.core.PreferenceAvailabilityObserver;
 import com.android.settings.testutils.FakeFeatureFactory;
 
 import org.junit.Before;
@@ -34,6 +35,7 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 /**
@@ -43,12 +45,14 @@ import static org.mockito.Mockito.when;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public final class ImePreferenceControllerTest {
 
-    private final String DEFAULT_IME_LABEL = "Test IME";
+    private static final String DEFAULT_IME_LABEL = "Test IME";
-    private final String DEFAULT_IME_TEXT = "Set to Test IME";
+    private static final String DEFAULT_IME_TEXT = "Set to Test IME";
+    private static final String KEY_INPUT_METHOD = "input_method";
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
     private FakeFeatureFactory mFeatureFactory;
+    @Mock private PreferenceAvailabilityObserver mObserver;
 
     private ImePreferenceController mController;
 
@@ -60,6 +64,12 @@ public final class ImePreferenceControllerTest {
         mController = new ImePreferenceController(mContext, null /* lifecycle */);
         when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name,
                 DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT);
+        mController.setAvailabilityObserver(mObserver);
+    }
+
+    @Test
+    public void testGetAvailabilityObserver() {
+        assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
     }
 
     @Test
@@ -77,10 +87,12 @@ public final class ImePreferenceControllerTest {
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
             .thenReturn(null);
         assertThat(mController.isAvailable()).isFalse();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, false);
 
         when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
             .thenReturn(DEFAULT_IME_LABEL);
         assertThat(mController.isAvailable()).isTrue();
+        verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, true);
     }
 
     @Test
@@ -91,6 +103,6 @@ public final class ImePreferenceControllerTest {
 
     @Test
     public void testGetPreferenceKey() {
-        assertThat(mController.getPreferenceKey()).isEqualTo("input_method");
+        assertThat(mController.getPreferenceKey()).isEqualTo(KEY_INPUT_METHOD);
     }
 }