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

Remove DynamicAvailabilityPreferenceController.

Browse Source 
- This class is over complex to use, and get in the way of show/hide
  pref when availability change.
- The function from DynamicAvailabilityPreferenceController can be done
  with PreferenceCategoryController.

Bug: 68956750
Bug: 32953042
Test: robotests
Change-Id: Ia7b7e214c072b8c77f5de3d959fdb1dc79217f76
This commit is contained in:
Fan Zhang
2017-11-07 10:57:47 -08:00
parent 2260321fd8
commit b5f5ffbece
46 changed files with 202 additions and 1048 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/com/android/settings/core/DynamicAvailabilityPreferenceController.java
View File

@@ -1,75 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.core;
import android.content.Context;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.lifecycle.LifecycleObserver;
import com.android.settingslib.core.lifecycle.events.OnResume;
public abstract class DynamicAvailabilityPreferenceController extends AbstractPreferenceController
implements PreferenceControllerMixin, LifecycleObserver, OnResume {
private Preference mPreference;
private PreferenceScreen mScreen;
private PreferenceAvailabilityObserver mAvailabilityObserver = null;
public DynamicAvailabilityPreferenceController(Context context, Lifecycle lifecycle) {
super(context);
if (lifecycle != null) {
lifecycle.addObserver(this);
}
}
public void setAvailabilityObserver(PreferenceAvailabilityObserver observer) {
mAvailabilityObserver = observer;
}
public PreferenceAvailabilityObserver getAvailabilityObserver() {
return mAvailabilityObserver;
}
@Override
public void displayPreference(PreferenceScreen screen) {
mScreen = screen;
mPreference = screen.findPreference(getPreferenceKey());
super.displayPreference(screen);
}
@Override
public void onResume() {
if (!isAvailable()) {
removePreference(mScreen, getPreferenceKey());
return;
}
updateState(mPreference);
if (mScreen.findPreference(getPreferenceKey()) == null) {
mScreen.addPreference(mPreference);
}
}
protected void notifyOnAvailabilityUpdate(boolean available) {
if (mAvailabilityObserver != null) {
mAvailabilityObserver.onPreferenceAvailabilityUpdated(getPreferenceKey(), available);
}
}
}

33
src/com/android/settings/core/PreferenceAvailabilityObserver.java
View File

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

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

