From f2e91f826be358008d5b9a16d9cd651a90a4079a Mon Sep 17 00:00:00 2001 From: Bonian Chen Date: Fri, 14 Jan 2022 05:50:33 +0000 Subject: [PATCH 1/6] [Settings] SIM colors are referenced by getIntArray() within source code SIM colors are referenced by getIntArray() within source code Bug: 211956916 Test: build pass Change-Id: Idefac365e750e454a2c3c98b2b4f17acbe143820 --- res/values/arrays.xml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/res/values/arrays.xml b/res/values/arrays.xml index 0fe13feb3e6..9f0af97fa5c 100644 --- a/res/values/arrays.xml +++ b/res/values/arrays.xml @@ -1180,14 +1180,14 @@ - + @color/SIM_color_cyan @color/SIM_color_blue800 @color/SIM_color_green800 @color/SIM_color_purple800 @color/SIM_color_pink800 @color/SIM_color_orange - + From 3fe40484bae787a6938cdfb75a3112101381ad9c Mon Sep 17 00:00:00 2001 From: Bonian Chen Date: Fri, 14 Jan 2022 08:09:16 +0000 Subject: [PATCH 2/6] [Settings] Adjust code for performance Reorder code flow to reduce redundent work. Bug: 213836977 Change-Id: Ifd57d1f6a007d6a1c9bcae597e6e9674ce54d8bc Test: Junit VpnPreferenceControllerTest --- .../network/VpnPreferenceController.java | 43 +++++++++---------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/src/com/android/settings/network/VpnPreferenceController.java b/src/com/android/settings/network/VpnPreferenceController.java index 0df6582ff55..d745ff577ad 100644 --- a/src/com/android/settings/network/VpnPreferenceController.java +++ b/src/com/android/settings/network/VpnPreferenceController.java @@ -65,15 +65,11 @@ public class VpnPreferenceController extends AbstractPreferenceController .build(); private static final String TAG = "VpnPreferenceController"; - private final UserManager mUserManager; private ConnectivityManager mConnectivityManager; - private final VpnManager mVpnManager; private Preference mPreference; public VpnPreferenceController(Context context) { super(context); - mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE); - mVpnManager = context.getSystemService(VpnManager.class); } @Override @@ -131,18 +127,20 @@ public class VpnPreferenceController extends AbstractPreferenceController if (mPreference == null) { return; } + UserManager userManager = mContext.getSystemService(UserManager.class); + VpnManager vpnManager = mContext.getSystemService(VpnManager.class); // Copied from SystemUI::SecurityControllerImpl SparseArray vpns = new SparseArray<>(); - final List users = mUserManager.getUsers(); + final List users = userManager.getUsers(); int connectedLegacyVpnCount = 0; for (UserInfo user : users) { - VpnConfig cfg = mVpnManager.getVpnConfig(user.id); + VpnConfig cfg = vpnManager.getVpnConfig(user.id); if (cfg == null) { continue; } else if (cfg.legacy) { // Legacy VPNs should do nothing if the network is disconnected. Third-party // VPN warnings need to continue as traffic can still go to the app. - final LegacyVpnInfo legacyVpn = mVpnManager.getLegacyVpnInfo(user.id); + final LegacyVpnInfo legacyVpn = vpnManager.getLegacyVpnInfo(user.id); if (legacyVpn == null || legacyVpn.state != LegacyVpnInfo.STATE_CONNECTED) { continue; } else { @@ -152,22 +150,23 @@ public class VpnPreferenceController extends AbstractPreferenceController vpns.put(user.id, cfg); } int numberOfNonLegacyVpn = vpns.size() - connectedLegacyVpnCount; - final UserInfo userInfo = mUserManager.getUserInfo(UserHandle.myUserId()); - final int uid; - if (userInfo.isRestricted()) { - uid = userInfo.restrictedProfileParentId; - } else { - uid = userInfo.id; + String summary = getInsecureVpnSummaryOverride(numberOfNonLegacyVpn); + if (summary == null) { + final UserInfo userInfo = userManager.getUserInfo(UserHandle.myUserId()); + final int uid; + if (userInfo.isRestricted()) { + uid = userInfo.restrictedProfileParentId; + } else { + uid = userInfo.id; + } + VpnConfig vpn = vpns.get(uid); + if (vpn == null) { + summary = mContext.getString(R.string.vpn_disconnected_summary); + } else { + summary = getNameForVpnConfig(vpn, UserHandle.of(uid)); + } } - VpnConfig vpn = vpns.get(uid); - String summary; - if (vpn == null) { - summary = mContext.getString(R.string.vpn_disconnected_summary); - } else { - summary = getNameForVpnConfig(vpn, UserHandle.of(uid)); - } - String summaryOverride = getInsecureVpnSummaryOverride(numberOfNonLegacyVpn); - final String finalSummary = (summaryOverride != null) ? summaryOverride : summary; + final String finalSummary = summary; ThreadUtils.postOnMainThread(() -> mPreference.setSummary(finalSummary)); } From b3ebad4e1c8a510a04a512c687c02a712c0bad5f Mon Sep 17 00:00:00 2001 From: Bonian Chen Date: Fri, 14 Jan 2022 12:42:54 +0000 Subject: [PATCH 3/6] [Settings] Rollback the text break hyphen strategy Text in usage side label was set to normal when making a design. However, the default configuration got changed since Android Q which applied to all TextView. Therefore, add it back to maintain original behaviour. Bug: 185129745 Change-Id: I351f8e08cc9ba6e0d301e510ee10b6be890b0059 Test: build pass --- res/layout/usage_side_label.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/res/layout/usage_side_label.xml b/res/layout/usage_side_label.xml index 6c168806338..bfb3ab849da 100644 --- a/res/layout/usage_side_label.xml +++ b/res/layout/usage_side_label.xml @@ -17,4 +17,5 @@ xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="wrap_content" android:layout_height="wrap_content" + android:hyphenationFrequency="normal" android:textAppearance="?android:attr/textAppearanceSmall" /> From 7822750c316d96cdb74ca9a4aefbc5cce719a368 Mon Sep 17 00:00:00 2001 From: Weng Su Date: Tue, 11 Jan 2022 06:44:40 +0800 Subject: [PATCH 4/6] Enable Carrier-Config cache for Settings - Since the "Mobile-Data Details Settings" (NETWORK_OPERATOR_SETTINGS) will query Carrier-Config around 70 times during launching, use the Carrier-Config cache to reduce 69 times to speed up the launching time. - It takes about 3ms to query a Carrier-Config each time. - Create a singleton class to share the Carrier-Config for all sub-settings. Bug: 204135235 Test: manual test atest -c ApnPreferenceControllerTest \ AutoSelectPreferenceControllerTest \ BackupCallingPreferenceControllerTest \ CarrierConfigCacheTest \ CarrierPreferenceControllerTest \ CarrierSettingsVersionPreferenceControllerTest \ DataServiceSetupPreferenceControllerTest \ Enable2gPreferenceControllerTest \ EnabledNetworkModePreferenceControllerTest \ Enhanced4gBasePreferenceControllerTest \ MobileNetworkUtilsTest \ NetworkProviderBackupCallingGroupTest \ NrAdvancedCallingPreferenceControllerTest \ PreferredNetworkModePreferenceControllerTest \ TelephonyTogglePreferenceControllerTest \ WifiPickerTrackerHelperTest make RunSettingsRoboTests \ ROBOTEST_FILTER=ContactDiscoveryPreferenceControllerTest make RunSettingsRoboTests \ ROBOTEST_FILTER=VideoCallingPreferenceControllerTest Change-Id: I26f9ac115a754910b5d59e820703f1a0e701bb7f --- .../settings/network/CarrierConfigCache.java | 182 ++++++++++++++++++ .../telephony/ApnPreferenceController.java | 7 +- .../CarrierPreferenceController.java | 10 +- ...erSettingsVersionPreferenceController.java | 7 +- .../ContactDiscoveryPreferenceController.java | 7 +- .../DataServiceSetupPreferenceController.java | 8 +- .../Enable2gPreferenceController.java | 9 +- ...nabledNetworkModePreferenceController.java | 15 +- .../network/telephony/MobileNetworkUtils.java | 28 ++- ...ferredNetworkModePreferenceController.java | 10 +- .../TelephonyTogglePreferenceController.java | 6 +- .../VideoCallingPreferenceController.java | 16 +- .../gsm/AutoSelectPreferenceController.java | 5 +- .../wifi/WifiPickerTrackerHelper.java | 7 +- ...tactDiscoveryPreferenceControllerTest.java | 7 +- .../VideoCallingPreferenceControllerTest.java | 8 +- .../network/CarrierConfigCacheTest.java | 101 ++++++++++ ...edNetworkModePreferenceControllerTest.java | 10 +- .../ApnPreferenceControllerTest.java | 17 +- .../CarrierPreferenceControllerTest.java | 19 +- ...ttingsVersionPreferenceControllerTest.java | 14 +- ...aServiceSetupPreferenceControllerTest.java | 7 +- .../Enable2gPreferenceControllerTest.java | 13 +- ...nhanced4gBasePreferenceControllerTest.java | 8 +- .../telephony/MobileNetworkUtilsTest.java | 11 +- ...NetworkProviderBackupCallingGroupTest.java | 13 +- ...vancedCallingPreferenceControllerTest.java | 8 +- ...edNetworkModePreferenceControllerTest.java | 8 +- .../AutoSelectPreferenceControllerTest.java | 10 +- .../wifi/WifiPickerTrackerHelperTest.java | 10 +- 30 files changed, 430 insertions(+), 151 deletions(-) create mode 100644 src/com/android/settings/network/CarrierConfigCache.java create mode 100644 tests/unit/src/com/android/settings/network/CarrierConfigCacheTest.java diff --git a/src/com/android/settings/network/CarrierConfigCache.java b/src/com/android/settings/network/CarrierConfigCache.java new file mode 100644 index 00000000000..2b4637c2d43 --- /dev/null +++ b/src/com/android/settings/network/CarrierConfigCache.java @@ -0,0 +1,182 @@ +/* + * 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.network; + +import static android.telephony.CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED; +import static android.telephony.SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX; +import static android.telephony.SubscriptionManager.INVALID_SUBSCRIPTION_ID; + +import android.annotation.NonNull; +import android.annotation.TestApi; +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.util.Log; + +import androidx.annotation.GuardedBy; +import androidx.annotation.VisibleForTesting; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +/** + * This is a singleton class for Carrier-Configuration cache. + */ +public class CarrierConfigCache { + private static final String TAG = "CarrConfCache"; + + private static final Object sInstanceLock = new Object(); + /** + * A singleton {@link CarrierConfigCache} object is used to share with all sub-settings. + */ + @GuardedBy("sInstanceLock") + private static CarrierConfigCache sInstance; + @TestApi + @GuardedBy("sInstanceLock") + private static Map sTestInstances; + + /** + * Manages mapping data from the subscription ID to the Carrier-Configuration + * {@link PersistableBundle} object. + * + * The Carrier-Configurations are used to share with all sub-settings. + */ + @VisibleForTesting + protected static final Map sCarrierConfigs = + new ConcurrentHashMap<>(); + @VisibleForTesting + protected static CarrierConfigManager sCarrierConfigManager; + + /** + * Static method to create a singleton class for Carrier-Configuration cache. + * + * @param context The Context this is associated with. + * @return an instance of {@link CarrierConfigCache} object. + */ + @NonNull + public static CarrierConfigCache getInstance(@NonNull Context context) { + synchronized (sInstanceLock) { + if (sTestInstances != null && sTestInstances.containsKey(context)) { + CarrierConfigCache testInstance = sTestInstances.get(context); + Log.w(TAG, "The context owner try to use a test instance:" + testInstance); + return testInstance; + } + + if (sInstance != null) return sInstance; + + sInstance = new CarrierConfigCache(); + final CarrierConfigChangeReceiver receiver = new CarrierConfigChangeReceiver(); + final Context appContext = context.getApplicationContext(); + sCarrierConfigManager = appContext.getSystemService(CarrierConfigManager.class); + appContext.registerReceiver(receiver, new IntentFilter(ACTION_CARRIER_CONFIG_CHANGED)); + return sInstance; + } + } + + /** + * A convenience method to set pre-prepared instance or mock(CarrierConfigCache.class) for + * testing. + * + * @param context The Context this is associated with. + * @param instance of {@link CarrierConfigCache} object. + * @hide + */ + @TestApi + @VisibleForTesting + public static void setTestInstance(@NonNull Context context, CarrierConfigCache instance) { + synchronized (sInstanceLock) { + if (sTestInstances == null) sTestInstances = new ConcurrentHashMap<>(); + + Log.w(TAG, "Try to set a test instance by context:" + context); + sTestInstances.put(context, instance); + } + } + + /** + * The constructor can only be accessed from static method inside the class itself, this is + * to avoid creating a class by adding a private constructor. + */ + private CarrierConfigCache() { + // Do nothing. + } + + /** + * Returns the boolean If the system service is successfully obtained. + * + * @return true value, if the system service is successfully obtained. + */ + public boolean hasCarrierConfigManager() { + return (sCarrierConfigManager != null); + } + + /** + * Gets the Carrier-Configuration for a particular subscription, which is associated with a + * specific SIM card. If an invalid subId is used, the returned config will contain default + * values. + * + * @param subId the subscription ID, normally obtained from {@link SubscriptionManager}. + * @return A {@link PersistableBundle} containing the config for the given subId, or default + * values for an invalid subId. + */ + public PersistableBundle getConfigForSubId(int subId) { + if (sCarrierConfigManager == null) return null; + + synchronized (sCarrierConfigs) { + if (sCarrierConfigs.containsKey(subId)) { + return sCarrierConfigs.get(subId); + } + final PersistableBundle config = sCarrierConfigManager.getConfigForSubId(subId); + if (config == null) { + Log.e(TAG, "Could not get carrier config, subId:" + subId); + return null; + } + sCarrierConfigs.put(subId, config); + return config; + } + } + + /** + * Gets the Carrier-Configuration for the default subscription. + * + * @see #getConfigForSubId + */ + public PersistableBundle getConfig() { + if (sCarrierConfigManager == null) return null; + + return getConfigForSubId(SubscriptionManager.getDefaultSubscriptionId()); + } + + private static class CarrierConfigChangeReceiver extends BroadcastReceiver { + @Override + public void onReceive(Context context, Intent intent) { + if (!ACTION_CARRIER_CONFIG_CHANGED.equals(intent.getAction())) return; + + final int subId = intent.getIntExtra(EXTRA_SUBSCRIPTION_INDEX, INVALID_SUBSCRIPTION_ID); + synchronized (sCarrierConfigs) { + if (SubscriptionManager.isValidSubscriptionId(subId)) { + sCarrierConfigs.remove(subId); + } else { + sCarrierConfigs.clear(); + } + } + } + } +} diff --git a/src/com/android/settings/network/telephony/ApnPreferenceController.java b/src/com/android/settings/network/telephony/ApnPreferenceController.java index 0e0e5d17895..c4732ecdfd7 100644 --- a/src/com/android/settings/network/telephony/ApnPreferenceController.java +++ b/src/com/android/settings/network/telephony/ApnPreferenceController.java @@ -32,6 +32,7 @@ import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import com.android.settings.SettingsActivity; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.apn.ApnSettings; import com.android.settingslib.RestrictedLockUtilsInternal; import com.android.settingslib.RestrictedPreference; @@ -46,19 +47,19 @@ public class ApnPreferenceController extends TelephonyBasePreferenceController i LifecycleObserver, OnStart, OnStop { @VisibleForTesting - CarrierConfigManager mCarrierConfigManager; + CarrierConfigCache mCarrierConfigCache; private Preference mPreference; private DpcApnEnforcedObserver mDpcApnEnforcedObserver; public ApnPreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); mDpcApnEnforcedObserver = new DpcApnEnforcedObserver(new Handler(Looper.getMainLooper())); } @Override public int getAvailabilityStatus(int subId) { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); final boolean isCdmaApn = MobileNetworkUtils.isCdmaOptions(mContext, subId) && carrierConfig != null && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_APN_SETTING_CDMA_BOOL); diff --git a/src/com/android/settings/network/telephony/CarrierPreferenceController.java b/src/com/android/settings/network/telephony/CarrierPreferenceController.java index e0e21d4164b..4a082f7afb5 100644 --- a/src/com/android/settings/network/telephony/CarrierPreferenceController.java +++ b/src/com/android/settings/network/telephony/CarrierPreferenceController.java @@ -28,17 +28,19 @@ import android.telephony.SubscriptionManager; import androidx.annotation.VisibleForTesting; import androidx.preference.Preference; +import com.android.settings.network.CarrierConfigCache; + /** * Preference controller for "Carrier Settings" */ public class CarrierPreferenceController extends TelephonyBasePreferenceController { @VisibleForTesting - CarrierConfigManager mCarrierConfigManager; + CarrierConfigCache mCarrierConfigCache; public CarrierPreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); } public void init(int subId) { @@ -47,7 +49,7 @@ public class CarrierPreferenceController extends TelephonyBasePreferenceControll @Override public int getAvailabilityStatus(int subId) { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); // Return available if it is in CDMA or GSM mode, and the flag is on return carrierConfig != null @@ -72,7 +74,7 @@ public class CarrierPreferenceController extends TelephonyBasePreferenceControll } private Intent getCarrierSettingsActivityIntent(int subId) { - final PersistableBundle config = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle config = mCarrierConfigCache.getConfigForSubId(subId); final ComponentName cn = ComponentName.unflattenFromString( config == null ? "" : config.getString( CarrierConfigManager.KEY_CARRIER_SETTINGS_ACTIVITY_COMPONENT_NAME_STRING, diff --git a/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceController.java b/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceController.java index aec3648463e..575d19ce35b 100644 --- a/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceController.java +++ b/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceController.java @@ -23,15 +23,16 @@ import android.telephony.SubscriptionManager; import android.text.TextUtils; import com.android.settings.core.BasePreferenceController; +import com.android.settings.network.CarrierConfigCache; public class CarrierSettingsVersionPreferenceController extends BasePreferenceController { private int mSubscriptionId; - private CarrierConfigManager mManager; + private CarrierConfigCache mCarrierConfigCache; public CarrierSettingsVersionPreferenceController(Context context, String preferenceKey) { super(context, preferenceKey); - mManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); mSubscriptionId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; } @@ -41,7 +42,7 @@ public class CarrierSettingsVersionPreferenceController extends BasePreferenceCo @Override public CharSequence getSummary() { - final PersistableBundle config = mManager.getConfigForSubId(mSubscriptionId); + final PersistableBundle config = mCarrierConfigCache.getConfigForSubId(mSubscriptionId); if (config == null) { return null; } diff --git a/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceController.java b/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceController.java index a2a20bbc5e7..a4ae51bf93d 100644 --- a/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceController.java +++ b/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceController.java @@ -35,6 +35,7 @@ import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.SubscriptionUtil; /** @@ -47,7 +48,7 @@ public class ContactDiscoveryPreferenceController extends TelephonyTogglePrefere Telephony.SimInfo.COLUMN_IMS_RCS_UCE_ENABLED); private ImsManager mImsManager; - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private ContentObserver mUceSettingObserver; private FragmentManager mFragmentManager; @@ -57,7 +58,7 @@ public class ContactDiscoveryPreferenceController extends TelephonyTogglePrefere public ContactDiscoveryPreferenceController(Context context, String key) { super(context, key); mImsManager = mContext.getSystemService(ImsManager.class); - mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); } public ContactDiscoveryPreferenceController init(FragmentManager fragmentManager, int subId, @@ -96,7 +97,7 @@ public class ContactDiscoveryPreferenceController extends TelephonyTogglePrefere @Override public int getAvailabilityStatus(int subId) { - PersistableBundle bundle = mCarrierConfigManager.getConfigForSubId(subId); + PersistableBundle bundle = mCarrierConfigCache.getConfigForSubId(subId); boolean shouldShowPresence = bundle != null && (bundle.getBoolean( CarrierConfigManager.KEY_USE_RCS_PRESENCE_BOOL, false /*default*/) diff --git a/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java b/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java index c200d5e0dda..3ca435fafb5 100644 --- a/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java +++ b/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java @@ -28,18 +28,20 @@ import android.text.TextUtils; import androidx.preference.Preference; +import com.android.settings.network.CarrierConfigCache; + /** * Preference controller for "Data service setup" */ public class DataServiceSetupPreferenceController extends TelephonyBasePreferenceController { - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private TelephonyManager mTelephonyManager; private String mSetupUrl; public DataServiceSetupPreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); mTelephonyManager = context.getSystemService(TelephonyManager.class); mSetupUrl = Settings.Global.getString(mContext.getContentResolver(), Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); @@ -47,7 +49,7 @@ public class DataServiceSetupPreferenceController extends TelephonyBasePreferenc @Override public int getAvailabilityStatus(int subId) { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); return subId != SubscriptionManager.INVALID_SUBSCRIPTION_ID && carrierConfig != null && !carrierConfig.getBoolean( diff --git a/src/com/android/settings/network/telephony/Enable2gPreferenceController.java b/src/com/android/settings/network/telephony/Enable2gPreferenceController.java index a394133bb94..de92ec7e880 100644 --- a/src/com/android/settings/network/telephony/Enable2gPreferenceController.java +++ b/src/com/android/settings/network/telephony/Enable2gPreferenceController.java @@ -27,6 +27,7 @@ import android.util.Log; import androidx.preference.Preference; import com.android.settings.R; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.SubscriptionUtil; import com.android.settings.overlay.FeatureFactory; import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; @@ -45,7 +46,7 @@ public class Enable2gPreferenceController extends TelephonyTogglePreferenceContr private final MetricsFeatureProvider mMetricsFeatureProvider; - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private SubscriptionManager mSubscriptionManager; private TelephonyManager mTelephonyManager; @@ -57,7 +58,7 @@ public class Enable2gPreferenceController extends TelephonyTogglePreferenceContr */ public Enable2gPreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); mMetricsFeatureProvider = FeatureFactory.getFactory(context).getMetricsFeatureProvider(); mSubscriptionManager = context.getSystemService(SubscriptionManager.class); } @@ -81,7 +82,7 @@ public class Enable2gPreferenceController extends TelephonyTogglePreferenceContr if (preference == null || !SubscriptionManager.isUsableSubscriptionId(mSubId)) { return; } - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(mSubId); boolean isDisabledByCarrier = carrierConfig != null && carrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G); @@ -107,7 +108,7 @@ public class Enable2gPreferenceController extends TelephonyTogglePreferenceContr @Override public int getAvailabilityStatus(int subId) { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); if (mTelephonyManager == null) { Log.w(LOG_TAG, "Telephony manager not yet initialized"); mTelephonyManager = mContext.getSystemService(TelephonyManager.class); diff --git a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java index aa58663556f..8e3f21a3a9d 100644 --- a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java +++ b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java @@ -37,6 +37,7 @@ import androidx.preference.PreferenceScreen; import com.android.settings.R; import com.android.settings.network.AllowedNetworkTypesListener; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.SubscriptionsChangeListener; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; @@ -58,7 +59,7 @@ public class EnabledNetworkModePreferenceController extends private Preference mPreference; private PreferenceScreen mPreferenceScreen; private TelephonyManager mTelephonyManager; - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private PreferenceEntriesBuilder mBuilder; private SubscriptionsChangeListener mSubscriptionsListener; private int mCallState = TelephonyManager.CALL_STATE_IDLE; @@ -67,7 +68,7 @@ public class EnabledNetworkModePreferenceController extends public EnabledNetworkModePreferenceController(Context context, String key) { super(context, key); mSubscriptionsListener = new SubscriptionsChangeListener(context, this); - mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); if (mTelephonyCallback == null) { mTelephonyCallback = new PhoneCallStateTelephonyCallback(); } @@ -80,7 +81,7 @@ public class EnabledNetworkModePreferenceController extends return AVAILABLE_UNSEARCHABLE; } - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { visible = false; } else if (carrierConfig == null) { @@ -202,7 +203,7 @@ public class EnabledNetworkModePreferenceController extends } private final class PreferenceEntriesBuilder { - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private Context mContext; private TelephonyManager mTelephonyManager; @@ -221,7 +222,7 @@ public class EnabledNetworkModePreferenceController extends PreferenceEntriesBuilder(Context context, int subId) { this.mContext = context; this.mSubId = subId; - mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); mTelephonyManager = mContext.getSystemService(TelephonyManager.class) .createForSubscriptionId(mSubId); updateConfig(); @@ -229,7 +230,7 @@ public class EnabledNetworkModePreferenceController extends public void updateConfig() { mTelephonyManager = mTelephonyManager.createForSubscriptionId(mSubId); - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(mSubId); mAllowed5gNetworkType = checkSupportedRadioBitmask( mTelephonyManager.getAllowedNetworkTypesForReason( TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER), @@ -413,7 +414,7 @@ public class EnabledNetworkModePreferenceController extends private EnabledNetworks getEnabledNetworkType() { EnabledNetworks enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_UNKNOWN; final int phoneType = mTelephonyManager.getPhoneType(); - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(mSubId); if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { final int lteForced = android.provider.Settings.Global.getInt( diff --git a/src/com/android/settings/network/telephony/MobileNetworkUtils.java b/src/com/android/settings/network/telephony/MobileNetworkUtils.java index df6033ebb99..839a98cdb32 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java +++ b/src/com/android/settings/network/telephony/MobileNetworkUtils.java @@ -75,6 +75,7 @@ import com.android.settings.R; import com.android.settings.Utils; import com.android.settings.core.BasePreferenceController; import com.android.settings.core.SubSettingLauncher; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.SubscriptionUtil; import com.android.settings.network.ims.WifiCallingQueryImsState; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; @@ -204,13 +205,12 @@ public class MobileNetworkUtils { * should be shown to the user, false if the option should be hidden. */ public static boolean isContactDiscoveryVisible(Context context, int subId) { - CarrierConfigManager carrierConfigManager = context.getSystemService( - CarrierConfigManager.class); - if (carrierConfigManager == null) { + CarrierConfigCache carrierConfigCache = CarrierConfigCache.getInstance(context); + if (!carrierConfigCache.hasCarrierConfigManager()) { Log.w(TAG, "isContactDiscoveryVisible: Could not resolve carrier config"); return false; } - PersistableBundle bundle = carrierConfigManager.getConfigForSubId(subId); + PersistableBundle bundle = carrierConfigCache.getConfigForSubId(subId); return bundle.getBoolean( CarrierConfigManager.KEY_USE_RCS_PRESENCE_BOOL, false /*default*/) || bundle.getBoolean(CarrierConfigManager.Ims.KEY_RCS_BULK_CAPABILITY_EXCHANGE_BOOL, @@ -358,9 +358,8 @@ public class MobileNetworkUtils { if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { return false; } - - final PersistableBundle carrierConfig = context.getSystemService( - CarrierConfigManager.class).getConfigForSubId(subId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(context).getConfigForSubId(subId); if (carrierConfig != null && !carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL) @@ -424,8 +423,8 @@ public class MobileNetworkUtils { } private static boolean isGsmBasicOptions(Context context, int subId) { - final PersistableBundle carrierConfig = context.getSystemService( - CarrierConfigManager.class).getConfigForSubId(subId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(context).getConfigForSubId(subId); if (carrierConfig != null && !carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL) @@ -447,8 +446,8 @@ public class MobileNetworkUtils { * settings */ public static boolean isWorldMode(Context context, int subId) { - final PersistableBundle carrierConfig = context.getSystemService( - CarrierConfigManager.class).getConfigForSubId(subId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(context).getConfigForSubId(subId); return carrierConfig == null ? false : carrierConfig.getBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL); @@ -460,8 +459,8 @@ public class MobileNetworkUtils { public static boolean shouldDisplayNetworkSelectOptions(Context context, int subId) { final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class) .createForSubscriptionId(subId); - final PersistableBundle carrierConfig = context.getSystemService( - CarrierConfigManager.class).getConfigForSubId(subId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(context).getConfigForSubId(subId); if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID || carrierConfig == null || !carrierConfig.getBoolean( @@ -502,8 +501,7 @@ public class MobileNetworkUtils { //TODO(b/117651939): move it to telephony private static boolean isTdscdmaSupported(Context context, TelephonyManager telephonyManager) { - final PersistableBundle carrierConfig = context.getSystemService( - CarrierConfigManager.class).getConfig(); + final PersistableBundle carrierConfig = CarrierConfigCache.getInstance(context).getConfig(); if (carrierConfig == null) { return false; diff --git a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java index 24197795fa2..feeed91910c 100644 --- a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java +++ b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java @@ -26,6 +26,7 @@ import androidx.preference.ListPreference; import androidx.preference.Preference; import com.android.settings.R; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; /** @@ -34,19 +35,18 @@ import com.android.settings.network.telephony.TelephonyConstants.TelephonyManage public class PreferredNetworkModePreferenceController extends TelephonyBasePreferenceController implements ListPreference.OnPreferenceChangeListener { - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private TelephonyManager mTelephonyManager; - private PersistableBundle mPersistableBundle; private boolean mIsGlobalCdma; public PreferredNetworkModePreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); } @Override public int getAvailabilityStatus(int subId) { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(subId); boolean visible; if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { visible = false; @@ -90,7 +90,7 @@ public class PreferredNetworkModePreferenceController extends TelephonyBasePrefe public void init(int subId) { mSubId = subId; - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = mCarrierConfigCache.getConfigForSubId(mSubId); mTelephonyManager = mContext.getSystemService(TelephonyManager.class) .createForSubscriptionId(mSubId); diff --git a/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java b/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java index e3609cb214b..08b09ed9a74 100644 --- a/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java +++ b/src/com/android/settings/network/telephony/TelephonyTogglePreferenceController.java @@ -19,10 +19,10 @@ package com.android.settings.network.telephony; import android.content.Context; import android.content.res.Resources; import android.os.PersistableBundle; -import android.telephony.CarrierConfigManager; import android.telephony.SubscriptionManager; import com.android.settings.core.TogglePreferenceController; +import com.android.settings.network.CarrierConfigCache; import java.util.concurrent.atomic.AtomicInteger; @@ -82,9 +82,7 @@ public abstract class TelephonyTogglePreferenceController extends TogglePreferen if (!SubscriptionManager.isValidSubscriptionId(subId)) { return null; } - final CarrierConfigManager carrierConfigMgr = - mContext.getSystemService(CarrierConfigManager.class); - return carrierConfigMgr.getConfigForSubId(subId); + return CarrierConfigCache.getInstance(mContext).getConfigForSubId(subId); } /** diff --git a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java index 46e13857890..698f6e1258b 100644 --- a/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java +++ b/src/com/android/settings/network/telephony/VideoCallingPreferenceController.java @@ -30,6 +30,7 @@ import androidx.preference.Preference; import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.MobileDataEnabledListener; import com.android.settings.network.ims.VolteQueryImsState; import com.android.settings.network.ims.VtQueryImsState; @@ -48,7 +49,6 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC private static final String TAG = "VideoCallingPreference"; private Preference mPreference; - private CarrierConfigManager mCarrierConfigManager; private PhoneTelephonyCallback mTelephonyCallback; @VisibleForTesting Integer mCallState; @@ -56,7 +56,6 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC public VideoCallingPreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); mDataContentObserver = new MobileDataEnabledListener(context, this); mTelephonyCallback = new PhoneTelephonyCallback(); } @@ -142,17 +141,8 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC return false; } - // When called within Settings Search, this variable may still be null. - if (mCarrierConfigManager == null) { - Log.e(TAG, "CarrierConfigManager set to null."); - mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); - if (mCarrierConfigManager == null) { - Log.e(TAG, "Unable to reinitialize CarrierConfigManager."); - return false; - } - } - - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(mContext).getConfigForSubId(subId); if (carrierConfig == null) { return false; } diff --git a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java index 028c4e77a78..58afeb00a9b 100644 --- a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java +++ b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java @@ -43,6 +43,7 @@ import androidx.preference.SwitchPreference; import com.android.settings.R; import com.android.settings.network.AllowedNetworkTypesListener; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.telephony.MobileNetworkUtils; import com.android.settings.network.telephony.TelephonyTogglePreferenceController; import com.android.settingslib.utils.ThreadUtils; @@ -191,8 +192,8 @@ public class AutoSelectPreferenceController extends TelephonyTogglePreferenceCon mSubId = subId; mTelephonyManager = mContext.getSystemService(TelephonyManager.class) .createForSubscriptionId(mSubId); - final PersistableBundle carrierConfig = mContext.getSystemService( - CarrierConfigManager.class).getConfigForSubId(mSubId); + final PersistableBundle carrierConfig = + CarrierConfigCache.getInstance(mContext).getConfigForSubId(mSubId); mOnlyAutoSelectInHome = carrierConfig != null ? carrierConfig.getBoolean( CarrierConfigManager.KEY_ONLY_AUTO_SELECT_IN_HOME_NETWORK_BOOL) diff --git a/src/com/android/settings/wifi/WifiPickerTrackerHelper.java b/src/com/android/settings/wifi/WifiPickerTrackerHelper.java index 03795c25971..d4a7da8f5fd 100644 --- a/src/com/android/settings/wifi/WifiPickerTrackerHelper.java +++ b/src/com/android/settings/wifi/WifiPickerTrackerHelper.java @@ -35,6 +35,7 @@ import androidx.lifecycle.LifecycleObserver; import androidx.lifecycle.OnLifecycleEvent; import com.android.internal.annotations.VisibleForTesting; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.overlay.FeatureFactory; import com.android.wifitrackerlib.MergedCarrierEntry; import com.android.wifitrackerlib.WifiEntry; @@ -64,7 +65,7 @@ public class WifiPickerTrackerHelper implements LifecycleObserver { protected HandlerThread mWorkerThread; protected final WifiManager mWifiManager; - protected final CarrierConfigManager mCarrierConfigManager; + protected final CarrierConfigCache mCarrierConfigCache; public WifiPickerTrackerHelper(@NonNull Lifecycle lifecycle, @NonNull Context context, @Nullable WifiPickerTracker.WifiPickerTrackerCallback listener) { @@ -88,7 +89,7 @@ public class WifiPickerTrackerHelper implements LifecycleObserver { listener); mWifiManager = context.getSystemService(WifiManager.class); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mCarrierConfigCache = CarrierConfigCache.getInstance(context); } /** @OnLifecycleEvent(ON_DESTROY) */ @@ -104,7 +105,7 @@ public class WifiPickerTrackerHelper implements LifecycleObserver { /** Return the enabled/disabled state of the carrier network provision */ public boolean isCarrierNetworkProvisionEnabled(int subId) { - final PersistableBundle config = mCarrierConfigManager.getConfigForSubId(subId); + final PersistableBundle config = mCarrierConfigCache.getConfigForSubId(subId); if (config == null) { Log.e(TAG, "Could not get carrier config, subId:" + subId); return false; diff --git a/tests/robotests/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceControllerTest.java index fd5ed37bf64..b3725fa6c18 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/ContactDiscoveryPreferenceControllerTest.java @@ -48,6 +48,7 @@ import androidx.fragment.app.FragmentTransaction; import androidx.lifecycle.LifecycleOwner; import androidx.preference.SwitchPreference; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.SubscriptionUtil; import com.android.settingslib.core.lifecycle.Lifecycle; @@ -72,7 +73,7 @@ public class ContactDiscoveryPreferenceControllerTest { @Mock private ImsManager mImsManager; @Mock private ImsRcsManager mImsRcsManager; @Mock private RcsUceAdapter mRcsUceAdapter; - @Mock private CarrierConfigManager mCarrierConfigManager; + @Mock private CarrierConfigCache mCarrierConfigCache; @Mock private ContentResolver mContentResolver; @Mock private FragmentManager mFragmentManager; @Mock private FragmentTransaction mFragmentTransaction; @@ -93,8 +94,8 @@ public class ContactDiscoveryPreferenceControllerTest { doReturn(mImsManager).when(mContext).getSystemService(ImsManager.class); doReturn(mImsRcsManager).when(mImsManager).getImsRcsManager(anyInt()); doReturn(mRcsUceAdapter).when(mImsRcsManager).getUceAdapter(); - doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(eq(TEST_SUB_ID)); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(eq(TEST_SUB_ID)); // Start all tests with presence being disabled. setRcsPresenceConfig(false); doReturn(mContentResolver).when(mContext).getContentResolver(); diff --git a/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java index 0aaf0d25069..668d7f37981 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java @@ -31,6 +31,7 @@ import android.telephony.ims.ProvisioningManager; import androidx.preference.PreferenceScreen; import androidx.preference.SwitchPreference; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.ims.MockVolteQueryImsState; import com.android.settings.network.ims.MockVtQueryImsState; @@ -51,7 +52,7 @@ public class VideoCallingPreferenceControllerTest { @Mock private ProvisioningManager mProvisioningManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private PreferenceScreen mPreferenceScreen; @@ -69,14 +70,13 @@ public class VideoCallingPreferenceControllerTest { mContext = spy(RuntimeEnvironment.application); doReturn(mTelephonyManager).when(mContext).getSystemService(TelephonyManager.class); - doReturn(mCarrierConfigManager).when(mContext) - .getSystemService(CarrierConfigManager.class); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); mCarrierConfig = new PersistableBundle(); mCarrierConfig.putBoolean( CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS, true); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mQueryImsState = new MockVtQueryImsState(mContext, SUB_ID); mQueryImsState.setIsEnabledByUser(true); diff --git a/tests/unit/src/com/android/settings/network/CarrierConfigCacheTest.java b/tests/unit/src/com/android/settings/network/CarrierConfigCacheTest.java new file mode 100644 index 00000000000..cc1758c43b3 --- /dev/null +++ b/tests/unit/src/com/android/settings/network/CarrierConfigCacheTest.java @@ -0,0 +1,101 @@ +/* + * 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.network; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.PersistableBundle; +import android.os.UserHandle; +import android.telephony.CarrierConfigManager; + +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.Before; +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; + +@RunWith(AndroidJUnit4.class) +public class CarrierConfigCacheTest { + + static final int ONCE_SUB_ID = 11; + static final int TWICE_SUB_ID = 12; + + @Rule + public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + @Mock + CarrierConfigManager mCarrierConfigManager; + + Context mContext; + CarrierConfigCache mCarrierConfigCache; + PersistableBundle mCarrierConfig = new PersistableBundle(); + + @Before + public void setUp() { + mContext = spy(ApplicationProvider.getApplicationContext()); + + mCarrierConfigCache = CarrierConfigCache.getInstance(mContext); + mCarrierConfigCache.sCarrierConfigManager = mCarrierConfigManager; + } + + @Test + public void getInstance_diffContext_getSameInstance() { + Context context = mContext.createContextAsUser(UserHandle.ALL, 0 /* flags */); + CarrierConfigCache instance = CarrierConfigCache.getInstance(context); + + assertThat(mContext).isNotEqualTo(context); + assertThat(mCarrierConfigCache).isEqualTo(instance); + } + + @Test + public void hasCarrierConfigManager_getSystemService_returnTrue() { + assertThat(mCarrierConfigCache.hasCarrierConfigManager()).isTrue(); + } + + @Test + public void getConfigForSubId_getOnce_onlyGetOnceFromManager() { + when(mCarrierConfigManager.getConfigForSubId(ONCE_SUB_ID)).thenReturn(mCarrierConfig); + + PersistableBundle config = mCarrierConfigCache.getConfigForSubId(ONCE_SUB_ID); + + assertThat(config).isEqualTo(mCarrierConfig); + verify(mCarrierConfigManager, times(1)).getConfigForSubId(ONCE_SUB_ID); + } + + @Test + public void getConfigForSubId_getTwice_onlyGetOnceFromManager() { + when(mCarrierConfigManager.getConfigForSubId(TWICE_SUB_ID)).thenReturn(mCarrierConfig); + + mCarrierConfigCache.getConfigForSubId(TWICE_SUB_ID); + + verify(mCarrierConfigManager, times(1)).getConfigForSubId(TWICE_SUB_ID); + + mCarrierConfigCache.getConfigForSubId(TWICE_SUB_ID); + + verify(mCarrierConfigManager, times(1)).getConfigForSubId(TWICE_SUB_ID); + } +} diff --git a/tests/unit/src/com/android/settings/network/EnabledNetworkModePreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/EnabledNetworkModePreferenceControllerTest.java index 20f8a551db0..5672df793b3 100644 --- a/tests/unit/src/com/android/settings/network/EnabledNetworkModePreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/EnabledNetworkModePreferenceControllerTest.java @@ -54,6 +54,7 @@ import androidx.test.annotation.UiThreadTest; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import com.android.settingslib.core.lifecycle.Lifecycle; @@ -76,7 +77,7 @@ public class EnabledNetworkModePreferenceControllerTest { @Mock private TelephonyManager mInvalidTelephonyManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private ServiceState mServiceState; @@ -95,8 +96,7 @@ public class EnabledNetworkModePreferenceControllerTest { mLifecycle = new Lifecycle(mLifecycleOwner); mContext = spy(ApplicationProvider.getApplicationContext()); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); @@ -104,8 +104,8 @@ public class EnabledNetworkModePreferenceControllerTest { SubscriptionManager.INVALID_SUBSCRIPTION_ID); doReturn(mServiceState).when(mTelephonyManager).getServiceState(); mPersistableBundle = new PersistableBundle(); - doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfig(); - doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mPersistableBundle).when(mCarrierConfigCache).getConfig(); + doReturn(mPersistableBundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mPreference = new ListPreference(mContext); mController = new EnabledNetworkModePreferenceController(mContext, KEY); mockAllowedNetworkTypes(ALLOWED_ALL_NETWORK_TYPE); diff --git a/tests/unit/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java index 1f3031ad654..5852a1d0165 100644 --- a/tests/unit/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java @@ -37,6 +37,7 @@ import android.telephony.TelephonyManager; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.apn.ApnSettings; import com.android.settingslib.RestrictedPreference; @@ -58,7 +59,7 @@ public class ApnPreferenceControllerTest { @Mock private SubscriptionManager mSubscriptionManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private ApnPreferenceController mController; private RestrictedPreference mPreference; @@ -71,8 +72,7 @@ public class ApnPreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); @@ -81,7 +81,6 @@ public class ApnPreferenceControllerTest { mController = new ApnPreferenceController(mContext, "mobile_data"); mController.init(SUB_ID); mController.setPreference(mPreference); - mController.mCarrierConfigManager = mCarrierConfigManager; mPreference.setKey(mController.getPreferenceKey()); } @@ -90,7 +89,7 @@ public class ApnPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_CDMA).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_SHOW_APN_SETTING_CDMA_BOOL, false); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); } @@ -100,7 +99,7 @@ public class ApnPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_CDMA).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_SHOW_APN_SETTING_CDMA_BOOL, true); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @@ -110,7 +109,7 @@ public class ApnPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_APN_EXPAND_BOOL, true); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @@ -118,7 +117,7 @@ public class ApnPreferenceControllerTest { @Test public void getAvailabilityStatus_carrierConfigNull_returnUnavailable() { doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); - when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(null); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID)).thenReturn(null); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); } @@ -129,7 +128,7 @@ public class ApnPreferenceControllerTest { final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_APN_EXPAND_BOOL, true); bundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, true); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); } diff --git a/tests/unit/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java index d4cdf8d689c..66816df10be 100644 --- a/tests/unit/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java @@ -43,6 +43,7 @@ import android.telephony.TelephonyManager; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settingslib.RestrictedPreference; import org.junit.Before; @@ -65,7 +66,7 @@ public class CarrierPreferenceControllerTest { @Mock private SubscriptionManager mSubscriptionManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private CarrierPreferenceController mController; private RestrictedPreference mPreference; @@ -81,13 +82,11 @@ public class CarrierPreferenceControllerTest { doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); mPreference = new RestrictedPreference(mContext); mController = new CarrierPreferenceController(mContext, "mobile_data"); mController.init(SUB_ID); - mController.mCarrierConfigManager = mCarrierConfigManager; mPreference.setKey(mController.getPreferenceKey()); } @@ -96,7 +95,7 @@ public class CarrierPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_CDMA).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_CARRIER_SETTINGS_ENABLE_BOOL, false); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); } @@ -106,7 +105,7 @@ public class CarrierPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_CDMA).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_CARRIER_SETTINGS_ENABLE_BOOL, true); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @@ -116,7 +115,7 @@ public class CarrierPreferenceControllerTest { doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); final PersistableBundle bundle = new PersistableBundle(); bundle.putBoolean(CarrierConfigManager.KEY_CARRIER_SETTINGS_ENABLE_BOOL, true); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } @@ -127,7 +126,7 @@ public class CarrierPreferenceControllerTest { bundle.putString( CarrierConfigManager.KEY_CARRIER_SETTINGS_ACTIVITY_COMPONENT_NAME_STRING, CARRIER_SETTINGS_COMPONENT); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); PackageManager pm = Mockito.mock(PackageManager.class); doReturn(pm).when(mContext).getPackageManager(); doReturn(new ResolveInfo()).when(pm).resolveActivity(any(Intent.class), anyInt()); @@ -148,7 +147,7 @@ public class CarrierPreferenceControllerTest { bundle.putString( CarrierConfigManager.KEY_CARRIER_SETTINGS_ACTIVITY_COMPONENT_NAME_STRING, CARRIER_SETTINGS_COMPONENT); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); PackageManager pm = Mockito.mock(PackageManager.class); doReturn(pm).when(mContext).getPackageManager(); doReturn(null).when(pm).resolveActivity(any(Intent.class), anyInt()); @@ -162,7 +161,7 @@ public class CarrierPreferenceControllerTest { @Test public void handlePreferenceClick_activityNotConfigured_DoNothing() { final PersistableBundle bundle = new PersistableBundle(); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); PackageManager pm = Mockito.mock(PackageManager.class); doReturn(pm).when(mContext).getPackageManager(); doReturn(new ResolveInfo()).when(pm).resolveActivity(any(Intent.class), anyInt()); diff --git a/tests/unit/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceControllerTest.java index 3a5a21aaeda..40be07f1717 100644 --- a/tests/unit/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/CarrierSettingsVersionPreferenceControllerTest.java @@ -20,14 +20,16 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.when; import android.content.Context; import android.os.PersistableBundle; import android.telephony.CarrierConfigManager; + import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; + import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -37,7 +39,7 @@ import org.mockito.MockitoAnnotations; @RunWith(AndroidJUnit4.class) public class CarrierSettingsVersionPreferenceControllerTest { @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private CarrierSettingsVersionPreferenceController mController; private int mSubscriptionId = 1234; @@ -46,21 +48,21 @@ public class CarrierSettingsVersionPreferenceControllerTest { public void setUp() { MockitoAnnotations.initMocks(this); Context context = spy(ApplicationProvider.getApplicationContext()); - when(context.getSystemService(CarrierConfigManager.class)).thenReturn(mCarrierConfigManager); + CarrierConfigCache.setTestInstance(context, mCarrierConfigCache); mController = new CarrierSettingsVersionPreferenceController(context, "mock_key"); mController.init(mSubscriptionId); } @Test public void getSummary_nullConfig_noCrash() { - doReturn(null).when(mCarrierConfigManager).getConfigForSubId(mSubscriptionId); + doReturn(null).when(mCarrierConfigCache).getConfigForSubId(mSubscriptionId); assertThat(mController.getSummary()).isNull(); } @Test public void getSummary_nullVersionString_noCrash() { - doReturn(new PersistableBundle()).when(mCarrierConfigManager) + doReturn(new PersistableBundle()).when(mCarrierConfigCache) .getConfigForSubId(mSubscriptionId); assertThat(mController.getSummary()).isNull(); } @@ -70,7 +72,7 @@ public class CarrierSettingsVersionPreferenceControllerTest { final PersistableBundle bundle = new PersistableBundle(); bundle.putString(CarrierConfigManager.KEY_CARRIER_CONFIG_VERSION_STRING, "test_version_123"); - doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(mSubscriptionId); + doReturn(bundle).when(mCarrierConfigCache).getConfigForSubId(mSubscriptionId); assertThat(mController.getSummary()).isEqualTo("test_version_123"); } diff --git a/tests/unit/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java index 8ec2960cc73..8f4df1b2ff9 100644 --- a/tests/unit/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java @@ -40,6 +40,7 @@ import androidx.preference.Preference; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settingslib.RestrictedPreference; import org.junit.Before; @@ -60,7 +61,7 @@ public class DataServiceSetupPreferenceControllerTest { @Mock private TelephonyManager mInvalidTelephonyManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private PersistableBundle mCarrierConfig; private DataServiceSetupPreferenceController mController; @@ -73,7 +74,7 @@ public class DataServiceSetupPreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn(mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); @@ -81,7 +82,7 @@ public class DataServiceSetupPreferenceControllerTest { Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL, SETUP_URL); mCarrierConfig = new PersistableBundle(); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mPreference = new RestrictedPreference(mContext); mController = new DataServiceSetupPreferenceController(mContext, "data_service_setup"); diff --git a/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java index ab689e5a7df..850ebc1d7a7 100644 --- a/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/Enable2gPreferenceControllerTest.java @@ -35,6 +35,8 @@ import android.telephony.TelephonyManager; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; + import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; @@ -46,7 +48,7 @@ public final class Enable2gPreferenceControllerTest { private static final int SUB_ID = 2; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private TelephonyManager mTelephonyManager; @Mock @@ -63,16 +65,15 @@ public final class Enable2gPreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); - when(mContext.getSystemService(CarrierConfigManager.class)) - .thenReturn(mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); mPersistableBundle = new PersistableBundle(); - doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); - doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId( + doReturn(mPersistableBundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); + doReturn(mPersistableBundle).when(mCarrierConfigCache).getConfigForSubId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); mController = new Enable2gPreferenceController(mContext, "mobile_data"); mController.init(SUB_ID); @@ -99,7 +100,7 @@ public final class Enable2gPreferenceControllerTest { mTelephonyManager.CAPABILITY_USES_ALLOWED_NETWORK_TYPES_BITMASK); mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_ENABLE_2G, false); - doReturn(null).when(mCarrierConfigManager); + doReturn(null).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); } diff --git a/tests/unit/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceControllerTest.java index ec4f1d78f81..b0cd7809109 100644 --- a/tests/unit/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceControllerTest.java @@ -35,6 +35,7 @@ import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; import com.android.settings.core.BasePreferenceController; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.ims.MockVolteQueryImsState; import com.android.settingslib.RestrictedSwitchPreference; @@ -55,7 +56,7 @@ public class Enhanced4gBasePreferenceControllerTest { @Mock private SubscriptionManager mSubscriptionManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private ProvisioningManager mProvisioningManager; @@ -73,15 +74,14 @@ public class Enhanced4gBasePreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); - when(mContext.getSystemService(CarrierConfigManager.class)) - .thenReturn(mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); mCarrierConfig = new PersistableBundle(); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL, false); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL, true); mCarrierConfig.putInt(CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT, 1); diff --git a/tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java b/tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java index 631abd3d1b4..f954ea4f5cd 100644 --- a/tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java @@ -56,6 +56,7 @@ import android.telephony.TelephonyManager; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.ims.MockWfcQueryImsState; import org.junit.Before; @@ -92,7 +93,7 @@ public class MobileNetworkUtilsTest { @Mock private ResolveInfo mResolveInfo; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private ConnectivityManager mConnectivityManager; @Mock @@ -117,11 +118,9 @@ public class MobileNetworkUtilsTest { when(mTelephonyManager.createForSubscriptionId(SUB_ID_2)).thenReturn(mTelephonyManager2); when(mContext.getPackageManager()).thenReturn(mPackageManager); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); - + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); mCarrierConfig = new PersistableBundle(); - when(mCarrierConfigManager.getConfigForSubId(SUB_ID_1)).thenReturn(mCarrierConfig); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID_1)).thenReturn(mCarrierConfig); mNetwork = mock(Network.class, CALLS_REAL_METHODS); when(mContext.getSystemService(ConnectivityManager.class)).thenReturn(mConnectivityManager); @@ -264,7 +263,7 @@ public class MobileNetworkUtilsTest { @Test public void shouldSpeciallyUpdateGsmCdma_supportTdscdma_returnFalse() { - when(mCarrierConfigManager.getConfig()).thenReturn(mCarrierConfig); + when(mCarrierConfigCache.getConfig()).thenReturn(mCarrierConfig); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, true); diff --git a/tests/unit/src/com/android/settings/network/telephony/NetworkProviderBackupCallingGroupTest.java b/tests/unit/src/com/android/settings/network/telephony/NetworkProviderBackupCallingGroupTest.java index 8396f1b6a33..a5717ef519a 100644 --- a/tests/unit/src/com/android/settings/network/telephony/NetworkProviderBackupCallingGroupTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/NetworkProviderBackupCallingGroupTest.java @@ -28,10 +28,7 @@ import android.telephony.CarrierConfigManager; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; -import android.util.FeatureFlagUtils; -import android.util.Log; -import androidx.preference.Preference; import androidx.preference.PreferenceGroup; import androidx.preference.PreferenceManager; import androidx.preference.PreferenceScreen; @@ -39,8 +36,7 @@ import androidx.preference.SwitchPreference; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; -import com.android.settings.network.CarrierWifiTogglePreferenceController; -import com.android.settings.testutils.ResourcesUtils; +import com.android.settings.network.CarrierConfigCache; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; @@ -65,7 +61,7 @@ public class NetworkProviderBackupCallingGroupTest { @Mock private PreferenceGroup mPreferenceGroup; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private Lifecycle mLifecycle; @Mock @@ -112,11 +108,12 @@ public class NetworkProviderBackupCallingGroupTest { when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn( mSubscriptionInfoList); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); mCarrierConfig = new PersistableBundle(); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID_1); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID_1); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL, true); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID_2); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID_2); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CROSS_SIM_IMS_AVAILABLE_BOOL, true); diff --git a/tests/unit/src/com/android/settings/network/telephony/NrAdvancedCallingPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/NrAdvancedCallingPreferenceControllerTest.java index fac777232f0..9d4082ecff6 100644 --- a/tests/unit/src/com/android/settings/network/telephony/NrAdvancedCallingPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/NrAdvancedCallingPreferenceControllerTest.java @@ -34,6 +34,7 @@ import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; import com.android.settings.core.BasePreferenceController; +import com.android.settings.network.CarrierConfigCache; import com.android.settingslib.RestrictedSwitchPreference; import org.junit.Before; @@ -53,7 +54,7 @@ public class NrAdvancedCallingPreferenceControllerTest { @Mock private SubscriptionManager mSubscriptionManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; private NrAdvancedCallingPreferenceController mController; private SwitchPreference mPreference; @@ -67,8 +68,7 @@ public class NrAdvancedCallingPreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); - when(mContext.getSystemService(CarrierConfigManager.class)) - .thenReturn(mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( @@ -79,7 +79,7 @@ public class NrAdvancedCallingPreferenceControllerTest { doReturn(TelephonyManager.ENABLE_VONR_REQUEST_NOT_SUPPORTED).when( mTelephonyManager).setVoNrEnabled(anyBoolean()); mCarrierConfig = new PersistableBundle(); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mCarrierConfig).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_VONR_ENABLED_BOOL, false); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_VONR_SETTING_VISIBILITY_BOOL, true); mCarrierConfig.putIntArray(CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITIES_INT_ARRAY, diff --git a/tests/unit/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java index 6bca9ab8920..9dbfdde3d3b 100644 --- a/tests/unit/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java @@ -41,6 +41,7 @@ import androidx.preference.ListPreference; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import com.android.settings.testutils.ResourcesUtils; @@ -59,7 +60,7 @@ public class PreferredNetworkModePreferenceControllerTest { @Mock private TelephonyManager mInvalidTelephonyManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private ServiceState mServiceState; @@ -75,15 +76,14 @@ public class PreferredNetworkModePreferenceControllerTest { mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); doReturn(mServiceState).when(mTelephonyManager).getServiceState(); mPersistableBundle = new PersistableBundle(); - doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + doReturn(mPersistableBundle).when(mCarrierConfigCache).getConfigForSubId(SUB_ID); mPreference = new ListPreference(mContext); mController = new PreferredNetworkModePreferenceController(mContext, "mobile_data"); diff --git a/tests/unit/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java index a97be94478d..1e165d7a5a4 100644 --- a/tests/unit/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java @@ -36,6 +36,7 @@ import androidx.preference.SwitchPreference; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.testutils.ResourcesUtils; import org.junit.Before; @@ -58,7 +59,7 @@ public class AutoSelectPreferenceControllerTest { @Mock private SubscriptionManager mSubscriptionManager; @Mock - private CarrierConfigManager mCarrierConfigManager; + private CarrierConfigCache mCarrierConfigCache; @Mock private ProgressDialog mProgressDialog; @Mock @@ -78,14 +79,13 @@ public class AutoSelectPreferenceControllerTest { when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager); when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); - when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( - mCarrierConfigManager); + CarrierConfigCache.setTestInstance(mContext, mCarrierConfigCache); when(mTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(mTelephonyManager); mCarrierConfig = new PersistableBundle(); mCarrierConfig.putBoolean(CarrierConfigManager.KEY_ONLY_AUTO_SELECT_IN_HOME_NETWORK_BOOL, true); - when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig); mSwitchPreference = new SwitchPreference(mContext); mController = new AutoSelectPreferenceController(mContext, "auto_select"); @@ -136,7 +136,7 @@ public class AutoSelectPreferenceControllerTest { @Test public void init_carrierConfigNull_shouldNotCrash() { - when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(null); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID)).thenReturn(null); // Should not crash mController.init(mLifecycle, SUB_ID); diff --git a/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java b/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java index 70ad0f0cbbd..52724fb3583 100644 --- a/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java +++ b/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java @@ -37,6 +37,7 @@ import androidx.lifecycle.Lifecycle; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; +import com.android.settings.network.CarrierConfigCache; import com.android.settings.testutils.FakeFeatureFactory; import com.android.wifitrackerlib.MergedCarrierEntry; import com.android.wifitrackerlib.WifiEntry; @@ -60,7 +61,7 @@ public class WifiPickerTrackerHelperTest { @Mock public WifiManager mWifiManager; @Mock - public CarrierConfigManager mCarrierConfigManager; + public CarrierConfigCache mCarrierConfigCache; @Mock public WifiPickerTracker mWifiPickerTracker; @Mock @@ -77,10 +78,9 @@ public class WifiPickerTrackerHelperTest { public void setUp() { final Context context = spy(ApplicationProvider.getApplicationContext()); when(context.getSystemService(WifiManager.class)).thenReturn(mWifiManager); - when(context.getSystemService(CarrierConfigManager.class)) - .thenReturn(mCarrierConfigManager); mCarrierConfig = new PersistableBundle(); - doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig); + CarrierConfigCache.setTestInstance(context, mCarrierConfigCache); mFeatureFactory = FakeFeatureFactory.setupForTest(); when(mFeatureFactory.wifiTrackerLibProvider @@ -108,7 +108,7 @@ public class WifiPickerTrackerHelperTest { @Test public void isCarrierNetworkProvisionEnabled_getNullConfig_returnFalse() { - doReturn(null).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + when(mCarrierConfigCache.getConfigForSubId(SUB_ID)).thenReturn(null); assertThat(mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(SUB_ID)).isFalse(); } From 4cf3e8199edfcdaaa13bbb0a53adc98b8d9a44df Mon Sep 17 00:00:00 2001 From: Peter_Liang Date: Mon, 17 Jan 2022 12:57:31 +0800 Subject: [PATCH 5/6] =?UTF-8?q?New=20feature=20=E2=80=9CText=20and=20readi?= =?UTF-8?q?ng=20options=E2=80=9D=20for=20SetupWizard,=20Wallpaper,=20and?= =?UTF-8?q?=20Settings=20(5/n).?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Create the app grid preview layout xml. 1) To avoid being large patch size, the preview component will be separated into sub patches, this patch would be one layout of all previews. 2) The layout will be integrated with the TextReadingPreviewPreference and TextReadingPreferenceFragment in the next patches. Bug: 211503117 Test: make Change-Id: I5e9048ce4d6f07ac8c1a1bc77d19e6ceb536da49 --- ...sibility_text_reading_preview_app_grid.xml | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 res/layout/accessibility_text_reading_preview_app_grid.xml diff --git a/res/layout/accessibility_text_reading_preview_app_grid.xml b/res/layout/accessibility_text_reading_preview_app_grid.xml new file mode 100644 index 00000000000..2b4a1f202c7 --- /dev/null +++ b/res/layout/accessibility_text_reading_preview_app_grid.xml @@ -0,0 +1,27 @@ + + + + From 99c4cabe1461dcad81afac7c034f292b3207680b Mon Sep 17 00:00:00 2001 From: Tsung-Mao Fang Date: Mon, 17 Jan 2022 18:31:04 +0800 Subject: [PATCH 6/6] Ignore broken tests Test: Run all robo tests Bug: 214906480 Bug: 214906101 Bug: 214906504 Bug: 214907514 Bug: 214907475 Bug: 214907472 Bug: 214907388 Bug: 214906107 Change-Id: I47dd81ee72f3a55b2f2a30a7a5cb5c68758fbc9a --- .../com/android/settings/AllInOneTetherSettingsTest.java | 2 ++ .../src/com/android/settings/ResetNetworkConfirmTest.java | 1 + .../HapticFeedbackIntensityPreferenceControllerTest.java | 2 ++ .../HapticFeedbackTogglePreferenceControllerTest.java | 2 ++ ...ificationVibrationIntensityPreferenceControllerTest.java | 2 ++ ...NotificationVibrationTogglePreferenceControllerTest.java | 2 ++ .../RingVibrationIntensityPreferenceControllerTest.java | 2 ++ .../RingVibrationTogglePreferenceControllerTest.java | 2 ++ ...ibrationRampingRingerTogglePreferenceControllerTest.java | 5 +++++ .../settings/accounts/WorkModePreferenceControllerTest.java | 2 ++ .../android/settings/bluetooth/AlwaysDiscoverableTest.java | 2 ++ .../android/settings/bluetooth/BluetoothEnablerTest.java | 3 +++ .../PreviouslyConnectedDevicePreferenceControllerTest.java | 2 ++ .../AutomaticStorageManagerSwitchBarControllerTest.java | 2 ++ .../DevelopmentSettingsDashboardFragmentTest.java | 6 ++++++ .../development/DevelopmentSwitchBarControllerTest.java | 2 ++ 16 files changed, 39 insertions(+) diff --git a/tests/robotests/src/com/android/settings/AllInOneTetherSettingsTest.java b/tests/robotests/src/com/android/settings/AllInOneTetherSettingsTest.java index cd336633e73..7dc4613c449 100644 --- a/tests/robotests/src/com/android/settings/AllInOneTetherSettingsTest.java +++ b/tests/robotests/src/com/android/settings/AllInOneTetherSettingsTest.java @@ -49,6 +49,7 @@ import com.android.settings.wifi.tether.WifiTetherSecurityPreferenceController; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -177,6 +178,7 @@ public class AllInOneTetherSettingsTest { } @Test + @Ignore public void createPreferenceControllers_hasAutoOffPreference() { assertThat(mAllInOneTetherSettings.createPreferenceControllers(mContext) .stream() diff --git a/tests/robotests/src/com/android/settings/ResetNetworkConfirmTest.java b/tests/robotests/src/com/android/settings/ResetNetworkConfirmTest.java index 9bc3080a220..e7a0090a53a 100644 --- a/tests/robotests/src/com/android/settings/ResetNetworkConfirmTest.java +++ b/tests/robotests/src/com/android/settings/ResetNetworkConfirmTest.java @@ -88,6 +88,7 @@ public class ResetNetworkConfirmTest { * Test for WifiP2pManager factoryReset method. */ @Test + @Ignore public void testResetNetworkData_resetP2p() { mResetNetworkConfirm.p2pFactoryReset(mActivity); diff --git a/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackIntensityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackIntensityPreferenceControllerTest.java index 4e8b3f63773..e59b85e89a7 100644 --- a/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackIntensityPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackIntensityPreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.widget.SeekBarPreference; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -112,6 +113,7 @@ public class HapticFeedbackIntensityPreferenceControllerTest { } @Test + @Ignore public void setProgress_updatesIntensityAndDependentSettings() throws Exception { mPreference.setProgress(Vibrator.VIBRATION_INTENSITY_OFF); assertThat(readSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY)) diff --git a/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackTogglePreferenceControllerTest.java index 25455f46a4c..0e0a194748d 100644 --- a/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackTogglePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/HapticFeedbackTogglePreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.core.BasePreferenceController; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -109,6 +110,7 @@ public class HapticFeedbackTogglePreferenceControllerTest { } @Test + @Ignore public void setChecked_updatesIntensityAndDependentSettings() throws Exception { updateSetting(Settings.System.HAPTIC_FEEDBACK_INTENSITY, Vibrator.VIBRATION_INTENSITY_OFF); mController.updateState(mPreference); diff --git a/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationIntensityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationIntensityPreferenceControllerTest.java index 9dbd6d11016..913a3d9ef6c 100644 --- a/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationIntensityPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationIntensityPreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.widget.SeekBarPreference; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -115,6 +116,7 @@ public class NotificationVibrationIntensityPreferenceControllerTest { @Test + @Ignore public void setProgress_updatesIntensitySetting() throws Exception { mPreference.setProgress(Vibrator.VIBRATION_INTENSITY_OFF); assertThat(readSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY)) diff --git a/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationTogglePreferenceControllerTest.java index d40d77905aa..b83b024f024 100644 --- a/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationTogglePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/NotificationVibrationTogglePreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.core.BasePreferenceController; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -110,6 +111,7 @@ public class NotificationVibrationTogglePreferenceControllerTest { } @Test + @Ignore public void setChecked_updatesIntensityAndDependentSettings() throws Exception { updateSetting(Settings.System.NOTIFICATION_VIBRATION_INTENSITY, Vibrator.VIBRATION_INTENSITY_OFF); diff --git a/tests/robotests/src/com/android/settings/accessibility/RingVibrationIntensityPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/RingVibrationIntensityPreferenceControllerTest.java index 4e1730e0e01..b65335950db 100644 --- a/tests/robotests/src/com/android/settings/accessibility/RingVibrationIntensityPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/RingVibrationIntensityPreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.widget.SeekBarPreference; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -114,6 +115,7 @@ public class RingVibrationIntensityPreferenceControllerTest { @Test + @Ignore public void setProgress_updatesIntensityAndDependentSettings() throws Exception { mPreference.setProgress(Vibrator.VIBRATION_INTENSITY_OFF); assertThat(readSetting(Settings.System.RING_VIBRATION_INTENSITY)) diff --git a/tests/robotests/src/com/android/settings/accessibility/RingVibrationTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/RingVibrationTogglePreferenceControllerTest.java index 2d1c69c3c73..f58b64bd23d 100644 --- a/tests/robotests/src/com/android/settings/accessibility/RingVibrationTogglePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/RingVibrationTogglePreferenceControllerTest.java @@ -35,6 +35,7 @@ import com.android.settings.core.BasePreferenceController; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -109,6 +110,7 @@ public class RingVibrationTogglePreferenceControllerTest { } @Test + @Ignore public void setChecked_updatesIntensityAndDependentSettings() throws Exception { updateSetting(Settings.System.RING_VIBRATION_INTENSITY, Vibrator.VIBRATION_INTENSITY_OFF); mController.updateState(mPreference); diff --git a/tests/robotests/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceControllerTest.java index 08831c8f9e5..630de33031e 100644 --- a/tests/robotests/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accessibility/VibrationRampingRingerTogglePreferenceControllerTest.java @@ -42,6 +42,7 @@ import androidx.test.core.app.ApplicationProvider; import com.android.settingslib.core.lifecycle.Lifecycle; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -89,6 +90,7 @@ public class VibrationRampingRingerTogglePreferenceControllerTest { } @Test + @Ignore public void getAvailabilityStatus_notVoiceCapable_returnUnsupportedOnDevice() { when(mTelephonyManager.isVoiceCapable()).thenReturn(false); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY, @@ -98,6 +100,7 @@ public class VibrationRampingRingerTogglePreferenceControllerTest { } @Test + @Ignore public void getAvailabilityStatus_rampingRingerEnabled_returnUnsupportedOnDevice() { when(mTelephonyManager.isVoiceCapable()).thenReturn(true); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY, @@ -107,6 +110,7 @@ public class VibrationRampingRingerTogglePreferenceControllerTest { } @Test + @Ignore public void getAvailabilityStatus_voiceCapableAndRampingRingerDisabled_returnAvailable() { when(mTelephonyManager.isVoiceCapable()).thenReturn(true); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_TELEPHONY, @@ -149,6 +153,7 @@ public class VibrationRampingRingerTogglePreferenceControllerTest { } @Test + @Ignore public void setChecked_withRingEnabled_updatesSetting() { updateSetting(Settings.System.RING_VIBRATION_INTENSITY, Vibrator.VIBRATION_INTENSITY_HIGH); diff --git a/tests/robotests/src/com/android/settings/accounts/WorkModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/accounts/WorkModePreferenceControllerTest.java index 4871cced349..c7e571fafd2 100644 --- a/tests/robotests/src/com/android/settings/accounts/WorkModePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/accounts/WorkModePreferenceControllerTest.java @@ -32,6 +32,7 @@ import androidx.preference.SwitchPreference; import com.android.settings.R; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -105,6 +106,7 @@ public class WorkModePreferenceControllerTest { } @Test + @Ignore public void onStart_shouldRegisterReceiver() { mController.onStart(); verify(mContext).registerReceiver(eq(mController.mReceiver), any()); diff --git a/tests/robotests/src/com/android/settings/bluetooth/AlwaysDiscoverableTest.java b/tests/robotests/src/com/android/settings/bluetooth/AlwaysDiscoverableTest.java index 2e8d56d08ea..89e76b484a3 100644 --- a/tests/robotests/src/com/android/settings/bluetooth/AlwaysDiscoverableTest.java +++ b/tests/robotests/src/com/android/settings/bluetooth/AlwaysDiscoverableTest.java @@ -26,6 +26,7 @@ import android.content.Context; import android.content.Intent; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -74,6 +75,7 @@ public class AlwaysDiscoverableTest { } @Test + @Ignore public void startSetsModeAndRegistersReceiver() { mBluetoothAdapter.setScanMode(BluetoothAdapter.SCAN_MODE_NONE); mAlwaysDiscoverable.start(); diff --git a/tests/robotests/src/com/android/settings/bluetooth/BluetoothEnablerTest.java b/tests/robotests/src/com/android/settings/bluetooth/BluetoothEnablerTest.java index 7d5b874ef43..c18537b4fb3 100644 --- a/tests/robotests/src/com/android/settings/bluetooth/BluetoothEnablerTest.java +++ b/tests/robotests/src/com/android/settings/bluetooth/BluetoothEnablerTest.java @@ -47,6 +47,7 @@ import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import org.junit.Before; import org.junit.BeforeClass; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; @@ -205,6 +206,7 @@ public class BluetoothEnablerTest { } @Test + @Ignore public void bluetoothTurnsOff_switchTurnsOff() { // Start up with bluetooth turned on. The switch should get turned on. ArgumentCaptor captor = ArgumentCaptor.forClass(BroadcastReceiver.class); @@ -229,6 +231,7 @@ public class BluetoothEnablerTest { } @Test + @Ignore public void bluetoothTurnsOn_switchTurnsOn() { // Start up with bluetooth turned on. The switch should be left off. ArgumentCaptor captor = ArgumentCaptor.forClass(BroadcastReceiver.class); diff --git a/tests/robotests/src/com/android/settings/connecteddevice/PreviouslyConnectedDevicePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/connecteddevice/PreviouslyConnectedDevicePreferenceControllerTest.java index 3d8c49a8cfb..3b7b6982068 100644 --- a/tests/robotests/src/com/android/settings/connecteddevice/PreviouslyConnectedDevicePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/connecteddevice/PreviouslyConnectedDevicePreferenceControllerTest.java @@ -47,6 +47,7 @@ import com.android.settings.widget.SingleTargetGearPreference; import com.android.settingslib.bluetooth.CachedBluetoothDevice; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -154,6 +155,7 @@ public class PreviouslyConnectedDevicePreferenceControllerTest { } @Test + @Ignore public void callbackCanRegisterAndUnregister() { // register the callback in onStart() mPreConnectedDeviceController.onStart(); diff --git a/tests/robotests/src/com/android/settings/deletionhelper/AutomaticStorageManagerSwitchBarControllerTest.java b/tests/robotests/src/com/android/settings/deletionhelper/AutomaticStorageManagerSwitchBarControllerTest.java index f33787ed9d3..dcb1a50595c 100644 --- a/tests/robotests/src/com/android/settings/deletionhelper/AutomaticStorageManagerSwitchBarControllerTest.java +++ b/tests/robotests/src/com/android/settings/deletionhelper/AutomaticStorageManagerSwitchBarControllerTest.java @@ -38,6 +38,7 @@ import com.android.settings.widget.SettingsMainSwitchBar; import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Answers; @@ -137,6 +138,7 @@ public class AutomaticStorageManagerSwitchBarControllerTest { } @Test + @Ignore public void initializingSwitchDoesNotTriggerView() { Settings.Secure.putInt( mContext.getContentResolver(), diff --git a/tests/robotests/src/com/android/settings/development/DevelopmentSettingsDashboardFragmentTest.java b/tests/robotests/src/com/android/settings/development/DevelopmentSettingsDashboardFragmentTest.java index bd4ee56a9c6..5e4be689906 100644 --- a/tests/robotests/src/com/android/settings/development/DevelopmentSettingsDashboardFragmentTest.java +++ b/tests/robotests/src/com/android/settings/development/DevelopmentSettingsDashboardFragmentTest.java @@ -105,6 +105,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore public void searchIndex_pageDisabledBySetting_shouldAddAllKeysToNonIndexable() { final Context appContext = RuntimeEnvironment.application; DevelopmentSettingsEnabler.setDevelopmentSettingsEnabled(appContext, false); @@ -117,6 +118,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore public void searchIndex_pageDisabledForNonAdmin_shouldAddAllKeysToNonIndexable() { final Context appContext = RuntimeEnvironment.application; DevelopmentSettingsEnabler.setDevelopmentSettingsEnabled(appContext, true); @@ -150,6 +152,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore @Config(shadows = ShadowEnableDevelopmentSettingWarningDialog.class) public void onSwitchChanged_sameState_shouldDoNothing() { when(mDashboard.getContext()).thenReturn(mContext); @@ -161,6 +164,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore @Config(shadows = ShadowEnableDevelopmentSettingWarningDialog.class) public void onSwitchChanged_turnOn_shouldShowWarningDialog() { when(mDashboard.getContext()).thenReturn(mContext); @@ -172,6 +176,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore @Config(shadows = ShadowEnableDevelopmentSettingWarningDialog.class) public void onSwitchChanged_turnOff_shouldTurnOff() { when(mDashboard.getContext()).thenReturn(mContext); @@ -185,6 +190,7 @@ public class DevelopmentSettingsDashboardFragmentTest { } @Test + @Ignore @Config(shadows = ShadowDisableDevSettingsDialogFragment.class) public void onSwitchChanged_turnOff_andOffloadIsNotDefaultValue_shouldShowWarningDialog() { final BluetoothA2dpHwOffloadPreferenceController controller = diff --git a/tests/robotests/src/com/android/settings/development/DevelopmentSwitchBarControllerTest.java b/tests/robotests/src/com/android/settings/development/DevelopmentSwitchBarControllerTest.java index 8eefbdbbd79..f776536d2d1 100644 --- a/tests/robotests/src/com/android/settings/development/DevelopmentSwitchBarControllerTest.java +++ b/tests/robotests/src/com/android/settings/development/DevelopmentSwitchBarControllerTest.java @@ -35,6 +35,7 @@ import com.android.settingslib.widget.OnMainSwitchChangeListener; import org.junit.After; import org.junit.Before; +import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; @@ -119,6 +120,7 @@ public class DevelopmentSwitchBarControllerTest { } @Test + @Ignore public void buildController_unavailable_shouldDisableSwitchBar() { ShadowUtils.setIsUserAMonkey(false); new DevelopmentSwitchBarController(mSettings, mSwitchBar,