diff --git a/res/values/strings.xml b/res/values/strings.xml index ee5b571bf93..91dd4e56fb3 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -8246,10 +8246,8 @@ Always-on VPN turned on in your work profile Global HTTP proxy set - - Trusted credentials - - Trusted credentials in your personal profile + + Trusted credentials %d CA certificate @@ -8260,8 +8258,6 @@ %d CA certificate. Tap to view. %d CA certificates. Tap to view. - - Trusted credentials in your work profile Admin can lock the device and reset password diff --git a/res/xml/enterprise_privacy_settings.xml b/res/xml/enterprise_privacy_settings.xml index 1a08cda2c8a..e6246c2c43b 100644 --- a/res/xml/enterprise_privacy_settings.xml +++ b/res/xml/enterprise_privacy_settings.xml @@ -90,11 +90,8 @@ android:title="@string/enterprise_privacy_global_http_proxy" settings:multiLine="true"/> - 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/CaCertsCurrentUserPreferenceController.java b/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java deleted file mode 100644 index 1895e09f234..00000000000 --- a/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java +++ /dev/null @@ -1,60 +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.content.res.Resources; -import android.support.v7.preference.Preference; - -import com.android.settings.R; -import com.android.settings.core.PreferenceController; -import com.android.settings.overlay.FeatureFactory; - -public class CaCertsCurrentUserPreferenceController extends PreferenceController { - - private static final String CA_CERTS_CURRENT_USER = "ca_certs_current_user"; - private final EnterprisePrivacyFeatureProvider mFeatureProvider; - - public CaCertsCurrentUserPreferenceController(Context context) { - super(context); - mFeatureProvider = FeatureFactory.getFactory(context) - .getEnterprisePrivacyFeatureProvider(context); - } - - @Override - public void updateState(Preference preference) { - final int certs = mFeatureProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser(); - if (certs == 0) { - preference.setVisible(false); - return; - } - preference.setTitle(mFeatureProvider.isInCompMode() - ? R.string.enterprise_privacy_ca_certs_personal - : R.string.enterprise_privacy_ca_certs_user); - preference.setSummary(mContext.getResources().getQuantityString( - R.plurals.enterprise_privacy_number_ca_certs, certs, certs)); - preference.setVisible(true); - } - - @Override - public boolean isAvailable() { - return true; - } - - @Override - public String getPreferenceKey() { - return CA_CERTS_CURRENT_USER; - } -} diff --git a/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java b/src/com/android/settings/enterprise/CaCertsPreferenceController.java similarity index 68% rename from src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java rename to src/com/android/settings/enterprise/CaCertsPreferenceController.java index cc0d4f68b06..d020676efb6 100644 --- a/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java +++ b/src/com/android/settings/enterprise/CaCertsPreferenceController.java @@ -19,39 +19,37 @@ 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 CaCertsManagedProfilePreferenceController extends PreferenceController { +public class CaCertsPreferenceController extends DynamicAvailabilityPreferenceController { - private static final String KEY_CA_CERTS_MANAGED_PROFILE = "ca_certs_managed_profile"; + private static final String CA_CERTS = "ca_certs"; private final EnterprisePrivacyFeatureProvider mFeatureProvider; - public CaCertsManagedProfilePreferenceController(Context context) { - super(context); + public CaCertsPreferenceController(Context context, Lifecycle lifecycle) { + super(context, lifecycle); mFeatureProvider = FeatureFactory.getFactory(context) .getEnterprisePrivacyFeatureProvider(context); } @Override public void updateState(Preference preference) { - final int certs = mFeatureProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile(); - if (certs == 0) { - preference.setVisible(false); - return; - } + final int certs = + mFeatureProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile(); 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 public String getPreferenceKey() { - return KEY_CA_CERTS_MANAGED_PROFILE; + return CA_CERTS; } } diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java index 2270efac8d5..447886595ac 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java @@ -98,15 +98,9 @@ public interface EnterprisePrivacyFeatureProvider { /** * Returns the number of CA certificates that the Device Owner or Profile Owner installed in - * the current user. + * the current user and the user's managed profile (if any). */ - int getNumberOfOwnerInstalledCaCertsInCurrentUser(); - - /** - * Returns the number of CA certificates that the Profile Owner installed in the current user's - * managed profile (if any). - */ - int getNumberOfOwnerInstalledCaCertsInManagedProfile(); + int getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile(); /** * Returns the number of Device Admin apps active in the current user and the user's managed diff --git a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java index 6cff807de91..69eaa2e40ab 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java @@ -189,19 +189,20 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe } @Override - public int getNumberOfOwnerInstalledCaCertsInCurrentUser() { - final List certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(MY_USER_ID)); - return certs != null ? certs.size() : 0; - } - - @Override - public int getNumberOfOwnerInstalledCaCertsInManagedProfile() { - final int userId = getManagedProfileUserId(); - if (userId == UserHandle.USER_NULL) { - return 0; + public int getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile() { + int num = 0; + List certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(MY_USER_ID)); + if (certs != null) { + num += certs.size(); } - final List certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(userId)); - return certs != null ? certs.size() : 0; + final int userId = getManagedProfileUserId(); + if (userId != UserHandle.USER_NULL) { + certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(userId)); + if (certs != null) { + num += certs.size(); + } + } + return num; } @Override diff --git a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java index 0fb341a4993..55ec3ea2886 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java @@ -64,18 +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 CaCertsCurrentUserPreferenceController(context)); - controllers.add(new CaCertsManagedProfilePreferenceController(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/CaCertsCurrentUserPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java deleted file mode 100644 index c8ffa7efce0..00000000000 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java +++ /dev/null @@ -1,139 +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.content.res.Resources; -import com.android.settings.R; -import android.support.v7.preference.Preference; - -import com.android.settings.SettingsRobolectricTestRunner; -import com.android.settings.TestConfig; -import com.android.settings.testutils.FakeFeatureFactory; - -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 static com.google.common.truth.Truth.assertThat; -import static org.mockito.Mockito.when; - -/** - * Tests for {@link CaCertsCurrentUserPreferenceController}. - */ -@RunWith(SettingsRobolectricTestRunner.class) -@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) -public final class CaCertsCurrentUserPreferenceControllerTest { - - private final String INSTALLED_CERTS_USER = "trusted credentials"; - private final String INSTALLED_CERTS_PERSONAL = "trusted credentials in personal profile"; - private final String NUMBER_INSTALLED_CERTS_1 = "1 cert"; - private final String NUMBER_INSTALLED_CERTS_10 = "10 certs"; - - @Mock(answer = Answers.RETURNS_DEEP_STUBS) - private Context mContext; - private FakeFeatureFactory mFeatureFactory; - - private CaCertsCurrentUserPreferenceController mController; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - FakeFeatureFactory.setupForTest(mContext); - mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new CaCertsCurrentUserPreferenceController(mContext); - - when(mContext.getString(R.string.enterprise_privacy_ca_certs_user)) - .thenReturn(INSTALLED_CERTS_USER); - when(mContext.getString(R.string.enterprise_privacy_ca_certs_personal)) - .thenReturn(INSTALLED_CERTS_PERSONAL); - when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, - 1, 1)).thenReturn(NUMBER_INSTALLED_CERTS_1); - when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, - 10, 10)).thenReturn(NUMBER_INSTALLED_CERTS_10); - } - - @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 - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(0); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(1); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_USER); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1); - - preference.setVisible(false); - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(10); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_USER); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider.isInCompMode()).thenReturn(true); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(0); - mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(1); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_PERSONAL); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1); - - preference.setVisible(false); - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInCurrentUser()).thenReturn(10); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getTitle()).isEqualTo(INSTALLED_CERTS_PERSONAL); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10); - } - - @Test - public void testIsAvailable() { - assertThat(mController.isAvailable()).isTrue(); - } - - @Test - public void testHandlePreferenceTreeClick() { - assertThat(mController.handlePreferenceTreeClick(new Preference(mContext, null, 0, 0))) - .isFalse(); - } - - @Test - public void testGetPreferenceKey() { - assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs_current_user"); - } -} diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java similarity index 65% rename from tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java rename to tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java index 693cfaea699..fef2e0f017f 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java @@ -37,60 +37,46 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.when; /** - * Tests for {@link CaCertsManagedProfilePreferenceController}. + * Tests for {@link CaCertsPreferenceController}. */ @RunWith(SettingsRobolectricTestRunner.class) @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) -public final class CaCertsManagedProfilePreferenceControllerTest { - - private final String NUMBER_INSTALLED_CERTS_1 = "1 cert"; - private final String NUMBER_INSTALLED_CERTS_10 = "10 certs"; +public final class CaCertsPreferenceControllerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) private Context mContext; private FakeFeatureFactory mFeatureFactory; - private CaCertsManagedProfilePreferenceController mController; + private CaCertsPreferenceController mController; @Before public void setUp() { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(mContext); mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext); - mController = new CaCertsManagedProfilePreferenceController(mContext); - - when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, - 1, 1)).thenReturn(NUMBER_INSTALLED_CERTS_1); - when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, - 10, 10)).thenReturn(NUMBER_INSTALLED_CERTS_10); + mController = new CaCertsPreferenceController(mContext, null /* lifecycle */); } @Test public void testUpdateState() { final Preference preference = new Preference(mContext, null, 0, 0); - preference.setVisible(true); + when(mContext.getResources().getQuantityString(R.plurals.enterprise_privacy_number_ca_certs, + 10, 10)).thenReturn("10 certs"); when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(0); + .getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()).thenReturn(10); mController.updateState(preference); - assertThat(preference.isVisible()).isFalse(); - - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(1); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_1); - - preference.setVisible(false); - when(mFeatureFactory.enterprisePrivacyFeatureProvider - .getNumberOfOwnerInstalledCaCertsInManagedProfile()).thenReturn(10); - mController.updateState(preference); - assertThat(preference.isVisible()).isTrue(); - assertThat(preference.getSummary()).isEqualTo(NUMBER_INSTALLED_CERTS_10); + 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(); } @@ -102,6 +88,6 @@ public final class CaCertsManagedProfilePreferenceControllerTest { @Test public void testGetPreferenceKey() { - assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs_managed_profile"); + assertThat(mController.getPreferenceKey()).isEqualTo("ca_certs"); } } 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/EnterprisePrivacyFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java index d4eec19f7bc..2afcab9b448 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java @@ -268,39 +268,45 @@ public final class EnterprisePrivacyFeatureProviderImplTest { } @Test - public void testGetNumberOfOwnerInstalledCaCertsInCurrentUser() { + public void testGetNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile() { final UserHandle userHandle = new UserHandle(UserHandle.USER_SYSTEM); - - when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) - .thenReturn(null); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(0); - when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) - .thenReturn(new ArrayList()); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(0); - when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) - .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"})); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInCurrentUser()).isEqualTo(2); - } - - @Test - public void testGetNumberOfOwnerInstalledCaCertsInManagedProfile() { - final UserHandle userHandle = new UserHandle(MANAGED_PROFILE_USER_ID); + final UserHandle managedProfileUserHandle = new UserHandle(MANAGED_PROFILE_USER_ID); final UserInfo managedProfile = new UserInfo(MANAGED_PROFILE_USER_ID, "", "", UserInfo.FLAG_MANAGED_PROFILE); - mProfiles.add(managedProfile); + when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle)) + .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"})); + when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) .thenReturn(null); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(0); when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) .thenReturn(new ArrayList()); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(0); when(mDevicePolicyManager.getOwnerInstalledCaCerts(userHandle)) .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"})); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(2); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(2); + + mProfiles.add(managedProfile); + when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle)) + .thenReturn(null); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(2); + when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle)) + .thenReturn(new ArrayList()); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(2); + when(mDevicePolicyManager.getOwnerInstalledCaCerts(managedProfileUserHandle)) + .thenReturn(Arrays.asList(new String[] {"ca1", "ca2"})); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(4); mProfiles.remove(managedProfile); - assertThat(mProvider.getNumberOfOwnerInstalledCaCertsInManagedProfile()).isEqualTo(0); + assertThat(mProvider.getNumberOfOwnerInstalledCaCertsForCurrentUserAndManagedProfile()) + .isEqualTo(2); } @Test diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java index 46d6b6c6e6b..8a117794d34 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java @@ -117,7 +117,7 @@ public final class EnterprisePrivacySettingsTest { private void verifyPreferenceControllers(List controllers) { assertThat(controllers).isNotNull(); - assertThat(controllers.size()).isEqualTo(17); + assertThat(controllers.size()).isEqualTo(16); assertThat(controllers.get(0)).isInstanceOf(InstalledPackagesPreferenceController.class); assertThat(controllers.get(1)).isInstanceOf(NetworkLogsPreferenceController.class); assertThat(controllers.get(2)).isInstanceOf(BugReportsPreferenceController.class); @@ -137,13 +137,11 @@ public final class EnterprisePrivacySettingsTest { assertThat(controllers.get(10)).isInstanceOf( AlwaysOnVpnManagedProfilePreferenceController.class); assertThat(controllers.get(11)).isInstanceOf(GlobalHttpProxyPreferenceController.class); - assertThat(controllers.get(12)).isInstanceOf(CaCertsCurrentUserPreferenceController.class); + assertThat(controllers.get(12)).isInstanceOf(CaCertsPreferenceController.class); assertThat(controllers.get(13)).isInstanceOf( - CaCertsManagedProfilePreferenceController.class); - assertThat(controllers.get(14)).isInstanceOf( FailedPasswordWipePrimaryUserPreferenceController.class); - assertThat(controllers.get(15)).isInstanceOf( + assertThat(controllers.get(14)).isInstanceOf( FailedPasswordWipeManagedProfilePreferenceController.class); - assertThat(controllers.get(16)).isInstanceOf(ImePreferenceController.class); + assertThat(controllers.get(15)).isInstanceOf(ImePreferenceController.class); } } 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(); }