@@ -17,18 +17,14 @@ package com.android.settings.enterprise;
import android.Manifest;
import android.content.Context;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class AdminGrantedCameraPermissionPreferenceController extends
AdminGrantedPermissionsPreferenceControllerBase {
private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_CAMERA_ACCESS_PACKAGES
= "enterprise_privacy_number_camera_access_packages";
public AdminGrantedCameraPermissionPreferenceController(Context context, Lifecycle lifecycle,
boolean async) {
super(context, lifecycle, async, new String[] {Manifest.permission.CAMERA},
Manifest.permission_group.CAMERA);
public AdminGrantedCameraPermissionPreferenceController(Context context, boolean async) {
super(context, async, new String[] {Manifest.permission.CAMERA});
}
@Override

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

@@ -17,18 +17,15 @@ package com.android.settings.enterprise;
import android.Manifest;
import android.content.Context;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class AdminGrantedLocationPermissionsPreferenceController extends
AdminGrantedPermissionsPreferenceControllerBase {
private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_LOCATION_ACCESS_PACKAGES
= "enterprise_privacy_number_location_access_packages";
public AdminGrantedLocationPermissionsPreferenceController(Context context, Lifecycle lifecycle,
boolean async) {
super(context, lifecycle, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION}, Manifest.permission_group.LOCATION);
public AdminGrantedLocationPermissionsPreferenceController(Context context, boolean async) {
super(context, async, new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION});
}
@Override

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

@@ -17,18 +17,14 @@ package com.android.settings.enterprise;
import android.Manifest;
import android.content.Context;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class AdminGrantedMicrophonePermissionPreferenceController extends
AdminGrantedPermissionsPreferenceControllerBase {
private static final String KEY_ENTERPRISE_PRIVACY_NUMBER_MICROPHONE_ACCESS_PACKAGES
= "enterprise_privacy_number_microphone_access_packages";
public AdminGrantedMicrophonePermissionPreferenceController(Context context,
Lifecycle lifecycle, boolean async) {
super(context, lifecycle, async, new String[] {Manifest.permission.RECORD_AUDIO},
Manifest.permission_group.MICROPHONE);
public AdminGrantedMicrophonePermissionPreferenceController(Context context, boolean async) {
super(context, async, new String[] {Manifest.permission.RECORD_AUDIO});
}
@Override

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

@@ -20,24 +20,22 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public abstract class AdminGrantedPermissionsPreferenceControllerBase
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
private final String[] mPermissions;
private final String mPermissionGroup;
private final ApplicationFeatureProvider mFeatureProvider;
private final boolean mAsync;
private boolean mHasApps;
public AdminGrantedPermissionsPreferenceControllerBase(Context context, Lifecycle lifecycle,
boolean async, String[] permissions, String permissionGroup) {
super(context, lifecycle);
public AdminGrantedPermissionsPreferenceControllerBase(Context context, boolean async,
String[] permissions) {
super(context);
mPermissions = permissions;
mPermissionGroup = permissionGroup;
mFeatureProvider = FeatureFactory.getFactory(context)
.getApplicationFeatureProvider(context);
mAsync = async;
@@ -58,7 +56,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase
mHasApps = true;
}
preference.setVisible(mHasApps);
notifyOnAvailabilityUpdate(mHasApps);
});
}
@@ -80,7 +77,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerBase
mFeatureProvider.calculateNumberOfAppsWithAdminGrantedPermissions(mPermissions,
false /* async */, (num) -> haveAppsWithAdminGrantedPermissions[0] = num > 0);
mHasApps = haveAppsWithAdminGrantedPermissions[0];
notifyOnAvailabilityUpdate(mHasApps);
return mHasApps;
}

14
src/com/android/settings/enterprise/AlwaysOnVpnCurrentUserPreferenceController.java
View File

@@ -17,18 +17,18 @@ import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class AlwaysOnVpnCurrentUserPreferenceController
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
private static final String KEY_ALWAYS_ON_VPN_PRIMARY_USER = "always_on_vpn_primary_user";
private final EnterprisePrivacyFeatureProvider mFeatureProvider;
public AlwaysOnVpnCurrentUserPreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public AlwaysOnVpnCurrentUserPreferenceController(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@@ -42,9 +42,7 @@ public class AlwaysOnVpnCurrentUserPreferenceController
@Override
public boolean isAvailable() {
final boolean available = mFeatureProvider.isAlwaysOnVpnSetInCurrentUser();
notifyOnAvailabilityUpdate(available);
return available;
return mFeatureProvider.isAlwaysOnVpnSetInCurrentUser();
}
@Override

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

@@ -15,27 +15,25 @@ package com.android.settings.enterprise;
import android.content.Context;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class AlwaysOnVpnManagedProfilePreferenceController
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
private static final String KEY_ALWAYS_ON_VPN_MANAGED_PROFILE = "always_on_vpn_managed_profile";
private final EnterprisePrivacyFeatureProvider mFeatureProvider;
public AlwaysOnVpnManagedProfilePreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public AlwaysOnVpnManagedProfilePreferenceController(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@Override
public boolean isAvailable() {
final boolean available = mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
notifyOnAvailabilityUpdate(available);
return available;
return mFeatureProvider.isAlwaysOnVpnSetInManagedProfile();
}
@Override

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

@@ -20,16 +20,13 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class CaCertsCurrentUserPreferenceController extends CaCertsPreferenceControllerBase {
@VisibleForTesting
static final String CA_CERTS_CURRENT_USER = "ca_certs_current_user";
public CaCertsCurrentUserPreferenceController(Context context,
Lifecycle lifecycle) {
super(context, lifecycle);
public CaCertsCurrentUserPreferenceController(Context context) {
super(context);
}
@Override

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

@@ -17,16 +17,13 @@ package com.android.settings.enterprise;
import android.content.Context;
import android.support.annotation.VisibleForTesting;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class CaCertsManagedProfilePreferenceController extends CaCertsPreferenceControllerBase {
@VisibleForTesting
static final String CA_CERTS_MANAGED_PROFILE = "ca_certs_managed_profile";
public CaCertsManagedProfilePreferenceController(Context context,
Lifecycle lifecycle) {
super(context, lifecycle);
public CaCertsManagedProfilePreferenceController(Context context) {
super(context);
}
@Override

14
src/com/android/settings/enterprise/CaCertsPreferenceControllerBase.java
View File

@@ -18,17 +18,17 @@ import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public abstract class CaCertsPreferenceControllerBase
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
protected final EnterprisePrivacyFeatureProvider mFeatureProvider;
public CaCertsPreferenceControllerBase(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public CaCertsPreferenceControllerBase(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@@ -42,9 +42,7 @@ public abstract class CaCertsPreferenceControllerBase
@Override
public boolean isAvailable() {
final boolean available = getNumberOfCaCerts() > 0;
notifyOnAvailabilityUpdate(available);
return available;
return getNumberOfCaCerts() > 0;
}
protected abstract int getNumberOfCaCerts();

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

@@ -18,21 +18,20 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class EnterpriseInstalledPackagesPreferenceController
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
private static final String KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES
= "number_enterprise_installed_packages";
private final ApplicationFeatureProvider mFeatureProvider;
private final boolean mAsync;
public EnterpriseInstalledPackagesPreferenceController(Context context, Lifecycle lifecycle,
boolean async) {
super(context, lifecycle);
public EnterpriseInstalledPackagesPreferenceController(Context context, boolean async) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getApplicationFeatureProvider(context);
mAsync = async;
@@ -53,7 +52,6 @@ public class EnterpriseInstalledPackagesPreferenceController
}
preference.setVisible(available);
notifyOnAvailabilityUpdate(available);
});
}
@@ -72,9 +70,8 @@ public class EnterpriseInstalledPackagesPreferenceController
final Boolean[] haveEnterpriseInstalledPackages = { null };
mFeatureProvider.calculateNumberOfPolicyInstalledApps(false /* async */,
(num) -> haveEnterpriseInstalledPackages[0] = num > 0);
final boolean available = haveEnterpriseInstalledPackages[0];
notifyOnAvailabilityUpdate(available);
return available;
return haveEnterpriseInstalledPackages[0];
}
@Override

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

@@ -17,23 +17,27 @@ import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class EnterprisePrivacyPreferenceController extends DynamicAvailabilityPreferenceController {
public class EnterprisePrivacyPreferenceController extends AbstractPreferenceController implements
PreferenceControllerMixin {
private static final String KEY_ENTERPRISE_PRIVACY = "enterprise_privacy";
private final EnterprisePrivacyFeatureProvider mFeatureProvider;
public EnterprisePrivacyPreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public EnterprisePrivacyPreferenceController(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@Override
public void updateState(Preference preference) {
if (preference == null) {
return;
}
final String organizationName = mFeatureProvider.getDeviceOwnerOrganizationName();
if (organizationName == null) {
preference.setSummary(R.string.enterprise_privacy_settings_summary_generic);
@@ -45,9 +49,7 @@ public class EnterprisePrivacyPreferenceController extends DynamicAvailabilityPr
@Override
public boolean isAvailable() {
final boolean available = mFeatureProvider.hasDeviceOwner();
notifyOnAvailabilityUpdate(available);
return available;
return mFeatureProvider.hasDeviceOwner();
}
@Override

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

@@ -21,12 +21,11 @@ import android.provider.SearchIndexableResource;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.dashboard.DashboardFragment;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settings.widget.PreferenceCategoryController;
import com.android.settingslib.core.AbstractPreferenceController;
import com.android.settingslib.core.lifecycle.Lifecycle;
import java.util.ArrayList;
import java.util.Arrays;
@@ -53,45 +52,41 @@ public class EnterprisePrivacySettings extends DashboardFragment {
@Override
protected List<AbstractPreferenceController> getPreferenceControllers(Context context) {
return buildPreferenceControllers(context, getLifecycle(), true /* async */);
return buildPreferenceControllers(context, true /* async */);
}
private static List<AbstractPreferenceController> buildPreferenceControllers(Context context,
Lifecycle lifecycle, boolean async) {
boolean async) {
final List<AbstractPreferenceController> controllers = new ArrayList<>();
controllers.add(new NetworkLogsPreferenceController(context));
controllers.add(new BugReportsPreferenceController(context));
controllers.add(new SecurityLogsPreferenceController(context));
final List<DynamicAvailabilityPreferenceController> exposureChangesCategoryControllers =
final List<AbstractPreferenceController> exposureChangesCategoryControllers =
new ArrayList<>();
exposureChangesCategoryControllers.add(new EnterpriseInstalledPackagesPreferenceController(
context, lifecycle, async));
context, async));
exposureChangesCategoryControllers.add(
new AdminGrantedLocationPermissionsPreferenceController(context, lifecycle, async));
new AdminGrantedLocationPermissionsPreferenceController(context, async));
exposureChangesCategoryControllers.add(
new AdminGrantedMicrophonePermissionPreferenceController(context, lifecycle,
async));
new AdminGrantedMicrophonePermissionPreferenceController(context, async));
exposureChangesCategoryControllers.add(new AdminGrantedCameraPermissionPreferenceController(
context, lifecycle, async));
context, async));
exposureChangesCategoryControllers.add(new EnterpriseSetDefaultAppsPreferenceController(
context, lifecycle));
context));
exposureChangesCategoryControllers.add(new AlwaysOnVpnCurrentUserPreferenceController(
context, lifecycle));
context));
exposureChangesCategoryControllers.add(new AlwaysOnVpnManagedProfilePreferenceController(
context, lifecycle));
exposureChangesCategoryControllers.add(new ImePreferenceController(context, lifecycle));
exposureChangesCategoryControllers.add(new GlobalHttpProxyPreferenceController(context,
lifecycle));
exposureChangesCategoryControllers.add(new CaCertsCurrentUserPreferenceController(
context, lifecycle));
context));
exposureChangesCategoryControllers.add(new ImePreferenceController(context));
exposureChangesCategoryControllers.add(new GlobalHttpProxyPreferenceController(context));
exposureChangesCategoryControllers.add(new CaCertsCurrentUserPreferenceController(context));
exposureChangesCategoryControllers.add(new CaCertsManagedProfilePreferenceController(
context, lifecycle));
context));
controllers.addAll(exposureChangesCategoryControllers);
controllers.add(new ExposureChangesCategoryPreferenceController(context, lifecycle,
exposureChangesCategoryControllers, async));
controllers.add(new FailedPasswordWipeCurrentUserPreferenceController(context, lifecycle));
controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context,
lifecycle));
controllers.add(new PreferenceCategoryController(context, "exposure_changes_category",
exposureChangesCategoryControllers));
controllers.add(new FailedPasswordWipeCurrentUserPreferenceController(context));
controllers.add(new FailedPasswordWipeManagedProfilePreferenceController(context));
return controllers;
}
@@ -114,11 +109,12 @@ public class EnterprisePrivacySettings extends DashboardFragment {
final SearchIndexableResource sir = new SearchIndexableResource(context);
sir.xmlResId = R.xml.enterprise_privacy_settings;
return Arrays.asList(sir);
}
}
@Override
public List<AbstractPreferenceController> getPreferenceControllers(Context context) {
return buildPreferenceControllers(context, null /* lifecycle */, false /* async */);
@Override
public List<AbstractPreferenceController> getPreferenceControllers(
Context context) {
return buildPreferenceControllers(context, false /* async */);
}
};
}

