From b076e00c5eed6720c5347a2d15890aa9d11157b0 Mon Sep 17 00:00:00 2001 From: Bartosz Fabianowski Date: Mon, 20 Mar 2017 15:27:28 +0100 Subject: [PATCH] Finish removing N/A DO disclosures from search index DO disclosures referring to actions that the admin did not actually take are hidden in the UI, but still show up in the search index. This CL switches the remaining PreferenceControllers from setting visibility to implementing isAvailable() instead. Bug: 32692748 Test: m RunSettingsRoboTests Change-Id: I54360698f28b549b18cdc230e3b9087cf4e9ff4a --- .../ApplicationFeatureProvider.java | 3 +- .../ApplicationFeatureProviderImpl.java | 12 ++++-- ...dCameraPermissionPreferenceController.java | 8 +++- ...cationPermissionsPreferenceController.java | 7 +++- ...rophonePermissionPreferenceController.java | 7 +++- ...edPermissionsPreferenceControllerBase.java | 34 ++++++++++++---- ...VpnManagedProfilePreferenceController.java | 18 ++++----- ...sOnVpnPrimaryUserPreferenceController.java | 13 +++--- .../CaCertsPreferenceController.java | 17 ++++---- .../enterprise/EnterprisePrivacySettings.java | 24 ++++++----- ...ipeManagedProfilePreferenceController.java | 6 ++- ...dPasswordWipePreferenceControllerBase.java | 23 +++++------ ...rdWipePrimaryUserPreferenceController.java | 6 ++- .../GlobalHttpProxyPreferenceController.java | 17 +++----- .../enterprise/ImePreferenceController.java | 20 ++++------ ...ithAdminGrantedPermissionsCounterTest.java | 24 ++++++++--- .../ApplicationFeatureProviderImplTest.java | 30 +++++++++----- ...eraPermissionPreferenceControllerTest.java | 6 +-- ...onPermissionsPreferenceControllerTest.java | 6 +-- ...onePermissionPreferenceControllerTest.java | 6 +-- ...rmissionsPreferenceControllerBaseTest.java | 11 +++-- ...rmissionsPreferenceControllerTestBase.java | 40 ++++++++++++++----- ...anagedProfilePreferenceControllerTest.java | 25 ++++-------- ...pnPrimaryUserPreferenceControllerTest.java | 29 +++++--------- .../CaCertsPreferenceControllerTest.java | 21 +++++----- ...alledPackagesPreferenceControllerTest.java | 2 +- ...anagedProfilePreferenceControllerTest.java | 3 +- ...swordWipePreferenceControllerBaseTest.java | 3 +- ...swordWipePreferenceControllerTestBase.java | 9 ++--- ...pePrimaryUserPreferenceControllerTest.java | 3 +- ...obalHttpProxyPreferenceControllerTest.java | 24 ++++------- .../ImePreferenceControllerTest.java | 15 ++++--- 32 files changed, 255 insertions(+), 217 deletions(-) diff --git a/src/com/android/settings/applications/ApplicationFeatureProvider.java b/src/com/android/settings/applications/ApplicationFeatureProvider.java index 7dce7936606..51e79d86641 100644 --- a/src/com/android/settings/applications/ApplicationFeatureProvider.java +++ b/src/com/android/settings/applications/ApplicationFeatureProvider.java @@ -54,9 +54,10 @@ public interface ApplicationFeatureProvider { * * @param permissions Only consider apps that have been granted one or more of these permissions * by the admin, either at run-time or install-time + * @param async Whether to count asynchronously in a background thread * @param callback The callback to invoke with the result */ - void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions, + void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions, boolean async, NumberOfAppsCallback callback); /** diff --git a/src/com/android/settings/applications/ApplicationFeatureProviderImpl.java b/src/com/android/settings/applications/ApplicationFeatureProviderImpl.java index 5ba228f4a8e..77c9f3e6b81 100644 --- a/src/com/android/settings/applications/ApplicationFeatureProviderImpl.java +++ b/src/com/android/settings/applications/ApplicationFeatureProviderImpl.java @@ -69,9 +69,15 @@ public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvide @Override public void calculateNumberOfAppsWithAdminGrantedPermissions(String[] permissions, - NumberOfAppsCallback callback) { - new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms, mDpm, - callback).execute(); + boolean async, NumberOfAppsCallback callback) { + final AllUserAppWithAdminGrantedPermissionsCounter counter = + new AllUserAppWithAdminGrantedPermissionsCounter(mContext, permissions, mPm, mPms, + mDpm, callback); + if (async) { + counter.execute(); + } else { + counter.executeInForeground(); + } } @Override diff --git a/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java index 83942628d15..003ed1188c6 100644 --- a/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java @@ -17,14 +17,18 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; +import com.android.settings.core.lifecycle.Lifecycle; + public class AdminGrantedCameraPermissionPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_CAMERA_ACCESS_PACKAGES = "enterprise_privacy_number_camera_access_packages"; - public AdminGrantedCameraPermissionPreferenceController(Context context) { - super(context, new String[] {Manifest.permission.CAMERA}, Manifest.permission_group.CAMERA); + public AdminGrantedCameraPermissionPreferenceController(Context context, Lifecycle lifecycle, + boolean async) { + super(context, lifecycle, async, new String[] {Manifest.permission.CAMERA}, + Manifest.permission_group.CAMERA); } @Override diff --git a/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java index 4dfc4be08c2..5343483827f 100644 --- a/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java @@ -17,14 +17,17 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; +import com.android.settings.core.lifecycle.Lifecycle; + public class AdminGrantedLocationPermissionsPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_LOCATION_ACCESS_PACKAGES = "enterprise_privacy_number_location_access_packages"; - public AdminGrantedLocationPermissionsPreferenceController(Context context) { - super(context, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION, + 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); } diff --git a/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java b/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java index e2ab55511a2..64396c54f77 100644 --- a/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java +++ b/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java @@ -17,14 +17,17 @@ package com.android.settings.enterprise; import android.Manifest; import android.content.Context; +import com.android.settings.core.lifecycle.Lifecycle; + public class AdminGrantedMicrophonePermissionPreferenceController extends AdminGrantedPermissionsPreferenceControllerBase { private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_MICROPHONE_ACCESS_PACKAGES = "enterprise_privacy_number_microphone_access_packages"; - public AdminGrantedMicrophonePermissionPreferenceController(Context context) { - super(context, new String[] {Manifest.permission.RECORD_AUDIO}, + public AdminGrantedMicrophonePermissionPreferenceController(Context context, + Lifecycle lifecycle, boolean async) { + super(context, lifecycle, async, new String[] {Manifest.permission.RECORD_AUDIO}, Manifest.permission_group.MICROPHONE); } diff --git a/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java b/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java index 5263817554b..c60d7e0c69b 100644 --- a/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java @@ -1,3 +1,4 @@ + /* * Copyright (C) 2017 The Android Open Source Project * @@ -20,28 +21,32 @@ import android.support.v7.preference.Preference; import com.android.settings.R; import com.android.settings.applications.ApplicationFeatureProvider; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public abstract class AdminGrantedPermissionsPreferenceControllerBase extends PreferenceController { +public abstract class AdminGrantedPermissionsPreferenceControllerBase + extends DynamicAvailabilityPreferenceController { private final String[] mPermissions; private final String mPermissionGroup; private final ApplicationFeatureProvider mFeatureProvider; + private final boolean mAsync; - public AdminGrantedPermissionsPreferenceControllerBase(Context context, - String[] permissions, - String permissionGroup) { - super(context); + public AdminGrantedPermissionsPreferenceControllerBase(Context context, Lifecycle lifecycle, + boolean async, String[] permissions, String permissionGroup) { + super(context, lifecycle); mPermissions = permissions; mPermissionGroup = permissionGroup; mFeatureProvider = FeatureFactory.getFactory(context) .getApplicationFeatureProvider(context); + mAsync = async; } @Override public void updateState(Preference preference) { mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions, + true /* async */, (num) -> { if (num == 0) { preference.setVisible(false); @@ -55,7 +60,22 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase extends Pr @Override public boolean isAvailable() { - return true; + if (mAsync) { + // When called on the main UI thread, we must not block. Since calculating the number of + // apps that the admin has granted a given permissions takes a bit of time, we always + // return true here and determine the pref's actual visibility asynchronously in + // updateState(). + return true; + } + + // When called by the search indexer, we are on a background thread that we can block. Also, + // changes to the pref's visibility made in updateState() would not be seen by the indexer. + // We block and return synchronously whether the admin has granted the given permissions to + // any apps or not. + final Boolean[] haveAppsWithAdminGrantedPermissions = { null }; + mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions, + false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0); + return haveAppsWithAdminGrantedPermissions[0]; } @Override diff --git a/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java index 52625ec77ff..4796b75190f 100644 --- a/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java @@ -14,30 +14,26 @@ package com.android.settings.enterprise; import android.content.Context; -import android.support.v7.preference.Preference; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public class AlwaysOnVpnManagedProfilePreferenceController extends PreferenceController { +public class AlwaysOnVpnManagedProfilePreferenceController + extends DynamicAvailabilityPreferenceController { private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public AlwaysOnVpnManagedProfilePreferenceController(Context context) { - super(context); + public AlwaysOnVpnManagedProfilePreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } - @Override - public void updateState(Preference preference) { - preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInManagedProfile()); - } - @Override public boolean isAvailable() { - return true; + return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile(); } @Override diff --git a/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java b/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java index c7ffeaf01d0..e5823fe7654 100644 --- a/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java +++ b/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java @@ -17,16 +17,18 @@ import android.content.Context; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceController { +public class AlwaysOnVpnPrimaryUserPreferenceController + extends DynamicAvailabilityPreferenceController { private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public AlwaysOnVpnPrimaryUserPreferenceController(Context context) { - super(context); + public AlwaysOnVpnPrimaryUserPreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -36,12 +38,11 @@ public class AlwaysOnVpnPrimaryUserPreferenceController extends PreferenceContro preference.setTitle(mFeatureProvider.isInCompMode() ? R.string.enterprise_privacy_always_on_vpn_personal : R.string.enterprise_privacy_always_on_vpn_device); - preference.setVisible(mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()); } @Override public boolean isAvailable() { - return true; + return mFeatureProvider.isAlwaysOnVpnSetInPrimaryUser(); } @Override diff --git a/src/com/android/settings/enterprise/CaCertsPreferenceController.java b/src/com/android/settings/enterprise/CaCertsPreferenceController.java index d18eff0dc7c..d020676efb6 100644 --- a/src/com/android/settings/enterprise/CaCertsPreferenceController.java +++ b/src/com/android/settings/enterprise/CaCertsPreferenceController.java @@ -19,16 +19,17 @@ import android.content.res.Resources; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public class CaCertsPreferenceController extends PreferenceController { +public class CaCertsPreferenceController extends DynamicAvailabilityPreferenceController { private static final String CA_CERTS = "ca_certs"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public CaCertsPreferenceController(Context context) { - super(context); + public CaCertsPreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -37,18 +38,14 @@ public class CaCertsPreferenceController extends PreferenceController { public void updateState(Preference preference) { final int certs = mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile(); - if (certs == 0) { - preference.setVisible(false); - return; - } preference.setSummary(mContext.getResources().getQuantityString( R.plurals.enterprise_privacy_number_ca_certs, certs, certs)); - preference.setVisible(true); } @Override public boolean isAvailable() { - return true; + return mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile() + > 0; } @Override diff --git a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java index 50f54548ec8..55ec3ea2886 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java @@ -64,17 +64,21 @@ public class EnterprisePrivacySettings extends DashboardFragment { controllers.add(new SecurityLogsPreferenceController(context)); controllers.add(new EnterpriseInstalledPackagesPreferenceController(context, lifecycle, async)); - controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context)); - controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context)); - controllers.add(new AdminGrantedCameraPermissionPreferenceController(context)); + controllers.add(new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle, + async)); + controllers.add(new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle, + async)); + controllers.add(new AdminGrantedCameraPermissionPreferenceController(context, lifecycle, + async)); controllers.add(new EnterpriseSetDefaultAppsPreferenceController(context, lifecycle)); - controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context)); - controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context)); - controllers.add(new GlobalHttpProxyPreferenceController(context)); - controllers.add(new CaCertsPreferenceController(context)); - controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context)); - controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context)); - controllers.add(new ImePreferenceController(context)); + controllers.add(new AlwaysOnVpnPrimaryUserPreferenceController(context, lifecycle)); + controllers.add(new AlwaysOnVpnManagedProfilePreferenceController(context, lifecycle)); + controllers.add(new GlobalHttpProxyPreferenceController(context, lifecycle)); + controllers.add(new CaCertsPreferenceController(context, lifecycle)); + controllers.add(new FailedPasswordWipePrimaryUserPreferenceController(context, lifecycle)); + controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context, + lifecycle)); + controllers.add(new ImePreferenceController(context, lifecycle)); return controllers; } diff --git a/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java index 5a0e7c8264d..205d7c17081 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java @@ -14,6 +14,7 @@ package com.android.settings.enterprise; import android.content.Context; +import com.android.settings.core.lifecycle.Lifecycle; public class FailedPasswordWipeManagedProfilePreferenceController extends FailedPasswordWipePreferenceControllerBase { @@ -21,8 +22,9 @@ public class FailedPasswordWipeManagedProfilePreferenceController private static final String KEY_FAILED_PASSWORD_WIPE_MANAGED_PROFILE = "failed_password_wipe_managed_profile"; - public FailedPasswordWipeManagedProfilePreferenceController(Context context) { - super(context); + public FailedPasswordWipeManagedProfilePreferenceController(Context context, + Lifecycle lifecycle) { + super(context, lifecycle); } @Override diff --git a/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java b/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java index ee4aecf52df..2f35da6bd2b 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java @@ -19,15 +19,17 @@ import android.content.res.Resources; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public abstract class FailedPasswordWipePreferenceControllerBase extends PreferenceController { +public abstract class FailedPasswordWipePreferenceControllerBase + extends DynamicAvailabilityPreferenceController { protected final EnterprisePrivacyFeatureProvider mFeatureProvider; - public FailedPasswordWipePreferenceControllerBase(Context context) { - super(context); + public FailedPasswordWipePreferenceControllerBase(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @@ -37,18 +39,13 @@ public abstract class FailedPasswordWipePreferenceControllerBase extends Prefere @Override public void updateState(Preference preference) { final int failedPasswordsBeforeWipe = getMaximumFailedPasswordsBeforeWipe(); - if (failedPasswordsBeforeWipe == 0) { - preference.setVisible(false); - } else { - preference.setVisible(true); - preference.setSummary(mContext.getResources().getQuantityString( - R.plurals.enterprise_privacy_number_failed_password_wipe, - failedPasswordsBeforeWipe, failedPasswordsBeforeWipe)); - } + preference.setSummary(mContext.getResources().getQuantityString( + R.plurals.enterprise_privacy_number_failed_password_wipe, + failedPasswordsBeforeWipe, failedPasswordsBeforeWipe)); } @Override public boolean isAvailable() { - return true; + return getMaximumFailedPasswordsBeforeWipe() > 0; } } diff --git a/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java b/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java index 44c63838d7f..2e18f899fa3 100644 --- a/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java +++ b/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java @@ -15,14 +15,16 @@ package com.android.settings.enterprise; import android.content.Context; +import com.android.settings.core.lifecycle.Lifecycle; + public class FailedPasswordWipePrimaryUserPreferenceController extends FailedPasswordWipePreferenceControllerBase { private static final String KEY_FAILED_PASSWORD_WIPE_PRIMARY_USER = "failed_password_wipe_primary_user"; - public FailedPasswordWipePrimaryUserPreferenceController(Context context) { - super(context); + public FailedPasswordWipePrimaryUserPreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); } @Override diff --git a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java index e2f2ab94ff2..6ee7fc4cdbc 100644 --- a/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java +++ b/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java @@ -14,30 +14,25 @@ package com.android.settings.enterprise; import android.content.Context; -import android.support.v7.preference.Preference; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public class GlobalHttpProxyPreferenceController extends PreferenceController { +public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPreferenceController { private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public GlobalHttpProxyPreferenceController(Context context) { - super(context); + public GlobalHttpProxyPreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } - @Override - public void updateState(Preference preference) { - preference.setVisible(mFeatureProvider.isGlobalHttpProxySet()); - } - @Override public boolean isAvailable() { - return true; + return mFeatureProvider.isGlobalHttpProxySet(); } @Override diff --git a/src/com/android/settings/enterprise/ImePreferenceController.java b/src/com/android/settings/enterprise/ImePreferenceController.java index 3c0cc26d0e3..b090bed9f56 100644 --- a/src/com/android/settings/enterprise/ImePreferenceController.java +++ b/src/com/android/settings/enterprise/ImePreferenceController.java @@ -19,35 +19,31 @@ import android.content.res.Resources; import android.support.v7.preference.Preference; import com.android.settings.R; -import com.android.settings.core.PreferenceController; +import com.android.settings.core.DynamicAvailabilityPreferenceController; +import com.android.settings.core.lifecycle.Lifecycle; import com.android.settings.overlay.FeatureFactory; -public class ImePreferenceController extends PreferenceController { +public class ImePreferenceController extends DynamicAvailabilityPreferenceController { private static final String KEY_INPUT_METHOD = "input_method"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public ImePreferenceController(Context context) { - super(context); + public ImePreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @Override public void updateState(Preference preference) { - final String ownerSetIme = mFeatureProvider.getImeLabelIfOwnerSet(); - if (ownerSetIme == null) { - preference.setVisible(false); - return; - } preference.setSummary(mContext.getResources().getString( - R.string.enterprise_privacy_input_method_name, ownerSetIme)); - preference.setVisible(true); + R.string.enterprise_privacy_input_method_name, + mFeatureProvider.getImeLabelIfOwnerSet())); } @Override public boolean isAvailable() { - return true; + return mFeatureProvider.getImeLabelIfOwnerSet() != null; } @Override diff --git a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java index 3dd3a651f97..dfef3b865fe 100644 --- a/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java +++ b/tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java @@ -89,8 +89,7 @@ public final class AppWithAdminGrantedPermissionsCounterTest { MockitoAnnotations.initMocks(this); } - @Test - public void testCountInstalledAppsAcrossAllUsers() throws Exception { + private void verifyCountInstalledAppsAcrossAllUsers(boolean async) throws Exception { // There are two users. mUsersToCount = Arrays.asList( new UserInfo(MAIN_USER_ID, "main", UserInfo.FLAG_ADMIN), @@ -181,10 +180,14 @@ public final class AppWithAdminGrantedPermissionsCounterTest { .thenReturn(PackageManager.INSTALL_REASON_UNKNOWN); // Count the number of all apps installed that were granted on or more permissions by the - // admin. Wait for the background task to finish. - (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).execute(); - ShadowApplication.runBackgroundTasks(); - + // admin. + if (async) { + (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).execute(); + // Wait for the background task to finish. + ShadowApplication.runBackgroundTasks(); + } else { + (new AppWithAdminGrantedPermissionsCounterTestable(PERMISSIONS)).executeInForeground(); + } assertThat(mAppCount).isEqualTo(3); // Verify that installed packages were retrieved for the users returned by @@ -194,7 +197,16 @@ public final class AppWithAdminGrantedPermissionsCounterTest { eq(MANAGED_PROFILE_ID)); verify(mPackageManager, atLeast(0)).getInstallReason(anyObject(), anyObject()); verifyNoMoreInteractions(mPackageManager); + } + @Test + public void testCountInstalledAppsAcrossAllUsersSync() throws Exception { + verifyCountInstalledAppsAcrossAllUsers(false /* async */); + } + + @Test + public void testCountInstalledAppsAcrossAllUsersAync() throws Exception { + verifyCountInstalledAppsAcrossAllUsers(true /* async */); } private class AppWithAdminGrantedPermissionsCounterTestable extends diff --git a/tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java index 3c8d933fa66..a513f71b0a0 100644 --- a/tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java @@ -88,7 +88,7 @@ public final class ApplicationFeatureProviderImplTest { mPackageManagerService, mDevicePolicyManager); } - private void testCalculateNumberOfInstalledApps(boolean async) { + private void verifyCalculateNumberOfInstalledApps(boolean async) { setUpUsersAndInstalledApps(); when(mPackageManager.getInstallReason(APP_1, new UserHandle(MAIN_USER_ID))) @@ -117,16 +117,16 @@ public final class ApplicationFeatureProviderImplTest { @Test public void testCalculateNumberOfInstalledAppsSync() { - testCalculateNumberOfInstalledApps(false /* async */); + verifyCalculateNumberOfInstalledApps(false /* async */); } @Test public void testCalculateNumberOfInstalledAppsAsync() { - testCalculateNumberOfInstalledApps(true /* async */); + verifyCalculateNumberOfInstalledApps(true /* async */); } - @Test - public void testCalculateNumberOfAppsWithAdminGrantedPermissions() throws Exception { + private void verifyCalculateNumberOfAppsWithAdminGrantedPermissions(boolean async) + throws Exception { setUpUsersAndInstalledApps(); when(mDevicePolicyManager.getPermissionGrantState(null, APP_1, PERMISSION)) @@ -143,15 +143,25 @@ public final class ApplicationFeatureProviderImplTest { .thenReturn(PackageManager.INSTALL_REASON_POLICY); mAppCount = -1; - mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION}, - (num) -> { - mAppCount = num; - }); - ShadowApplication.runBackgroundTasks(); + mProvider.calculateNumberOfAppsWithAdminGrantedPermissions(new String[] {PERMISSION}, async, + (num) -> mAppCount = num); + if (async) { + ShadowApplication.runBackgroundTasks(); + } assertThat(mAppCount).isEqualTo(2); } + @Test + public void testCalculateNumberOfAppsWithAdminGrantedPermissionsSync() throws Exception { + verifyCalculateNumberOfAppsWithAdminGrantedPermissions(false /* async */); + } + + @Test + public void testCalculateNumberOfAppsWithAdminGrantedPermissionsAsync() throws Exception { + verifyCalculateNumberOfAppsWithAdminGrantedPermissions(true /* async */); + } + @Test public void testFindPersistentPreferredActivities() throws Exception { when(mUserManager.getUserProfiles()).thenReturn(Arrays.asList(new UserHandle(MAIN_USER_ID), diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java index a998fb57f38..0281ce5dc8f 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java @@ -39,8 +39,8 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends } @Override - public void setUp() { - super.setUp(); - mController = new AdminGrantedCameraPermissionPreferenceController(mContext); + protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { + return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */, + async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java index e7aa358f5d1..d556296479c 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java @@ -40,8 +40,8 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten } @Override - public void setUp() { - super.setUp(); - mController = new AdminGrantedLocationPermissionsPreferenceController(mContext); + protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { + return new AdminGrantedLocationPermissionsPreferenceController(mContext, + null /* lifecycle */, async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java index 8c84af27ab7..e2a45ecd03b 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java @@ -39,8 +39,8 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte } @Override - public void setUp() { - super.setUp(); - mController = new AdminGrantedMicrophonePermissionPreferenceController(mContext); + protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { + return new AdminGrantedMicrophonePermissionPreferenceController(mContext, + null /* lifecycle */, async); } } diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java index 0d53fb6daa4..4da1cd28b0c 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java @@ -40,17 +40,16 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends } @Override - public void setUp() { - super.setUp(); - mController = new AdminGrantedPermissionsPreferenceControllerBaseTestable(); + protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) { + return new AdminGrantedPermissionsPreferenceControllerBaseTestable(async); } private class AdminGrantedPermissionsPreferenceControllerBaseTestable extends AdminGrantedPermissionsPreferenceControllerBase { - AdminGrantedPermissionsPreferenceControllerBaseTestable() { - super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext, mPermissions, - mPermissionGroup); + AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) { + super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext, + null /* lifecycle */, async, mPermissions, mPermissionGroup); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java index 5a70b7a4f40..69e6237713d 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java @@ -68,39 +68,56 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); + mController = createController(true /* async */); } - private void setNumberOfPackagesWithAdminGrantedPermissions(int number) { + private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) { doAnswer(new Answer() { public Object answer(InvocationOnMock invocation) { ((ApplicationFeatureProvider.NumberOfAppsCallback) - invocation.getArguments()[1]).onNumberOfAppsResult(number); + invocation.getArguments()[2]).onNumberOfAppsResult(number); return null; }}).when(mFeatureFactory.applicationFeatureProvider) .calculateNumberOfAppsWithAdminGrantedPermissions(eq(mPermissions), - anyObject()); + eq(async), anyObject()); } @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(false); + preference.setVisible(true); - setNumberOfPackagesWithAdminGrantedPermissions(20); + setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */); + mController.updateState(preference); + assertThat(preference.isVisible()).isFalse(); + + setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */); when(mContext.getResources().getQuantityString( R.plurals.enterprise_privacy_number_packages_actionable,20, 20)) .thenReturn("20 packages"); mController.updateState(preference); assertThat(preference.getSummary()).isEqualTo("20 packages"); assertThat(preference.isVisible()).isTrue(); - - setNumberOfPackagesWithAdminGrantedPermissions(0); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); } @Test - public void testIsAvailable() { + public void testIsAvailableSync() { + final AdminGrantedPermissionsPreferenceControllerBase controller + = createController(false /* async */); + + setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */); + assertThat(controller.isAvailable()).isFalse(); + + setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */); + assertThat(controller.isAvailable()).isTrue(); + } + + @Test + public void testIsAvailableAsync() { + setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */); + assertThat(mController.isAvailable()).isTrue(); + + setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */); assertThat(mController.isAvailable()).isTrue(); } @@ -125,4 +142,7 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase { public void testGetPreferenceKey() { assertThat(mController.getPreferenceKey()).isEqualTo(mKey); } + + protected abstract AdminGrantedPermissionsPreferenceControllerBase createController( + boolean async); } diff --git a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java index a52e049808b..8ac10d16630 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java @@ -52,27 +52,18 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext); - } - - @Test - public void testUpdateState() { - final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile()) - .thenReturn(false); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile()) - .thenReturn(true); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); + mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext, + null /* lifecycle */); } @Test public void testIsAvailable() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile()) + .thenReturn(false); + assertThat(mController.isAvailable()).isFalse(); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile()) + .thenReturn(true); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java index d504b842f65..12fdb4f58b7 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java @@ -56,7 +56,8 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext); + mController = new AlwaysOnVpnPrimaryUserPreferenceController(mContext, + null /* lifecycle */); when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device)) .thenReturn(VPN_SET_DEVICE); when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal)) @@ -66,37 +67,27 @@ public final class AlwaysOnVpnPrimaryUserPreferenceControllerTest { @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) - .thenReturn(false); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) .thenReturn(true); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(false); mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); assertThat(preference.getTitle()).isEqualTo(VPN_SET_DEVICE); when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) - .thenReturn(false); mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) - .thenReturn(true); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); assertThat(preference.getTitle()).isEqualTo(VPN_SET_PERSONAL); } @Test public void testIsAvailable() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) + .thenReturn(false); + assertThat(mController.isAvailable()).isFalse(); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInPrimaryUser()) + .thenReturn(true); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java index 1d0e1498cba..fef2e0f017f 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java @@ -54,32 +54,29 @@ public final class CaCertsPreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new CaCertsPreferenceController(mContext); - - when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, - 10, 10)).thenReturn("10 certs"); + mController = new CaCertsPreferenceController(mContext, null /* lifecycle */); } @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - preference.setVisible(false); + when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, + 10, 10)).thenReturn("10 certs"); when(mFeatureFactory.enterprisePrivacyFeatureProvider .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10); mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); assertThat(preference.getSummary()).isEqualTo("10 certs"); } @Test public void testIsAvailable() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider + .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(0); + assertThat(mController.isAvailable()).isFalse(); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider + .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java index 6ff1703e835..98d0fa696d4 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java @@ -96,7 +96,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest { @Test public void testIsAvailableSync() { - EnterpriseInstalledPackagesPreferenceController controller + final EnterpriseInstalledPackagesPreferenceController controller = new EnterpriseInstalledPackagesPreferenceController(mContext, null /* lifecycle */, false /* async */); diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java index c9981f9b74e..99c68f88883 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java @@ -43,7 +43,8 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte @Override public void setUp() { super.setUp(); - mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext); + mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext, + null /* lifecycle */); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java index 1c7b448efc5..74c3de5b52b 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java @@ -50,7 +50,8 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends private class FailedPasswordWipePreferenceControllerBaseTestable extends FailedPasswordWipePreferenceControllerBase { FailedPasswordWipePreferenceControllerBaseTestable() { - super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext); + super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext, + null /* lifecycle */); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java index aa189e2c672..c14b71e24f9 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java @@ -61,7 +61,6 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase { @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(false); setMaximumFailedPasswordsBeforeWipe(10); when(mContext.getResources().getQuantityString( @@ -69,14 +68,14 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase { .thenReturn("10 attempts"); mController.updateState(preference); assertThat(preference.getSummary()).isEqualTo("10 attempts"); - - setMaximumFailedPasswordsBeforeWipe(0); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); } @Test public void testIsAvailable() { + setMaximumFailedPasswordsBeforeWipe(0); + assertThat(mController.isAvailable()).isFalse(); + + setMaximumFailedPasswordsBeforeWipe(10); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java index 65c982829c7..d74b9b86089 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java @@ -43,7 +43,8 @@ public final class FailedPasswordWipePrimaryUserPreferenceControllerTest extends @Override public void setUp() { super.setUp(); - mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext); + mController = new FailedPasswordWipePrimaryUserPreferenceController(mContext, + null /* lifecycle */); } @Override diff --git a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java index d505bad7bf4..a0bc9ee2b3f 100644 --- a/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java @@ -51,27 +51,17 @@ public final class GlobalHttpProxyPreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new GlobalHttpProxyPreferenceController(mContext); - } - - @Test - public void testUpdateState() { - final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(false); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) - .thenReturn(true); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); + mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */); } @Test public void testIsAvailable() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) + .thenReturn(false); + assertThat(mController.isAvailable()).isFalse(); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet()) + .thenReturn(true); assertThat(mController.isAvailable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java index 547746c84eb..05d053553ed 100644 --- a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java @@ -57,7 +57,7 @@ public final class ImePreferenceControllerTest { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new ImePreferenceController(mContext); + mController = new ImePreferenceController(mContext, null /* lifecycle */); when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name, DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT); } @@ -65,22 +65,21 @@ public final class ImePreferenceControllerTest { @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) - .thenReturn(null); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) .thenReturn(DEFAULT_IME_LABEL); mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT); } @Test public void testIsAvailable() { + when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) + .thenReturn(null); + assertThat(mController.isAvailable()).isFalse(); + + when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet()) + .thenReturn(DEFAULT_IME_LABEL); assertThat(mController.isAvailable()).isTrue(); }