From b5f5ffbece14b4f2882144f465ee67b35d5aa567 Mon Sep 17 00:00:00 2001 From: Fan Zhang Date: Tue, 7 Nov 2017 10:57:47 -0800 Subject: [PATCH] Remove DynamicAvailabilityPreferenceController. - This class is over complex to use, and get in the way of show/hide pref when availability change. - The function from DynamicAvailabilityPreferenceController can be done with PreferenceCategoryController. Bug: 68956750 Bug: 32953042 Test: robotests Change-Id: Ia7b7e214c072b8c77f5de3d959fdb1dc79217f76 --- ...namicAvailabilityPreferenceController.java | 75 ------- .../core/PreferenceAvailabilityObserver.java | 33 --- ...dCameraPermissionPreferenceController.java | 8 +- ...cationPermissionsPreferenceController.java | 9 +- ...rophonePermissionPreferenceController.java | 8 +- ...edPermissionsPreferenceControllerBase.java | 16 +- ...sOnVpnCurrentUserPreferenceController.java | 14 +- ...VpnManagedProfilePreferenceController.java | 14 +- ...aCertsCurrentUserPreferenceController.java | 7 +- ...rtsManagedProfilePreferenceController.java | 7 +- .../CaCertsPreferenceControllerBase.java | 14 +- ...InstalledPackagesPreferenceController.java | 17 +- ...EnterprisePrivacyPreferenceController.java | 18 +- .../enterprise/EnterprisePrivacySettings.java | 52 +++-- ...iseSetDefaultAppsPreferenceController.java | 14 +- ...reChangesCategoryPreferenceController.java | 111 ---------- ...rdWipeCurrentUserPreferenceController.java | 6 +- ...ipeManagedProfilePreferenceController.java | 6 +- ...dPasswordWipePreferenceControllerBase.java | 15 +- .../GlobalHttpProxyPreferenceController.java | 15 +- .../enterprise/ImePreferenceController.java | 20 +- .../settings/security/SecuritySettings.java | 8 +- ...cAvailabilityPreferenceControllerTest.java | 157 -------------- ...eraPermissionPreferenceControllerTest.java | 6 +- ...onPermissionsPreferenceControllerTest.java | 8 +- ...onePermissionPreferenceControllerTest.java | 8 +- ...rmissionsPreferenceControllerBaseTest.java | 6 +- ...rmissionsPreferenceControllerTestBase.java | 35 +--- ...pnCurrentUserPreferenceControllerTest.java | 24 +-- ...anagedProfilePreferenceControllerTest.java | 22 +- .../ApplicationListFragmentTest.java | 10 +- ...tsCurrentUserPreferenceControllerTest.java | 2 +- ...anagedProfilePreferenceControllerTest.java | 2 +- .../CaCertsPreferenceControllerBaseTest.java | 2 +- .../CaCertsPreferenceControllerTestBase.java | 13 -- ...alledPackagesPreferenceControllerTest.java | 48 ++--- ...rprisePrivacyPreferenceControllerTest.java | 23 +-- .../EnterprisePrivacySettingsTest.java | 87 +------- ...etDefaultAppsPreferenceControllerTest.java | 20 +- ...angesCategoryPreferenceControllerTest.java | 192 ------------------ ...peCurrentUserPreferenceControllerTest.java | 11 +- ...anagedProfilePreferenceControllerTest.java | 11 +- ...swordWipePreferenceControllerBaseTest.java | 5 +- ...swordWipePreferenceControllerTestBase.java | 20 +- ...obalHttpProxyPreferenceControllerTest.java | 21 +- .../ImePreferenceControllerTest.java | 30 +-- 46 files changed, 202 insertions(+), 1048 deletions(-) delete mode 100644 src/com/android/settings/core/DynamicAvailabilityPreferenceController.java delete mode 100644 src/com/android/settings/core/PreferenceAvailabilityObserver.java delete mode 100644 src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceController.java delete mode 100644 tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java delete mode 100644 tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java diff --git a/src/com/android/settings/core/DynamicAvailabilityPreferenceController.java b/src/com/android/settings/core/DynamicAvailabilityPreferenceController.java deleted file mode 100644 index 04a561cb54e..00000000000 --- a/src/com/android/settings/core/DynamicAvailabilityPreferenceController.java +++ /dev/null @@ -1,75 +0,0 @@ -/* - * 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; - -import android.content.Context; -import android.support.v7.preference.Preference; -import android.support.v7.preference.PreferenceScreen; - -import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.Lifecycle; -import com.android.settingslib.core.lifecycle.LifecycleObserver; -import com.android.settingslib.core.lifecycle.events.OnResume; - -public abstract class DynamicAvailabilityPreferenceController extends AbstractPreferenceController - implements PreferenceControllerMixin, LifecycleObserver, OnResume { - - private Preference mPreference; - private PreferenceScreen mScreen; - private PreferenceAvailabilityObserver mAvailabilityObserver = null; - - public DynamicAvailabilityPreferenceController(Context context, Lifecycle lifecycle) { - super(context); - if (lifecycle != null) { - lifecycle.addObserver(this); - } - } - - public void setAvailabilityObserver(PreferenceAvailabilityObserver observer) { - mAvailabilityObserver = observer; - } - - public PreferenceAvailabilityObserver getAvailabilityObserver() { - return mAvailabilityObserver; - } - - @Override - public void displayPreference(PreferenceScreen screen) { - mScreen = screen; - mPreference = screen.findPreference(getPreferenceKey()); - super.displayPreference(screen); - } - - @Override - public void onResume() { - if (!isAvailable()) { - removePreference(mScreen, getPreferenceKey()); - return; - } - - updateState(mPreference); - if (mScreen.findPreference(getPreferenceKey()) == null) { - mScreen.addPreference(mPreference); - } - } - - protected void notifyOnAvailabilityUpdate(boolean available) { - if (mAvailabilityObserver != null) { - mAvailabilityObserver.onPreferenceAvailabilityUpdated(getPreferenceKey(), available); - } - } -} diff --git a/src/com/android/settings/core/PreferenceAvailabilityObserver.java b/src/com/android/settings/core/PreferenceAvailabilityObserver.java deleted file mode 100644 index 46ff3bacb54..00000000000 --- a/src/com/android/settings/core/PreferenceAvailabilityObserver.java +++ /dev/null @@ -1,33 +0,0 @@ -/* - * 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); -} diff --git a/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java index be41e4d5e64..6b4e70d1adc 100644 --- a/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java @@ -17,18 +17,14 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class AdminGrantedCameraPermissionPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_CAMERA_ACCESS_PACKAGES = "enterprise_privacy_number_camera_access_packages"; - public AdminGrantedCameraPermissionPreferenceController(Context context, Lifecycle lifecycle, - boolean async) { - super(context, lifecycle, async, new String[] {Manifest.permission.CAMERA}, - Manifest.permission_group.CAMERA); + public AdminGrantedCameraPermissionPreferenceController(Context context, boolean async) { + super(context, async, new String[] {Manifest.permission.CAMERA}); } @Override diff --git a/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java index 77c60403788..5c6dfc263dd 100644 --- a/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java @@ -17,18 +17,15 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class AdminGrantedLocationPermissionsPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_LOCATION_ACCESS_PACKAGES = "enterprise_privacy_number_location_access_packages"; - public AdminGrantedLocationPermissionsPreferenceController(Context context, Lifecycle lifecycle, - boolean async) { - super(context, lifecycle, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION, - Manifest.permission.ACCESS_FINE_LOCATION}, Manifest.permission_group.LOCATION); + public AdminGrantedLocationPermissionsPreferenceController(Context context, boolean async) { + super(context, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION, + Manifest.permission.ACCESS_FINE_LOCATION}); } @Override diff --git a/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java index 9896420eadb..74e260a0d74 100644 --- a/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java @@ -17,18 +17,14 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class AdminGrantedMicrophonePermissionPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_MICROPHONE_ACCESS_PACKAGES = "enterprise_privacy_number_microphone_access_packages"; - public AdminGrantedMicrophonePermissionPreferenceController(Context context, - Lifecycle lifecycle, boolean async) { - super(context, lifecycle, async, new String[] {Manifest.permission.RECORD_AUDIO}, - Manifest.permission_group.MICROPHONE); + public AdminGrantedMicrophonePermissionPreferenceController(Context context, boolean async) { + super(context, async, new String[] {Manifest.permission.RECORD_AUDIO}); } @Override diff --git a/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java b/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java index 9187cecd33c..dd5ab34b9ba 100644 --- a/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java @@ -20,24 +20,22 @@ import android.support.v7.preference.Preference; import com.android.settings.R; import com.android.settings.applications.ApplicationFeatureProvider; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public abstract class AdminGrantedPermissionsPreferenceControllerBase - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { private final String[] mPermissions; - private final String mPermissionGroup; private final ApplicationFeatureProvider mFeatureProvider; private final boolean mAsync; private boolean mHasApps; - public AdminGrantedPermissionsPreferenceControllerBase(Context context, Lifecycle lifecycle, - boolean async, String[] permissions, String permissionGroup) { - super(context, lifecycle); + public AdminGrantedPermissionsPreferenceControllerBase(Context context, boolean async, + String[] permissions) { + super(context); mPermissions = permissions; - mPermissionGroup = permissionGroup; mFeatureProvider = FeatureFactory.getFactory(context) .getApplicationFeatureProvider(context); mAsync = async; @@ -58,7 +56,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase mHasApps = true; } preference.setVisible(mHasApps); - notifyOnAvailabilityUpdate(mHasApps); }); } @@ -80,7 +77,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions, false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0); mHasApps = haveAppsWithAdminGrantedPermissions[0]; - notifyOnAvailabilityUpdate(mHasApps); return mHasApps; } diff --git a/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceController.java b/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceController.java index ed91fef0538..883fd36bf97 100644 --- a/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceController.java +++ b/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceController.java @@ -17,18 +17,18 @@ import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public class AlwaysOnVpnCurrentUserPreferenceController - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public AlwaysOnVpnCurrentUserPreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public AlwaysOnVpnCurrentUserPreferenceController(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -42,9 +42,7 @@ public class AlwaysOnVpnCurrentUserPreferenceController @Override public boolean isAvailable() { - final boolean available = mFeatureProvider.isAlwaysOnVpnSetInCurrentUser(); - notifyOnAvailabilityUpdate(available); - return available; + return mFeatureProvider.isAlwaysOnVpnSetInCurrentUser(); } @Override diff --git a/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java index db6fc1d5b01..a23af0cde5d 100644 --- a/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java @@ -15,27 +15,25 @@ package com.android.settings.enterprise; import android.content.Context; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public class AlwaysOnVpnManagedProfilePreferenceController - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public AlwaysOnVpnManagedProfilePreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public AlwaysOnVpnManagedProfilePreferenceController(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @Override public boolean isAvailable() { - final boolean available = mFeatureProvider.isAlwaysOnVpnSetInManagedProfile(); - notifyOnAvailabilityUpdate(available); - return available; + return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile(); } @Override diff --git a/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java b/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java index 30da90718a7..e328fc579e4 100644 --- a/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java +++ b/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java @@ -20,16 +20,13 @@ import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class CaCertsCurrentUserPreferenceController extends CaCertsPreferenceControllerBase { @VisibleForTesting static final String CA_CERTS_CURRENT_USER = "ca_certs_current_user"; - public CaCertsCurrentUserPreferenceController(Context context, - Lifecycle lifecycle) { - super(context, lifecycle); + public CaCertsCurrentUserPreferenceController(Context context) { + super(context); } @Override diff --git a/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java index 2b4e72d724d..94b923ff679 100644 --- a/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java @@ -17,16 +17,13 @@ package com.android.settings.enterprise; import android.content.Context; import android.support.annotation.VisibleForTesting; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class CaCertsManagedProfilePreferenceController extends CaCertsPreferenceControllerBase { @VisibleForTesting static final String CA_CERTS_MANAGED_PROFILE = "ca_certs_managed_profile"; - public CaCertsManagedProfilePreferenceController(Context context, - Lifecycle lifecycle) { - super(context, lifecycle); + public CaCertsManagedProfilePreferenceController(Context context) { + super(context); } @Override diff --git a/src/com/android/settings/enterprise/CaCertsPreferenceControllerBase.java b/src/com/android/settings/enterprise/CaCertsPreferenceControllerBase.java index 8009caf6fe7..b9df20a728e 100644 --- a/src/com/android/settings/enterprise/CaCertsPreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/CaCertsPreferenceControllerBase.java @@ -18,17 +18,17 @@ import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public abstract class CaCertsPreferenceControllerBase - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { protected final EnterprisePrivacyFeatureProvider mFeatureProvider; - public CaCertsPreferenceControllerBase(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public CaCertsPreferenceControllerBase(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -42,9 +42,7 @@ public abstract class CaCertsPreferenceControllerBase @Override public boolean isAvailable() { - final boolean available = getNumberOfCaCerts() > 0; - notifyOnAvailabilityUpdate(available); - return available; + return getNumberOfCaCerts() > 0; } protected abstract int getNumberOfCaCerts(); diff --git a/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceController.java b/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceController.java index cced8e85269..1086c0e059d 100644 --- a/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceController.java +++ b/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceController.java @@ -18,21 +18,20 @@ import android.support.v7.preference.Preference; import com.android.settings.R; import com.android.settings.applications.ApplicationFeatureProvider; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public class EnterpriseInstalledPackagesPreferenceController - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { 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, Lifecycle lifecycle, - boolean async) { - super(context, lifecycle); + public EnterpriseInstalledPackagesPreferenceController(Context context, boolean async) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getApplicationFeatureProvider(context); mAsync = async; @@ -53,7 +52,6 @@ public class EnterpriseInstalledPackagesPreferenceController } preference.setVisible(available); - notifyOnAvailabilityUpdate(available); }); } @@ -72,9 +70,8 @@ public class EnterpriseInstalledPackagesPreferenceController final Boolean[] haveEnterpriseInstalledPackages = { null }; mFeatureProvider.calculateNumberOfPolicyInstalledApps(false /* async */, (num) -> haveEnterpriseInstalledPackages[0] = num > 0); - final boolean available = haveEnterpriseInstalledPackages[0]; - notifyOnAvailabilityUpdate(available); - return available; + return haveEnterpriseInstalledPackages[0]; + } @Override diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceController.java b/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceController.java index 6ec091bbca5..11fc29e78eb 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceController.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceController.java @@ -17,23 +17,27 @@ import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; -public class EnterprisePrivacyPreferenceController extends DynamicAvailabilityPreferenceController { +public class EnterprisePrivacyPreferenceController extends AbstractPreferenceController implements + PreferenceControllerMixin { private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public EnterprisePrivacyPreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public EnterprisePrivacyPreferenceController(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @Override public void updateState(Preference preference) { + if (preference == null) { + return; + } final String organizationName = mFeatureProvider.getDeviceOwnerOrganizationName(); if (organizationName == null) { preference.setSummary(R.string.enterprise_privacy_settings_summary_generic); @@ -45,9 +49,7 @@ public class EnterprisePrivacyPreferenceController extends DynamicAvailabilityPr @Override public boolean isAvailable() { - final boolean available = mFeatureProvider.hasDeviceOwner(); - notifyOnAvailabilityUpdate(available); - return available; + return mFeatureProvider.hasDeviceOwner(); } @Override diff --git a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java index 4caec302cc5..0628dbb8269 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java @@ -21,12 +21,11 @@ import android.provider.SearchIndexableResource; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; import com.android.settings.dashboard.DashboardFragment; import com.android.settings.overlay.FeatureFactory; import com.android.settings.search.BaseSearchIndexProvider; +import com.android.settings.widget.PreferenceCategoryController; import com.android.settingslib.core.AbstractPreferenceController; -import com.android.settingslib.core.lifecycle.Lifecycle; import java.util.ArrayList; import java.util.Arrays; @@ -53,45 +52,41 @@ public class EnterprisePrivacySettings extends DashboardFragment { @Override protected List getPreferenceControllers(Context context) { - return buildPreferenceControllers(context, getLifecycle(), true /* async */); + return buildPreferenceControllers(context, true /* async */); } private static List buildPreferenceControllers(Context context, - Lifecycle lifecycle, boolean async) { + boolean async) { final List controllers = new ArrayList<>(); controllers.add(new NetworkLogsPreferenceController(context)); controllers.add(new BugReportsPreferenceController(context)); controllers.add(new SecurityLogsPreferenceController(context)); - final List exposureChangesCategoryControllers = + final List exposureChangesCategoryControllers = new ArrayList<>(); exposureChangesCategoryControllers.add(new EnterpriseInstalledPackagesPreferenceController( - context, lifecycle, async)); + context, async)); exposureChangesCategoryControllers.add( - new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle, async)); + new AdminGrantedLocationPermissionsPreferenceController(context, async)); exposureChangesCategoryControllers.add( - new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle, - async)); + new AdminGrantedMicrophonePermissionPreferenceController(context, async)); exposureChangesCategoryControllers.add(new AdminGrantedCameraPermissionPreferenceController( - context, lifecycle, async)); + context, async)); exposureChangesCategoryControllers.add(new EnterpriseSetDefaultAppsPreferenceController( - context, lifecycle)); + context)); exposureChangesCategoryControllers.add(new AlwaysOnVpnCurrentUserPreferenceController( - context, lifecycle)); + context)); exposureChangesCategoryControllers.add(new AlwaysOnVpnManagedProfilePreferenceController( - context, lifecycle)); - exposureChangesCategoryControllers.add(new ImePreferenceController(context, lifecycle)); - exposureChangesCategoryControllers.add(new GlobalHttpProxyPreferenceController(context, - lifecycle)); - exposureChangesCategoryControllers.add(new CaCertsCurrentUserPreferenceController( - context, lifecycle)); + context)); + exposureChangesCategoryControllers.add(new ImePreferenceController(context)); + exposureChangesCategoryControllers.add(new GlobalHttpProxyPreferenceController(context)); + exposureChangesCategoryControllers.add(new CaCertsCurrentUserPreferenceController(context)); exposureChangesCategoryControllers.add(new CaCertsManagedProfilePreferenceController( - context, lifecycle)); + context)); 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 PreferenceCategoryController(context, "exposure_changes_category", + exposureChangesCategoryControllers)); + controllers.add(new FailedPasswordWipeCurrentUserPreferenceController(context)); + controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context)); return controllers; } @@ -114,11 +109,12 @@ public class EnterprisePrivacySettings extends DashboardFragment { final SearchIndexableResource sir = new SearchIndexableResource(context); sir.xmlResId = R.xml.enterprise_privacy_settings; return Arrays.asList(sir); - } + } - @Override - public List getPreferenceControllers(Context context) { - return buildPreferenceControllers(context, null /* lifecycle */, false /* async */); + @Override + public List getPreferenceControllers( + Context context) { + return buildPreferenceControllers(context, false /* async */); } }; } diff --git a/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceController.java b/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceController.java index 537ef780d13..0f9584beebd 100644 --- a/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceController.java +++ b/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceController.java @@ -21,20 +21,20 @@ import android.support.v7.preference.Preference; import com.android.settings.R; import com.android.settings.applications.ApplicationFeatureProvider; import com.android.settings.applications.EnterpriseDefaultApps; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; import com.android.settings.users.UserFeatureProvider; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public class EnterpriseSetDefaultAppsPreferenceController - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { private static final String KEY_DEFAULT_APPS = "number_enterprise_set_default_apps"; private final ApplicationFeatureProvider mApplicationFeatureProvider; private final UserFeatureProvider mUserFeatureProvider; - public EnterpriseSetDefaultAppsPreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public EnterpriseSetDefaultAppsPreferenceController(Context context) { + super(context); final FeatureFactory factory = FeatureFactory.getFactory(context); mApplicationFeatureProvider = factory.getApplicationFeatureProvider(context); mUserFeatureProvider = factory.getUserFeatureProvider(context); @@ -49,9 +49,7 @@ public class EnterpriseSetDefaultAppsPreferenceController @Override public boolean isAvailable() { - final boolean available = getNumberOfEnterpriseSetDefaultApps() > 0; - notifyOnAvailabilityUpdate(available); - return available; + return getNumberOfEnterpriseSetDefaultApps() > 0; } @Override diff --git a/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceController.java b/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceController.java deleted file mode 100644 index 7833325b995..00000000000 --- a/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceController.java +++ /dev/null @@ -1,111 +0,0 @@ - -/* - * 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 mAvailablePrefs = new HashSet(); - 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 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; - } -} diff --git a/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceController.java b/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceController.java index d7f8dc0506d..f93025cdcbc 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceController.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceController.java @@ -15,16 +15,14 @@ package com.android.settings.enterprise; import android.content.Context; -import com.android.settingslib.core.lifecycle.Lifecycle; - public class FailedPasswordWipeCurrentUserPreferenceController extends FailedPasswordWipePreferenceControllerBase { private static final String KEY_FAILED_PASSWORD_WIPE_CURRENT_USER = "failed_password_wipe_current_user"; - public FailedPasswordWipeCurrentUserPreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public FailedPasswordWipeCurrentUserPreferenceController(Context context) { + super(context); } @Override diff --git a/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java index 739003a588e..5a0e7c8264d 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java @@ -14,7 +14,6 @@ package com.android.settings.enterprise; import android.content.Context; -import com.android.settingslib.core.lifecycle.Lifecycle; public class FailedPasswordWipeManagedProfilePreferenceController extends FailedPasswordWipePreferenceControllerBase { @@ -22,9 +21,8 @@ public class FailedPasswordWipeManagedProfilePreferenceController private static final String KEY_FAILED_PASSWORD_WIPE_MANAGED_PROFILE = "failed_password_wipe_managed_profile"; - public FailedPasswordWipeManagedProfilePreferenceController(Context context, - Lifecycle lifecycle) { - super(context, lifecycle); + public FailedPasswordWipeManagedProfilePreferenceController(Context context) { + super(context); } @Override diff --git a/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java b/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java index 298f9119997..3c78c213359 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java @@ -15,21 +15,20 @@ package com.android.settings.enterprise; import android.content.Context; -import android.content.res.Resources; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; public abstract class FailedPasswordWipePreferenceControllerBase - extends DynamicAvailabilityPreferenceController { + extends AbstractPreferenceController implements PreferenceControllerMixin { protected final EnterprisePrivacyFeatureProvider mFeatureProvider; - public FailedPasswordWipePreferenceControllerBase(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public FailedPasswordWipePreferenceControllerBase(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -46,8 +45,6 @@ public abstract class FailedPasswordWipePreferenceControllerBase @Override public boolean isAvailable() { - final boolean available = getMaximumFailedPasswordsBeforeWipe() > 0; - notifyOnAvailabilityUpdate(available); - return available; + return getMaximumFailedPasswordsBeforeWipe() > 0; } } diff --git a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java index 55552b689a7..04e63aa1e8b 100644 --- a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java +++ b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java @@ -15,26 +15,25 @@ package com.android.settings.enterprise; import android.content.Context; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; -public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPreferenceController { +public class GlobalHttpProxyPreferenceController extends AbstractPreferenceController implements + PreferenceControllerMixin { private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public GlobalHttpProxyPreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public GlobalHttpProxyPreferenceController(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @Override public boolean isAvailable() { - final boolean available = mFeatureProvider.isGlobalHttpProxySet(); - notifyOnAvailabilityUpdate(available); - return available; + return mFeatureProvider.isGlobalHttpProxySet(); } @Override diff --git a/src/com/android/settings/enterprise/ImePreferenceController.java b/src/com/android/settings/enterprise/ImePreferenceController.java index ca52fc00f30..7a4ea2cea8c 100644 --- a/src/com/android/settings/enterprise/ImePreferenceController.java +++ b/src/com/android/settings/enterprise/ImePreferenceController.java @@ -15,21 +15,21 @@ package com.android.settings.enterprise; import android.content.Context; -import android.content.res.Resources; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.PreferenceControllerMixin; import com.android.settings.overlay.FeatureFactory; -import com.android.settingslib.core.lifecycle.Lifecycle; +import com.android.settingslib.core.AbstractPreferenceController; -public class ImePreferenceController extends DynamicAvailabilityPreferenceController { +public class ImePreferenceController extends AbstractPreferenceController implements + PreferenceControllerMixin { private static final String KEY_INPUT_METHOD = "input_method"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public ImePreferenceController(Context context, Lifecycle lifecycle) { - super(context, lifecycle); + public ImePreferenceController(Context context) { + super(context); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -37,15 +37,13 @@ public class ImePreferenceController extends DynamicAvailabilityPreferenceContro @Override public void updateState(Preference preference) { preference.setSummary(mContext.getResources().getString( - R.string.enterprise_privacy_input_method_name, - mFeatureProvider.getImeLabelIfOwnerSet())); + R.string.enterprise_privacy_input_method_name, + mFeatureProvider.getImeLabelIfOwnerSet())); } @Override public boolean isAvailable() { - final boolean available = mFeatureProvider.getImeLabelIfOwnerSet() != null; - notifyOnAvailabilityUpdate(available); - return available; + return mFeatureProvider.getImeLabelIfOwnerSet() != null; } @Override diff --git a/src/com/android/settings/security/SecuritySettings.java b/src/com/android/settings/security/SecuritySettings.java index 02beaaad172..35ce909f58e 100644 --- a/src/com/android/settings/security/SecuritySettings.java +++ b/src/com/android/settings/security/SecuritySettings.java @@ -206,7 +206,7 @@ public class SecuritySettings extends SettingsPreferenceFragment mManageDeviceAdminPreferenceController = new ManageDeviceAdminPreferenceController(activity); mEnterprisePrivacyPreferenceController - = new EnterprisePrivacyPreferenceController(activity, null /* lifecycle */); + = new EnterprisePrivacyPreferenceController(activity); mLockScreenNotificationPreferenceController = new LockScreenNotificationPreferenceController(activity); } @@ -400,7 +400,9 @@ public class SecuritySettings extends SettingsPreferenceFragment mManageDeviceAdminPreferenceController.updateState( root.findPreference(KEY_MANAGE_DEVICE_ADMIN)); mEnterprisePrivacyPreferenceController.displayPreference(root); - mEnterprisePrivacyPreferenceController.onResume(); + final Preference enterprisePrivacyPreference = root.findPreference( + mEnterprisePrivacyPreferenceController.getPreferenceKey()); + mEnterprisePrivacyPreferenceController.updateState(enterprisePrivacyPreference); return root; } @@ -893,7 +895,7 @@ public class SecuritySettings extends SettingsPreferenceFragment keys.add(KEY_MANAGE_TRUST_AGENTS); } - if (!(new EnterprisePrivacyPreferenceController(context, null /* lifecycle */)) + if (!(new EnterprisePrivacyPreferenceController(context)) .isAvailable()) { keys.add(KEY_ENTERPRISE_PRIVACY); } diff --git a/tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java deleted file mode 100644 index 9bf73cea278..00000000000 --- a/tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java +++ /dev/null @@ -1,157 +0,0 @@ -/* - * 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; - -import android.content.Context; -import android.support.v7.preference.Preference; -import android.support.v7.preference.PreferenceScreen; - -import com.android.settings.testutils.SettingsRobolectricTestRunner; -import com.android.settings.TestConfig; -import com.android.settingslib.core.lifecycle.Lifecycle; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.robolectric.annotation.Config; - -import static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.reset; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -/** - * Tests for {@link DynamicAvailabilityPreferenceController}. - */ -@RunWith(SettingsRobolectricTestRunner.class) -@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) -public final class DynamicAvailabilityPreferenceControllerTest { - - private final String PREFERENCE_KEY = "preference_key"; - - private @Mock Context mContext; - private @Mock Preference mPreference; - private @Mock PreferenceScreen mScreen; - private @Mock Lifecycle mLifecycle; - private @Mock PreferenceAvailabilityObserver mObserver; - - private boolean mIsAvailable; - private Preference mUpdatedPreference = null; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - when(mPreference.getKey()).thenReturn(PREFERENCE_KEY); - when(mScreen.findPreference(PREFERENCE_KEY)).thenReturn(mPreference); - when(mScreen.getPreferenceCount()).thenReturn(1); - when(mScreen.getPreference(0)).thenReturn(mPreference); - } - - @Test - public void testAvailableToUnavailable() { - mIsAvailable = true; - - final DynamicAvailabilityPreferenceController controller - = new DynamicAvailabilityPreferenceControllerTestable(mLifecycle); - verify(mLifecycle).addObserver(controller); - - controller.displayPreference(mScreen); - verify(mScreen, never()).removePreference(mPreference); - verify(mScreen, never()).addPreference(mPreference); - assertThat(mUpdatedPreference).isNull(); - - controller.onResume(); - verify(mScreen, never()).removePreference(mPreference); - verify(mScreen, never()).addPreference(mPreference); - assertThat(mUpdatedPreference).isEqualTo(mPreference); - - mUpdatedPreference = null; - mIsAvailable = false; - controller.onResume(); - verify(mScreen).removePreference(mPreference); - verify(mScreen, never()).addPreference(mPreference); - assertThat(mUpdatedPreference).isNull(); - } - - @Test - public void testUnavailableToAvailable() { - mIsAvailable = false; - - final DynamicAvailabilityPreferenceController controller - = new DynamicAvailabilityPreferenceControllerTestable(mLifecycle); - verify(mLifecycle).addObserver(controller); - - controller.displayPreference(mScreen); - verify(mScreen).removePreference(mPreference); - verify(mScreen, never()).addPreference(mPreference); - assertThat(mUpdatedPreference).isNull(); - - reset(mScreen); - controller.onResume(); - verify(mScreen, never()).removePreference(mPreference); - verify(mScreen, never()).addPreference(mPreference); - assertThat(mUpdatedPreference).isNull(); - - mIsAvailable = true; - controller.onResume(); - verify(mScreen, never()).removePreference(mPreference); - verify(mScreen).addPreference(mPreference); - 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 { - public DynamicAvailabilityPreferenceControllerTestable(Lifecycle lifecycle) { - super(DynamicAvailabilityPreferenceControllerTest.this.mContext, lifecycle); - } - - @Override - public boolean isAvailable() { - notifyOnAvailabilityUpdate(mIsAvailable); - return mIsAvailable; - } - - @Override - public void updateState(Preference preference) { - mUpdatedPreference = preference; - } - - @Override - public String getPreferenceKey() { - return PREFERENCE_KEY; - } - } -} diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java index 491fcdba99d..1154aa7bbe3 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java @@ -34,13 +34,11 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends public AdminGrantedCameraPermissionPreferenceControllerTest() { super("enterprise_privacy_number_camera_access_packages", - new String[] {Manifest.permission.CAMERA}, - Manifest.permission_group.CAMERA); + new String[] {Manifest.permission.CAMERA}); } @Override protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { - return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */, - async); + return new AdminGrantedCameraPermissionPreferenceController(mContext, async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java index 01a13d29394..1c30da167fa 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java @@ -18,8 +18,8 @@ package com.android.settings.enterprise; import android.Manifest; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; @@ -35,13 +35,11 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten public AdminGrantedLocationPermissionsPreferenceControllerTest() { super("enterprise_privacy_number_location_access_packages", new String[] {Manifest.permission.ACCESS_COARSE_LOCATION, - Manifest.permission.ACCESS_FINE_LOCATION}, - Manifest.permission_group.LOCATION); + Manifest.permission.ACCESS_FINE_LOCATION}); } @Override protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { - return new AdminGrantedLocationPermissionsPreferenceController(mContext, - null /* lifecycle */, async); + return new AdminGrantedLocationPermissionsPreferenceController(mContext, async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java index fed16317219..624022b90ed 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java @@ -18,8 +18,8 @@ package com.android.settings.enterprise; import android.Manifest; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; @@ -34,13 +34,11 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte public AdminGrantedMicrophonePermissionPreferenceControllerTest() { super("enterprise_privacy_number_microphone_access_packages", - new String[] {Manifest.permission.RECORD_AUDIO}, - Manifest.permission_group.MICROPHONE); + new String[] {Manifest.permission.RECORD_AUDIO}); } @Override protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { - return new AdminGrantedMicrophonePermissionPreferenceController(mContext, - null /* lifecycle */, async); + return new AdminGrantedMicrophonePermissionPreferenceController(mContext, async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java index a209a46256e..a5d1d1a855d 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java @@ -16,8 +16,8 @@ package com.android.settings.enterprise; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; @@ -31,7 +31,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends AdminGrantedPermissionsPreferenceControllerTestBase { public AdminGrantedPermissionsPreferenceControllerBaseTest() { - super("some.key", new String[] {"some.permission"}, "some.permission"); + super("some.key", new String[] {"some.permission"}); } @Override @@ -44,7 +44,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) { super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext, - null /* lifecycle */, async, mPermissions, mPermissionGroup); + async, mPermissions); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java index c1a3143065b..421fb0f42ab 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java @@ -16,12 +16,17 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.when; + import android.content.Context; 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,35 +37,22 @@ import org.mockito.MockitoAnnotations; 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; - /** * Common base for testing subclasses of {@link AdminGrantedPermissionsPreferenceControllerBase}. */ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase { protected final String mKey; protected final String[] mPermissions; - protected final String mPermissionGroup; @Mock(answer = Answers.RETURNS_DEEP_STUBS) protected Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; protected AdminGrantedPermissionsPreferenceControllerBase mController; - public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions, - String permissionGroup) { + public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions) { mKey = key; mPermissions = permissions; - mPermissionGroup = permissionGroup; } @Before @@ -69,12 +61,6 @@ 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) { @@ -96,7 +82,6 @@ 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( @@ -105,33 +90,27 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceControllerTest.java index 045acf2ebd0..365b9beb662 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceControllerTest.java @@ -16,14 +16,16 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + import android.content.Context; -import com.android.settings.R; import android.support.v7.preference.Preference; -import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settings.R; import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceAvailabilityObserver; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -33,10 +35,6 @@ import org.mockito.Mock; 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; - /** * Tests for {@link AlwaysOnVpnCurrentUserPreferenceController}. */ @@ -51,7 +49,6 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private AlwaysOnVpnCurrentUserPreferenceController mController; @@ -60,18 +57,11 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext, - null /* lifecycle */); + mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext); when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device)) .thenReturn(VPN_SET_DEVICE); when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal)) .thenReturn(VPN_SET_PERSONAL); - mController.setAvailabilityObserver(mObserver); - } - - @Test - public void testGetAvailabilityObserver() { - assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver); } @Test @@ -95,12 +85,10 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java index b321652168b..5f921cd9b5a 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java @@ -16,13 +16,15 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + import android.content.Context; import android.support.v7.preference.Preference; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceAvailabilityObserver; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -32,10 +34,6 @@ import org.mockito.Mock; 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; - /** * Tests for {@link AlwaysOnVpnManagedProfilePreferenceController}. */ @@ -48,7 +46,6 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private AlwaysOnVpnManagedProfilePreferenceController mController; @@ -57,14 +54,7 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext, - null /* lifecycle */); - mController.setAvailabilityObserver(mObserver); - } - - @Test - public void testGetAvailabilityObserver() { - assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver); + mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext); } @Test @@ -72,12 +62,10 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/ApplicationListFragmentTest.java b/tests/robotests/src/com/android/settings/enterprise/ApplicationListFragmentTest.java index a6f95aac599..80d4aafa46a 100644 --- a/tests/robotests/src/com/android/settings/enterprise/ApplicationListFragmentTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/ApplicationListFragmentTest.java @@ -17,9 +17,7 @@ package com.android.settings.enterprise; import static com.android.settings.testutils.ApplicationTestUtils.buildInfo; - import static com.google.common.truth.Truth.assertThat; - import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.when; @@ -30,10 +28,10 @@ import android.support.v7.preference.PreferenceScreen; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; import com.android.settings.applications.ApplicationFeatureProvider; import com.android.settings.applications.UserAppInfo; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settingslib.core.AbstractPreferenceController; import org.junit.Before; @@ -86,7 +84,8 @@ public class ApplicationListFragmentTest { @Test public void getPreferenceControllers() { - final List controllers = mFragment.getPreferenceControllers(mContext); + final List controllers = mFragment.getPreferenceControllers( + mContext); assertThat(controllers).isNotNull(); assertThat(controllers.size()).isEqualTo(1); int position = 0; @@ -94,7 +93,8 @@ public class ApplicationListFragmentTest { ApplicationListPreferenceController.class); } - @Test public void getCategories() { + @Test + public void getCategories() { assertThat(new ApplicationListFragment.AdminGrantedPermissionCamera().getMetricsCategory()) .isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_PERMISSIONS); assertThat(new ApplicationListFragment.AdminGrantedPermissionLocation(). diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java index 35d78a57c34..5ee1145952c 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java @@ -73,7 +73,7 @@ public final class CaCertsCurrentUserPreferenceControllerTest extends @Override CaCertsPreferenceControllerBase createController() { - return new CaCertsCurrentUserPreferenceController(mContext, null /* lifecycle */); + return new CaCertsCurrentUserPreferenceController(mContext); } private void assertUpdateState(boolean isCompMode, String expectedTitle) { diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java index 41b7f45da1e..2aa5306d543 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java @@ -45,6 +45,6 @@ public final class CaCertsManagedProfilePreferenceControllerTest extends @Override CaCertsPreferenceControllerBase createController() { - return new CaCertsManagedProfilePreferenceController(mContext, null /* lifecycle */); + return new CaCertsManagedProfilePreferenceController(mContext); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerBaseTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerBaseTest.java index 37b903acd4f..ec76b2b4b7a 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerBaseTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerBaseTest.java @@ -50,7 +50,7 @@ public class CaCertsPreferenceControllerBaseTest extends CaCertsPreferenceContro CaCertsPreferenceControllerBase { public CaCertsPreferenceControllerBaseTestable(Context context) { - super(context, null); + super(context); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java index c171fba6ab6..c2fb4da756e 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java @@ -17,15 +17,12 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; - -import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.content.Context; 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; @@ -43,8 +40,6 @@ public abstract class CaCertsPreferenceControllerTestBase { protected Context mContext; protected FakeFeatureFactory mFeatureFactory; protected CaCertsPreferenceControllerBase mController; - @Mock - private PreferenceAvailabilityObserver mObserver; @Before public void setUp() { @@ -52,12 +47,6 @@ public abstract class CaCertsPreferenceControllerTestBase { FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); mController = createController(); - mController.setAvailabilityObserver(mObserver); - } - - @Test - public void testGetAvailabilityObserver() { - assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver); } @Test @@ -75,11 +64,9 @@ public abstract class CaCertsPreferenceControllerTestBase { public void testIsAvailable() { mockGetNumberOfCaCerts(0); assertThat(mController.isAvailable()).isFalse(); - verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), false); mockGetNumberOfCaCerts(10); assertThat(mController.isAvailable()).isTrue(); - verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), true); } @Test diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java index cc6335fea57..b4f7827646d 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java @@ -16,15 +16,20 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.anyObject; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.when; + import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.testutils.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 com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -36,15 +41,6 @@ import org.mockito.invocation.InvocationOnMock; 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; - /** * Tests for {@link EnterpriseInstalledPackagesPreferenceController}. */ @@ -58,7 +54,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private EnterpriseInstalledPackagesPreferenceController mController; @@ -68,13 +63,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest { FakeFeatureFactory.setupForTest(mContext); 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); + true /* async */); } private void setNumberOfEnterpriseInstalledPackages(int number, boolean async) { @@ -83,8 +72,9 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest { ((ApplicationFeatureProvider.NumberOfAppsCallback) invocation.getArguments()[1]).onNumberOfAppsResult(number); return null; - }}).when(mFeatureFactory.applicationFeatureProvider) - .calculateNumberOfPolicyInstalledApps(eq(async), anyObject()); + } + }).when(mFeatureFactory.applicationFeatureProvider) + .calculateNumberOfPolicyInstalledApps(eq(async), anyObject()); } @Test @@ -95,8 +85,6 @@ 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( @@ -105,39 +93,27 @@ 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 public void testIsAvailableSync() { final EnterpriseInstalledPackagesPreferenceController controller - = new EnterpriseInstalledPackagesPreferenceController(mContext, - null /* lifecycle */, false /* async */); - controller.setAvailabilityObserver(mObserver); + = new EnterpriseInstalledPackagesPreferenceController(mContext, false /* async */); 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java index 7077ad52a2a..18f16f458d8 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java @@ -16,14 +16,16 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceAvailabilityObserver; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -33,10 +35,6 @@ import org.mockito.Mock; 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; - /** * Tests for {@link EnterprisePrivacyPreferenceController}. */ @@ -52,7 +50,6 @@ public final class EnterprisePrivacyPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private EnterprisePrivacyPreferenceController mController; @@ -61,13 +58,7 @@ public final class EnterprisePrivacyPreferenceControllerTest { MockitoAnnotations.initMocks(this); 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); + mController = new EnterprisePrivacyPreferenceController(mContext); } @Test @@ -88,17 +79,15 @@ public final class EnterprisePrivacyPreferenceControllerTest { .thenReturn(MANAGING_ORGANIZATION); mController.updateState(preference); assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME); - } + } @Test 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java index 4da328977c2..a2b539dcb71 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java @@ -17,18 +17,16 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; - import static org.mockito.Mockito.when; import android.content.Context; -import android.content.res.XmlResourceParser; import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.TestConfig; -import com.android.settings.core.DynamicAvailabilityPreferenceController; import com.android.settings.testutils.FakeFeatureFactory; import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settings.widget.PreferenceCategoryController; import com.android.settingslib.core.AbstractPreferenceController; import org.junit.Before; @@ -37,14 +35,10 @@ 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; /** * Tests for {@link EnterprisePrivacySettings}. @@ -53,9 +47,6 @@ import java.util.Set; @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; @@ -71,23 +62,11 @@ public final class EnterprisePrivacySettingsTest { } @Test - public void testGetMetricsCategory() { + public void verifyConstants() { assertThat(mSettings.getMetricsCategory()) .isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_SETTINGS); - } - - @Test - public void testGetCategoryKey() { - assertThat(mSettings.getCategoryKey()).isNull(); - } - - @Test - public void testGetLogTag() { assertThat(mSettings.getLogTag()).isEqualTo("EnterprisePrivacySettings"); - } - - @Test - public void testGetPreferenceScreenResId() { + assertThat(mSettings.getCategoryKey()).isNull(); assertThat(mSettings.getPreferenceScreenResId()) .isEqualTo(R.xml.enterprise_privacy_settings); } @@ -121,7 +100,7 @@ public final class EnterprisePrivacySettingsTest { public void getSearchIndexProviderPreferenceControllers() throws Exception { final List controllers = EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers( - ShadowApplication.getInstance().getApplicationContext()); + ShadowApplication.getInstance().getApplicationContext()); verifyPreferenceControllers(controllers); } @@ -155,67 +134,11 @@ public final class EnterprisePrivacySettingsTest { CaCertsCurrentUserPreferenceController.class); assertThat(controllers.get(position++)).isInstanceOf( CaCertsManagedProfilePreferenceController.class); - final AbstractPreferenceController exposureChangesCategoryController = - controllers.get(position); - final int exposureChangesCategoryControllerIndex = position; assertThat(controllers.get(position++)).isInstanceOf( - ExposureChangesCategoryPreferenceController.class); + PreferenceCategoryController.class); assertThat(controllers.get(position++)).isInstanceOf( FailedPasswordWipeCurrentUserPreferenceController.class); assertThat(controllers.get(position++)).isInstanceOf( FailedPasswordWipeManagedProfilePreferenceController.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 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 actualObserved = new HashSet<>(); - int maxObservedIndex = -1; - for (int i = 0; i < controllers.size(); i++) { - final AbstractPreferenceController 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); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java index bb21bf7c561..9eb6d664541 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java @@ -17,7 +17,6 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; - import static org.mockito.ArgumentMatchers.any; import static org.mockito.Matchers.anyInt; import static org.mockito.Matchers.argThat; @@ -29,16 +28,14 @@ import android.content.Intent; import android.content.pm.ApplicationInfo; import android.content.pm.UserInfo; import android.os.UserHandle; -import android.os.UserManager; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.testutils.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 com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -51,8 +48,6 @@ import org.robolectric.annotation.Config; import java.util.ArrayList; import java.util.List; - -import static org.mockito.Mockito.verify; /** * Tests for {@link EnterpriseSetDefaultAppsPreferenceController}. */ @@ -65,9 +60,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest { @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; @@ -76,14 +69,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new EnterpriseSetDefaultAppsPreferenceController(mContext, - null /* lifecycle */); - mController.setAvailabilityObserver(mObserver); - } - - @Test - public void testGetAvailabilityObserver() { - assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver); + mController = new EnterpriseSetDefaultAppsPreferenceController(mContext); } private void setEnterpriseSetDefaultApps(Intent[] intents, int number) { @@ -130,12 +116,10 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java deleted file mode 100644 index f77aef84b0e..00000000000 --- a/tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java +++ /dev/null @@ -1,192 +0,0 @@ -/* - * 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.testutils.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 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); - } -} diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceControllerTest.java index db9182bcf81..8453d621003 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeCurrentUserPreferenceControllerTest.java @@ -16,14 +16,14 @@ package com.android.settings.enterprise; -import com.android.settings.testutils.SettingsRobolectricTestRunner; +import static org.mockito.Mockito.when; + import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; -import static org.mockito.Mockito.when; - /** * Tests for {@link FailedPasswordWipeCurrentUserPreferenceController}. */ @@ -32,8 +32,6 @@ import static org.mockito.Mockito.when; public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends FailedPasswordWipePreferenceControllerTestBase { - private int mMaximumFailedPasswordsBeforeWipe = 0; - public FailedPasswordWipeCurrentUserPreferenceControllerTest() { super("failed_password_wipe_current_user"); } @@ -41,8 +39,7 @@ public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends @Override public void setUp() { super.setUp(); - mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext, - null /* lifecycle */); + mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java index 329c52694b1..a001a9cc8e7 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java @@ -16,14 +16,14 @@ package com.android.settings.enterprise; -import com.android.settings.testutils.SettingsRobolectricTestRunner; +import static org.mockito.Mockito.when; + import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; -import static org.mockito.Mockito.when; - /** * Tests for {@link FailedPasswordWipeManagedProfilePreferenceController}. */ @@ -32,8 +32,6 @@ import static org.mockito.Mockito.when; public final class FailedPasswordWipeManagedProfilePreferenceControllerTest extends FailedPasswordWipePreferenceControllerTestBase { - private int mMaximumFailedPasswordsBeforeWipe = 0; - public FailedPasswordWipeManagedProfilePreferenceControllerTest() { super("failed_password_wipe_managed_profile"); } @@ -41,8 +39,7 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte @Override public void setUp() { super.setUp(); - mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext, - null /* lifecycle */); + mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java index 5d1b28a3142..f80667c676d 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java @@ -16,8 +16,8 @@ package com.android.settings.enterprise; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.runner.RunWith; import org.robolectric.annotation.Config; @@ -50,8 +50,7 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends private class FailedPasswordWipePreferenceControllerBaseTestable extends FailedPasswordWipePreferenceControllerBase { FailedPasswordWipePreferenceControllerBaseTestable() { - super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext, - null /* lifecycle */); + super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java index cbc220fbd7e..fe4fb6bb027 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java @@ -16,12 +16,13 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + import android.content.Context; -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,10 +31,6 @@ import org.mockito.Answers; 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; - /** * Common base for testing subclasses of {@link FailedPasswordWipePreferenceControllerBase}. */ @@ -44,7 +41,6 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase { @Mock(answer = Answers.RETURNS_DEEP_STUBS) protected Context mContext; protected FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; protected FailedPasswordWipePreferenceControllerBase mController; @@ -59,12 +55,6 @@ 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 @@ -81,15 +71,11 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java index d5ce1024bee..b9c24bff0c4 100644 --- a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java @@ -16,13 +16,15 @@ package com.android.settings.enterprise; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; + import android.content.Context; import android.support.v7.preference.Preference; -import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceAvailabilityObserver; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -32,10 +34,6 @@ import org.mockito.Mock; 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; - /** * Tests for {@link GlobalHttpProxyPreferenceController}. */ @@ -48,7 +46,6 @@ public final class GlobalHttpProxyPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private GlobalHttpProxyPreferenceController mController; @@ -57,13 +54,7 @@ public final class GlobalHttpProxyPreferenceControllerTest { MockitoAnnotations.initMocks(this); 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); + mController = new GlobalHttpProxyPreferenceController(mContext); } @Test @@ -71,12 +62,10 @@ 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 diff --git a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java index 22d2a7d50a0..1e053833999 100644 --- a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java @@ -16,15 +16,16 @@ package com.android.settings.enterprise; -import android.content.Context; +import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.when; -import com.android.settings.R; +import android.content.Context; import android.support.v7.preference.Preference; -import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settings.R; import com.android.settings.TestConfig; -import com.android.settings.core.PreferenceAvailabilityObserver; import com.android.settings.testutils.FakeFeatureFactory; +import com.android.settings.testutils.SettingsRobolectricTestRunner; import org.junit.Before; import org.junit.Test; @@ -34,10 +35,6 @@ import org.mockito.Mock; 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; - /** * Tests for {@link ImePreferenceController}. */ @@ -52,7 +49,6 @@ public final class ImePreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - @Mock private PreferenceAvailabilityObserver mObserver; private ImePreferenceController mController; @@ -61,15 +57,9 @@ public final class ImePreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new ImePreferenceController(mContext, null /* lifecycle */); + mController = new ImePreferenceController(mContext); 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,7 +67,7 @@ public final class ImePreferenceControllerTest { final Preference preference = new Preference(mContext, null, 0, 0); when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) - .thenReturn(DEFAULT_IME_LABEL); + .thenReturn(DEFAULT_IME_LABEL); mController.updateState(preference); assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT); } @@ -85,14 +75,12 @@ public final class ImePreferenceControllerTest { @Test public void testIsAvailable() { when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) - .thenReturn(null); + .thenReturn(null); assertThat(mController.isAvailable()).isFalse(); - verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, false); when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) - .thenReturn(DEFAULT_IME_LABEL); + .thenReturn(DEFAULT_IME_LABEL); assertThat(mController.isAvailable()).isTrue(); - verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, true); } @Test