14
src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceController.java
View File

@@ -21,20 +21,20 @@ import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.applications.EnterpriseDefaultApps;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.users.UserFeatureProvider;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class EnterpriseSetDefaultAppsPreferenceController
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
private static final String KEY_DEFAULT_APPS = "number_enterprise_set_default_apps";
private final ApplicationFeatureProvider mApplicationFeatureProvider;
private final UserFeatureProvider mUserFeatureProvider;
public EnterpriseSetDefaultAppsPreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public EnterpriseSetDefaultAppsPreferenceController(Context context) {
super(context);
final FeatureFactory factory = FeatureFactory.getFactory(context);
mApplicationFeatureProvider = factory.getApplicationFeatureProvider(context);
mUserFeatureProvider = factory.getUserFeatureProvider(context);
@@ -49,9 +49,7 @@ public class EnterpriseSetDefaultAppsPreferenceController
@Override
public boolean isAvailable() {
final boolean available = getNumberOfEnterpriseSetDefaultApps() > 0;
notifyOnAvailabilityUpdate(available);
return available;
return getNumberOfEnterpriseSetDefaultApps() > 0;
}
@Override

111
src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceController.java
View File

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

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

@@ -15,16 +15,14 @@ package com.android.settings.enterprise;
import android.content.Context;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class FailedPasswordWipeCurrentUserPreferenceController
extends FailedPasswordWipePreferenceControllerBase {
private static final String KEY_FAILED_PASSWORD_WIPE_CURRENT_USER
= "failed_password_wipe_current_user";
public FailedPasswordWipeCurrentUserPreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public FailedPasswordWipeCurrentUserPreferenceController(Context context) {
super(context);
}
@Override

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

@@ -14,7 +14,6 @@
package com.android.settings.enterprise;
import android.content.Context;
import com.android.settingslib.core.lifecycle.Lifecycle;
public class FailedPasswordWipeManagedProfilePreferenceController
extends FailedPasswordWipePreferenceControllerBase {
@@ -22,9 +21,8 @@ public class FailedPasswordWipeManagedProfilePreferenceController
private static final String KEY_FAILED_PASSWORD_WIPE_MANAGED_PROFILE
= "failed_password_wipe_managed_profile";
public FailedPasswordWipeManagedProfilePreferenceController(Context context,
Lifecycle lifecycle) {
super(context, lifecycle);
public FailedPasswordWipeManagedProfilePreferenceController(Context context) {
super(context);
}
@Override

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

@@ -15,21 +15,20 @@
package com.android.settings.enterprise;
import android.content.Context;
import android.content.res.Resources;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public abstract class FailedPasswordWipePreferenceControllerBase
extends DynamicAvailabilityPreferenceController {
extends AbstractPreferenceController implements PreferenceControllerMixin {
protected final EnterprisePrivacyFeatureProvider mFeatureProvider;
public FailedPasswordWipePreferenceControllerBase(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public FailedPasswordWipePreferenceControllerBase(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@@ -46,8 +45,6 @@ public abstract class FailedPasswordWipePreferenceControllerBase
@Override
public boolean isAvailable() {
final boolean available = getMaximumFailedPasswordsBeforeWipe() > 0;
notifyOnAvailabilityUpdate(available);
return available;
return getMaximumFailedPasswordsBeforeWipe() > 0;
}
}

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

@@ -15,26 +15,25 @@ package com.android.settings.enterprise;
import android.content.Context;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class GlobalHttpProxyPreferenceController extends DynamicAvailabilityPreferenceController {
public class GlobalHttpProxyPreferenceController extends AbstractPreferenceController implements
PreferenceControllerMixin {
private static final String KEY_GLOBAL_HTTP_PROXY = "global_http_proxy";
private final EnterprisePrivacyFeatureProvider mFeatureProvider;
public GlobalHttpProxyPreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public GlobalHttpProxyPreferenceController(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@Override
public boolean isAvailable() {
final boolean available = mFeatureProvider.isGlobalHttpProxySet();
notifyOnAvailabilityUpdate(available);
return available;
return mFeatureProvider.isGlobalHttpProxySet();
}
@Override

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

@@ -15,21 +15,21 @@
package com.android.settings.enterprise;
import android.content.Context;
import android.content.res.Resources;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.core.PreferenceControllerMixin;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.lifecycle.Lifecycle;
import com.android.settingslib.core.AbstractPreferenceController;
public class ImePreferenceController extends DynamicAvailabilityPreferenceController {
public class ImePreferenceController extends AbstractPreferenceController implements
PreferenceControllerMixin {
private static final String KEY_INPUT_METHOD = "input_method";
private final EnterprisePrivacyFeatureProvider mFeatureProvider;
public ImePreferenceController(Context context, Lifecycle lifecycle) {
super(context, lifecycle);
public ImePreferenceController(Context context) {
super(context);
mFeatureProvider = FeatureFactory.getFactory(context)
.getEnterprisePrivacyFeatureProvider(context);
}
@@ -37,15 +37,13 @@ public class ImePreferenceController extends DynamicAvailabilityPreferenceContro
@Override
public void updateState(Preference preference) {
preference.setSummary(mContext.getResources().getString(
R.string.enterprise_privacy_input_method_name,
mFeatureProvider.getImeLabelIfOwnerSet()));
R.string.enterprise_privacy_input_method_name,
mFeatureProvider.getImeLabelIfOwnerSet()));
}
@Override
public boolean isAvailable() {
final boolean available = mFeatureProvider.getImeLabelIfOwnerSet() != null;
notifyOnAvailabilityUpdate(available);
return available;
return mFeatureProvider.getImeLabelIfOwnerSet() != null;
}
@Override

8
src/com/android/settings/security/SecuritySettings.java
View File

@@ -206,7 +206,7 @@ public class SecuritySettings extends SettingsPreferenceFragment
mManageDeviceAdminPreferenceController
= new ManageDeviceAdminPreferenceController(activity);
mEnterprisePrivacyPreferenceController
= new EnterprisePrivacyPreferenceController(activity, null /* lifecycle */);
= new EnterprisePrivacyPreferenceController(activity);
mLockScreenNotificationPreferenceController
= new LockScreenNotificationPreferenceController(activity);
}
@@ -400,7 +400,9 @@ public class SecuritySettings extends SettingsPreferenceFragment
mManageDeviceAdminPreferenceController.updateState(
root.findPreference(KEY_MANAGE_DEVICE_ADMIN));
mEnterprisePrivacyPreferenceController.displayPreference(root);
mEnterprisePrivacyPreferenceController.onResume();
final Preference enterprisePrivacyPreference = root.findPreference(
mEnterprisePrivacyPreferenceController.getPreferenceKey());
mEnterprisePrivacyPreferenceController.updateState(enterprisePrivacyPreference);
return root;
}
@@ -893,7 +895,7 @@ public class SecuritySettings extends SettingsPreferenceFragment
keys.add(KEY_MANAGE_TRUST_AGENTS);
}
if (!(new EnterprisePrivacyPreferenceController(context, null /* lifecycle */))
if (!(new EnterprisePrivacyPreferenceController(context))
.isAvailable()) {
keys.add(KEY_ENTERPRISE_PRIVACY);
}

157
tests/robotests/src/com/android/settings/core/DynamicAvailabilityPreferenceControllerTest.java
View File

@@ -1,157 +0,0 @@
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.core;
import android.content.Context;
import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceScreen;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settingslib.core.lifecycle.Lifecycle;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link DynamicAvailabilityPreferenceController}.
*/
@RunWith(SettingsRobolectricTestRunner.class)
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class DynamicAvailabilityPreferenceControllerTest {
private final String PREFERENCE_KEY = "preference_key";
private @Mock Context mContext;
private @Mock Preference mPreference;
private @Mock PreferenceScreen mScreen;
private @Mock Lifecycle mLifecycle;
private @Mock PreferenceAvailabilityObserver mObserver;
private boolean mIsAvailable;
private Preference mUpdatedPreference = null;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
when(mPreference.getKey()).thenReturn(PREFERENCE_KEY);
when(mScreen.findPreference(PREFERENCE_KEY)).thenReturn(mPreference);
when(mScreen.getPreferenceCount()).thenReturn(1);
when(mScreen.getPreference(0)).thenReturn(mPreference);
}
@Test
public void testAvailableToUnavailable() {
mIsAvailable = true;
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
verify(mLifecycle).addObserver(controller);
controller.displayPreference(mScreen);
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isEqualTo(mPreference);
mUpdatedPreference = null;
mIsAvailable = false;
controller.onResume();
verify(mScreen).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
}
@Test
public void testUnavailableToAvailable() {
mIsAvailable = false;
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
verify(mLifecycle).addObserver(controller);
controller.displayPreference(mScreen);
verify(mScreen).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
reset(mScreen);
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen, never()).addPreference(mPreference);
assertThat(mUpdatedPreference).isNull();
mIsAvailable = true;
controller.onResume();
verify(mScreen, never()).removePreference(mPreference);
verify(mScreen).addPreference(mPreference);
assertThat(mUpdatedPreference).isEqualTo(mPreference);
}
@Test
public void testNotifyOnAvailabilityUpdate() {
final DynamicAvailabilityPreferenceController controller
= new DynamicAvailabilityPreferenceControllerTestable(mLifecycle);
controller.setAvailabilityObserver(mObserver);
assertThat(controller.getAvailabilityObserver()).isEqualTo(mObserver);
mIsAvailable = false;
controller.isAvailable();
verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, false);
mIsAvailable = true;
controller.isAvailable();
verify(mObserver).onPreferenceAvailabilityUpdated(PREFERENCE_KEY, true);
}
private class DynamicAvailabilityPreferenceControllerTestable
extends DynamicAvailabilityPreferenceController {
public DynamicAvailabilityPreferenceControllerTestable(Lifecycle lifecycle) {
super(DynamicAvailabilityPreferenceControllerTest.this.mContext, lifecycle);
}
@Override
public boolean isAvailable() {
notifyOnAvailabilityUpdate(mIsAvailable);
return mIsAvailable;
}
@Override
public void updateState(Preference preference) {
mUpdatedPreference = preference;
}
@Override
public String getPreferenceKey() {
return PREFERENCE_KEY;
}
}
}

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

@@ -34,13 +34,11 @@ public final class AdminGrantedCameraPermissionPreferenceControllerTest extends
public AdminGrantedCameraPermissionPreferenceControllerTest() {
super("enterprise_privacy_number_camera_access_packages",
new String[] {Manifest.permission.CAMERA},
Manifest.permission_group.CAMERA);
new String[] {Manifest.permission.CAMERA});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedCameraPermissionPreferenceController(mContext,null /* lifecycle */,
async);
return new AdminGrantedCameraPermissionPreferenceController(mContext, async);
}
}

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

@@ -18,8 +18,8 @@ package com.android.settings.enterprise;
import android.Manifest;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -35,13 +35,11 @@ public final class AdminGrantedLocationPermissionsPreferenceControllerTest exten
public AdminGrantedLocationPermissionsPreferenceControllerTest() {
super("enterprise_privacy_number_location_access_packages",
new String[] {Manifest.permission.ACCESS_COARSE_LOCATION,
Manifest.permission.ACCESS_FINE_LOCATION},
Manifest.permission_group.LOCATION);
Manifest.permission.ACCESS_FINE_LOCATION});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedLocationPermissionsPreferenceController(mContext,
null /* lifecycle */, async);
return new AdminGrantedLocationPermissionsPreferenceController(mContext, async);
}
}

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

