PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes I54360698,Ic8a3db21

Browse Source 
* changes:
  Finish removing N/A DO disclosures from search index
  DO Disclosures: Combine personal and work CA cert
This commit is contained in:
TreeHugger Robot
2017-03-21 23:04:07 +00:00
committed by Android (Google) Code Review
parent 19449197e6 b076e00c5e
commit ca3997d27e
40 changed files with 315 additions and 495 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
res/values/strings.xml
View File

@@ -8246,10 +8246,8 @@
<string name="enterprise_privacy_always_on_vpn_work">Always-on VPN turned on in your work profile</string>
<!-- Label explaining that a global HTTP proxy was set by the admin. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_global_http_proxy">Global HTTP proxy set</string>
<!-- Label explaining that the admin installed trusted CA certificates for the current user. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_ca_certs_user">Trusted credentials</string>
<!-- Label explaining that the admin installed trusted CA certificates for the personal profile. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_ca_certs_personal">Trusted credentials in your personal profile</string>
<!-- Label explaining that the admin installed trusted CA certificates. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_ca_certs">Trusted credentials</string>
<!-- Summary indicating the number of trusted CA certificates installed by the admin. [CHAR LIMIT=NONE] -->
<plurals name="enterprise_privacy_number_ca_certs">
<item quantity="one"><xliff:g id="count">%d</xliff:g> CA certificate</item>
@@ -8260,8 +8258,6 @@
<item quantity="one"><xliff:g id="count">%d</xliff:g> CA certificate. Tap to view.</item>
<item quantity="other"><xliff:g id="count">%d</xliff:g> CA certificates. Tap to view.</item>
</plurals>
<!-- Label explaining that the admin installed trusted CA certificates for the work profile. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_ca_certs_work">Trusted credentials in your work profile</string>
<!-- Label explaining that the admin can lock the device and change the user's password. [CHAR LIMIT=NONE] -->
<string name="enterprise_privacy_lock_device">Admin can lock the device and reset password</string>
<!-- Label explaining that the admin can wipe the device remotely. [CHAR LIMIT=NONE] -->

7
res/xml/enterprise_privacy_settings.xml
View File

@@ -90,11 +90,8 @@
android:title="@string/enterprise_privacy_global_http_proxy"
settings:multiLine="true"/>
<com.android.settings.DividerPreference
android:key="ca_certs_current_user"
settings:multiLine="true"/>
<com.android.settings.DividerPreference
android:key="ca_certs_managed_profile"
android:title="@string/enterprise_privacy_ca_certs_work"
android:key="ca_certs"
android:title="@string/enterprise_privacy_ca_certs"
settings:multiLine="true"/>
</PreferenceCategory>

3
src/com/android/settings/applications/ApplicationFeatureProvider.java
View File

@@ -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);
/**

12
src/com/android/settings/applications/ApplicationFeatureProviderImpl.java
View File

@@ -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

8
src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceController.java
View File

@@ -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

7
src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceController.java
View File

@@ -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);
}

7
src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceController.java
View File

@@ -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);
}

34
src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBase.java
View File

@@ -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

18
src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceController.java
View File

@@ -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

13
src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceController.java
View File

@@ -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

60
src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceController.java
View File

@@ -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;
}
}

24
src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceController.java → src/com/android/settings/enterprise/CaCertsPreferenceController.java
View File

@@ -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;
}
}

10
src/com/android/settings/enterprise/EnterprisePrivacyFeatureProvider.java
View File

@@ -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

25
src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImpl.java
View File

@@ -189,19 +189,20 @@ public class EnterprisePrivacyFeatureProviderImpl implements EnterprisePrivacyFe
}
@Override
public int getNumberOfOwnerInstalledCaCertsInCurrentUser() {
final List<String> 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<String> certs = mDpm.getOwnerInstalledCaCerts(new UserHandle(MY_USER_ID));
if (certs != null) {
num += certs.size();
}
final List<String> 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

25
src/com/android/settings/enterprise/EnterprisePrivacySettings.java
View File

@@ -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;
}

6
src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceController.java
View File

@@ -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

23
src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBase.java
View File

@@ -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;
}
}

6
src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceController.java
View File

@@ -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

17
src/com/android/settings/enterprise/GlobalHttpProxyPreferenceController.java
View File

@@ -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

20
src/com/android/settings/enterprise/ImePreferenceController.java
View File

@@ -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

24
tests/robotests/src/com/android/settings/applications/AppWithAdminGrantedPermissionsCounterTest.java
View File

@@ -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

30
tests/robotests/src/com/android/settings/applications/ApplicationFeatureProviderImplTest.java
View File

@@ -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),

6
tests/robotests/src/com/android/settings/enterprise/AdminGrantedCameraPermissionPreferenceControllerTest.java
View File

@@ -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);
}
}

6
tests/robotests/src/com/android/settings/enterprise/AdminGrantedLocationPermissionsPreferenceControllerTest.java
View File

@@ -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);
}
}

6
tests/robotests/src/com/android/settings/enterprise/AdminGrantedMicrophonePermissionPreferenceControllerTest.java
View File

@@ -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);
}
}

11
tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerBaseTest.java
View File

@@ -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

40
tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java
View File

@@ -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);
}

25
tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java
View File

@@ -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();
}

29
tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnPrimaryUserPreferenceControllerTest.java
View File

@@ -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();
}

139
tests/robotests/src/com/android/settings/enterprise/CaCertsCurrentUserPreferenceControllerTest.java
View File

@@ -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");
}
}

44
tests/robotests/src/com/android/settings/enterprise/CaCertsManagedProfilePreferenceControllerTest.java → tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTest.java
View File

@@ -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");
}
}

2
tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java
View File

@@ -96,7 +96,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
@Test
public void testIsAvailableSync() {
EnterpriseInstalledPackagesPreferenceController controller
final EnterpriseInstalledPackagesPreferenceController controller
= new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, false /* async */);

48
tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyFeatureProviderImplTest.java
View File

@@ -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<String>());
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<String>());
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<String>());
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

10
tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacySettingsTest.java
View File

@@ -117,7 +117,7 @@ public final class EnterprisePrivacySettingsTest {
private void verifyPreferenceControllers(List<PreferenceController> 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);
}
}

3
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipeManagedProfilePreferenceControllerTest.java
View File

@@ -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

3
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerBaseTest.java
View File

@@ -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

9
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java
View File

@@ -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();
}

3
tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePrimaryUserPreferenceControllerTest.java
View File

@@ -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

24
tests/robotests/src/com/android/settings/enterprise/GlobalHttpProxyPreferenceControllerTest.java
View File

@@ -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();
}

15
tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java
View File

@@ -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();
}