diff --git a/AndroidManifest.xml b/AndroidManifest.xml index 60815aac4b3..0aed9e015a3 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -1781,6 +1781,10 @@ + + + + diff --git a/res/drawable/bluetooth_broadcast_dialog_done.xml b/res/drawable/bluetooth_broadcast_dialog_done.xml new file mode 100644 index 00000000000..b2a5cc62681 --- /dev/null +++ b/res/drawable/bluetooth_broadcast_dialog_done.xml @@ -0,0 +1,26 @@ + + + + + diff --git a/res/layout/admin_disabled_other_options_footer.xml b/res/layout/admin_disabled_other_options_footer.xml index 31327bbfe72..f5c6b86b60e 100644 --- a/res/layout/admin_disabled_other_options_footer.xml +++ b/res/layout/admin_disabled_other_options_footer.xml @@ -25,6 +25,7 @@ + + + + + + \ No newline at end of file diff --git a/res/values/strings.xml b/res/values/strings.xml index 63db309b17f..e10405262a2 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -6627,10 +6627,14 @@ Refresh - + Mediaserver App optimization + + Tethering + + Removed apps Battery Saver @@ -7613,15 +7617,15 @@ Trust or remove certificates - - %s has installed a certificate authority on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin. - %s has installed certificate authorities on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin. - + {numberOfCertificates, plural, + =1 {{orgName} has installed a certificate authority on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.} + other {{orgName} has installed certificate authorities on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.} + } - - %s has installed a certificate authority for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin. - %s has installed certificate authorities for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin. - + {numberOfCertificates, plural, + =1 {{orgName} has installed a certificate authority for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.} + other {{orgName} has installed certificate authorities for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.} + } A third party is capable of monitoring your network activity, including emails, apps, and secure websites.\n\nA trusted credential installed on your device is making this possible. @@ -14139,4 +14143,10 @@ Leave broadcast Scan QR code + + Enter password + + Can\u2019t connect. Try again. + + Wrong password diff --git a/res/xml/app_list_disclosure_settings.xml b/res/xml/app_list_disclosure_settings.xml index 0874407ba2b..3224974667a 100644 --- a/res/xml/app_list_disclosure_settings.xml +++ b/res/xml/app_list_disclosure_settings.xml @@ -23,5 +23,6 @@ diff --git a/src/com/android/settings/MonitoringCertInfoActivity.java b/src/com/android/settings/MonitoringCertInfoActivity.java index eadebc1f4fe..5c15eb3a73b 100644 --- a/src/com/android/settings/MonitoringCertInfoActivity.java +++ b/src/com/android/settings/MonitoringCertInfoActivity.java @@ -16,12 +16,16 @@ package com.android.settings; +import static android.app.admin.DevicePolicyResources.Strings.Settings.DEVICE_OWNER_INSTALLED_CERTIFICATE_AUTHORITY_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_INSTALLED_CERTIFICATE_AUTHORITY_WARNING; + import android.app.Activity; import android.app.admin.DevicePolicyManager; import android.content.DialogInterface; import android.content.DialogInterface.OnClickListener; import android.content.DialogInterface.OnDismissListener; import android.content.Intent; +import android.icu.text.MessageFormat; import android.os.Bundle; import android.os.UserHandle; import android.provider.Settings; @@ -30,6 +34,10 @@ import androidx.appcompat.app.AlertDialog; import com.android.settingslib.RestrictedLockUtils; +import java.util.HashMap; +import java.util.Locale; +import java.util.Map; + /** * Activity that shows a dialog explaining that a CA cert is allowing someone to monitor network * traffic. This activity should be launched for the user into which the CA cert is installed @@ -71,12 +79,30 @@ public class MonitoringCertInfoActivity extends Activity implements OnClickListe builder.setOnDismissListener(this); if (dpm.getProfileOwnerAsUser(mUserId) != null) { - builder.setMessage(getResources().getQuantityString(R.plurals.ssl_ca_cert_info_message, - numberOfCertificates, dpm.getProfileOwnerNameAsUser(mUserId))); + MessageFormat msgFormat = new MessageFormat( + dpm.getResources().getString( + WORK_PROFILE_INSTALLED_CERTIFICATE_AUTHORITY_WARNING, + () -> getString(R.string.ssl_ca_cert_info_message)), + Locale.getDefault()); + + Map arguments = new HashMap<>(); + arguments.put("numberOfCertificates", numberOfCertificates); + arguments.put("orgName", dpm.getProfileOwnerNameAsUser(mUserId)); + + builder.setMessage(msgFormat.format(arguments)); } else if (dpm.getDeviceOwnerComponentOnCallingUser() != null) { - builder.setMessage(getResources().getQuantityString( - R.plurals.ssl_ca_cert_info_message_device_owner, numberOfCertificates, - dpm.getDeviceOwnerNameOnAnyUser())); + MessageFormat msgFormat = new MessageFormat( + dpm.getResources() + .getString(DEVICE_OWNER_INSTALLED_CERTIFICATE_AUTHORITY_WARNING, + () -> getResources().getString( + R.string.ssl_ca_cert_info_message_device_owner)), + Locale.getDefault()); + + Map arguments = new HashMap<>(); + arguments.put("numberOfCertificates", numberOfCertificates); + arguments.put("orgName", dpm.getDeviceOwnerNameOnAnyUser()); + + builder.setMessage(msgFormat.format(arguments)); } else { // Consumer case. Show scary warning. builder.setIcon(android.R.drawable.stat_notify_error); diff --git a/src/com/android/settings/SettingsPreferenceFragment.java b/src/com/android/settings/SettingsPreferenceFragment.java index d3e1c49c06f..8c97f0244a7 100644 --- a/src/com/android/settings/SettingsPreferenceFragment.java +++ b/src/com/android/settings/SettingsPreferenceFragment.java @@ -18,6 +18,7 @@ package com.android.settings; import android.app.Activity; import android.app.Dialog; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.content.DialogInterface; @@ -70,6 +71,7 @@ public abstract class SettingsPreferenceFragment extends InstrumentedPreferenceF private static final int ORDER_FIRST = -1; + protected DevicePolicyManager mDevicePolicyManager; private SettingsDialogFragment mDialogFragment; // Cache the content resolver for async callbacks private ContentResolver mContentResolver; @@ -135,6 +137,7 @@ public abstract class SettingsPreferenceFragment extends InstrumentedPreferenceF public void onCreate(Bundle icicle) { super.onCreate(icicle); + mDevicePolicyManager = getContext().getSystemService(DevicePolicyManager.class); if (icicle != null) { mPreferenceHighlighted = icicle.getBoolean(SAVE_HIGHLIGHTED_KEY); } @@ -728,4 +731,35 @@ public abstract class SettingsPreferenceFragment extends InstrumentedPreferenceF final Activity activity = getActivity(); return activity == null || activity.isFinishing() || activity.isDestroyed(); } + + protected void replaceEnterprisePreferenceScreenTitle(String overrideKey, int resource) { + getActivity().setTitle(mDevicePolicyManager.getResources().getString( + overrideKey, () -> getString(resource))); + } + + protected void replaceEnterpriseStringSummary( + String preferenceKey, String overrideKey, int resource) { + Preference preference = findPreference(preferenceKey); + if (preference == null) { + Log.d(TAG, "Could not find enterprise preference " + preferenceKey); + return; + } + + preference.setSummary( + mDevicePolicyManager.getResources().getString(overrideKey, + () -> getString(resource))); + } + + protected void replaceEnterpriseStringTitle( + String preferenceKey, String overrideKey, int resource) { + Preference preference = findPreference(preferenceKey); + if (preference == null) { + Log.d(TAG, "Could not find enterprise preference " + preferenceKey); + return; + } + + preference.setTitle( + mDevicePolicyManager.getResources().getString(overrideKey, + () -> getString(resource))); + } } diff --git a/src/com/android/settings/accounts/ManagedProfileSettings.java b/src/com/android/settings/accounts/ManagedProfileSettings.java index 001a2cd7dbb..9c4d855f61b 100644 --- a/src/com/android/settings/accounts/ManagedProfileSettings.java +++ b/src/com/android/settings/accounts/ManagedProfileSettings.java @@ -18,6 +18,7 @@ package com.android.settings.accounts; import static android.app.admin.DevicePolicyResources.Strings.Settings.CROSS_PROFILE_CALENDAR_SUMMARY; import static android.app.admin.DevicePolicyResources.Strings.Settings.CROSS_PROFILE_CALENDAR_TITLE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.MANAGED_PROFILE_SETTINGS_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_CONTACT_SEARCH_SUMMARY; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_CONTACT_SEARCH_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_SETTING; @@ -84,6 +85,8 @@ public class ManagedProfileSettings extends DashboardFragment { super.onCreate(icicle); mManagedProfileBroadcastReceiver = new ManagedProfileBroadcastReceiver(); mManagedProfileBroadcastReceiver.register(getActivity()); + replaceEnterprisePreferenceScreenTitle( + MANAGED_PROFILE_SETTINGS_TITLE, R.string.managed_profile_settings_title); replaceEnterpriseStringTitle("work_mode", WORK_PROFILE_SETTING, R.string.work_mode_label); replaceEnterpriseStringTitle("contacts_search", diff --git a/src/com/android/settings/applications/AppLocaleUtil.java b/src/com/android/settings/applications/AppLocaleUtil.java index 700437774da..3cba27c3ada 100644 --- a/src/com/android/settings/applications/AppLocaleUtil.java +++ b/src/com/android/settings/applications/AppLocaleUtil.java @@ -35,6 +35,7 @@ public class AppLocaleUtil { public static final Intent LAUNCHER_ENTRY_INTENT = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER); + /** * Decides the UI display of per app locale. */ @@ -42,9 +43,15 @@ public class AppLocaleUtil { @NonNull Context context, @NonNull String packageName, @NonNull List infos) { - return !isDisallowedPackage(context, packageName) - && !isSignedWithPlatformKey(context, packageName) - && hasLauncherEntry(packageName, infos); + boolean isDisallowedPackage = isDisallowedPackage(context, packageName); + boolean hasLauncherEntry = hasLauncherEntry(packageName, infos); + boolean isSignedWithPlatformKey = isSignedWithPlatformKey(context, packageName); + Log.i(TAG, "Can display preference - [" + packageName + "] :" + + " isDisallowedPackage : " + isDisallowedPackage + + " / isSignedWithPlatformKey : " + isSignedWithPlatformKey + + " / hasLauncherEntry : " + hasLauncherEntry); + + return !isDisallowedPackage && !isSignedWithPlatformKey && hasLauncherEntry; } private static boolean isDisallowedPackage(Context context, String packageName) { diff --git a/src/com/android/settings/applications/autofill/PasswordsPreferenceController.java b/src/com/android/settings/applications/autofill/PasswordsPreferenceController.java index cb8b73d2896..a130bb28302 100644 --- a/src/com/android/settings/applications/autofill/PasswordsPreferenceController.java +++ b/src/com/android/settings/applications/autofill/PasswordsPreferenceController.java @@ -16,6 +16,8 @@ package com.android.settings.applications.autofill; +import static android.app.admin.DevicePolicyResources.Strings.Settings.AUTO_SYNC_PERSONAL_DATA; +import static android.app.admin.DevicePolicyResources.Strings.Settings.AUTO_SYNC_WORK_DATA; import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; import static android.service.autofill.AutofillService.EXTRA_RESULT; @@ -114,6 +116,11 @@ public class PasswordsPreferenceController extends BasePreferenceController super.displayPreference(screen); final PreferenceGroup group = screen.findPreference(getPreferenceKey()); addPasswordPreferences(screen.getContext(), getUser(), group); + + replaceEnterpriseStringTitle(screen, "auto_sync_personal_account_data", + AUTO_SYNC_PERSONAL_DATA, R.string.account_settings_menu_auto_sync_personal); + replaceEnterpriseStringTitle(screen, "auto_sync_work_account_data", + AUTO_SYNC_WORK_DATA, R.string.account_settings_menu_auto_sync_work); } private void addPasswordPreferences( diff --git a/src/com/android/settings/applications/specialaccess/deviceadmin/DeviceAdminSettings.java b/src/com/android/settings/applications/specialaccess/deviceadmin/DeviceAdminSettings.java index 38191242c78..2258bf17d48 100644 --- a/src/com/android/settings/applications/specialaccess/deviceadmin/DeviceAdminSettings.java +++ b/src/com/android/settings/applications/specialaccess/deviceadmin/DeviceAdminSettings.java @@ -16,6 +16,7 @@ package com.android.settings.applications.specialaccess.deviceadmin; +import static android.app.admin.DevicePolicyResources.Strings.Settings.MANAGE_DEVICE_ADMIN_APPS; import static android.app.admin.DevicePolicyResources.Strings.Settings.NO_DEVICE_ADMINS; import android.app.settings.SettingsEnums; @@ -37,7 +38,8 @@ public class DeviceAdminSettings extends DashboardFragment { @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); - // TODO: Replace PreferenceScreen title manage_device_admin/MANAGE_DEVICE_ADMIN_APPS + replaceEnterprisePreferenceScreenTitle( + MANAGE_DEVICE_ADMIN_APPS, R.string.manage_device_admin); replaceEnterpriseStringTitle("device_admin_footer", NO_DEVICE_ADMINS, R.string.no_device_admins); } diff --git a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java index e3161253bf5..b59928f21fd 100644 --- a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java +++ b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesDetails.java @@ -18,6 +18,7 @@ package com.android.settings.applications.specialaccess.interactacrossprofiles; import static android.app.admin.DevicePolicyResources.Strings.Settings.APP_CAN_ACCESS_PERSONAL_DATA; import static android.app.admin.DevicePolicyResources.Strings.Settings.APP_CAN_ACCESS_PERSONAL_PERMISSIONS; import static android.app.admin.DevicePolicyResources.Strings.Settings.CONNECTED_APPS_SHARE_PERMISSIONS_AND_DATA; +import static android.app.admin.DevicePolicyResources.Strings.Settings.CONNECTED_WORK_AND_PERSONAL_APPS_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.CONNECT_APPS_DIALOG_SUMMARY; import static android.app.admin.DevicePolicyResources.Strings.Settings.CONNECT_APPS_DIALOG_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.HOW_TO_DISCONNECT_APPS; @@ -81,7 +82,6 @@ public class InteractAcrossProfilesDetails extends AppInfoBase private Context mContext; private CrossProfileApps mCrossProfileApps; - private DevicePolicyManager mDevicePolicyManager; private UserManager mUserManager; private RestrictedSwitchPreference mSwitchPref; private LayoutPreference mHeader; @@ -101,7 +101,6 @@ public class InteractAcrossProfilesDetails extends AppInfoBase mContext = getContext(); mCrossProfileApps = mContext.getSystemService(CrossProfileApps.class); - mDevicePolicyManager = mContext.getSystemService(DevicePolicyManager.class); mUserManager = mContext.getSystemService(UserManager.class); mPackageManager = mContext.getPackageManager(); @@ -115,6 +114,8 @@ public class InteractAcrossProfilesDetails extends AppInfoBase addPreferencesFromResource(R.xml.interact_across_profiles_permissions_details); + replaceEnterprisePreferenceScreenTitle(CONNECTED_WORK_AND_PERSONAL_APPS_TITLE, + R.string.interact_across_profiles_title); replaceEnterpriseStringSummary("interact_across_profiles_summary_1", CONNECTED_APPS_SHARE_PERMISSIONS_AND_DATA, R.string.interact_across_profiles_summary_1); @@ -147,19 +148,6 @@ public class InteractAcrossProfilesDetails extends AppInfoBase logPageLaunchMetrics(); } - private void replaceEnterpriseStringSummary( - String preferenceKey, String overrideKey, int resource) { - Preference preference = findPreference(preferenceKey); - if (preference == null) { - Log.d(TAG, "Could not find enterprise preference " + preferenceKey); - return; - } - - preference.setSummary( - mDevicePolicyManager.getResources().getString(overrideKey, - () -> getString(resource))); - } - private void maybeShowExtraSummary() { Preference extraSummary = findPreference(INTERACT_ACROSS_PROFILE_EXTRA_SUMMARY_KEY); if (extraSummary == null) { diff --git a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesSettings.java b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesSettings.java index 6ce086916ae..ba0d9afd97f 100644 --- a/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesSettings.java +++ b/src/com/android/settings/applications/specialaccess/interactacrossprofiles/InteractAcrossProfilesSettings.java @@ -53,7 +53,6 @@ public class InteractAcrossProfilesSettings extends EmptyTextSettings { private Context mContext; private PackageManager mPackageManager; private UserManager mUserManager; - private DevicePolicyManager mDevicePolicyManager; private CrossProfileApps mCrossProfileApps; private IconDrawableFactory mIconDrawableFactory; @@ -66,7 +65,6 @@ public class InteractAcrossProfilesSettings extends EmptyTextSettings { mUserManager = mContext.getSystemService(UserManager.class); mIconDrawableFactory = IconDrawableFactory.newInstance(mContext); mCrossProfileApps = mContext.getSystemService(CrossProfileApps.class); - mDevicePolicyManager = mContext.getSystemService(DevicePolicyManager.class); } @Override @@ -76,6 +74,9 @@ public class InteractAcrossProfilesSettings extends EmptyTextSettings { final PreferenceScreen screen = getPreferenceScreen(); screen.removeAll(); + replaceEnterprisePreferenceScreenTitle(CONNECTED_WORK_AND_PERSONAL_APPS_TITLE, + R.string.interact_across_profiles_title); + final ArrayList> crossProfileApps = collectConfigurableApps(mPackageManager, mUserManager, mCrossProfileApps); diff --git a/src/com/android/settings/bluetooth/BluetoothBroadcastSourcePreference.java b/src/com/android/settings/bluetooth/BluetoothBroadcastSourcePreference.java new file mode 100644 index 00000000000..17b604c58ff --- /dev/null +++ b/src/com/android/settings/bluetooth/BluetoothBroadcastSourcePreference.java @@ -0,0 +1,141 @@ +/* + * Copyright (C) 2022 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.bluetooth; + +import android.bluetooth.BluetoothLeBroadcastMetadata; +import android.bluetooth.BluetoothLeBroadcastSubgroup; +import android.content.Context; +import android.graphics.drawable.Drawable; +import android.text.TextUtils; +import android.view.View; +import android.widget.ImageButton; +import android.widget.ImageView; + +import androidx.annotation.NonNull; +import androidx.preference.Preference; +import androidx.preference.PreferenceViewHolder; + +import com.android.settings.R; +import com.android.settingslib.Utils; + +import java.util.List; + +/** + * Preference to display a broadcast source in the Broadcast Source List. + */ +class BluetoothBroadcastSourcePreference extends Preference { + + private static final int RESOURCE_ID_UNKNOWN_PROGRAM_INFO = R.string.device_info_default; + private static final int RESOURCE_ID_ICON = R.drawable.settings_input_antenna; + + private BluetoothLeBroadcastMetadata mBluetoothLeBroadcastMetadata; + private ImageView mFrictionImageView; + private String mTitle; + private boolean mStatus; + private boolean mIsEncrypted; + + BluetoothBroadcastSourcePreference(@NonNull Context context, + @NonNull BluetoothLeBroadcastMetadata source) { + super(context); + initUi(); + updateMetadataAndRefreshUi(source, false); + } + + @Override + public void onBindViewHolder(final PreferenceViewHolder view) { + super.onBindViewHolder(view); + view.findViewById(R.id.two_target_divider).setVisibility(View.INVISIBLE); + final ImageButton imageButton = (ImageButton) view.findViewById(R.id.icon_button); + imageButton.setVisibility(View.GONE); + mFrictionImageView = (ImageView) view.findViewById(R.id.friction_icon); + updateStatusButton(); + } + + private void initUi() { + setLayoutResource(R.layout.preference_access_point); + setWidgetLayoutResource(R.layout.access_point_friction_widget); + + mStatus = false; + final Drawable drawable = getContext().getDrawable(RESOURCE_ID_ICON); + if (drawable != null) { + drawable.setTint(Utils.getColorAttrDefaultColor(getContext(), + android.R.attr.colorControlNormal)); + setIcon(drawable); + } + } + + private void updateStatusButton() { + if (mFrictionImageView == null) { + return; + } + if (mStatus || mIsEncrypted) { + Drawable drawable; + if (mStatus) { + drawable = getContext().getDrawable(R.drawable.bluetooth_broadcast_dialog_done); + } else { + drawable = getContext().getDrawable(R.drawable.ic_friction_lock_closed); + } + if (drawable != null) { + drawable.setTint(Utils.getColorAttrDefaultColor(getContext(), + android.R.attr.colorControlNormal)); + mFrictionImageView.setImageDrawable(drawable); + } + mFrictionImageView.setVisibility(View.VISIBLE); + } else { + mFrictionImageView.setVisibility(View.GONE); + } + } + + /** + * Updates the title and status from BluetoothLeBroadcastMetadata. + */ + public void updateMetadataAndRefreshUi(BluetoothLeBroadcastMetadata source, boolean status) { + mBluetoothLeBroadcastMetadata = source; + mTitle = getBroadcastMetadataProgramInfo(); + mIsEncrypted = mBluetoothLeBroadcastMetadata.isEncrypted(); + mStatus = status; + + refresh(); + } + + /** + * Gets the BluetoothLeBroadcastMetadata. + */ + public BluetoothLeBroadcastMetadata getBluetoothLeBroadcastMetadata() { + return mBluetoothLeBroadcastMetadata; + } + + private void refresh() { + setTitle(mTitle); + updateStatusButton(); + } + + private String getBroadcastMetadataProgramInfo() { + if (mBluetoothLeBroadcastMetadata == null) { + return getContext().getString(RESOURCE_ID_UNKNOWN_PROGRAM_INFO); + } + final List subgroups = + mBluetoothLeBroadcastMetadata.getSubgroups(); + if (subgroups.isEmpty()) { + return getContext().getString(RESOURCE_ID_UNKNOWN_PROGRAM_INFO); + } + return subgroups.stream() + .map(i -> i.getContentMetadata().getProgramInfo()) + .filter(i -> !TextUtils.isEmpty(i)) + .findFirst().orElse(getContext().getString(RESOURCE_ID_UNKNOWN_PROGRAM_INFO)); + } +} diff --git a/src/com/android/settings/bluetooth/BluetoothFindBroadcastsFragment.java b/src/com/android/settings/bluetooth/BluetoothFindBroadcastsFragment.java index f251db50ab9..9a26a57f0fc 100644 --- a/src/com/android/settings/bluetooth/BluetoothFindBroadcastsFragment.java +++ b/src/com/android/settings/bluetooth/BluetoothFindBroadcastsFragment.java @@ -19,33 +19,53 @@ package com.android.settings.bluetooth; import static android.bluetooth.BluetoothDevice.BOND_NONE; import static android.os.UserManager.DISALLOW_CONFIG_BLUETOOTH; +import android.app.AlertDialog; import android.app.settings.SettingsEnums; import android.bluetooth.BluetoothDevice; +import android.bluetooth.BluetoothLeBroadcastAssistant; +import android.bluetooth.BluetoothLeBroadcastMetadata; +import android.bluetooth.BluetoothLeBroadcastReceiveState; +import android.bluetooth.le.ScanFilter; import android.content.Context; +import android.os.Bundle; import android.util.Log; +import android.view.LayoutInflater; +import android.view.View; +import android.view.WindowManager; +import android.widget.EditText; +import android.widget.TextView; +import androidx.annotation.NonNull; import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; +import androidx.preference.PreferenceCategory; import com.android.settings.R; import com.android.settings.dashboard.RestrictedDashboardFragment; import com.android.settingslib.bluetooth.CachedBluetoothDevice; +import com.android.settingslib.bluetooth.LocalBluetoothLeBroadcastAssistant; import com.android.settingslib.bluetooth.LocalBluetoothManager; +import com.android.settingslib.bluetooth.LocalBluetoothProfileManager; import com.android.settingslib.core.AbstractPreferenceController; import com.android.settingslib.core.lifecycle.Lifecycle; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; +import java.util.Collections; import java.util.List; +import java.util.concurrent.Executor; +import java.util.concurrent.Executors; + /** * This fragment allowed users to find the nearby broadcast sources. */ public class BluetoothFindBroadcastsFragment extends RestrictedDashboardFragment { - private static final String TAG = "BTFindBroadcastsFrg"; + private static final String TAG = "BtFindBroadcastsFrg"; public static final String KEY_DEVICE_ADDRESS = "device_address"; - - public static final String PREF_KEY_BROADCAST_SOURCE = "broadcast_source"; + public static final String PREF_KEY_BROADCAST_SOURCE_LIST = "broadcast_source_list"; @VisibleForTesting String mDeviceAddress; @@ -53,6 +73,91 @@ public class BluetoothFindBroadcastsFragment extends RestrictedDashboardFragment LocalBluetoothManager mManager; @VisibleForTesting CachedBluetoothDevice mCachedDevice; + @VisibleForTesting + PreferenceCategory mBroadcastSourceListCategory; + private LocalBluetoothLeBroadcastAssistant mLeBroadcastAssistant; + private BluetoothBroadcastSourcePreference mSelectedPreference; + private Executor mExecutor; + private int mSourceId; + + private BluetoothLeBroadcastAssistant.Callback mBroadcastAssistantCallback = + new BluetoothLeBroadcastAssistant.Callback() { + @Override + public void onSearchStarted(int reason) { + Log.d(TAG, "onSearchStarted: " + reason); + + getActivity().runOnUiThread( + () -> cacheRemoveAllPrefs(mBroadcastSourceListCategory)); + } + + @Override + public void onSearchStartFailed(int reason) { + Log.d(TAG, "onSearchStartFailed: " + reason); + + } + + @Override + public void onSearchStopped(int reason) { + Log.d(TAG, "onSearchStopped: " + reason); + } + + @Override + public void onSearchStopFailed(int reason) { + Log.d(TAG, "onSearchStopFailed: " + reason); + } + + @Override + public void onSourceFound(@NonNull BluetoothLeBroadcastMetadata source) { + Log.d(TAG, "onSourceFound:"); + getActivity().runOnUiThread(() -> updateListCategory(source, false)); + } + + @Override + public void onSourceAdded(@NonNull BluetoothDevice sink, int sourceId, int reason) { + setSourceId(sourceId); + if (mSelectedPreference == null) { + Log.w(TAG, "onSourceAdded: mSelectedPreference == null!"); + return; + } + getActivity().runOnUiThread(() -> updateListCategory( + mSelectedPreference.getBluetoothLeBroadcastMetadata(), true)); + } + + @Override + public void onSourceAddFailed(@NonNull BluetoothDevice sink, + @NonNull BluetoothLeBroadcastMetadata source, int reason) { + mSelectedPreference = null; + Log.d(TAG, "onSourceAddFailed: clear the mSelectedPreference."); + } + + @Override + public void onSourceModified(@NonNull BluetoothDevice sink, int sourceId, + int reason) { + } + + @Override + public void onSourceModifyFailed(@NonNull BluetoothDevice sink, int sourceId, + int reason) { + } + + @Override + public void onSourceRemoved(@NonNull BluetoothDevice sink, int sourceId, + int reason) { + Log.d(TAG, "onSourceRemoved:"); + } + + @Override + public void onSourceRemoveFailed(@NonNull BluetoothDevice sink, int sourceId, + int reason) { + Log.d(TAG, "onSourceRemoveFailed:"); + } + + @Override + public void onReceiveStateChanged(@NonNull BluetoothDevice sink, int sourceId, + @NonNull BluetoothLeBroadcastReceiveState state) { + Log.d(TAG, "onReceiveStateChanged:"); + } + }; public BluetoothFindBroadcastsFragment() { super(DISALLOW_CONFIG_BLUETOOTH); @@ -75,19 +180,50 @@ public class BluetoothFindBroadcastsFragment extends RestrictedDashboardFragment mDeviceAddress = getArguments().getString(KEY_DEVICE_ADDRESS); mManager = getLocalBluetoothManager(context); mCachedDevice = getCachedDevice(mDeviceAddress); + mLeBroadcastAssistant = getLeBroadcastAssistant(); + mExecutor = Executors.newSingleThreadExecutor(); + super.onAttach(context); - if (mCachedDevice == null) { + if (mCachedDevice == null || mLeBroadcastAssistant == null) { //Close this page if device is null with invalid device mac address - Log.w(TAG, "onAttach() CachedDevice is null!"); + //or if the device does not have LeBroadcastAssistant profile + Log.w(TAG, "onAttach() CachedDevice or LeBroadcastAssistant is null!"); finish(); return; } } + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + mBroadcastSourceListCategory = findPreference(PREF_KEY_BROADCAST_SOURCE_LIST); + } + + @Override + public void onStart() { + super.onStart(); + if (mLeBroadcastAssistant != null) { + mLeBroadcastAssistant.registerServiceCallBack(mExecutor, mBroadcastAssistantCallback); + } + } + @Override public void onResume() { super.onResume(); finishFragmentIfNecessary(); + //check assistant status. Start searching... + if (mLeBroadcastAssistant != null && !mLeBroadcastAssistant.isSearchInProgress()) { + mLeBroadcastAssistant.startSearchingForSources(getScanFilter()); + } + } + + @Override + public void onStop() { + super.onStop(); + if (mLeBroadcastAssistant != null) { + mLeBroadcastAssistant.unregisterServiceCallBack(mBroadcastAssistantCallback); + } } @VisibleForTesting @@ -125,4 +261,110 @@ public class BluetoothFindBroadcastsFragment extends RestrictedDashboardFragment } return controllers; } + + private LocalBluetoothLeBroadcastAssistant getLeBroadcastAssistant() { + if (mManager == null) { + Log.w(TAG, "getLeBroadcastAssistant: LocalBluetoothManager is null!"); + return null; + } + + LocalBluetoothProfileManager profileManager = mManager.getProfileManager(); + if (profileManager == null) { + Log.w(TAG, "getLeBroadcastAssistant: LocalBluetoothProfileManager is null!"); + return null; + } + + return profileManager.getLeAudioBroadcastAssistantProfile(); + } + + private List getScanFilter() { + // Currently there is no function for setting the ScanFilter. It may have this function + // in the further. + return Collections.emptyList(); + } + + private void updateListCategory(BluetoothLeBroadcastMetadata source, boolean isConnected) { + BluetoothBroadcastSourcePreference item = mBroadcastSourceListCategory.findPreference( + Integer.toString(source.getBroadcastId())); + if (item == null) { + item = createBluetoothBroadcastSourcePreference(source); + mBroadcastSourceListCategory.addPreference(item); + } + item.updateMetadataAndRefreshUi(source, isConnected); + item.setOrder(isConnected ? 0 : 1); + } + + private BluetoothBroadcastSourcePreference createBluetoothBroadcastSourcePreference( + BluetoothLeBroadcastMetadata source) { + BluetoothBroadcastSourcePreference pref = new BluetoothBroadcastSourcePreference( + getContext(), source); + pref.setKey(Integer.toString(source.getBroadcastId())); + pref.setOnPreferenceClickListener(preference -> { + if (source.isEncrypted()) { + launchBroadcastCodeDialog(pref); + } else { + addSource(pref); + } + return true; + }); + return pref; + } + + private void addSource(BluetoothBroadcastSourcePreference pref) { + if (mLeBroadcastAssistant == null || mCachedDevice == null) { + Log.w(TAG, "addSource: LeBroadcastAssistant or CachedDevice is null!"); + return; + } + if (mSelectedPreference != null) { + // The previous preference status set false after user selects the new Preference. + getActivity().runOnUiThread( + () -> { + mSelectedPreference.updateMetadataAndRefreshUi( + mSelectedPreference.getBluetoothLeBroadcastMetadata(), false); + mSelectedPreference.setOrder(1); + }); + } + mSelectedPreference = pref; + mLeBroadcastAssistant.addSource(mCachedDevice.getDevice(), + pref.getBluetoothLeBroadcastMetadata(), true); + } + + private void addBroadcastCodeIntoPreference(BluetoothBroadcastSourcePreference pref, + String broadcastCode) { + BluetoothLeBroadcastMetadata metadata = + new BluetoothLeBroadcastMetadata.Builder(pref.getBluetoothLeBroadcastMetadata()) + .setBroadcastCode(broadcastCode.getBytes(StandardCharsets.UTF_8)) + .build(); + pref.updateMetadataAndRefreshUi(metadata, false); + } + + private void launchBroadcastCodeDialog(BluetoothBroadcastSourcePreference pref) { + final View layout = LayoutInflater.from(getContext()).inflate( + R.layout.bluetooth_find_broadcast_password_dialog, null); + final TextView broadcastName = layout.requireViewById(R.id.broadcast_name_text); + final EditText editText = layout.requireViewById(R.id.broadcast_edit_text); + broadcastName.setText(pref.getTitle()); + AlertDialog alertDialog = new AlertDialog.Builder(getContext()) + .setTitle(R.string.find_broadcast_password_dialog_title) + .setView(layout) + .setNeutralButton(android.R.string.cancel, null) + .setPositiveButton(R.string.bluetooth_connect_access_dialog_positive, + (d, w) -> { + Log.d(TAG, "setPositiveButton: clicked"); + addBroadcastCodeIntoPreference(pref, editText.getText().toString()); + addSource(pref); + }) + .create(); + + alertDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG); + alertDialog.show(); + } + + public int getSourceId() { + return mSourceId; + } + + public void setSourceId(int sourceId) { + mSourceId = sourceId; + } } diff --git a/src/com/android/settings/dashboard/DashboardFragment.java b/src/com/android/settings/dashboard/DashboardFragment.java index aaa9b3d3bca..378d55e1bc9 100644 --- a/src/com/android/settings/dashboard/DashboardFragment.java +++ b/src/com/android/settings/dashboard/DashboardFragment.java @@ -79,7 +79,6 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment private DashboardTilePlaceholderPreferenceController mPlaceholderPreferenceController; private boolean mListeningToCategoryChange; private List mSuppressInjectedTileKeys; - private DevicePolicyManager mDevicePolicyManager; @Override public void onAttach(Context context) { @@ -154,7 +153,6 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); - mDevicePolicyManager = getSystemService(DevicePolicyManager.class); // Set ComparisonCallback so we get better animation when list changes. getPreferenceManager().setPreferenceComparisonCallback( new PreferenceManager.SimplePreferenceComparisonCallback()); @@ -548,30 +546,4 @@ public abstract class DashboardFragment extends SettingsPreferenceFragment resolver.unregisterContentObserver(observer); }); } - - protected void replaceEnterpriseStringTitle( - String preferenceKey, String overrideKey, int resource) { - Preference preference = findPreference(preferenceKey); - if (preference == null) { - Log.d(TAG, "Could not find enterprise preference " + preferenceKey); - return; - } - - preference.setTitle( - mDevicePolicyManager.getResources().getString(overrideKey, - () -> getString(resource))); - } - - protected void replaceEnterpriseStringSummary( - String preferenceKey, String overrideKey, int resource) { - Preference preference = findPreference(preferenceKey); - if (preference == null) { - Log.d(TAG, "Could not find enterprise preference " + preferenceKey); - return; - } - - preference.setSummary( - mDevicePolicyManager.getResources().getString(overrideKey, - () -> getString(resource))); - } } diff --git a/src/com/android/settings/display/TimeoutListPreference.java b/src/com/android/settings/display/TimeoutListPreference.java index 0b2d18fdee5..5079ccae29d 100644 --- a/src/com/android/settings/display/TimeoutListPreference.java +++ b/src/com/android/settings/display/TimeoutListPreference.java @@ -16,6 +16,8 @@ package com.android.settings.display; +import static android.app.admin.DevicePolicyResources.Strings.Settings.OTHER_OPTIONS_DISABLED_BY_ADMIN; + import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; import android.app.Dialog; @@ -24,7 +26,9 @@ import android.content.Context; import android.content.DialogInterface; import android.util.AttributeSet; import android.util.Log; +import android.view.LayoutInflater; import android.view.View; +import android.widget.TextView; import androidx.appcompat.app.AlertDialog.Builder; @@ -52,13 +56,26 @@ public class TimeoutListPreference extends RestrictedListPreference { DialogInterface.OnClickListener listener) { super.onPrepareDialogBuilder(builder, listener); if (mAdmin != null) { - builder.setView(R.layout.admin_disabled_other_options_footer); - // TODO: replace Text on textview with admin_disabled_other_options + updateTextOnDialog(builder); } else { builder.setView(null); } } + private void updateTextOnDialog(Builder builder) { + LayoutInflater inflater = getContext().getSystemService(LayoutInflater.class); + DevicePolicyManager devicePolicyManager = getContext() + .getSystemService(DevicePolicyManager.class); + View v = inflater.inflate(R.layout.admin_disabled_other_options_footer, null); + builder.setView(v); + TextView textView = v.findViewById(R.id.admin_disabled_other_options_text); + String replacementText = devicePolicyManager.getResources().getString( + OTHER_OPTIONS_DISABLED_BY_ADMIN, () -> null); + if (replacementText != null) { + textView.setText(replacementText); + } + } + @Override protected void onDialogCreated(Dialog dialog) { super.onDialogCreated(dialog); diff --git a/src/com/android/settings/enterprise/AdminActionPreferenceControllerBase.java b/src/com/android/settings/enterprise/AdminActionPreferenceControllerBase.java index e5484dba71f..cf1b8a35a69 100644 --- a/src/com/android/settings/enterprise/AdminActionPreferenceControllerBase.java +++ b/src/com/android/settings/enterprise/AdminActionPreferenceControllerBase.java @@ -52,7 +52,8 @@ public abstract class AdminActionPreferenceControllerBase extends } private String getEnterprisePrivacyNone() { - return mContext.getSystemService(DevicePolicyManager.class).getResources() + return ((DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE)) + .getResources() .getString(ADMIN_ACTION_NONE, () -> mContext.getString(R.string.enterprise_privacy_none)); } diff --git a/src/com/android/settings/enterprise/ApplicationListFragment.java b/src/com/android/settings/enterprise/ApplicationListFragment.java index a82789b02f2..38a5c6f0526 100644 --- a/src/com/android/settings/enterprise/ApplicationListFragment.java +++ b/src/com/android/settings/enterprise/ApplicationListFragment.java @@ -16,6 +16,8 @@ package com.android.settings.enterprise; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_APPS_COUNT_ESTIMATED; + import android.Manifest; import android.app.settings.SettingsEnums; import android.content.Context; @@ -47,6 +49,10 @@ public abstract class ApplicationListFragment extends DashboardFragment @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); + + replaceEnterpriseStringTitle("enterprise_privacy_apps_footer", + ADMIN_ACTION_APPS_COUNT_ESTIMATED, + R.string.enterprise_privacy_apps_count_estimation_info); } @Override diff --git a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java index 1aad54448f6..92e4f4a5c43 100644 --- a/src/com/android/settings/enterprise/EnterprisePrivacySettings.java +++ b/src/com/android/settings/enterprise/EnterprisePrivacySettings.java @@ -16,11 +16,39 @@ package com.android.settings.enterprise; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_ACCESS_CAMERA; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_ACCESS_LOCATION; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_ACCESS_MICROPHONE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_APPS_INSTALLED; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_SET_CURRENT_INPUT_METHOD; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_SET_DEFAULT_APPS; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_ACTION_SET_HTTP_PROXY; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_LOCK_DEVICE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_APPS_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_BUG_REPORT_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_NETWORK_LOGS_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_SECURITY_LOGS_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_USAGE_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_SEE_WORK_DATA_WARNING; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CAN_WIPE_DEVICE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CONFIGURED_FAILED_PASSWORD_WIPE_DEVICE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ADMIN_CONFIGURED_FAILED_PASSWORD_WIPE_WORK_PROFILE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ALWAYS_ON_VPN_WORK_PROFILE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.CA_CERTS_PERSONAL_PROFILE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.CA_CERTS_WORK_PROFILE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.CHANGES_BY_ORGANIZATION_TITLE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.ENTERPRISE_PRIVACY_FOOTER; +import static android.app.admin.DevicePolicyResources.Strings.Settings.INFORMATION_SEEN_BY_ORGANIZATION_TITLE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.MANAGED_DEVICE_INFO; +import static android.app.admin.DevicePolicyResources.Strings.Settings.YOUR_ACCESS_TO_THIS_DEVICE_TITLE; + import android.app.settings.SettingsEnums; import android.content.Context; +import android.os.Bundle; import android.provider.SearchIndexableResource; import com.android.internal.annotations.VisibleForTesting; +import com.android.settings.R; import com.android.settings.dashboard.DashboardFragment; import com.android.settings.overlay.FeatureFactory; import com.android.settings.search.BaseSearchIndexProvider; @@ -45,6 +73,70 @@ public class EnterprisePrivacySettings extends DashboardFragment { super.onAttach(context); } + @Override + public void onCreate(Bundle icicle) { + super.onCreate(icicle); + + replaceEnterprisePreferenceScreenTitle( + MANAGED_DEVICE_INFO, R.string.enterprise_privacy_settings); + + replaceEnterpriseStringTitle("exposure_category", + INFORMATION_SEEN_BY_ORGANIZATION_TITLE, + R.string.enterprise_privacy_exposure_category); + replaceEnterpriseStringTitle("enterprise_privacy_enterprise_data", + ADMIN_CAN_SEE_WORK_DATA_WARNING, R.string.enterprise_privacy_enterprise_data); + replaceEnterpriseStringTitle("enterprise_privacy_installed_packages", + ADMIN_CAN_SEE_APPS_WARNING, R.string.enterprise_privacy_installed_packages); + replaceEnterpriseStringTitle("enterprise_privacy_usage_stats", + ADMIN_CAN_SEE_USAGE_WARNING, R.string.enterprise_privacy_usage_stats); + replaceEnterpriseStringTitle("network_logs", + ADMIN_CAN_SEE_NETWORK_LOGS_WARNING, R.string.enterprise_privacy_network_logs); + replaceEnterpriseStringTitle("bug_reports", + ADMIN_CAN_SEE_BUG_REPORT_WARNING, R.string.enterprise_privacy_bug_reports); + replaceEnterpriseStringTitle("security_logs", + ADMIN_CAN_SEE_SECURITY_LOGS_WARNING, R.string.enterprise_privacy_security_logs); + replaceEnterpriseStringTitle("exposure_changes_category", + CHANGES_BY_ORGANIZATION_TITLE, + R.string.enterprise_privacy_exposure_changes_category); + replaceEnterpriseStringTitle("number_enterprise_installed_packages", + ADMIN_ACTION_APPS_INSTALLED, + R.string.enterprise_privacy_enterprise_installed_packages); + replaceEnterpriseStringTitle("enterprise_privacy_number_location_access_packages", + ADMIN_ACTION_ACCESS_LOCATION, R.string.enterprise_privacy_location_access); + replaceEnterpriseStringTitle("enterprise_privacy_number_microphone_access_packages", + ADMIN_ACTION_ACCESS_MICROPHONE, R.string.enterprise_privacy_microphone_access); + replaceEnterpriseStringTitle("enterprise_privacy_number_camera_access_packages", + ADMIN_ACTION_ACCESS_CAMERA, R.string.enterprise_privacy_camera_access); + replaceEnterpriseStringTitle("number_enterprise_set_default_apps", + ADMIN_ACTION_SET_DEFAULT_APPS, + R.string.enterprise_privacy_enterprise_set_default_apps); + replaceEnterpriseStringTitle("always_on_vpn_managed_profile", + ALWAYS_ON_VPN_WORK_PROFILE, R.string.enterprise_privacy_always_on_vpn_work); + replaceEnterpriseStringTitle("input_method", + ADMIN_ACTION_SET_CURRENT_INPUT_METHOD, R.string.enterprise_privacy_input_method); + replaceEnterpriseStringTitle("global_http_proxy", + ADMIN_ACTION_SET_HTTP_PROXY, R.string.enterprise_privacy_global_http_proxy); + replaceEnterpriseStringTitle("ca_certs_current_user", + CA_CERTS_PERSONAL_PROFILE, R.string.enterprise_privacy_ca_certs_personal); + replaceEnterpriseStringTitle("ca_certs_managed_profile", + CA_CERTS_WORK_PROFILE, R.string.enterprise_privacy_ca_certs_work); + replaceEnterpriseStringTitle("device_access_category", + YOUR_ACCESS_TO_THIS_DEVICE_TITLE, + R.string.enterprise_privacy_device_access_category); + replaceEnterpriseStringTitle("enterprise_privacy_lock_device", + ADMIN_CAN_LOCK_DEVICE, R.string.enterprise_privacy_lock_device); + replaceEnterpriseStringTitle("enterprise_privacy_wipe_device", + ADMIN_CAN_WIPE_DEVICE, R.string.enterprise_privacy_wipe_device); + replaceEnterpriseStringTitle("failed_password_wipe_current_user", + ADMIN_CONFIGURED_FAILED_PASSWORD_WIPE_DEVICE, + R.string.enterprise_privacy_failed_password_wipe_device); + replaceEnterpriseStringTitle("failed_password_wipe_managed_profile", + ADMIN_CONFIGURED_FAILED_PASSWORD_WIPE_WORK_PROFILE, + R.string.enterprise_privacy_failed_password_wipe_work); + replaceEnterpriseStringTitle("enterprise_privacy_footer", + ENTERPRISE_PRIVACY_FOOTER, R.string.enterprise_privacy_header); + } + @Override public void onDetach() { mPrivacySettingsPreference = null; diff --git a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java index 1ecde443dce..9e1bbb3cb06 100644 --- a/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java +++ b/src/com/android/settings/fuelgauge/BatteryAppListPreferenceController.java @@ -243,7 +243,8 @@ public class BatteryAppListPreferenceController extends AbstractPreferenceContro continue; } - final UserHandle userHandle = new UserHandle(UserHandle.getUserId(entry.getUid())); + final int uid = entry.getUid(); + final UserHandle userHandle = new UserHandle(UserHandle.getUserId(uid)); final Drawable badgedIcon = mUserManager.getBadgedIconForUser(entry.getIcon(), userHandle); final CharSequence contentDescription = mUserManager.getBadgedLabelForUser( @@ -261,6 +262,8 @@ public class BatteryAppListPreferenceController extends AbstractPreferenceContro pref.setOrder(i + 1); pref.setPercent(percentOfTotal); pref.shouldShowAnomalyIcon(false); + pref.setEnabled(uid != BatteryUtils.UID_TETHERING + && uid != BatteryUtils.UID_REMOVED_APPS); setUsageSummary(pref, entry); addedSome = true; mAppListGroup.addPreference(pref); diff --git a/src/com/android/settings/fuelgauge/BatteryDiffEntry.java b/src/com/android/settings/fuelgauge/BatteryDiffEntry.java index 5ef111005f0..403f79cffa4 100644 --- a/src/com/android/settings/fuelgauge/BatteryDiffEntry.java +++ b/src/com/android/settings/fuelgauge/BatteryDiffEntry.java @@ -153,13 +153,16 @@ public class BatteryDiffEntry { case ConvertUtils.CONSUMER_TYPE_SYSTEM_BATTERY: return true; case ConvertUtils.CONSUMER_TYPE_UID_BATTERY: - if (mBatteryHistEntry.mIsHidden) { + final int uid = (int) mBatteryHistEntry.mUid; + if (mBatteryHistEntry.mIsHidden + || uid == BatteryUtils.UID_REMOVED_APPS + || uid == BatteryUtils.UID_TETHERING) { return true; } final boolean combineSystemComponents = mContext.getResources().getBoolean( R.bool.config_battery_combine_system_components); - return combineSystemComponents && isSystemUid((int) mBatteryHistEntry.mUid); + return combineSystemComponents && isSystemUid(uid); } return false; } diff --git a/src/com/android/settings/fuelgauge/BatteryEntry.java b/src/com/android/settings/fuelgauge/BatteryEntry.java index c9acc4c46ca..518dc96693b 100644 --- a/src/com/android/settings/fuelgauge/BatteryEntry.java +++ b/src/com/android/settings/fuelgauge/BatteryEntry.java @@ -550,6 +550,10 @@ public class BatteryEntry { Drawable icon = context.getDrawable(R.drawable.ic_power_system); if (uid == 0) { name = context.getResources().getString(R.string.process_kernel_label); + } else if (uid == BatteryUtils.UID_REMOVED_APPS) { + name = context.getResources().getString(R.string.process_removed_apps); + } else if (uid == BatteryUtils.UID_TETHERING) { + name = context.getResources().getString(R.string.process_network_tethering); } else if ("mediaserver".equals(name)) { name = context.getResources().getString(R.string.process_mediaserver_label); } else if ("dex2oat".equals(name) || "dex2oat32".equals(name) || diff --git a/src/com/android/settings/fuelgauge/BatteryUtils.java b/src/com/android/settings/fuelgauge/BatteryUtils.java index 67ffa7d4520..29c2fc96d86 100644 --- a/src/com/android/settings/fuelgauge/BatteryUtils.java +++ b/src/com/android/settings/fuelgauge/BatteryUtils.java @@ -65,6 +65,10 @@ import java.util.List; public class BatteryUtils { public static final int UID_NULL = -1; public static final int SDK_NULL = -1; + /** Special UID value for data usage by removed apps. */ + public static final int UID_REMOVED_APPS = -4; + /** Special UID value for data usage by tethering. */ + public static final int UID_TETHERING = -5; @Retention(RetentionPolicy.SOURCE) @IntDef({StatusType.SCREEN_USAGE, @@ -188,7 +192,10 @@ public class BatteryUtils { */ boolean shouldHideUidBatteryConsumerUnconditionally(UidBatteryConsumer consumer, String[] packages) { - return consumer.getUid() < 0 || isHiddenSystemModule(packages); + final int uid = consumer.getUid(); + return uid == UID_TETHERING + ? false + : uid < 0 || isHiddenSystemModule(packages); } /** diff --git a/src/com/android/settings/network/NetworkProviderSettings.java b/src/com/android/settings/network/NetworkProviderSettings.java index ae030f47951..de4d127a84e 100644 --- a/src/com/android/settings/network/NetworkProviderSettings.java +++ b/src/com/android/settings/network/NetworkProviderSettings.java @@ -49,6 +49,7 @@ import android.view.MenuItem; import android.view.View; import android.widget.Toast; +import androidx.annotation.Nullable; import androidx.annotation.VisibleForTesting; import androidx.appcompat.app.AlertDialog; import androidx.fragment.app.Fragment; @@ -87,6 +88,7 @@ import com.android.settingslib.search.SearchIndexable; import com.android.settingslib.utils.ThreadUtils; import com.android.settingslib.widget.FooterPreference; import com.android.settingslib.widget.LayoutPreference; +import com.android.settingslib.wifi.WifiEnterpriseRestrictionUtils; import com.android.settingslib.wifi.WifiSavedConfigUtils; import com.android.wifitrackerlib.WifiEntry; import com.android.wifitrackerlib.WifiEntry.ConnectCallback; @@ -127,6 +129,8 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment private static final String PREF_KEY_AIRPLANE_MODE_MSG = "airplane_mode_message"; private static final String PREF_KEY_EMPTY_WIFI_LIST = "wifi_empty_list"; + @VisibleForTesting + static final String PREF_KEY_WIFI_TOGGLE = "main_toggle_wifi"; // TODO(b/70983952): Rename these to use WifiEntry instead of AccessPoint. @VisibleForTesting static final String PREF_KEY_CONNECTED_ACCESS_POINTS = "connected_access_point"; @@ -1236,26 +1240,54 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment } }; - public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = - new BaseSearchIndexProvider(R.xml.network_provider_settings) { + public static final SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = + new SearchIndexProvider(R.xml.network_provider_settings); - @Override - public List getNonIndexableKeys(Context context) { - final List keys = super.getNonIndexableKeys(context); + @VisibleForTesting + static class SearchIndexProvider extends BaseSearchIndexProvider { - final WifiManager wifiManager = context.getSystemService(WifiManager.class); - if (wifiManager == null) return keys; + private final WifiRestriction mWifiRestriction; - if (WifiSavedConfigUtils.getAllConfigsCount(context, wifiManager) == 0) { - keys.add(PREF_KEY_SAVED_NETWORKS); - } + SearchIndexProvider(int xmlRes) { + super(xmlRes); + mWifiRestriction = new WifiRestriction(); + } - if (!DataUsageUtils.hasWifiRadio(context)) { - keys.add(PREF_KEY_DATA_USAGE); - } - return keys; - } - }; + @VisibleForTesting + SearchIndexProvider(int xmlRes, WifiRestriction wifiRestriction) { + super(xmlRes); + mWifiRestriction = wifiRestriction; + } + + @Override + public List getNonIndexableKeys(Context context) { + final List keys = super.getNonIndexableKeys(context); + + if (!mWifiRestriction.isChangeWifiStateAllowed(context)) { + keys.add(PREF_KEY_WIFI_TOGGLE); + } + + final WifiManager wifiManager = context.getSystemService(WifiManager.class); + if (wifiManager == null) return keys; + + if (WifiSavedConfigUtils.getAllConfigsCount(context, wifiManager) == 0) { + keys.add(PREF_KEY_SAVED_NETWORKS); + } + + if (!DataUsageUtils.hasWifiRadio(context)) { + keys.add(PREF_KEY_DATA_USAGE); + } + return keys; + } + } + + @VisibleForTesting + static class WifiRestriction { + public boolean isChangeWifiStateAllowed(@Nullable Context context) { + if (context == null) return true; + return WifiEnterpriseRestrictionUtils.isChangeWifiStateAllowed(context); + } + } private class WifiEntryConnectCallback implements ConnectCallback { final WifiEntry mConnectWifiEntry; diff --git a/src/com/android/settings/notification/LockScreenNotificationPreferenceController.java b/src/com/android/settings/notification/LockScreenNotificationPreferenceController.java index 1c024e362cb..1ede911c3c4 100644 --- a/src/com/android/settings/notification/LockScreenNotificationPreferenceController.java +++ b/src/com/android/settings/notification/LockScreenNotificationPreferenceController.java @@ -18,6 +18,8 @@ package com.android.settings.notification; import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS; import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS; +import static android.app.admin.DevicePolicyResources.Strings.Settings.LOCK_SCREEN_HIDE_WORK_NOTIFICATION_CONTENT; +import static android.app.admin.DevicePolicyResources.Strings.Settings.LOCK_SCREEN_SHOW_WORK_NOTIFICATION_CONTENT; import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; @@ -158,8 +160,13 @@ public class LockScreenNotificationPreferenceController extends AbstractPreferen ArrayList entries = new ArrayList<>(); ArrayList values = new ArrayList<>(); - String summaryShowEntry = mContext.getString( - R.string.lock_screen_notifications_summary_show_profile); + DevicePolicyManager devicePolicyManager = + mContext.getSystemService(DevicePolicyManager.class); + + String summaryShowEntry = devicePolicyManager + .getResources().getString(LOCK_SCREEN_SHOW_WORK_NOTIFICATION_CONTENT, + () -> mContext.getString( + R.string.lock_screen_notifications_summary_show_profile)); String summaryShowEntryValue = Integer.toString( R.string.lock_screen_notifications_summary_show_profile); entries.add(summaryShowEntry); @@ -168,8 +175,10 @@ public class LockScreenNotificationPreferenceController extends AbstractPreferen KEYGUARD_DISABLE_SECURE_NOTIFICATIONS | KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS); if (mSecureProfile) { - String summaryHideEntry = mContext.getString( - R.string.lock_screen_notifications_summary_hide_profile); + String summaryHideEntry = devicePolicyManager + .getResources().getString(LOCK_SCREEN_HIDE_WORK_NOTIFICATION_CONTENT, + () -> mContext.getString( + R.string.lock_screen_notifications_summary_hide_profile)); String summaryHideEntryValue = Integer.toString( R.string.lock_screen_notifications_summary_hide_profile); entries.add(summaryHideEntry); diff --git a/src/com/android/settings/notification/RedactionInterstitial.java b/src/com/android/settings/notification/RedactionInterstitial.java index d6cf0c60ecb..f243250a611 100644 --- a/src/com/android/settings/notification/RedactionInterstitial.java +++ b/src/com/android/settings/notification/RedactionInterstitial.java @@ -18,11 +18,14 @@ package com.android.settings.notification; import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_SECURE_NOTIFICATIONS; import static android.app.admin.DevicePolicyManager.KEYGUARD_DISABLE_UNREDACTED_NOTIFICATIONS; +import static android.app.admin.DevicePolicyResources.Strings.Settings.LOCK_SCREEN_HIDE_WORK_NOTIFICATION_CONTENT; +import static android.app.admin.DevicePolicyResources.Strings.Settings.LOCK_SCREEN_SHOW_WORK_NOTIFICATION_CONTENT; import static android.provider.Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS; import static android.provider.Settings.Secure.LOCK_SCREEN_SHOW_NOTIFICATIONS; import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; +import android.app.admin.DevicePolicyManager; import android.app.settings.SettingsEnums; import android.content.Context; import android.content.Intent; @@ -115,6 +118,7 @@ public class RedactionInterstitial extends SettingsActivity { @Override public void onViewCreated(View view, Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); + DevicePolicyManager devicePolicyManager = getSystemService(DevicePolicyManager.class); mRadioGroup = (RadioGroup) view.findViewById(R.id.radio_group); mShowAllButton = (RestrictedRadioButton) view.findViewById(R.id.show_all); mRedactSensitiveButton = @@ -126,9 +130,15 @@ public class RedactionInterstitial extends SettingsActivity { if (UserManager.get(getContext()).isManagedProfile(mUserId)) { ((TextView) view.findViewById(R.id.sud_layout_description)) .setText(R.string.lock_screen_notifications_interstitial_message_profile); - mShowAllButton.setText(R.string.lock_screen_notifications_summary_show_profile); + mShowAllButton.setText(devicePolicyManager + .getResources().getString(LOCK_SCREEN_SHOW_WORK_NOTIFICATION_CONTENT, + () -> getString( + R.string.lock_screen_notifications_summary_show_profile))); mRedactSensitiveButton - .setText(R.string.lock_screen_notifications_summary_hide_profile); + .setText(devicePolicyManager.getResources().getString( + LOCK_SCREEN_HIDE_WORK_NOTIFICATION_CONTENT, + () -> getString( + R.string.lock_screen_notifications_summary_hide_profile))); ((RadioButton) view.findViewById(R.id.hide_all)).setVisibility(View.GONE); } diff --git a/src/com/android/settings/notification/SoundWorkSettings.java b/src/com/android/settings/notification/SoundWorkSettings.java index eb7f05ed8ca..2cb42154e96 100644 --- a/src/com/android/settings/notification/SoundWorkSettings.java +++ b/src/com/android/settings/notification/SoundWorkSettings.java @@ -19,6 +19,7 @@ package com.android.settings.notification; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_ALARM_RINGTONE_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_NOTIFICATION_RINGTONE_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_RINGTONE_TITLE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_SOUND_SETTINGS_SECTION_HEADER; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_USE_PERSONAL_SOUNDS_SUMMARY; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_USE_PERSONAL_SOUNDS_TITLE; @@ -70,6 +71,8 @@ public class SoundWorkSettings extends DashboardFragment implements OnActivityRe mRequestPreference = findPreference(selectedPreference); } } + replaceEnterprisePreferenceScreenTitle( + WORK_PROFILE_SOUND_SETTINGS_SECTION_HEADER, R.string.sound_work_settings); replaceEnterpriseStringTitle("work_use_personal_sounds", WORK_PROFILE_USE_PERSONAL_SOUNDS_TITLE, R.string.work_use_personal_sounds_title); replaceEnterpriseStringSummary("work_use_personal_sounds", @@ -79,7 +82,7 @@ public class SoundWorkSettings extends DashboardFragment implements OnActivityRe WORK_PROFILE_RINGTONE_TITLE, R.string.work_ringtone_title); replaceEnterpriseStringTitle("work_alarm_ringtone", WORK_PROFILE_ALARM_RINGTONE_TITLE, R.string.work_alarm_ringtone_title); - replaceEnterpriseStringTitle("work_notification", + replaceEnterpriseStringTitle("work_notification_ringtone", WORK_PROFILE_NOTIFICATION_RINGTONE_TITLE, R.string.work_notification_ringtone_title); } diff --git a/src/com/android/settings/password/ChooseLockGeneric.java b/src/com/android/settings/password/ChooseLockGeneric.java index 841d1f9440b..e340b505356 100644 --- a/src/com/android/settings/password/ChooseLockGeneric.java +++ b/src/com/android/settings/password/ChooseLockGeneric.java @@ -22,6 +22,7 @@ import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_HIGH; import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_LOW; import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_MEDIUM; import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_NONE; +import static android.app.admin.DevicePolicyResources.Strings.Settings.LOCK_SETTINGS_NEW_PROFILE_LOCK_TITLE; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_IT_ADMIN_CANT_RESET_SCREEN_LOCK; import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_PROFILE_SCREEN_LOCK_SETUP_MESSAGE; @@ -347,7 +348,9 @@ public class ChooseLockGeneric extends SettingsActivity { if (updateExistingLock) { getActivity().setTitle(R.string.lock_settings_picker_update_profile_lock_title); } else { - getActivity().setTitle(R.string.lock_settings_picker_new_profile_lock_title); + getActivity().setTitle(mDpm.getResources().getString( + LOCK_SETTINGS_NEW_PROFILE_LOCK_TITLE, + () -> getString(R.string.lock_settings_picker_new_profile_lock_title))); } } else { updateExistingLock = mLockPatternUtils.isSecure(mUserId); diff --git a/src/com/android/settings/password/ForgotPasswordActivity.java b/src/com/android/settings/password/ForgotPasswordActivity.java index 657139e16e0..d9db335c2c5 100644 --- a/src/com/android/settings/password/ForgotPasswordActivity.java +++ b/src/com/android/settings/password/ForgotPasswordActivity.java @@ -17,6 +17,7 @@ package com.android.settings.password; import static android.app.admin.DevicePolicyResources.Strings.Settings.FORGOT_PASSWORD_TEXT; +import static android.app.admin.DevicePolicyResources.Strings.Settings.FORGOT_PASSWORD_TITLE; import android.app.Activity; import android.app.admin.DevicePolicyManager; @@ -64,6 +65,9 @@ public class ForgotPasswordActivity extends Activity { .build() ); + layout.setHeaderText(devicePolicyManager.getResources().getString( + FORGOT_PASSWORD_TITLE, () -> getString(R.string.forgot_password_title))); + UserManager.get(this).requestQuietModeEnabled( false, UserHandle.of(userId), UserManager.QUIET_MODE_DISABLE_DONT_ASK_CREDENTIAL); } diff --git a/src/com/android/settings/security/SecurityAdvancedSettingsController.java b/src/com/android/settings/security/SecurityAdvancedSettingsController.java index 904141d5485..22a482db3d1 100644 --- a/src/com/android/settings/security/SecurityAdvancedSettingsController.java +++ b/src/com/android/settings/security/SecurityAdvancedSettingsController.java @@ -16,6 +16,9 @@ package com.android.settings.security; +import static android.app.admin.DevicePolicyResources.Strings.Settings.MORE_SECURITY_SETTINGS_WORK_PROFILE_SUMMARY; + +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.pm.CrossProfileApps; @@ -29,11 +32,13 @@ import com.android.settings.core.BasePreferenceController; public class SecurityAdvancedSettingsController extends BasePreferenceController { private final CrossProfileApps mCrossProfileApps; + private final DevicePolicyManager mDevicePolicyManager; public SecurityAdvancedSettingsController(Context context, String preferenceKey) { super(context, preferenceKey); mCrossProfileApps = context.getSystemService(CrossProfileApps.class); + mDevicePolicyManager = context.getSystemService(DevicePolicyManager.class); } @Override @@ -44,8 +49,10 @@ public class SecurityAdvancedSettingsController extends BasePreferenceController @Override public CharSequence getSummary() { return isWorkProfilePresent() - ? mContext.getResources().getString( - R.string.security_advanced_settings_work_profile_settings_summary) + ? mDevicePolicyManager.getResources().getString( + MORE_SECURITY_SETTINGS_WORK_PROFILE_SUMMARY, + () -> mContext.getResources().getString( + R.string.security_advanced_settings_work_profile_settings_summary)) : mContext.getResources().getString( R.string.security_advanced_settings_no_work_profile_settings_summary); } diff --git a/src/com/android/settings/wifi/slice/WifiSlice.java b/src/com/android/settings/wifi/slice/WifiSlice.java index f59dc60d6e0..76dfab8491b 100644 --- a/src/com/android/settings/wifi/slice/WifiSlice.java +++ b/src/com/android/settings/wifi/slice/WifiSlice.java @@ -37,6 +37,7 @@ import android.os.Bundle; import android.text.TextUtils; import android.util.Log; +import androidx.annotation.Nullable; import androidx.annotation.VisibleForTesting; import androidx.core.graphics.drawable.IconCompat; import androidx.slice.Slice; @@ -56,6 +57,7 @@ import com.android.settings.wifi.AppStateChangeWifiStateBridge; import com.android.settings.wifi.WifiDialogActivity; import com.android.settings.wifi.WifiUtils; import com.android.settings.wifi.details.WifiNetworkDetailsFragment; +import com.android.settingslib.wifi.WifiEnterpriseRestrictionUtils; import com.android.wifitrackerlib.WifiEntry; import java.util.Arrays; @@ -74,10 +76,17 @@ public class WifiSlice implements CustomSliceable { protected final Context mContext; protected final WifiManager mWifiManager; + protected final WifiRestriction mWifiRestriction; public WifiSlice(Context context) { + this(context, new WifiRestriction()); + } + + @VisibleForTesting + WifiSlice(Context context, WifiRestriction wifiRestriction) { mContext = context; mWifiManager = mContext.getSystemService(WifiManager.class); + mWifiRestriction = wifiRestriction; } @Override @@ -88,14 +97,13 @@ public class WifiSlice implements CustomSliceable { @Override public Slice getSlice() { // If external calling package doesn't have Wi-Fi permission. - if (!Utils.isSettingsIntelligence(mContext) && !isPermissionGranted(mContext)) { - Log.i(TAG, "No wifi permissions to control wifi slice."); - return null; - } - + final boolean isPermissionGranted = + Utils.isSettingsIntelligence(mContext) || isPermissionGranted(mContext); final boolean isWifiEnabled = isWifiEnabled(); - ListBuilder listBuilder = getListBuilder(isWifiEnabled, null /* wifiSliceItem */); - if (!isWifiEnabled) { + ListBuilder listBuilder = getListBuilder(isWifiEnabled, null /* wifiSliceItem */, + isPermissionGranted); + // If the caller doesn't have the permission granted, just return a slice without a toggle. + if (!isWifiEnabled || !isPermissionGranted) { return listBuilder.build(); } @@ -107,7 +115,8 @@ public class WifiSlice implements CustomSliceable { if (isFirstApActive) { // refresh header subtext - listBuilder = getListBuilder(true /* isWifiEnabled */, apList.get(0)); + listBuilder = getListBuilder( + true /* isWifiEnabled */, apList.get(0), true /* isWiFiPermissionGranted */); } if (isApRowCollapsed()) { @@ -167,20 +176,31 @@ public class WifiSlice implements CustomSliceable { final SliceAction primarySliceAction = SliceAction.createDeeplink(primaryAction, icon, ListBuilder.ICON_IMAGE, title); - return new ListBuilder.RowBuilder() + final ListBuilder.RowBuilder builder = new ListBuilder.RowBuilder() .setTitle(title) .setPrimaryAction(primarySliceAction); + + if (!mWifiRestriction.isChangeWifiStateAllowed(mContext)) { + builder.setSubtitle(mContext.getString(R.string.not_allowed_by_ent)); + } + return builder; } - private ListBuilder getListBuilder(boolean isWifiEnabled, WifiSliceItem wifiSliceItem) { - final PendingIntent toggleAction = getBroadcastIntent(mContext); - final SliceAction toggleSliceAction = SliceAction.createToggle(toggleAction, - null /* actionTitle */, isWifiEnabled); + private ListBuilder getListBuilder(boolean isWifiEnabled, WifiSliceItem wifiSliceItem, + boolean isWiFiPermissionGranted) { final ListBuilder builder = new ListBuilder(mContext, getUri(), ListBuilder.INFINITY) .setAccentColor(COLOR_NOT_TINTED) .setKeywords(getKeywords()) - .addRow(getHeaderRow(isWifiEnabled, wifiSliceItem)) - .addAction(toggleSliceAction); + .addRow(getHeaderRow(isWifiEnabled, wifiSliceItem)); + if (!isWiFiPermissionGranted || !mWifiRestriction.isChangeWifiStateAllowed(mContext)) { + return builder; + } + + final PendingIntent toggleAction = getBroadcastIntent(mContext); + final SliceAction toggleSliceAction = SliceAction.createToggle(toggleAction, + null /* actionTitle */, isWifiEnabled); + builder.addAction(toggleSliceAction); + return builder; } @@ -349,4 +369,12 @@ public class WifiSlice implements CustomSliceable { public Class getBackgroundWorkerClass() { return WifiScanWorker.class; } + + @VisibleForTesting + static class WifiRestriction { + public boolean isChangeWifiStateAllowed(@Nullable Context context) { + if (context == null) return true; + return WifiEnterpriseRestrictionUtils.isChangeWifiStateAllowed(context); + } + } } diff --git a/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java index 67ec836a32e..ece7ea9d699 100644 --- a/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accounts/EmergencyInfoPreferenceControllerTest.java @@ -20,12 +20,14 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import android.app.Activity; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.Intent; import android.content.pm.ResolveInfo; @@ -70,6 +72,8 @@ public class EmergencyInfoPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new EmergencyInfoPreferenceController(mContext, "test_key"); mPreference = new Preference(Robolectric.setupActivity(Activity.class)); mPreference.setKey(mController.getPreferenceKey()); diff --git a/tests/robotests/src/com/android/settings/applications/defaultapps/DefaultAppPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/applications/defaultapps/DefaultAppPreferenceControllerTest.java index e78a3942728..e4d3ca58a27 100644 --- a/tests/robotests/src/com/android/settings/applications/defaultapps/DefaultAppPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/applications/defaultapps/DefaultAppPreferenceControllerTest.java @@ -18,10 +18,12 @@ package com.android.settings.applications.defaultapps; import static com.android.settingslib.widget.TwoTargetPreference.ICON_SIZE_MEDIUM; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.os.UserManager; @@ -57,6 +59,8 @@ public class DefaultAppPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); } @Test diff --git a/tests/robotests/src/com/android/settings/dashboard/DashboardTilePlaceholderPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/dashboard/DashboardTilePlaceholderPreferenceControllerTest.java index 8b4686bfc9a..9696776dd14 100644 --- a/tests/robotests/src/com/android/settings/dashboard/DashboardTilePlaceholderPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/dashboard/DashboardTilePlaceholderPreferenceControllerTest.java @@ -20,8 +20,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -47,6 +50,8 @@ public class DashboardTilePlaceholderPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new DashboardTilePlaceholderPreferenceController(mContext); } diff --git a/tests/robotests/src/com/android/settings/deviceinfo/FccEquipmentIdPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/FccEquipmentIdPreferenceControllerTest.java index 1e3b11286ef..f6bda32afad 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/FccEquipmentIdPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/FccEquipmentIdPreferenceControllerTest.java @@ -17,8 +17,11 @@ package com.android.settings.deviceinfo; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.os.SystemProperties; @@ -47,6 +50,8 @@ public class FccEquipmentIdPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new FccEquipmentIdPreferenceController(mContext); when(mPreferenceScreen.findPreference(mController.getPreferenceKey())) .thenReturn(mPreference); diff --git a/tests/robotests/src/com/android/settings/deviceinfo/FeedbackPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/FeedbackPreferenceControllerTest.java index eef262c328b..38140c528f4 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/FeedbackPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/FeedbackPreferenceControllerTest.java @@ -18,8 +18,11 @@ package com.android.settings.deviceinfo; import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.fragment.app.Fragment; @@ -51,6 +54,8 @@ public class FeedbackPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new FeedbackPreferenceController(mFragment, mContext); final String prefKey = mController.getPreferenceKey(); when(mScreen.findPreference(prefKey)).thenReturn(mPreference); diff --git a/tests/robotests/src/com/android/settings/deviceinfo/ManualPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/ManualPreferenceControllerTest.java index 1da1f214638..11550253698 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/ManualPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/ManualPreferenceControllerTest.java @@ -19,8 +19,11 @@ package com.android.settings.deviceinfo; import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import org.junit.Before; @@ -41,6 +44,8 @@ public class ManualPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new ManualPreferenceController(mContext); } diff --git a/tests/robotests/src/com/android/settings/deviceinfo/RegulatoryInfoPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/RegulatoryInfoPreferenceControllerTest.java index 464d9a25cc0..6a85ab955eb 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/RegulatoryInfoPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/RegulatoryInfoPreferenceControllerTest.java @@ -19,8 +19,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; @@ -56,6 +59,8 @@ public class RegulatoryInfoPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mContext.getPackageManager()).thenReturn(mPackageManager); mController = new RegulatoryInfoPreferenceController(mContext); diff --git a/tests/robotests/src/com/android/settings/deviceinfo/storage/AutomaticStorageManagementSwitchPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/deviceinfo/storage/AutomaticStorageManagementSwitchPreferenceControllerTest.java index a0f188dc873..3552e1618ef 100644 --- a/tests/robotests/src/com/android/settings/deviceinfo/storage/AutomaticStorageManagementSwitchPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/deviceinfo/storage/AutomaticStorageManagementSwitchPreferenceControllerTest.java @@ -20,6 +20,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.spy; @@ -27,6 +28,7 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.content.res.Resources; @@ -77,6 +79,10 @@ public class AutomaticStorageManagementSwitchPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); mContext = spy(RuntimeEnvironment.application.getApplicationContext()); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); + doReturn(mock(DevicePolicyManager.class)).when(mMockContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); FeatureFactory.getFactory(mContext); mResources = spy(mContext.getResources()); when(mContext.getResources()).thenReturn(mResources); diff --git a/tests/robotests/src/com/android/settings/display/AutoRotatePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/AutoRotatePreferenceControllerTest.java index 54e6b991108..5611e93a846 100644 --- a/tests/robotests/src/com/android/settings/display/AutoRotatePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/AutoRotatePreferenceControllerTest.java @@ -20,8 +20,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.content.pm.PackageManager; @@ -60,6 +63,8 @@ public class AutoRotatePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); FakeFeatureFactory.setupForTest(); mContentResolver = RuntimeEnvironment.application.getContentResolver(); mPreference = new SwitchPreference(RuntimeEnvironment.application); diff --git a/tests/robotests/src/com/android/settings/display/DisplayWhiteBalancePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/DisplayWhiteBalancePreferenceControllerTest.java index dfc13de8e14..25d52411be6 100644 --- a/tests/robotests/src/com/android/settings/display/DisplayWhiteBalancePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/DisplayWhiteBalancePreferenceControllerTest.java @@ -1,13 +1,15 @@ package com.android.settings.display; +import static com.google.common.truth.Truth.assertThat; + import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.reset; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -import static com.google.common.truth.Truth.assertThat; - +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.hardware.display.ColorDisplayManager; @@ -17,6 +19,7 @@ import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import com.android.settings.testutils.shadow.SettingsShadowResources; + import org.junit.After; import org.junit.Before; import org.junit.Test; @@ -56,6 +59,8 @@ public class DisplayWhiteBalancePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mContentResolver = RuntimeEnvironment.application.getContentResolver(); when(mContext.getContentResolver()).thenReturn(mContentResolver); diff --git a/tests/robotests/src/com/android/settings/display/ShowOperatorNamePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/ShowOperatorNamePreferenceControllerTest.java index 6a461103551..c6f8a1fa340 100644 --- a/tests/robotests/src/com/android/settings/display/ShowOperatorNamePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/ShowOperatorNamePreferenceControllerTest.java @@ -20,8 +20,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.os.PersistableBundle; import android.provider.Settings; @@ -60,6 +63,8 @@ public class ShowOperatorNamePreferenceControllerTest { when(mConfigManager.getConfigForSubId(anyInt())).thenReturn(mConfig); when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn(mConfigManager); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new ShowOperatorNamePreferenceController(mContext); } diff --git a/tests/robotests/src/com/android/settings/display/ThemePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/display/ThemePreferenceControllerTest.java index 5133ae6436c..af466634ed3 100644 --- a/tests/robotests/src/com/android/settings/display/ThemePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/display/ThemePreferenceControllerTest.java @@ -22,10 +22,12 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.om.IOverlayManager; import android.content.om.OverlayInfo; @@ -70,6 +72,8 @@ public class ThemePreferenceControllerTest { public void setUp() throws NameNotFoundException { MockitoAnnotations.initMocks(this); FakeFeatureFactory.setupForTest(); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mPackageManager.getApplicationInfo(any(), anyInt())).thenReturn(mApplicationInfo); when(mContext.getPackageManager()).thenReturn(mPackageManager); when(mContext.getString(R.string.default_theme)) diff --git a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java index 6c136f1c045..09d1c84f994 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/AdminGrantedPermissionsPreferenceControllerTestBase.java @@ -21,8 +21,11 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyObject; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -61,6 +64,8 @@ public abstract class AdminGrantedPermissionsPreferenceControllerTestBase { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = createController(true /* async */); } diff --git a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java index 5a4f38bfc09..2b122ab827c 100644 --- a/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/AlwaysOnVpnManagedProfilePreferenceControllerTest.java @@ -18,8 +18,11 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -48,6 +51,8 @@ public class AlwaysOnVpnManagedProfilePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new AlwaysOnVpnManagedProfilePreferenceController(mContext); } diff --git a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java index 47db2c7aec0..e26915b1083 100644 --- a/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/CaCertsPreferenceControllerTestBase.java @@ -18,8 +18,11 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -46,6 +49,8 @@ public abstract class CaCertsPreferenceControllerTestBase { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = createController(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java index 232d3e792c7..f39b4b8821b 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseInstalledPackagesPreferenceControllerTest.java @@ -20,9 +20,12 @@ 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.doReturn; import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -56,6 +59,8 @@ public class EnterpriseInstalledPackagesPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new EnterpriseInstalledPackagesPreferenceController(mContext, true /* async */); diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java index afb1971fa8a..62133d933f8 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterprisePrivacyPreferenceControllerTest.java @@ -18,9 +18,12 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -47,6 +50,8 @@ public class EnterprisePrivacyPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new EnterprisePrivacyPreferenceController( mContext, mPrivacyPreferenceControllerHelper, KEY_ENTERPRISE_PRIVACY); } diff --git a/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java index b91582bb9f8..7a38feb97fe 100644 --- a/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/EnterpriseSetDefaultAppsPreferenceControllerTest.java @@ -22,8 +22,11 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.argThat; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.Intent; import android.content.pm.ApplicationInfo; @@ -64,6 +67,8 @@ public final class EnterpriseSetDefaultAppsPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new EnterpriseSetDefaultAppsPreferenceController(mContext); } diff --git a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java index 9dd02dea413..03854bffad0 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java +++ b/tests/robotests/src/com/android/settings/enterprise/FailedPasswordWipePreferenceControllerTestBase.java @@ -18,8 +18,11 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -53,6 +56,8 @@ public abstract class FailedPasswordWipePreferenceControllerTestBase { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); } diff --git a/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java index 61da68eb036..8d8228425eb 100644 --- a/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/FinancedPrivacyPreferenceControllerTest.java @@ -18,9 +18,12 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -47,6 +50,8 @@ public class FinancedPrivacyPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new FinancedPrivacyPreferenceController( mContext, mPrivacyPreferenceControllerHelper, PREF_KEY_FINANCED_PRIVACY); } diff --git a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java index dc9fb0cea83..c9ce0607d91 100644 --- a/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/enterprise/ImePreferenceControllerTest.java @@ -18,8 +18,11 @@ package com.android.settings.enterprise; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -52,6 +55,8 @@ public class ImePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); mController = new ImePreferenceController(mContext); when(mContext.getResources().getString(R.string.enterprise_privacy_input_method_name, diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java index 5e69b8fb05b..46773c96622 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryAppListPreferenceControllerTest.java @@ -26,6 +26,7 @@ import static org.mockito.Mockito.when; import android.content.Context; import android.content.pm.PackageManager; import android.content.res.Resources; +import android.os.Process; import android.os.UserManager; import android.text.format.DateUtils; @@ -101,13 +102,22 @@ public class BatteryAppListPreferenceControllerTest { } @Test - public void testSetUsageSummary_timeLessThanOneMinute_DoNotSetSummary() { + public void testSetUsageSummary_timeLessThanOneMinute_doNotSetSummary() { when(mBatteryEntry.getTimeInForegroundMs()).thenReturn(59 * DateUtils.SECOND_IN_MILLIS); mPreferenceController.setUsageSummary(mPreference, mBatteryEntry); assertThat(mPreference.getSummary()).isNull(); } + @Test + public void testSetUsageSummary_systemProcessUid_doNotSetSummary() { + when(mBatteryEntry.getTimeInForegroundMs()).thenReturn(DateUtils.MINUTE_IN_MILLIS); + when(mBatteryEntry.getUid()).thenReturn(Process.SYSTEM_UID); + + mPreferenceController.setUsageSummary(mPreference, mBatteryEntry); + assertThat(mPreference.getSummary()).isNull(); + } + @Test public void testSetUsageSummary_timeMoreThanOneMinute_normalApp_setScreenSummary() { when(mBatteryEntry.getTimeInForegroundMs()).thenReturn(2 * DateUtils.MINUTE_IN_MILLIS); diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java index 710d0653a4e..6ea13901eef 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryDiffEntryTest.java @@ -357,6 +357,24 @@ public final class BatteryDiffEntryTest { assertThat(entry.isSystemEntry()).isFalse(); } + @Test + public void testIsSystemEntry_uidBatteryWithTetheringProcess_returnTrue() { + final BatteryDiffEntry entry = + createBatteryDiffEntry( + ConvertUtils.CONSUMER_TYPE_UID_BATTERY, + /*uid=*/ BatteryUtils.UID_TETHERING, /*isHidden=*/ false); + assertThat(entry.isSystemEntry()).isTrue(); + } + + @Test + public void testIsSystemEntry_uidBatteryWithRemovedAppsProcess_returnTrue() { + final BatteryDiffEntry entry = + createBatteryDiffEntry( + ConvertUtils.CONSUMER_TYPE_UID_BATTERY, + /*uid=*/ BatteryUtils.UID_REMOVED_APPS, /*isHidden=*/ false); + assertThat(entry.isSystemEntry()).isTrue(); + } + @Test public void testUpdateRestrictionFlagState_updateFlagAsExpected() throws Exception { final String expectedAppLabel = "fake app label"; diff --git a/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java index 966bc701ced..707a658c569 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/BatteryEntryTest.java @@ -278,6 +278,22 @@ public class BatteryEntryTest { assertNameAndIcon("dex2oat", R.string.process_dex2oat_label); } + @Test + public void getNameAndIconFromUid_tetheringUid_rerturnExpectedName() { + final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid( + mContext, /* name */ null, /* uid */ BatteryUtils.UID_TETHERING); + + assertThat(nameAndIcon.mName).isEqualTo(getString(R.string.process_network_tethering)); + } + + @Test + public void getNameAndIconFromUid_removedAppsUid_rerturnExpectedName() { + final NameAndIcon nameAndIcon = BatteryEntry.getNameAndIconFromUid( + mContext, /* name */ null, /* uid */ BatteryUtils.UID_REMOVED_APPS); + + assertThat(nameAndIcon.mName).isEqualTo(getString(R.string.process_removed_apps)); + } + @Test public void getNameAndIconFromPowerComponent_rerturnExpectedNameAndIcon() { assertNameAndIcon(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY, diff --git a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java index b132a9708ab..6691bd5fdf1 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/SmartBatteryPreferenceControllerTest.java @@ -19,15 +19,18 @@ package com.android.settings.fuelgauge; import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; +import android.content.Context; import android.provider.Settings; import androidx.preference.SwitchPreference; import com.android.settings.core.BasePreferenceController; import com.android.settings.testutils.FakeFeatureFactory; -import com.android.settingslib.widget.MainSwitchPreference; import org.junit.Before; import org.junit.Test; @@ -42,6 +45,7 @@ public class SmartBatteryPreferenceControllerTest { private static final int ON = 1; private static final int OFF = 0; + private Context mContext = spy(RuntimeEnvironment.application); private SmartBatteryPreferenceController mController; private SwitchPreference mPreference; private ContentResolver mContentResolver; @@ -50,11 +54,13 @@ public class SmartBatteryPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFeatureFactory = FakeFeatureFactory.setupForTest(); - mContentResolver = RuntimeEnvironment.application.getContentResolver(); - mController = new SmartBatteryPreferenceController(RuntimeEnvironment.application); - mPreference = new SwitchPreference(RuntimeEnvironment.application); + mContentResolver = mContext.getContentResolver(); + mController = new SmartBatteryPreferenceController(mContext); + mPreference = new SwitchPreference(mContext); } @Test @@ -118,7 +124,7 @@ public class SmartBatteryPreferenceControllerTest { @Test public void isSliceableCorrectKey_returnsTrue() { final SmartBatteryPreferenceController controller = - new SmartBatteryPreferenceController(null); + new SmartBatteryPreferenceController(mContext); assertThat(controller.isSliceable()).isTrue(); } diff --git a/tests/robotests/src/com/android/settings/gestures/AssistGestureSettingsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/AssistGestureSettingsPreferenceControllerTest.java index e77521dfcee..498494635da 100644 --- a/tests/robotests/src/com/android/settings/gestures/AssistGestureSettingsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/AssistGestureSettingsPreferenceControllerTest.java @@ -18,8 +18,11 @@ package com.android.settings.gestures; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import com.android.settings.testutils.FakeFeatureFactory; @@ -48,6 +51,8 @@ public class AssistGestureSettingsPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mFactory = FakeFeatureFactory.setupForTest(); mController = new AssistGestureSettingsPreferenceController(mContext, KEY_ASSIST); mController.setAssistOnly(false); diff --git a/tests/robotests/src/com/android/settings/gestures/DoubleTapScreenPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/DoubleTapScreenPreferenceControllerTest.java index edcbd764013..6069253aa68 100644 --- a/tests/robotests/src/com/android/settings/gestures/DoubleTapScreenPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/DoubleTapScreenPreferenceControllerTest.java @@ -22,8 +22,11 @@ import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.SharedPreferences; import android.hardware.display.AmbientDisplayConfiguration; @@ -53,6 +56,8 @@ public class DoubleTapScreenPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new DoubleTapScreenPreferenceController(mContext, KEY_DOUBLE_TAP_SCREEN); mController.setConfig(mAmbientDisplayConfiguration); } diff --git a/tests/robotests/src/com/android/settings/gestures/DoubleTwistPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/DoubleTwistPreferenceControllerTest.java index 630d4804202..f04505b23be 100644 --- a/tests/robotests/src/com/android/settings/gestures/DoubleTwistPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/DoubleTwistPreferenceControllerTest.java @@ -19,10 +19,12 @@ package com.android.settings.gestures; import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorManager; @@ -61,6 +63,8 @@ public class DoubleTwistPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mock(UserManager.class)); mController = new DoubleTwistPreferenceController(mContext, KEY_DOUBLE_TWIST); } diff --git a/tests/robotests/src/com/android/settings/gestures/GesturePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/GesturePreferenceControllerTest.java index 1707c9dc85f..6339546dbe7 100644 --- a/tests/robotests/src/com/android/settings/gestures/GesturePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/GesturePreferenceControllerTest.java @@ -19,10 +19,12 @@ package com.android.settings.gestures; import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -55,6 +57,8 @@ public class GesturePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new TestPrefController(mContext, "testKey"); mPreference = new Preference(RuntimeEnvironment.application); mPreference.setKey(mController.getPreferenceKey()); diff --git a/tests/robotests/src/com/android/settings/gestures/GesturesSettingsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/GesturesSettingsPreferenceControllerTest.java index c185810946f..fc0f45c16f7 100644 --- a/tests/robotests/src/com/android/settings/gestures/GesturesSettingsPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/GesturesSettingsPreferenceControllerTest.java @@ -20,7 +20,12 @@ import static com.android.settings.core.BasePreferenceController.AVAILABLE; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + import android.app.Activity; +import android.app.admin.DevicePolicyManager; +import android.content.Context; import com.android.settings.testutils.FakeFeatureFactory; import com.android.settingslib.core.AbstractPreferenceController; @@ -49,6 +54,8 @@ public class GesturesSettingsPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mActivity) + .getSystemService(Context.DEVICE_POLICY_SERVICE); FakeFeatureFactory.setupForTest(); mController = new GesturesSettingPreferenceController(mActivity); } diff --git a/tests/robotests/src/com/android/settings/gestures/PickupGesturePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/PickupGesturePreferenceControllerTest.java index b694db38029..3fd68777f2e 100644 --- a/tests/robotests/src/com/android/settings/gestures/PickupGesturePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/PickupGesturePreferenceControllerTest.java @@ -22,8 +22,11 @@ import static com.android.settings.core.BasePreferenceController.UNSUPPORTED_ON_ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.SharedPreferences; import android.hardware.display.AmbientDisplayConfiguration; @@ -54,6 +57,8 @@ public class PickupGesturePreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new PickupGesturePreferenceController(mContext, KEY_PICK_UP); mController.setConfig(mAmbientDisplayConfiguration); } diff --git a/tests/robotests/src/com/android/settings/gestures/SwipeToNotificationPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/gestures/SwipeToNotificationPreferenceControllerTest.java index 519232e2898..13856d0d61d 100644 --- a/tests/robotests/src/com/android/settings/gestures/SwipeToNotificationPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/gestures/SwipeToNotificationPreferenceControllerTest.java @@ -20,8 +20,11 @@ import static android.provider.Settings.Secure.SYSTEM_NAVIGATION_KEYS_ENABLED; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.SharedPreferences; import android.content.pm.PackageManager; @@ -55,6 +58,8 @@ public class SwipeToNotificationPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new SwipeToNotificationPreferenceController(mContext, KEY_SWIPE_DOWN); when(mContext.getPackageManager()).thenReturn(mPackageManager); when(mContext.getSystemService(Context.FINGERPRINT_SERVICE)) diff --git a/tests/robotests/src/com/android/settings/inputmethod/SpellCheckerPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/inputmethod/SpellCheckerPreferenceControllerTest.java index ead12cf7ebe..b050970c5ec 100644 --- a/tests/robotests/src/com/android/settings/inputmethod/SpellCheckerPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/inputmethod/SpellCheckerPreferenceControllerTest.java @@ -18,9 +18,11 @@ package com.android.settings.inputmethod; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.res.Resources; import android.view.textservice.SpellCheckerInfo; @@ -59,6 +61,8 @@ public class SpellCheckerPreferenceControllerTest { mAppContext = RuntimeEnvironment.application; when(mContext.getSystemService(Context.TEXT_SERVICES_MANAGER_SERVICE)) .thenReturn(mTextServicesManager); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mContext.getResources()).thenReturn(mResources); when(mResources.getBoolean(R.bool.config_show_spellcheckers_settings)).thenReturn(true); mPreference = new Preference(mAppContext); diff --git a/tests/robotests/src/com/android/settings/language/UserDictionaryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/language/UserDictionaryPreferenceControllerTest.java index 29492b6862e..ed48fd17558 100644 --- a/tests/robotests/src/com/android/settings/language/UserDictionaryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/language/UserDictionaryPreferenceControllerTest.java @@ -18,6 +18,10 @@ package com.android.settings.language; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; + +import android.app.admin.DevicePolicyManager; import android.content.Context; import androidx.preference.Preference; @@ -48,6 +52,8 @@ public class UserDictionaryPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); FakeFeatureFactory.setupForTest(); mController = new TestController(mContext); mPreference = new Preference(RuntimeEnvironment.application); diff --git a/tests/robotests/src/com/android/settings/localepicker/AppLocalePickerActivityTest.java b/tests/robotests/src/com/android/settings/localepicker/AppLocalePickerActivityTest.java index 4d5e0b98172..332a39b3436 100644 --- a/tests/robotests/src/com/android/settings/localepicker/AppLocalePickerActivityTest.java +++ b/tests/robotests/src/com/android/settings/localepicker/AppLocalePickerActivityTest.java @@ -18,6 +18,10 @@ package com.android.settings.localepicker; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import android.app.Activity; import android.app.ApplicationPackageManager; import android.content.Context; @@ -28,14 +32,15 @@ import android.os.Process; import android.os.UserHandle; import android.telephony.TelephonyManager; -import androidx.fragment.app.Fragment; - -import com.android.settings.R; +import com.android.internal.app.LocaleStore; import com.android.settings.applications.AppInfoBase; +import java.util.Locale; + import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; +import org.mockito.Mock; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; import org.robolectric.Robolectric; @@ -56,6 +61,9 @@ public class AppLocalePickerActivityTest { private static final String TEST_PACKAGE_NAME = "com.android.settings"; private static final Uri TEST_PACKAGE_URI = Uri.parse("package:" + TEST_PACKAGE_NAME); + @Mock + LocaleStore.LocaleInfo mLocaleInfo; + @Rule public MockitoRule rule = MockitoJUnit.rule(); @@ -79,6 +87,38 @@ public class AppLocalePickerActivityTest { assertThat(controller.get().isFinishing()).isTrue(); } + @Test + public void onLocaleSelected_getLocaleNotNull_getLanguageTag() { + ActivityController controller = + initActivityController(true); + Locale locale = new Locale("en", "US"); + when(mLocaleInfo.getLocale()).thenReturn(locale); + when(mLocaleInfo.isSystemLocale()).thenReturn(false); + + controller.create(); + AppLocalePickerActivity mActivity = controller.get(); + mActivity.onLocaleSelected(mLocaleInfo); + + verify(mLocaleInfo, times(2)).getLocale(); + assertThat(mLocaleInfo.getLocale().toLanguageTag()).isEqualTo("en-US"); + assertThat(controller.get().isFinishing()).isTrue(); + } + + @Test + public void onLocaleSelected_getLocaleNull_getEmptyLanguageTag() { + ActivityController controller = + initActivityController(true); + when(mLocaleInfo.getLocale()).thenReturn(null); + when(mLocaleInfo.isSystemLocale()).thenReturn(false); + + controller.create(); + AppLocalePickerActivity mActivity = controller.get(); + mActivity.onLocaleSelected(mLocaleInfo); + + verify(mLocaleInfo, times(1)).getLocale(); + assertThat(controller.get().isFinishing()).isTrue(); + } + private ActivityController initActivityController( boolean hasPackageName) { Intent data = new Intent(); diff --git a/tests/robotests/src/com/android/settings/network/AllInOneTetherPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/AllInOneTetherPreferenceControllerTest.java index c216671eca1..15e24e15f3b 100644 --- a/tests/robotests/src/com/android/settings/network/AllInOneTetherPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/AllInOneTetherPreferenceControllerTest.java @@ -131,9 +131,11 @@ public class AllInOneTetherPreferenceControllerTest { @Before public void setUp() { - mContext = ApplicationProvider.getApplicationContext(); + mContext = spy(ApplicationProvider.getApplicationContext()); MockitoAnnotations.initMocks(this); - mController = spy(AllInOneTetherPreferenceController.class); + doReturn(null).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); + mController = spy(new AllInOneTetherPreferenceController(mContext, /* key= */ "test")); ReflectionHelpers.setField(mController, "mContext", mContext); ReflectionHelpers.setField(mController, "mBluetoothAdapter", mBluetoothAdapter); ReflectionHelpers.setField(mController, "mPreferenceKey", PREF_KEY); diff --git a/tests/robotests/src/com/android/settings/network/NetworkProviderSettingsTest.java b/tests/robotests/src/com/android/settings/network/NetworkProviderSettingsTest.java index 5ee96769696..1424d0eced1 100644 --- a/tests/robotests/src/com/android/settings/network/NetworkProviderSettingsTest.java +++ b/tests/robotests/src/com/android/settings/network/NetworkProviderSettingsTest.java @@ -60,6 +60,7 @@ import androidx.preference.PreferenceFragmentCompat; import androidx.preference.PreferenceManager; import androidx.preference.PreferenceScreen; import androidx.recyclerview.widget.RecyclerView; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.AirplaneModeEnabler; import com.android.settings.R; @@ -77,24 +78,33 @@ import com.android.wifitrackerlib.WifiEntry; import com.android.wifitrackerlib.WifiPickerTracker; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; import org.robolectric.annotation.Implementation; import org.robolectric.annotation.Implements; import org.robolectric.shadows.ShadowToast; +import java.util.List; + @RunWith(RobolectricTestRunner.class) public class NetworkProviderSettingsTest { + private static final int XML_RES = R.xml.wifi_tether_settings; private static final int NUM_NETWORKS = 4; private static final String FAKE_URI_STRING = "fakeuri"; + @Rule + public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + @Spy + Context mContext = ApplicationProvider.getApplicationContext(); @Mock private PowerManager mPowerManager; @Mock @@ -107,7 +117,6 @@ public class NetworkProviderSettingsTest { private AirplaneModeEnabler mAirplaneModeEnabler; @Mock private DataUsagePreference mDataUsagePreference; - private Context mContext; private NetworkProviderSettings mNetworkProviderSettings; @Mock private WifiPickerTracker mMockWifiPickerTracker; @@ -131,12 +140,11 @@ public class NetworkProviderSettingsTest { PreferenceCategory mConnectedWifiEntryPreferenceCategory; @Mock PreferenceCategory mFirstWifiEntryPreferenceCategory; + @Mock + NetworkProviderSettings.WifiRestriction mWifiRestriction; @Before public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = spy(RuntimeEnvironment.application); - mNetworkProviderSettings = spy(new NetworkProviderSettings()); doReturn(mContext).when(mNetworkProviderSettings).getContext(); doReturn(mPreferenceManager).when(mNetworkProviderSettings).getPreferenceManager(); @@ -721,6 +729,28 @@ public class NetworkProviderSettingsTest { verify(mContextMenu, never()).add(anyInt(), eq(MENU_ID_FORGET), anyInt(), anyInt()); } + @Test + public void getNonIndexableKeys_allowedChangeWifiState_keyNotReturned() { + when(mWifiRestriction.isChangeWifiStateAllowed(mContext)).thenReturn(true); + NetworkProviderSettings.SearchIndexProvider searchIndexProvider = + new NetworkProviderSettings.SearchIndexProvider(XML_RES, mWifiRestriction); + + final List keys = searchIndexProvider.getNonIndexableKeys(mContext); + + assertThat(keys).doesNotContain(NetworkProviderSettings.PREF_KEY_WIFI_TOGGLE); + } + + @Test + public void getNonIndexableKeys_disallowedChangeWifiState_keyReturned() { + when(mWifiRestriction.isChangeWifiStateAllowed(mContext)).thenReturn(false); + NetworkProviderSettings.SearchIndexProvider searchIndexProvider = + new NetworkProviderSettings.SearchIndexProvider(XML_RES, mWifiRestriction); + + final List keys = searchIndexProvider.getNonIndexableKeys(mContext); + + assertThat(keys).contains(NetworkProviderSettings.PREF_KEY_WIFI_TOGGLE); + } + @Implements(PreferenceFragmentCompat.class) public static class ShadowPreferenceFragmentCompat { diff --git a/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java index b80bc11169b..bafc021d9b2 100644 --- a/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/TetherPreferenceControllerTest.java @@ -17,6 +17,7 @@ package com.android.settings.network; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; @@ -24,6 +25,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions; import static org.mockito.Mockito.verifyZeroInteractions; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothPan; import android.bluetooth.BluetoothProfile; @@ -67,7 +69,9 @@ public class TetherPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); - mController = spy(TetherPreferenceController.class); + doReturn(null).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); + mController = spy(new TetherPreferenceController(mContext, /* lifecycle= */ null)); ReflectionHelpers.setField(mController, "mContext", mContext); ReflectionHelpers.setField(mController, "mTetheringManager", mTetheringManager); ReflectionHelpers.setField(mController, "mBluetoothAdapter", mBluetoothAdapter); diff --git a/tests/robotests/src/com/android/settings/notification/BadgingNotificationPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/BadgingNotificationPreferenceControllerTest.java index 89cf2f719ba..e2226d92d75 100644 --- a/tests/robotests/src/com/android/settings/notification/BadgingNotificationPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/BadgingNotificationPreferenceControllerTest.java @@ -23,10 +23,12 @@ import static com.android.settings.notification.BadgingNotificationPreferenceCon import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.provider.Settings; @@ -59,6 +61,8 @@ public class BadgingNotificationPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new BadgingNotificationPreferenceController(mContext, KEY_NOTIFICATION_BADGING); mPreference = new Preference(RuntimeEnvironment.application); diff --git a/tests/robotests/src/com/android/settings/notification/BootSoundPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/BootSoundPreferenceControllerTest.java index 9a2ab9be765..76a64d37a10 100644 --- a/tests/robotests/src/com/android/settings/notification/BootSoundPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/BootSoundPreferenceControllerTest.java @@ -18,9 +18,12 @@ package com.android.settings.notification; import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.os.SystemProperties; @@ -52,6 +55,8 @@ public class BootSoundPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mContext.getResources().getBoolean(R.bool.has_boot_sounds)) .thenReturn(true); mController = new BootSoundPreferenceController(mContext); diff --git a/tests/robotests/src/com/android/settings/notification/DockAudioMediaPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/DockAudioMediaPreferenceControllerTest.java index db502144493..d237b271f57 100644 --- a/tests/robotests/src/com/android/settings/notification/DockAudioMediaPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/DockAudioMediaPreferenceControllerTest.java @@ -21,8 +21,10 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.provider.Settings.Global; @@ -59,6 +61,8 @@ public class DockAudioMediaPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mSetting.getActivity()).thenReturn(mActivity); when(mActivity.getContentResolver()).thenReturn(mContentResolver); when(mActivity.getResources().getBoolean(com.android.settings.R.bool.has_dock_settings)) diff --git a/tests/robotests/src/com/android/settings/notification/DockingSoundPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/DockingSoundPreferenceControllerTest.java index b6942684351..0cfc6b704c9 100644 --- a/tests/robotests/src/com/android/settings/notification/DockingSoundPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/DockingSoundPreferenceControllerTest.java @@ -20,8 +20,10 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Answers.RETURNS_DEEP_STUBS; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.provider.Settings.Global; @@ -58,6 +60,8 @@ public class DockingSoundPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mSetting.getActivity()).thenReturn(mActivity); when(mActivity.getContentResolver()).thenReturn(mContentResolver); mPreference = new SwitchPreference(RuntimeEnvironment.application); diff --git a/tests/robotests/src/com/android/settings/notification/EmergencyBroadcastPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/EmergencyBroadcastPreferenceControllerTest.java index 822ca5f5533..ec9bfc558bd 100644 --- a/tests/robotests/src/com/android/settings/notification/EmergencyBroadcastPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/EmergencyBroadcastPreferenceControllerTest.java @@ -20,10 +20,13 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.content.pm.PackageManager; import android.os.UserManager; @@ -60,6 +63,8 @@ public class EmergencyBroadcastPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager); when(mContext.getPackageManager()).thenReturn(mPackageManager); mController = diff --git a/tests/robotests/src/com/android/settings/notification/SnoozeNotificationPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/notification/SnoozeNotificationPreferenceControllerTest.java index 6779ff1edb5..1426cccaa1a 100644 --- a/tests/robotests/src/com/android/settings/notification/SnoozeNotificationPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/notification/SnoozeNotificationPreferenceControllerTest.java @@ -16,7 +16,6 @@ package com.android.settings.notification; -import static android.provider.Settings.Secure.NOTIFICATION_BADGING; import static android.provider.Settings.Secure.SHOW_NOTIFICATION_SNOOZE; import static com.android.settings.notification.BadgingNotificationPreferenceController.OFF; @@ -24,13 +23,17 @@ import static com.android.settings.notification.BadgingNotificationPreferenceCon import static com.google.common.truth.Truth.assertThat; +import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.provider.Settings; +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -40,10 +43,6 @@ import org.mockito.MockitoAnnotations; import org.robolectric.RobolectricTestRunner; import org.robolectric.RuntimeEnvironment; -import androidx.preference.Preference; -import androidx.preference.PreferenceScreen; -import androidx.preference.TwoStatePreference; - @RunWith(RobolectricTestRunner.class) public class SnoozeNotificationPreferenceControllerTest { @@ -58,6 +57,8 @@ public class SnoozeNotificationPreferenceControllerTest { @Before public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); mController = new SnoozeNotificationPreferenceController(mContext, "key"); mPreference = new Preference(RuntimeEnvironment.application); diff --git a/tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java b/tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java index 5b7a7d6c33f..8e42fcd225a 100644 --- a/tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java +++ b/tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java @@ -25,7 +25,6 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.spy; import static org.mockito.Mockito.when; import android.content.ContentResolver; @@ -37,9 +36,13 @@ import android.net.wifi.WifiManager; import androidx.slice.Slice; import androidx.slice.SliceItem; +import androidx.slice.SliceMetadata; import androidx.slice.SliceProvider; +import androidx.slice.core.SliceAction; import androidx.slice.core.SliceQuery; +import androidx.slice.widget.ListContent; import androidx.slice.widget.SliceLiveData; +import androidx.test.core.app.ApplicationProvider; import com.android.settings.R; import com.android.settings.slices.SliceBackgroundWorker; @@ -49,12 +52,14 @@ import com.android.wifitrackerlib.WifiEntry; import com.android.wifitrackerlib.WifiEntry.ConnectedState; import org.junit.Before; +import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.MockitoAnnotations; +import org.mockito.Spy; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; import org.robolectric.RobolectricTestRunner; -import org.robolectric.RuntimeEnvironment; import org.robolectric.annotation.Config; import org.robolectric.annotation.Implementation; import org.robolectric.annotation.Implements; @@ -74,26 +79,29 @@ public class WifiSliceTest { private static final String AP3_NAME = "ap3"; private static final int USER_ID = 1; + @Rule + public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + @Spy + Context mContext = ApplicationProvider.getApplicationContext(); @Mock private WifiManager mWifiManager; @Mock private PackageManager mPackageManager; - - - private Context mContext; + @Mock private ContentResolver mResolver; + @Mock + private WifiSlice.WifiRestriction mWifiRestriction; + private WifiSlice mWifiSlice; private String mSIPackageName; @Before public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = spy(RuntimeEnvironment.application); - mResolver = mock(ContentResolver.class); doReturn(mResolver).when(mContext).getContentResolver(); doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class); doReturn(WifiManager.WIFI_STATE_ENABLED).when(mWifiManager).getWifiState(); when(mContext.getPackageManager()).thenReturn(mPackageManager); + when(mWifiRestriction.isChangeWifiStateAllowed(mContext)).thenReturn(true); // Set-up specs for SliceMetadata. SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS); @@ -102,7 +110,7 @@ public class WifiSliceTest { ShadowBinder.setCallingUid(USER_ID); when(mPackageManager.getPackagesForUid(USER_ID)).thenReturn(new String[]{mSIPackageName}); ShadowWifiSlice.setWifiPermissible(true); - mWifiSlice = new WifiSlice(mContext); + mWifiSlice = new WifiSlice(mContext, mWifiRestriction); } @Test @@ -113,6 +121,11 @@ public class WifiSliceTest { final Slice wifiSlice = mWifiSlice.getSlice(); assertThat(wifiSlice).isNotNull(); + + final SliceMetadata metadata = SliceMetadata.from(mContext, wifiSlice); + final List toggles = metadata.getToggles(); + + assertThat(toggles).hasSize(1); } @Test @@ -121,18 +134,29 @@ public class WifiSliceTest { ShadowWifiSlice.setWifiPermissible(true); final Slice wifiSlice = mWifiSlice.getSlice(); - assertThat(wifiSlice).isNotNull(); + + final SliceMetadata metadata = SliceMetadata.from(mContext, wifiSlice); + final List toggles = metadata.getToggles(); + + assertThat(toggles).hasSize(1); } @Test - public void getWifiSlice_notFromSIPackageAndWithoutWifiPermission_shouldNoSlice() { + public void getWifiSlice_notFromSIPackageAndWithoutWifiPermission_shouldReturnNoToggle() { when(mPackageManager.getPackagesForUid(USER_ID)).thenReturn(new String[]{"com.test"}); ShadowWifiSlice.setWifiPermissible(false); final Slice wifiSlice = mWifiSlice.getSlice(); + final SliceMetadata metadata = SliceMetadata.from(mContext, wifiSlice); + final List toggles = metadata.getToggles(); - assertThat(wifiSlice).isNull(); + assertThat(toggles).hasSize(0); + + final int rows = SliceQuery.findAll(wifiSlice, FORMAT_SLICE, HINT_LIST_ITEM, + null /* nonHints */).size(); + // Title row + assertThat(rows).isEqualTo(1); } @Test @@ -143,7 +167,6 @@ public class WifiSliceTest { final int rows = SliceQuery.findAll(wifiSlice, FORMAT_SLICE, HINT_LIST_ITEM, null /* nonHints */).size(); - // Title row assertThat(rows).isEqualTo(1); } @@ -241,6 +264,30 @@ public class WifiSliceTest { mContext.getString(R.string.wifi_empty_list_wifi_on)); } + @Test + public void getWifiSlice_disallowedChangeWifiState_addSubtitleAndNoToggle() { + when(mWifiRestriction.isChangeWifiStateAllowed(mContext)).thenReturn(false); + + final Slice slice = mWifiSlice.getSlice(); + + final ListContent listContent = SliceMetadata.from(mContext, slice).getListContent(); + assertThat(slice).isNotNull(); + assertThat(listContent.getHeader().getSubtitleItem()).isNotNull(); + assertThat(listContent.getSliceActions()).isNull(); + } + + @Test + public void getWifiSlice_allowedChangeWifiState_noSubtitleAndAddToggle() { + when(mWifiRestriction.isChangeWifiStateAllowed(mContext)).thenReturn(true); + + final Slice slice = mWifiSlice.getSlice(); + + final ListContent listContent = SliceMetadata.from(mContext, slice).getListContent(); + assertThat(slice).isNotNull(); + assertThat(listContent.getHeader().getSubtitleItem()).isNull(); + assertThat(listContent.getSliceActions()).isNotNull(); + } + @Test public void handleUriChange_updatesWifi() { final Intent intent = mWifiSlice.getIntent(); diff --git a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherFooterPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherFooterPreferenceControllerTest.java index c1d6c16a687..432c7e2c6c9 100644 --- a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherFooterPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherFooterPreferenceControllerTest.java @@ -18,10 +18,12 @@ package com.android.settings.wifi.tether; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.content.Context; import android.net.TetheringManager; import android.net.wifi.WifiManager; @@ -58,6 +60,8 @@ public class WifiTetherFooterPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class); doReturn(mTetheringManager).when(mContext).getSystemService(TetheringManager.class); when(mContext.getSystemService(Context.TETHERING_SERVICE)).thenReturn(mTetheringManager); diff --git a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherPasswordPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherPasswordPreferenceControllerTest.java index bb61eb9dc2c..081a078b42b 100644 --- a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherPasswordPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherPasswordPreferenceControllerTest.java @@ -20,11 +20,13 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.app.settings.SettingsEnums; import android.content.Context; import android.net.TetheringManager; @@ -76,6 +78,8 @@ public class WifiTetherPasswordPreferenceControllerTest { .setPassphrase(INITIAL_PASSWORD, SoftApConfiguration.SECURITY_TYPE_WPA2_PSK) .build(); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class); when(mWifiManager.getSoftApConfiguration()).thenReturn(mConfig); doReturn(mTetheringManager).when(mContext).getSystemService(TetheringManager.class); diff --git a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSSIDPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSSIDPreferenceControllerTest.java index 2d887227ace..07d57623745 100644 --- a/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSSIDPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/wifi/tether/WifiTetherSSIDPreferenceControllerTest.java @@ -20,11 +20,13 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.mock; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import android.app.admin.DevicePolicyManager; import android.app.settings.SettingsEnums; import android.content.Context; import android.net.TetheringManager; @@ -68,6 +70,8 @@ public class WifiTetherSSIDPreferenceControllerTest { MockitoAnnotations.initMocks(this); mPreference = new WifiTetherSsidPreference(RuntimeEnvironment.application); + doReturn(mock(DevicePolicyManager.class)).when(mContext) + .getSystemService(Context.DEVICE_POLICY_SERVICE); doReturn(mWifiManager).when(mContext).getSystemService(WifiManager.class); doReturn(mTetheringManager).when(mContext).getSystemService(TetheringManager.class); when(mTetheringManager.getTetherableWifiRegexs()).thenReturn(new String[]{"1", "2"});