@@ -18,8 +18,8 @@ package com.android.settings.enterprise;
import android.Manifest;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -34,13 +34,11 @@ public final class AdminGrantedMicrophonePermissionPreferenceControllerTest exte
public AdminGrantedMicrophonePermissionPreferenceControllerTest() {
super("enterprise_privacy_number_microphone_access_packages",
new String[] {Manifest.permission.RECORD_AUDIO},
Manifest.permission_group.MICROPHONE);
new String[] {Manifest.permission.RECORD_AUDIO});
}
@Override
protected AdminGrantedPermissionsPreferenceControllerBase createController(boolean async) {
return new AdminGrantedMicrophonePermissionPreferenceController(mContext,
null /* lifecycle */, async);
return new AdminGrantedMicrophonePermissionPreferenceController(mContext, async);
}
}

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

@@ -16,8 +16,8 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -31,7 +31,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
AdminGrantedPermissionsPreferenceControllerTestBase {
public AdminGrantedPermissionsPreferenceControllerBaseTest() {
super("some.key", new String[] {"some.permission"}, "some.permission");
super("some.key", new String[] {"some.permission"});
}
@Override
@@ -44,7 +44,7 @@ public final class AdminGrantedPermissionsPreferenceControllerBaseTest extends
AdminGrantedPermissionsPreferenceControllerBaseTestable(boolean async) {
super(AdminGrantedPermissionsPreferenceControllerBaseTest.this.mContext,
null /* lifecycle */, async, mPermissions, mPermissionGroup);
async, mPermissions);
}
@Override

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

@@ -16,12 +16,17 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -32,35 +37,22 @@ import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyObject;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Common base for testing subclasses of {@link AdminGrantedPermissionsPreferenceControllerBase}.
*/
public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
protected final String mKey;
protected final String[] mPermissions;
protected final String mPermissionGroup;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
protected Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
protected AdminGrantedPermissionsPreferenceControllerBase mController;
public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions,
String permissionGroup) {
public AdminGrantedPermissionsPreferenceControllerTestBase(String key, String[] permissions) {
mKey = key;
mPermissions = permissions;
mPermissionGroup = permissionGroup;
}
@Before
@@ -69,12 +61,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = createController(true /* async */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
private void setNumberOfPackagesWithAdminGrantedPermissions(int number, boolean async) {
@@ -96,7 +82,6 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
mController.updateState(preference);
assertThat(preference.isVisible()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
when(mContext.getResources().getQuantityString(
@@ -105,33 +90,27 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase {
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
assertThat(preference.isVisible()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
}
@Test
public void testIsAvailableSync() {
final AdminGrantedPermissionsPreferenceControllerBase controller
= createController(false /* async */);
controller.setAvailabilityObserver(mObserver);
setNumberOfPackagesWithAdminGrantedPermissions(0, false /* async */);
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, false);
setNumberOfPackagesWithAdminGrantedPermissions(20, false /* async */);
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(mKey, true);
}
@Test
public void testIsAvailableAsync() {
setNumberOfPackagesWithAdminGrantedPermissions(0, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
setNumberOfPackagesWithAdminGrantedPermissions(20, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(eq(mKey), anyBoolean());
}
@Test

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

@@ -16,14 +16,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import com.android.settings.R;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -33,10 +35,6 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link AlwaysOnVpnCurrentUserPreferenceController}.
*/
@@ -51,7 +49,6 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnCurrentUserPreferenceController mController;
@@ -60,18 +57,11 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext,
null /* lifecycle */);
mController = new AlwaysOnVpnCurrentUserPreferenceController(mContext);
when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_device))
.thenReturn(VPN_SET_DEVICE);
when(mContext.getString(R.string.enterprise_privacy_always_on_vpn_personal))
.thenReturn(VPN_SET_PERSONAL);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -95,12 +85,10 @@ public final class AlwaysOnVpnCurrentUserPreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInCurrentUser())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_PRIMARY_USER, true);
}
@Test

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

@@ -16,13 +16,15 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -32,10 +34,6 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link AlwaysOnVpnManagedProfilePreferenceController}.
*/
@@ -48,7 +46,6 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private AlwaysOnVpnManagedProfilePreferenceController mController;
@@ -57,14 +54,7 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext);
}
@Test
@@ -72,12 +62,10 @@ public final class AlwaysOnVpnManagedProfilePreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isAlwaysOnVpnSetInManagedProfile())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ALWAYS_ON_VPN_MANAGED_PROFILE, true);
}
@Test

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

@@ -17,9 +17,7 @@
package com.android.settings.enterprise;
import static com.android.settings.testutils.ApplicationTestUtils.buildInfo;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Answers.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.when;
@@ -30,10 +28,10 @@ import android.support.v7.preference.PreferenceScreen;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.applications.UserAppInfo;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settingslib.core.AbstractPreferenceController;
import org.junit.Before;
@@ -86,7 +84,8 @@ public class ApplicationListFragmentTest {
@Test
public void getPreferenceControllers() {
final List<AbstractPreferenceController> controllers = mFragment.getPreferenceControllers(mContext);
final List<AbstractPreferenceController> controllers = mFragment.getPreferenceControllers(
mContext);
assertThat(controllers).isNotNull();
assertThat(controllers.size()).isEqualTo(1);
int position = 0;
@@ -94,7 +93,8 @@ public class ApplicationListFragmentTest {
ApplicationListPreferenceController.class);
}
@Test public void getCategories() {
@Test
public void getCategories() {
assertThat(new ApplicationListFragment.AdminGrantedPermissionCamera().getMetricsCategory())
.isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_PERMISSIONS);
assertThat(new ApplicationListFragment.AdminGrantedPermissionLocation().

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

@@ -73,7 +73,7 @@ public final class CaCertsCurrentUserPreferenceControllerTest extends
@Override
CaCertsPreferenceControllerBase createController() {
return new CaCertsCurrentUserPreferenceController(mContext, null /* lifecycle */);
return new CaCertsCurrentUserPreferenceController(mContext);
}
private void assertUpdateState(boolean isCompMode, String expectedTitle) {

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

@@ -45,6 +45,6 @@ public final class CaCertsManagedProfilePreferenceControllerTest extends
@Override
CaCertsPreferenceControllerBase createController() {
return new CaCertsManagedProfilePreferenceController(mContext, null /* lifecycle */);
return new CaCertsManagedProfilePreferenceController(mContext);
}
}

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

@@ -50,7 +50,7 @@ public class CaCertsPreferenceControllerBaseTest extends CaCertsPreferenceContro
CaCertsPreferenceControllerBase {
public CaCertsPreferenceControllerBaseTestable(Context context) {
super(context, null);
super(context);
}
@Override

13
tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java
View File

@@ -17,15 +17,12 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import org.junit.Before;
@@ -43,8 +40,6 @@ public abstract class CaCertsPreferenceControllerTestBase {
protected Context mContext;
protected FakeFeatureFactory mFeatureFactory;
protected CaCertsPreferenceControllerBase mController;
@Mock
private PreferenceAvailabilityObserver mObserver;
@Before
public void setUp() {
@@ -52,12 +47,6 @@ public abstract class CaCertsPreferenceControllerTestBase {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = createController();
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -75,11 +64,9 @@ public abstract class CaCertsPreferenceControllerTestBase {
public void testIsAvailable() {
mockGetNumberOfCaCerts(0);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), false);
mockGetNumberOfCaCerts(10);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(getPreferenceKey(), true);
}
@Test

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

@@ -16,15 +16,20 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyObject;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.ApplicationFeatureProvider;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -36,15 +41,6 @@ import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.anyObject;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link EnterpriseInstalledPackagesPreferenceController}.
*/
@@ -58,7 +54,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterpriseInstalledPackagesPreferenceController mController;
@@ -68,13 +63,7 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, true /* async */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
true /* async */);
}
private void setNumberOfEnterpriseInstalledPackages(int number, boolean async) {
@@ -83,8 +72,9 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
((ApplicationFeatureProvider.NumberOfAppsCallback)
invocation.getArguments()[1]).onNumberOfAppsResult(number);
return null;
}}).when(mFeatureFactory.applicationFeatureProvider)
.calculateNumberOfPolicyInstalledApps(eq(async), anyObject());
}
}).when(mFeatureFactory.applicationFeatureProvider)
.calculateNumberOfPolicyInstalledApps(eq(async), anyObject());
}
@Test
@@ -95,8 +85,6 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
setNumberOfEnterpriseInstalledPackages(0, true /* async */);
mController.updateState(preference);
assertThat(preference.isVisible()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
false);
setNumberOfEnterpriseInstalledPackages(20, true /* async */);
when(mContext.getResources().getQuantityString(
@@ -105,39 +93,27 @@ public final class EnterpriseInstalledPackagesPreferenceControllerTest {
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo("minimum 20 apps");
assertThat(preference.isVisible()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES,
true);
}
@Test
public void testIsAvailableSync() {
final EnterpriseInstalledPackagesPreferenceController controller
= new EnterpriseInstalledPackagesPreferenceController(mContext,
null /* lifecycle */, false /* async */);
controller.setAvailabilityObserver(mObserver);
= new EnterpriseInstalledPackagesPreferenceController(mContext, false /* async */);
setNumberOfEnterpriseInstalledPackages(0, false /* async */);
assertThat(controller.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(
KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, false);
setNumberOfEnterpriseInstalledPackages(20, false /* async */);
assertThat(controller.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(
KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES, true);
}
@Test
public void testIsAvailableAsync() {
setNumberOfEnterpriseInstalledPackages(0, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
setNumberOfEnterpriseInstalledPackages(20, true /* async */);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver, never()).onPreferenceAvailabilityUpdated(
eq(KEY_NUMBER_ENTERPRISE_INSTALLED_PACKAGES), anyBoolean());
}
@Test

23
tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java
View File

@@ -16,14 +16,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -33,10 +35,6 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link EnterprisePrivacyPreferenceController}.
*/
@@ -52,7 +50,6 @@ public final class EnterprisePrivacyPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterprisePrivacyPreferenceController mController;
@@ -61,13 +58,7 @@ public final class EnterprisePrivacyPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterprisePrivacyPreferenceController(mContext, null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new EnterprisePrivacyPreferenceController(mContext);
}
@Test
@@ -88,17 +79,15 @@ public final class EnterprisePrivacyPreferenceControllerTest {
.thenReturn(MANAGING_ORGANIZATION);
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo(MANAGED_WITH_NAME);
}
}
@Test
public void testIsAvailable() {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.hasDeviceOwner()).thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_ENTERPRISE_PRIVACY, true);
}
@Test

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

@@ -17,18 +17,16 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.content.res.XmlResourceParser;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.DynamicAvailabilityPreferenceController;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.widget.PreferenceCategoryController;
import com.android.settingslib.core.AbstractPreferenceController;
import org.junit.Before;
@@ -37,14 +35,10 @@ import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowApplication;
import org.xmlpull.v1.XmlPullParser;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Tests for {@link EnterprisePrivacySettings}.
@@ -53,9 +47,6 @@ import java.util.Set;
@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
public final class EnterprisePrivacySettingsTest {
private final static String RESOURCES_NAMESPACE = "http://schemas.android.com/apk/res/android";
private final static String ATTR_KEY = "key";
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@@ -71,23 +62,11 @@ public final class EnterprisePrivacySettingsTest {
}
@Test
public void testGetMetricsCategory() {
public void verifyConstants() {
assertThat(mSettings.getMetricsCategory())
.isEqualTo(MetricsEvent.ENTERPRISE_PRIVACY_SETTINGS);
}
@Test
public void testGetCategoryKey() {
assertThat(mSettings.getCategoryKey()).isNull();
}
@Test
public void testGetLogTag() {
assertThat(mSettings.getLogTag()).isEqualTo("EnterprisePrivacySettings");
}
@Test
public void testGetPreferenceScreenResId() {
assertThat(mSettings.getCategoryKey()).isNull();
assertThat(mSettings.getPreferenceScreenResId())
.isEqualTo(R.xml.enterprise_privacy_settings);
}
@@ -121,7 +100,7 @@ public final class EnterprisePrivacySettingsTest {
public void getSearchIndexProviderPreferenceControllers() throws Exception {
final List<AbstractPreferenceController> controllers
= EnterprisePrivacySettings.SEARCH_INDEX_DATA_PROVIDER.getPreferenceControllers(
ShadowApplication.getInstance().getApplicationContext());
ShadowApplication.getInstance().getApplicationContext());
verifyPreferenceControllers(controllers);
}
@@ -155,67 +134,11 @@ public final class EnterprisePrivacySettingsTest {
CaCertsCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
CaCertsManagedProfilePreferenceController.class);
final AbstractPreferenceController exposureChangesCategoryController =
controllers.get(position);
final int exposureChangesCategoryControllerIndex = position;
assertThat(controllers.get(position++)).isInstanceOf(
ExposureChangesCategoryPreferenceController.class);
PreferenceCategoryController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeCurrentUserPreferenceController.class);
assertThat(controllers.get(position++)).isInstanceOf(
FailedPasswordWipeManagedProfilePreferenceController.class);
// The "Changes made by your organization's admin" category is hidden when all Preferences
// inside it become unavailable. To do this correctly, the category's controller must:
// a) Observe the availability of all Preferences in the category and
// b) Be listed after those Preferences' controllers, so that availability is updated in
// the correct order
// Find all Preferences in the category.
final XmlResourceParser parser = RuntimeEnvironment.application.getResources().getXml(
R.xml.enterprise_privacy_settings);
boolean done = false;
int type;
final Set<String> expectedObserved = new HashSet<>();
while (!done && (type = parser.next()) != XmlPullParser.END_DOCUMENT) {
if (type != XmlPullParser.START_TAG || !"exposure_changes_category".equals(
parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY))) {
continue;
}
int depth = 1;
while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
if (type == XmlPullParser.START_TAG) {
final String key = parser.getAttributeValue(RESOURCES_NAMESPACE, ATTR_KEY);
if (key != null) {
expectedObserved.add(key);
}
depth++;
} else if (type == XmlPullParser.END_TAG) {
depth--;
if (depth == 0) {
done = true;
break;
}
}
}
}
// Find all Preferences the category's controller is observing.
final Set<String> actualObserved = new HashSet<>();
int maxObservedIndex = -1;
for (int i = 0; i < controllers.size(); i++) {
final AbstractPreferenceController controller = controllers.get(i);
if (controller instanceof DynamicAvailabilityPreferenceController &&
((DynamicAvailabilityPreferenceController) controller).getAvailabilityObserver()
== exposureChangesCategoryController) {
actualObserved.add(controller.getPreferenceKey());
maxObservedIndex = i;
}
}
// Verify that the category's controller is observing the Preferences inside it.
assertThat(actualObserved).isEqualTo(expectedObserved);
// Verify that the category's controller is listed after the Preferences' controllers.
assertThat(maxObservedIndex).isLessThan(exposureChangesCategoryControllerIndex);
}
}

20
tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java
View File

@@ -17,7 +17,6 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.argThat;
@@ -29,16 +28,14 @@ import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.UserInfo;
import android.os.UserHandle;
import android.os.UserManager;
import android.support.v7.preference.Preference;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.applications.EnterpriseDefaultApps;
import com.android.settings.applications.UserAppInfo;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -51,8 +48,6 @@ import org.robolectric.annotation.Config;
import java.util.ArrayList;
import java.util.List;
import static org.mockito.Mockito.verify;
/**
* Tests for {@link EnterpriseSetDefaultAppsPreferenceController}.
*/
@@ -65,9 +60,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private UserManager mUm;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private EnterpriseSetDefaultAppsPreferenceController mController;
@@ -76,14 +69,7 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new EnterpriseSetDefaultAppsPreferenceController(mContext,
null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new EnterpriseSetDefaultAppsPreferenceController(mContext);
}
private void setEnterpriseSetDefaultApps(Intent[] intents, int number) {
@@ -130,12 +116,10 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest {
when(mFeatureFactory.applicationFeatureProvider.findPersistentPreferredActivities(anyInt(),
any(Intent[].class))).thenReturn(new ArrayList<>());
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, false);
setEnterpriseSetDefaultApps(EnterpriseDefaultApps.BROWSER.getIntents(), 1);
configureUsers(1);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_DEFAULT_APPS, true);
}
@Test

192
tests/robotests/src/com/android/settings/enterprise/ExposureChangesCategoryPreferenceControllerTest.java
View File

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

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

@@ -16,14 +16,14 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import static org.mockito.Mockito.when;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import static org.mockito.Mockito.when;
/**
* Tests for {@link FailedPasswordWipeCurrentUserPreferenceController}.
*/
@@ -32,8 +32,6 @@ import static org.mockito.Mockito.when;
public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends
FailedPasswordWipePreferenceControllerTestBase {
private int mMaximumFailedPasswordsBeforeWipe = 0;
public FailedPasswordWipeCurrentUserPreferenceControllerTest() {
super("failed_password_wipe_current_user");
}
@@ -41,8 +39,7 @@ public final class FailedPasswordWipeCurrentUserPreferenceControllerTest extends
@Override
public void setUp() {
super.setUp();
mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext,
null /* lifecycle */);
mController = new FailedPasswordWipeCurrentUserPreferenceController(mContext);
}
@Override

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

@@ -16,14 +16,14 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import static org.mockito.Mockito.when;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import static org.mockito.Mockito.when;
/**
* Tests for {@link FailedPasswordWipeManagedProfilePreferenceController}.
*/
@@ -32,8 +32,6 @@ import static org.mockito.Mockito.when;
public final class FailedPasswordWipeManagedProfilePreferenceControllerTest extends
FailedPasswordWipePreferenceControllerTestBase {
private int mMaximumFailedPasswordsBeforeWipe = 0;
public FailedPasswordWipeManagedProfilePreferenceControllerTest() {
super("failed_password_wipe_managed_profile");
}
@@ -41,8 +39,7 @@ public final class FailedPasswordWipeManagedProfilePreferenceControllerTest exte
@Override
public void setUp() {
super.setUp();
mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext,
null /* lifecycle */);
mController = new FailedPasswordWipeManagedProfilePreferenceController(mContext);
}
@Override

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

@@ -16,8 +16,8 @@
package com.android.settings.enterprise;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
@@ -50,8 +50,7 @@ public final class FailedPasswordWipePreferenceControllerBaseTest extends
private class FailedPasswordWipePreferenceControllerBaseTestable extends
FailedPasswordWipePreferenceControllerBase {
FailedPasswordWipePreferenceControllerBaseTestable() {
super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext,
null /* lifecycle */);
super(FailedPasswordWipePreferenceControllerBaseTest.this.mContext);
}
@Override

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

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

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

@@ -16,13 +16,15 @@
package com.android.settings.enterprise;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -32,10 +34,6 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link GlobalHttpProxyPreferenceController}.
*/
@@ -48,7 +46,6 @@ public final class GlobalHttpProxyPreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private GlobalHttpProxyPreferenceController mController;
@@ -57,13 +54,7 @@ public final class GlobalHttpProxyPreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new GlobalHttpProxyPreferenceController(mContext, null /* lifecycle */);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
mController = new GlobalHttpProxyPreferenceController(mContext);
}
@Test
@@ -71,12 +62,10 @@ public final class GlobalHttpProxyPreferenceControllerTest {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
.thenReturn(false);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.isGlobalHttpProxySet())
.thenReturn(true);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_GLOBAL_HTTP_PROXY, true);
}
@Test

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

@@ -16,15 +16,16 @@
package com.android.settings.enterprise;
import android.content.Context;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.when;
import com.android.settings.R;
import android.content.Context;
import android.support.v7.preference.Preference;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.R;
import com.android.settings.TestConfig;
import com.android.settings.core.PreferenceAvailabilityObserver;
import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import org.junit.Before;
import org.junit.Test;
@@ -34,10 +35,6 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Tests for {@link ImePreferenceController}.
*/
@@ -52,7 +49,6 @@ public final class ImePreferenceControllerTest {
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private Context mContext;
private FakeFeatureFactory mFeatureFactory;
@Mock private PreferenceAvailabilityObserver mObserver;
private ImePreferenceController mController;
@@ -61,15 +57,9 @@ public final class ImePreferenceControllerTest {
MockitoAnnotations.initMocks(this);
FakeFeatureFactory.setupForTest(mContext);
mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
mController = new ImePreferenceController(mContext, null /* lifecycle */);
mController = new ImePreferenceController(mContext);
when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name,
DEFAULT_IME_LABEL)).thenReturn(DEFAULT_IME_TEXT);
mController.setAvailabilityObserver(mObserver);
}
@Test
public void testGetAvailabilityObserver() {
assertThat(mController.getAvailabilityObserver()).isEqualTo(mObserver);
}
@Test
@@ -77,7 +67,7 @@ public final class ImePreferenceControllerTest {
final Preference preference = new Preference(mContext, null, 0, 0);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(DEFAULT_IME_LABEL);
.thenReturn(DEFAULT_IME_LABEL);
mController.updateState(preference);
assertThat(preference.getSummary()).isEqualTo(DEFAULT_IME_TEXT);
}
@@ -85,14 +75,12 @@ public final class ImePreferenceControllerTest {
@Test
public void testIsAvailable() {
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(null);
.thenReturn(null);
assertThat(mController.isAvailable()).isFalse();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, false);
when(mFeatureFactory.enterprisePrivacyFeatureProvider.getImeLabelIfOwnerSet())
.thenReturn(DEFAULT_IME_LABEL);
.thenReturn(DEFAULT_IME_LABEL);
assertThat(mController.isAvailable()).isTrue();
verify(mObserver).onPreferenceAvailabilityUpdated(KEY_INPUT_METHOD, true);
}
@Test