diff --git a/AndroidManifest.xml b/AndroidManifest.xml index 109f2b9e8f7..af690d920b1 100644 --- a/AndroidManifest.xml +++ b/AndroidManifest.xml @@ -2534,7 +2534,6 @@ android:label="@string/sound_settings" android:icon="@drawable/ic_homepage_sound" android:exported="true" - android:taskAffinity="com.android.settings" android:parentActivityName="Settings"> diff --git a/res/layout/homepage_slice_tile.xml b/res/layout/homepage_slice_tile.xml index 151ad24e4c9..bd69eeeed2d 100644 --- a/res/layout/homepage_slice_tile.xml +++ b/res/layout/homepage_slice_tile.xml @@ -25,7 +25,7 @@ false - + diff --git a/res/values/dimens.xml b/res/values/dimens.xml index 2d2bfb781ef..edece3cb930 100755 --- a/res/values/dimens.xml +++ b/res/values/dimens.xml @@ -350,6 +350,10 @@ 6dp 6dp + + 288dp + 24dp diff --git a/res/values/strings.xml b/res/values/strings.xml index ac8f305dbf1..615749c8684 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -10261,7 +10261,12 @@ App data usage + + Invalid Network Mode %1$d. Ignore. Unavailable when connected to %1$s + + + Medical info, emergency contacts diff --git a/res/xml/network_setting_fragment.xml b/res/xml/network_setting_fragment.xml index 74e03ed9f15..e54a90d7730 100644 --- a/res/xml/network_setting_fragment.xml +++ b/res/xml/network_setting_fragment.xml @@ -20,10 +20,11 @@ android:title="@string/network_settings_title" settings:initialExpandedChildrenCount="4"> - - + android:title="@string/cdma_lte_data_service" + settings:controller="com.android.settings.network.telephony.DataServiceSetupPreferenceController"> + + android:summary="@string/enhanced_4g_lte_mode_summary" + settings:controller="com.android.settings.network.telephony.Enhanced4gLtePreferenceController"/> + android:dialogTitle="@string/preferred_network_mode_dialogtitle" + settings:controller="com.android.settings.network.telephony.PreferredNetworkModePreferenceController"/> + android:dialogTitle="@string/preferred_network_mode_dialogtitle" + settings:controller="com.android.settings.network.telephony.EnabledNetworkModePreferenceController"/> > { final double rankingScore = 0.0; final List result = new ArrayList() {{ add(new ContextualCard.Builder() - .setSliceUri(DataUsageSlice.DATA_USAGE_CARD_URI.toString()) - .setName(packageName + "/" + DataUsageSlice.PATH_DATA_USAGE_CARD) + .setSliceUri(DataUsageSlice.DATA_USAGE_CARD_URI) + .setName(DataUsageSlice.PATH_DATA_USAGE) .setPackageName(packageName) .setRankingScore(rankingScore) .setAppVersion(appVersionCode) .setCardType(ContextualCard.CardType.SLICE) - .setIsHalfWidth(true) + .setIsHalfWidth(false) .build()); //TODO(b/115971399): Will change following values of SliceUri and Name // after landing these slice cards. @@ -114,22 +113,13 @@ public class CardContentLoader extends AsyncLoaderCompat> { // .setIsHalfWidth(true) // .build()); add(new ContextualCard.Builder() - .setSliceUri(DeviceInfoSlice.DEVICE_INFO_CARD_URI.toString()) - .setName(packageName + "/" + DeviceInfoSlice.PATH_DEVICE_INFO_CARD) + .setSliceUri(DeviceInfoSlice.DEVICE_INFO_CARD_URI) + .setName(DeviceInfoSlice.PATH_DEVICE_INFO) .setPackageName(packageName) .setRankingScore(rankingScore) .setAppVersion(appVersionCode) .setCardType(ContextualCard.CardType.SLICE) - .setIsHalfWidth(true) - .build()); - add(new ContextualCard.Builder() - .setSliceUri(StorageSlice.STORAGE_CARD_URI.toString()) - .setName(StorageSlice.PATH_STORAGE_CARD) - .setPackageName(packageName) - .setRankingScore(rankingScore) - .setAppVersion(appVersionCode) - .setCardType(ContextualCard.CardType.SLICE) - .setIsHalfWidth(true) + .setIsHalfWidth(false) .build()); }}; return result; diff --git a/src/com/android/settings/homepage/ContextualCard.java b/src/com/android/settings/homepage/ContextualCard.java index 130b878f00e..bb83836fc1d 100644 --- a/src/com/android/settings/homepage/ContextualCard.java +++ b/src/com/android/settings/homepage/ContextualCard.java @@ -244,8 +244,8 @@ public class ContextualCard { return this; } - public Builder setSliceUri(String sliceUri) { - mSliceUri = sliceUri; + public Builder setSliceUri(Uri sliceUri) { + mSliceUri = sliceUri.toString(); return this; } diff --git a/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProvider.java b/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProvider.java index 2dede95e758..26f86b9da5e 100644 --- a/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProvider.java +++ b/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProvider.java @@ -21,6 +21,9 @@ import static android.provider.SettingsSlicesContract.KEY_WIFI; import android.annotation.Nullable; import com.android.settings.homepage.deviceinfo.DataUsageSlice; +import com.android.settings.homepage.deviceinfo.DeviceInfoSlice; +import com.android.settings.homepage.deviceinfo.StorageSlice; +import com.android.settings.homepage.deviceinfo.EmergencyInfoSlice; import com.android.settings.intelligence.ContextualCardProto.ContextualCard; import com.android.settings.intelligence.ContextualCardProto.ContextualCardList; import com.android.settings.wifi.WifiSlice; @@ -43,11 +46,29 @@ public class SettingsContextualCardProvider extends ContextualCardProvider { final ContextualCard dataUsageCard = ContextualCard.newBuilder() .setSliceUri(DataUsageSlice.DATA_USAGE_CARD_URI.toString()) - .setCardName(DataUsageSlice.PATH_DATA_USAGE_CARD) + .setCardName(DataUsageSlice.PATH_DATA_USAGE) + .build(); + final ContextualCard deviceInfoCard = + ContextualCard.newBuilder() + .setSliceUri(DeviceInfoSlice.DEVICE_INFO_CARD_URI.toString()) + .setCardName(DeviceInfoSlice.PATH_DEVICE_INFO) + .build(); + final ContextualCard storageInfoCard = + ContextualCard.newBuilder() + .setSliceUri(StorageSlice.STORAGE_CARD_URI.toString()) + .setCardName(StorageSlice.PATH_STORAGE_INFO) + .build(); + final ContextualCard emergencyInfoCard = + ContextualCard.newBuilder() + .setSliceUri(EmergencyInfoSlice.EMERGENCY_INFO_CARD_URI.toString()) + .setCardName(EmergencyInfoSlice.PATH_EMERGENCY_INFO_CARD) .build(); final ContextualCardList cards = ContextualCardList.newBuilder() .addCard(wifiCard) .addCard(dataUsageCard) + .addCard(deviceInfoCard) + .addCard(storageInfoCard) + .addCard(emergencyInfoCard) .build(); return cards; diff --git a/src/com/android/settings/homepage/deviceinfo/DataUsageSlice.java b/src/com/android/settings/homepage/deviceinfo/DataUsageSlice.java index d78b93de688..aebeaaeceb1 100644 --- a/src/com/android/settings/homepage/deviceinfo/DataUsageSlice.java +++ b/src/com/android/settings/homepage/deviceinfo/DataUsageSlice.java @@ -53,7 +53,7 @@ public class DataUsageSlice implements CustomSliceable { /** * The path denotes the unique name of data usage slice. */ - public static final String PATH_DATA_USAGE_CARD = "data_usage_card"; + public static final String PATH_DATA_USAGE = "data_usage_card"; /** * Backing Uri for the Data usage Slice. @@ -61,7 +61,7 @@ public class DataUsageSlice implements CustomSliceable { public static final Uri DATA_USAGE_CARD_URI = new Uri.Builder() .scheme(ContentResolver.SCHEME_CONTENT) .authority(SettingsSliceProvider.SLICE_AUTHORITY) - .appendPath(PATH_DATA_USAGE_CARD) + .appendPath(PATH_DATA_USAGE) .build(); private final Context mContext; @@ -88,8 +88,8 @@ public class DataUsageSlice implements CustomSliceable { final DataUsageController.DataUsageInfo info = dataUsageController.getDataUsageInfo(); final ListBuilder listBuilder = new ListBuilder(mContext, DATA_USAGE_CARD_URI, ListBuilder.INFINITY) - .setAccentColor(Utils.getColorAccentDefaultColor(mContext)) - .setHeader(new ListBuilder.HeaderBuilder().setTitle(title)); + .setAccentColor(Utils.getColorAccentDefaultColor(mContext)) + .setHeader(new ListBuilder.HeaderBuilder().setTitle(title)); if (DataUsageUtils.hasSim(mContext)) { listBuilder.addRow(new ListBuilder.RowBuilder() .setTitle(getDataUsageText(info)) @@ -106,9 +106,9 @@ public class DataUsageSlice implements CustomSliceable { @Override public Intent getIntent() { final String screenTitle = mContext.getText(R.string.data_usage_wifi_title).toString(); - final Uri contentUri = new Uri.Builder().appendPath(PATH_DATA_USAGE_CARD).build(); + final Uri contentUri = new Uri.Builder().appendPath(PATH_DATA_USAGE).build(); return SliceBuilderUtils.buildSearchResultPageIntent(mContext, - DataUsageSummary.class.getName(), PATH_DATA_USAGE_CARD, screenTitle, + DataUsageSummary.class.getName(), PATH_DATA_USAGE, screenTitle, MetricsProto.MetricsEvent.SLICE) .setClassName(mContext.getPackageName(), SubSettings.class.getName()) .setData(contentUri); diff --git a/src/com/android/settings/homepage/deviceinfo/DeviceInfoSlice.java b/src/com/android/settings/homepage/deviceinfo/DeviceInfoSlice.java index dc315c53515..ded48984fba 100644 --- a/src/com/android/settings/homepage/deviceinfo/DeviceInfoSlice.java +++ b/src/com/android/settings/homepage/deviceinfo/DeviceInfoSlice.java @@ -23,7 +23,6 @@ import android.content.Intent; import android.net.Uri; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; -import android.telephony.TelephonyManager; import android.text.BidiFormatter; import android.text.TextDirectionHeuristics; import android.text.TextUtils; @@ -53,7 +52,7 @@ public class DeviceInfoSlice implements CustomSliceable { /** * The path denotes the unique name of device info slice */ - public static final String PATH_DEVICE_INFO_CARD = "device_info_card"; + public static final String PATH_DEVICE_INFO = "device_info_card"; /** * Backing Uri for the Device info Slice. @@ -61,16 +60,14 @@ public class DeviceInfoSlice implements CustomSliceable { public static final Uri DEVICE_INFO_CARD_URI = new Uri.Builder() .scheme(ContentResolver.SCHEME_CONTENT) .authority(SettingsSliceProvider.SLICE_AUTHORITY) - .appendPath(PATH_DEVICE_INFO_CARD) + .appendPath(PATH_DEVICE_INFO) .build(); private final Context mContext; - private final TelephonyManager mTelephonyManager; private final SubscriptionManager mSubscriptionManager; public DeviceInfoSlice(Context context) { mContext = context; - mTelephonyManager = mContext.getSystemService(TelephonyManager.class); mSubscriptionManager = mContext.getSystemService(SubscriptionManager.class); } @@ -101,9 +98,9 @@ public class DeviceInfoSlice implements CustomSliceable { @Override public Intent getIntent() { final String screenTitle = mContext.getText(R.string.device_info_label).toString(); - final Uri contentUri = new Uri.Builder().appendPath(PATH_DEVICE_INFO_CARD).build(); + final Uri contentUri = new Uri.Builder().appendPath(PATH_DEVICE_INFO).build(); return SliceBuilderUtils.buildSearchResultPageIntent(mContext, - MyDeviceInfoFragment.class.getName(), PATH_DEVICE_INFO_CARD, screenTitle, + MyDeviceInfoFragment.class.getName(), PATH_DEVICE_INFO, screenTitle, MetricsProto.MetricsEvent.SLICE) .setClassName(mContext.getPackageName(), SubSettings.class.getName()) .setData(contentUri); diff --git a/src/com/android/settings/homepage/deviceinfo/EmergencyInfoSlice.java b/src/com/android/settings/homepage/deviceinfo/EmergencyInfoSlice.java new file mode 100644 index 00000000000..62678b37516 --- /dev/null +++ b/src/com/android/settings/homepage/deviceinfo/EmergencyInfoSlice.java @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2018 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.homepage.deviceinfo; + +import android.app.PendingIntent; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.net.Uri; + +import androidx.core.graphics.drawable.IconCompat; +import androidx.slice.Slice; +import androidx.slice.builders.ListBuilder; +import androidx.slice.builders.SliceAction; + +import com.android.settings.R; +import com.android.settings.slices.SettingsSliceProvider; + +// This is a slice helper class for EmergencyInfo +public class EmergencyInfoSlice { + /** + * The path denotes the unique name of emergency info slice. + */ + public static final String PATH_EMERGENCY_INFO_CARD = "emergency_info_card"; + + /** + * Backing Uri for the Emergency Info Slice. + */ + public static final Uri EMERGENCY_INFO_CARD_URI = new Uri.Builder() + .scheme(ContentResolver.SCHEME_CONTENT) + .authority(SettingsSliceProvider.SLICE_AUTHORITY) + .appendPath(PATH_EMERGENCY_INFO_CARD) + .build(); + + private static final String ACTION_EDIT_EMERGENCY_INFO = "android.settings.EDIT_EMERGENCY_INFO"; + + public static Slice getSlice(Context context) { + final ListBuilder listBuilder = new ListBuilder(context, EMERGENCY_INFO_CARD_URI, + ListBuilder.INFINITY); + listBuilder.addRow( + new ListBuilder.RowBuilder() + .setTitle(context.getText(R.string.emergency_info_title)) + .setSubtitle( + context.getText(R.string.emergency_info_contextual_card_summary)) + .setPrimaryAction(generatePrimaryAction(context))); + return listBuilder.build(); + } + + private static SliceAction generatePrimaryAction(Context context) { + PendingIntent pendingIntent = + PendingIntent.getActivity( + context, + 0 /* requestCode */, + new Intent(ACTION_EDIT_EMERGENCY_INFO), + PendingIntent.FLAG_UPDATE_CURRENT); + + return SliceAction.create( + pendingIntent, + IconCompat.createWithResource(context, R.drawable.empty_icon), + ListBuilder.SMALL_IMAGE, + context.getText(R.string.emergency_info_title)); + } +} diff --git a/src/com/android/settings/homepage/deviceinfo/StorageSlice.java b/src/com/android/settings/homepage/deviceinfo/StorageSlice.java index c9464e40061..0f95c57fa03 100644 --- a/src/com/android/settings/homepage/deviceinfo/StorageSlice.java +++ b/src/com/android/settings/homepage/deviceinfo/StorageSlice.java @@ -48,7 +48,7 @@ public class StorageSlice implements CustomSliceable { /** * The path denotes the unique name of storage slicel */ - public static final String PATH_STORAGE_CARD = "storage_card"; + public static final String PATH_STORAGE_INFO = "storage_card"; /** * Backing Uri for the storage slice. @@ -56,7 +56,7 @@ public class StorageSlice implements CustomSliceable { public static final Uri STORAGE_CARD_URI = new Uri.Builder() .scheme(ContentResolver.SCHEME_CONTENT) .authority(SettingsSliceProvider.SLICE_AUTHORITY) - .appendPath(PATH_STORAGE_CARD) + .appendPath(PATH_STORAGE_INFO) .build(); private final Context mContext; @@ -93,9 +93,9 @@ public class StorageSlice implements CustomSliceable { @Override public Intent getIntent() { final String screenTitle = mContext.getText(R.string.storage_label).toString(); - final Uri contentUri = new Uri.Builder().appendPath(PATH_STORAGE_CARD).build(); + final Uri contentUri = new Uri.Builder().appendPath(PATH_STORAGE_INFO).build(); return SliceBuilderUtils.buildSearchResultPageIntent(mContext, - StorageDashboardFragment.class.getName(), PATH_STORAGE_CARD, screenTitle, + StorageDashboardFragment.class.getName(), PATH_STORAGE_INFO, screenTitle, MetricsProto.MetricsEvent.SLICE) .setClassName(mContext.getPackageName(), SubSettings.class.getName()) .setData(contentUri); diff --git a/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java b/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java new file mode 100644 index 00000000000..129ceb13712 --- /dev/null +++ b/src/com/android/settings/network/telephony/DataServiceSetupPreferenceController.java @@ -0,0 +1,91 @@ +/* + * Copyright (C) 2018 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.telephony; + +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.text.TextUtils; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; + +import com.android.internal.telephony.PhoneConstants; +import com.android.settings.core.BasePreferenceController; + +/** + * Preference controller for "Data service setup" + */ +public class DataServiceSetupPreferenceController extends BasePreferenceController { + + private CarrierConfigManager mCarrierConfigManager; + private TelephonyManager mTelephonyManager; + private PersistableBundle mCarrierConfig; + private String mSetupUrl; + private int mSubId; + + public DataServiceSetupPreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mTelephonyManager = context.getSystemService(TelephonyManager.class); + mSetupUrl = Settings.Global.getString(mContext.getContentResolver(), + Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode() + == PhoneConstants.LTE_ON_CDMA_TRUE; + return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + && mCarrierConfig != null + && !mCarrierConfig.getBoolean( + CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL) + && isLteOnCdma && !TextUtils.isEmpty(mSetupUrl) + ? AVAILABLE + : CONDITIONALLY_UNAVAILABLE; + } + + public void init(int subId) { + mSubId = subId; + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + mCarrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (getPreferenceKey().equals(preference.getKey())) { + if (!TextUtils.isEmpty(mSetupUrl)) { + String imsi = mTelephonyManager.getSubscriberId(); + if (imsi == null) { + imsi = ""; + } + final String url = TextUtils.expandTemplate(mSetupUrl, imsi).toString(); + Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); + mContext.startActivity(intent); + } + return true; + } + + return false; + } +} diff --git a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java new file mode 100644 index 00000000000..46773dc01f1 --- /dev/null +++ b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java @@ -0,0 +1,334 @@ +/* + * Copyright (C) 2018 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.telephony; + +import android.content.Context; +import android.content.res.Resources; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.ListPreference; +import androidx.preference.Preference; + +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneConstants; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; + +/** + * Preference controller for "Enabled network mode" + */ +public class EnabledNetworkModePreferenceController extends BasePreferenceController implements + ListPreference.OnPreferenceChangeListener { + + private CarrierConfigManager mCarrierConfigManager; + private TelephonyManager mTelephonyManager; + private PersistableBundle mPersistableBundle; + private int mSubId; + private boolean mIsGlobalCdma; + private boolean mShow4GForLTE; + + public EnabledNetworkModePreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + boolean visible; + if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + visible = false; + } else if (mPersistableBundle == null) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) + && !mTelephonyManager.getServiceState().getRoaming() + && mTelephonyManager.getServiceState().getDataRegState() + == ServiceState.STATE_IN_SERVICE) { + visible = false; + } else if (mPersistableBundle.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { + visible = false; + } else { + visible = true; + } + + return visible ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + final ListPreference listPreference = (ListPreference) preference; + final int networkMode = getPreferredNetworkMode(); + updatePreferenceEntries(listPreference); + updatePreferenceValueAndSummary(listPreference, networkMode); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object object) { + final int settingsMode = Integer.parseInt((String) object); + + if (mTelephonyManager.setPreferredNetworkType(mSubId, settingsMode)) { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + settingsMode); + updatePreferenceValueAndSummary((ListPreference) preference, settingsMode); + return true; + } + + return false; + } + + public void init(int subId) { + mSubId = subId; + mPersistableBundle = mCarrierConfigManager.getConfigForSubId(mSubId); + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + + final boolean isLteOnCdma = + mTelephonyManager.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; + mIsGlobalCdma = isLteOnCdma + && mPersistableBundle.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); + initShow4GForLTE(); + } + + @VisibleForTesting + void initShow4GForLTE() { + mShow4GForLTE = MobileNetworkUtils.isShow4GForLTE(mContext); + } + + private int getPreferredNetworkMode() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + Phone.PREFERRED_NT_MODE); + } + + private void updatePreferenceEntries(ListPreference preference) { + final int phoneType = mTelephonyManager.getPhoneType(); + final Resources resources = mContext.getResources(); + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { + final int lteForced = android.provider.Settings.Global.getInt( + mContext.getContentResolver(), + android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId, + 0); + final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode() + == PhoneConstants.LTE_ON_CDMA_TRUE; + final int settingsNetworkMode = android.provider.Settings.Global.getInt( + mContext.getContentResolver(), + android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + Phone.PREFERRED_NT_MODE); + if (isLteOnCdma) { + if (lteForced == 0) { + preference.setEntries( + R.array.enabled_networks_cdma_choices); + preference.setEntryValues( + R.array.enabled_networks_cdma_values); + } else { + switch (settingsNetworkMode) { + case TelephonyManager.NETWORK_MODE_CDMA_EVDO: + case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: + case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: + preference.setEntries( + R.array.enabled_networks_cdma_no_lte_choices); + preference.setEntryValues( + R.array.enabled_networks_cdma_no_lte_values); + break; + case TelephonyManager.NETWORK_MODE_GLOBAL: + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + case TelephonyManager.NETWORK_MODE_LTE_ONLY: + preference.setEntries( + R.array.enabled_networks_cdma_only_lte_choices); + preference.setEntryValues( + R.array.enabled_networks_cdma_only_lte_values); + break; + default: + preference.setEntries( + R.array.enabled_networks_cdma_choices); + preference.setEntryValues( + R.array.enabled_networks_cdma_values); + break; + } + } + } + } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { + if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { + preference.setEntries( + R.array.enabled_networks_tdscdma_choices); + preference.setEntryValues( + R.array.enabled_networks_tdscdma_values); + } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) + && !resources.getBoolean(R.bool.config_enabled_lte)) { + preference.setEntries(R.array.enabled_networks_except_gsm_lte_choices); + preference.setEntryValues(R.array.enabled_networks_except_gsm_lte_values); + } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { + int select = mShow4GForLTE + ? R.array.enabled_networks_except_gsm_4g_choices + : R.array.enabled_networks_except_gsm_choices; + preference.setEntries(select); + preference.setEntryValues( + R.array.enabled_networks_except_gsm_values); + } else if (!resources.getBoolean(R.bool.config_enabled_lte)) { + preference.setEntries( + R.array.enabled_networks_except_lte_choices); + preference.setEntryValues( + R.array.enabled_networks_except_lte_values); + } else if (mIsGlobalCdma) { + preference.setEntries(R.array.enabled_networks_cdma_choices); + preference.setEntryValues(R.array.enabled_networks_cdma_values); + } else { + int select = mShow4GForLTE ? R.array.enabled_networks_4g_choices + : R.array.enabled_networks_choices; + preference.setEntries(select); + preference.setEntryValues(R.array.enabled_networks_values); + } + } + //TODO(b/117881708): figure out what world mode is, then we can optimize code. Otherwise + // I prefer to keep this old code + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + preference.setEntries( + R.array.preferred_network_mode_choices_world_mode); + preference.setEntryValues( + R.array.preferred_network_mode_values_world_mode); + } + } + + private void updatePreferenceValueAndSummary(ListPreference preference, int networkMode) { + switch (networkMode) { + case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); + preference.setSummary(R.string.network_3G); + break; + case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: + case TelephonyManager.NETWORK_MODE_GSM_UMTS: + case TelephonyManager.NETWORK_MODE_WCDMA_PREF: + if (!mIsGlobalCdma) { + preference.setValue(Integer.toString(TelephonyManager.NETWORK_MODE_WCDMA_PREF)); + preference.setSummary(R.string.network_3G); + } else { + preference.setValue(Integer.toString(TelephonyManager + .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); + preference.setSummary(R.string.network_global); + } + break; + case TelephonyManager.NETWORK_MODE_GSM_ONLY: + if (!mIsGlobalCdma) { + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_GSM_ONLY)); + preference.setSummary(R.string.network_2G); + } else { + preference.setValue( + Integer.toString(TelephonyManager + .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); + preference.setSummary(R.string.network_global); + } + break; + case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + preference.setSummary( + R.string.preferred_network_mode_lte_gsm_umts_summary); + break; + } + case TelephonyManager.NETWORK_MODE_LTE_ONLY: + case TelephonyManager.NETWORK_MODE_LTE_WCDMA: + if (!mIsGlobalCdma) { + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA)); + preference.setSummary( + mShow4GForLTE ? R.string.network_4G : R.string.network_lte); + } else { + preference.setValue( + Integer.toString(TelephonyManager + .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); + preference.setSummary(R.string.network_global); + } + break; + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + preference.setSummary( + R.string.preferred_network_mode_lte_cdma_summary); + } else { + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO)); + preference.setSummary(R.string.network_lte); + } + break; + case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + preference.setValue(Integer.toString(TelephonyManager + .NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); + preference.setSummary(R.string.network_3G); + break; + case TelephonyManager.NETWORK_MODE_CDMA_EVDO: + case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: + case TelephonyManager.NETWORK_MODE_GLOBAL: + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_EVDO)); + preference.setSummary(R.string.network_3G); + break; + case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO)); + preference.setSummary(R.string.network_1x); + break; + case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: + preference.setValue( + Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY)); + preference.setSummary(R.string.network_3G); + break; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { + preference.setValue( + Integer.toString(TelephonyManager + .NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); + preference.setSummary(R.string.network_lte); + } else { + preference.setValue( + Integer.toString(TelephonyManager + .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); + if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA + || mIsGlobalCdma + || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + preference.setSummary(R.string.network_global); + } else { + preference.setSummary(mShow4GForLTE + ? R.string.network_4G : R.string.network_lte); + } + } + break; + default: + preference.setSummary( + mContext.getString(R.string.mobile_network_mode_error, networkMode)); + } + } +} diff --git a/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceController.java b/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceController.java new file mode 100644 index 00000000000..d6773ed3fe6 --- /dev/null +++ b/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceController.java @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2018 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.telephony; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.PhoneStateListener; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; +import androidx.preference.SwitchPreference; + +import com.android.ims.ImsManager; +import com.android.settings.R; +import com.android.settings.core.TogglePreferenceController; +import com.android.settingslib.core.lifecycle.LifecycleObserver; +import com.android.settingslib.core.lifecycle.events.OnStart; +import com.android.settingslib.core.lifecycle.events.OnStop; + +/** + * Preference controller for "Enhanced 4G LTE" + */ +public class Enhanced4gLtePreferenceController extends TogglePreferenceController implements + LifecycleObserver, OnStart, OnStop { + + private Preference mPreference; + private TelephonyManager mTelephonyManager; + private CarrierConfigManager mCarrierConfigManager; + private PersistableBundle mCarrierConfig; + @VisibleForTesting + ImsManager mImsManager; + private PhoneCallStateListener mPhoneStateListener; + private int mSubId; + + public Enhanced4gLtePreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mPhoneStateListener = new PhoneCallStateListener(); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + final boolean isVisible = mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + && mImsManager != null && mCarrierConfig != null + && mImsManager.isVolteEnabledByPlatform() + && mImsManager.isVolteProvisionedOnDevice() + && MobileNetworkUtils.isImsServiceStateReady(mImsManager) + && !mCarrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL); + return isVisible + ? (is4gLtePrefEnabled() ? AVAILABLE : AVAILABLE_UNSEARCHABLE) + : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public void onStart() { + mPhoneStateListener.register(mSubId); + } + + @Override + public void onStop() { + mPhoneStateListener.unregister(); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + final SwitchPreference switchPreference = (SwitchPreference) preference; + final boolean useVariant4glteTitle = mCarrierConfig.getInt( + CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT) != 0; + int enhanced4glteModeTitleId = useVariant4glteTitle ? + R.string.enhanced_4g_lte_mode_title_variant : + R.string.enhanced_4g_lte_mode_title; + switchPreference.setTitle(enhanced4glteModeTitleId); + switchPreference.setEnabled(is4gLtePrefEnabled()); + switchPreference.setChecked(mImsManager.isEnhanced4gLteModeSettingEnabledByUser() + && mImsManager.isNonTtyOrTtyOnVolteEnabled()); + } + + @Override + public boolean setChecked(boolean isChecked) { + mImsManager.setEnhanced4gLteModeSetting(isChecked); + return true; + } + + @Override + public boolean isChecked() { + return mImsManager.isEnhanced4gLteModeSettingEnabledByUser(); + } + + public void init(int subId) { + mSubId = subId; + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + mCarrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + mImsManager = ImsManager.getInstance(mContext, SubscriptionManager.getPhoneId(mSubId)); + } + } + + private boolean is4gLtePrefEnabled() { + return mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID + && mTelephonyManager.getCallState(mSubId) == TelephonyManager.CALL_STATE_IDLE + && mImsManager != null + && mImsManager.isNonTtyOrTtyOnVolteEnabled() + && mCarrierConfig.getBoolean( + CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL); + } + + private class PhoneCallStateListener extends PhoneStateListener { + @Override + public void onCallStateChanged(int state, String incomingNumber) { + updateState(mPreference); + } + + public void register(int subId) { + mSubId = subId; + mTelephonyManager.listen(this, PhoneStateListener.LISTEN_CALL_STATE); + } + + public void unregister() { + mTelephonyManager.listen(this, PhoneStateListener.LISTEN_NONE); + } + } +} diff --git a/src/com/android/settings/network/telephony/MobileNetworkFragment.java b/src/com/android/settings/network/telephony/MobileNetworkFragment.java index dfccab62bf6..cb54e5b17d6 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkFragment.java +++ b/src/com/android/settings/network/telephony/MobileNetworkFragment.java @@ -29,13 +29,10 @@ import android.database.ContentObserver; import android.net.Uri; import android.os.AsyncTask; import android.os.Bundle; -import android.os.Handler; import android.os.Message; import android.os.PersistableBundle; -import android.os.UserHandle; import android.os.UserManager; import android.provider.SearchIndexableResource; -import android.provider.Settings; import android.telecom.PhoneAccountHandle; import android.telecom.TelecomManager; import android.telephony.CarrierConfigManager; @@ -50,7 +47,6 @@ import android.util.Log; import android.view.MenuItem; import androidx.fragment.app.FragmentActivity; -import androidx.preference.ListPreference; import androidx.preference.Preference; import androidx.preference.PreferenceCategory; import androidx.preference.PreferenceFragmentCompat; @@ -71,12 +67,9 @@ import com.android.settings.network.telephony.cdma.CdmaSubscriptionPreferenceCon import com.android.settings.network.telephony.cdma.CdmaSystemSelectPreferenceController; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settings.search.Indexable; -import com.android.settingslib.RestrictedLockUtilsInternal; -import com.android.settingslib.RestrictedSwitchPreference; import com.android.settingslib.search.SearchIndexable; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC) @@ -88,15 +81,6 @@ public class MobileNetworkFragment extends DashboardFragment implements private static final boolean DBG = true; public static final int REQUEST_CODE_EXIT_ECM = 17; - // Number of active Subscriptions to show tabs - private static final int TAB_THRESHOLD = 2; - - // Number of last phone number digits shown in Euicc Setting tab - private static final int NUM_LAST_PHONE_DIGITS = 4; - - // fragment tag for roaming data dialog - private static final String ROAMING_TAG = "RoamingDialogFragment"; - //String keys for preference lookup private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key"; private static final String BUTTON_ROAMING_KEY = "button_roaming_key"; @@ -131,30 +115,13 @@ public class MobileNetworkFragment extends DashboardFragment implements static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE; - //Information about logical "up" Activity - private static final String UP_ACTIVITY_PACKAGE = "com.android.settings"; - private static final String UP_ACTIVITY_CLASS = - "com.android.settings.Settings$WirelessSettingsActivity"; - - //Information that needs to save into Bundle. - private static final String EXPAND_ADVANCED_FIELDS = "expand_advanced_fields"; - //Intent extra to indicate expand all fields. - private static final String EXPAND_EXTRA = "expandable"; - - private enum TabState { - NO_TABS, UPDATE, DO_NOTHING - } - private SubscriptionManager mSubscriptionManager; private TelephonyManager mTelephonyManager; private CarrierConfigManager mCarrierConfigManager; private int mSubId; //UI objects - private ListPreference mButtonPreferredNetworkMode; - private ListPreference mButtonEnabledNetworks; private SwitchPreference mButton4glte; - private Preference mLteDataServicePref; private Preference mEuiccSettingsPref; private PreferenceCategory mCallingCategory; private Preference mWiFiCallingPref; @@ -169,7 +136,6 @@ public class MobileNetworkFragment extends DashboardFragment implements private UserManager mUm; private ImsManager mImsMgr; - private MyHandler mHandler; private boolean mOkClicked; //GsmUmts options and Cdma options @@ -193,7 +159,6 @@ public class MobileNetworkFragment extends DashboardFragment implements public void onCallStateChanged(int state, String incomingNumber) { if (DBG) log("PhoneStateListener.onCallStateChanged: state=" + state); - updateEnhanced4gLteState(); updateWiFiCallState(); updateVideoCallState(); updatePreferredNetworkType(); @@ -257,52 +222,15 @@ public class MobileNetworkFragment extends DashboardFragment implements REQUEST_CODE_EXIT_ECM); } return true; - } else if (preference == mButtonPreferredNetworkMode) { - //displays the value taken from the Settings.System - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId, - preferredNetworkMode); - mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); - return true; - } else if (preference == mLteDataServicePref) { - String tmpl = android.provider.Settings.Global.getString( - getContext().getContentResolver(), - android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); - if (!TextUtils.isEmpty(tmpl)) { - String imsi = mTelephonyManager.getSubscriberId(); - if (imsi == null) { - imsi = ""; - } - final String url = TextUtils.isEmpty(tmpl) ? null - : TextUtils.expandTemplate(tmpl, imsi).toString(); - Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); - startActivity(intent); - } else { - android.util.Log.e(LOG_TAG, "Missing SETUP_PREPAID_DATA_SERVICE_URL"); - } - return true; - } else if (preference == mButtonEnabledNetworks) { - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId, - preferredNetworkMode); - mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); - return true; } else if (preference == mEuiccSettingsPref) { Intent intent = new Intent(EuiccManager.ACTION_MANAGE_EMBEDDED_SUBSCRIPTIONS); startActivity(intent); return true; } else if (preference == mWiFiCallingPref || preference == mVideoCallingPref) { return false; - } else { - // if the button is anything but the simple toggle preference, - // we'll need to disable all preferences to reject all click - // events until the sub-activity's UI comes up. - getPreferenceScreen().setEnabled(false); - // Let the intents be launched by the Preference manager - return false; } + + return true; } private final SubscriptionManager.OnSubscriptionsChangedListener @@ -315,15 +243,6 @@ public class MobileNetworkFragment extends DashboardFragment implements } }; - private int getSlotIdFromIntent(Intent intent) { - Bundle data = intent.getExtras(); - int subId = -1; - if (data != null) { - subId = data.getInt(Settings.EXTRA_SUB_ID, -1); - } - return SubscriptionManager.getSlotIndex(subId); - } - private void initializeSubscriptions() { final FragmentActivity activity = getActivity(); if (activity == null) { @@ -335,39 +254,6 @@ public class MobileNetworkFragment extends DashboardFragment implements if (DBG) log("initializeSubscriptions:-"); } - private TabState isUpdateTabsNeeded(List newSil) { - TabState state = TabState.DO_NOTHING; - if (newSil == null) { - if (mActiveSubInfos.size() >= TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: NO_TABS, size unknown and was tabbed"); - state = TabState.NO_TABS; - } - } else if (newSil.size() < TAB_THRESHOLD && mActiveSubInfos.size() >= TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: NO_TABS, size went to small"); - state = TabState.NO_TABS; - } else if (newSil.size() >= TAB_THRESHOLD && mActiveSubInfos.size() < TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: UPDATE, size changed"); - state = TabState.UPDATE; - } else if (newSil.size() >= TAB_THRESHOLD) { - Iterator siIterator = mActiveSubInfos.iterator(); - for(SubscriptionInfo newSi : newSil) { - SubscriptionInfo curSi = siIterator.next(); - if (!newSi.getDisplayName().equals(curSi.getDisplayName())) { - if (DBG) log("isUpdateTabsNeeded: UPDATE, new name=" - + newSi.getDisplayName()); - state = TabState.UPDATE; - break; - } - } - } - if (DBG) { - Log.i(LOG_TAG, "isUpdateTabsNeeded:- " + state - + " newSil.size()=" + ((newSil != null) ? newSil.size() : 0) - + " mActiveSubInfos.size()=" + mActiveSubInfos.size()); - } - return state; - } - private void updatePhone() { if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { mImsMgr = ImsManager.getInstance(getContext(), @@ -389,6 +275,10 @@ public class MobileNetworkFragment extends DashboardFragment implements use(CdmaApnPreferenceController.class).init(mSubId); use(CarrierPreferenceController.class).init(mSubId); use(DataUsagePreferenceController.class).init(mSubId); + use(PreferredNetworkModePreferenceController.class).init(mSubId); + use(EnabledNetworkModePreferenceController.class).init(mSubId); + use(Enhanced4gLtePreferenceController.class).init(mSubId); + use(DataServiceSetupPreferenceController.class).init(mSubId); mCdmaSystemSelectPreferenceController = use(CdmaSystemSelectPreferenceController.class); mCdmaSystemSelectPreferenceController.init(getPreferenceManager(), mSubId); @@ -407,7 +297,6 @@ public class MobileNetworkFragment extends DashboardFragment implements return; } - mHandler = new MyHandler(); mUm = (UserManager) context.getSystemService(Context.USER_SERVICE); mSubscriptionManager = SubscriptionManager.from(context); mTelephonyManager = (TelephonyManager) context.getSystemService( @@ -415,7 +304,6 @@ public class MobileNetworkFragment extends DashboardFragment implements mCarrierConfigManager = new CarrierConfigManager(getContext()); mButton4glte = (SwitchPreference)findPreference(BUTTON_4G_LTE_KEY); - mButton4glte.setOnPreferenceChangeListener(this); mCallingCategory = (PreferenceCategory) findPreference(CATEGORY_CALLING_KEY); mWiFiCallingPref = findPreference(BUTTON_WIFI_CALLING_KEY); @@ -434,13 +322,6 @@ public class MobileNetworkFragment extends DashboardFragment implements //get UI object references PreferenceScreen prefSet = getPreferenceScreen(); - mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference( - BUTTON_PREFERED_NETWORK_MODE); - mButtonEnabledNetworks = (ListPreference) prefSet.findPreference( - BUTTON_ENABLED_NETWORKS_KEY); - - mLteDataServicePref = prefSet.findPreference(BUTTON_CDMA_LTE_DATA_SERVICE_KEY); - mEuiccSettingsPref = prefSet.findPreference(BUTTON_CARRIER_SETTINGS_EUICC_KEY); mEuiccSettingsPref.setOnPreferenceChangeListener(this); @@ -449,9 +330,6 @@ public class MobileNetworkFragment extends DashboardFragment implements mActiveSubInfos = mSubscriptionManager.getActiveSubscriptionInfoList(); updatePhone(); - if (hasActiveSubscriptions()) { - updateEnabledNetworksEntries(); - } Log.i(LOG_TAG, "onCreate:-"); } @@ -510,16 +388,8 @@ public class MobileNetworkFragment extends DashboardFragment implements // preferences. getPreferenceScreen().setEnabled(true); - if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null - || getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { - updatePreferredNetworkUIFromDb(); - } - mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); - // NOTE: Buttons will be enabled/disabled in mPhoneStateListener - updateEnhanced4gLteState(); - // Video calling and WiFi calling state might have changed. updateCallingCategory(); @@ -598,10 +468,6 @@ public class MobileNetworkFragment extends DashboardFragment implements log("updateBody: isLteOnCdma=" + isLteOnCdma + " phoneSubId=" + phoneSubId); } - prefSet.addPreference(mButtonPreferredNetworkMode); - prefSet.addPreference(mButtonEnabledNetworks); - prefSet.addPreference(mButton4glte); - if (MobileNetworkUtils.showEuiccSettings(getContext())) { prefSet.addPreference(mEuiccSettingsPref); String spn = mTelephonyManager.getSimOperatorName(); @@ -622,16 +488,11 @@ public class MobileNetworkFragment extends DashboardFragment implements && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); if (carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { - prefSet.removePreference(mButtonPreferredNetworkMode); - prefSet.removePreference(mButtonEnabledNetworks); - prefSet.removePreference(mLteDataServicePref); } else if (carrierConfig.getBoolean(CarrierConfigManager .KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) && !mTelephonyManager.getServiceState().getRoaming() && mTelephonyManager.getServiceState().getDataRegState() == ServiceState.STATE_IN_SERVICE) { - prefSet.removePreference(mButtonPreferredNetworkMode); - prefSet.removePreference(mButtonEnabledNetworks); final int phoneType = mTelephonyManager.getPhoneType(); if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { @@ -645,32 +506,18 @@ public class MobileNetworkFragment extends DashboardFragment implements // in case it is currently something else. That is possible if user // changed the setting while roaming and is now back to home network. settingsNetworkMode = preferredNetworkMode; - } else if (carrierConfig.getBoolean( - CarrierConfigManager.KEY_WORLD_PHONE_BOOL) == true) { - prefSet.removePreference(mButtonEnabledNetworks); + } else if (carrierConfig.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { // set the listener for the mButtonPreferredNetworkMode list preference so we can issue // change Preferred Network Mode. - mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this); updateCdmaOptions(this, prefSet, mSubId); updateGsmUmtsOptions(this, prefSet, phoneSubId); - } else { - prefSet.removePreference(mButtonPreferredNetworkMode); - updateEnabledNetworksEntries(); - mButtonEnabledNetworks.setOnPreferenceChangeListener(this); - if (DBG) log("settingsNetworkMode: " + settingsNetworkMode); } final boolean missingDataServiceUrl = TextUtils.isEmpty( android.provider.Settings.Global.getString(activity.getContentResolver(), android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL)); - if (!isLteOnCdma || missingDataServiceUrl) { - prefSet.removePreference(mLteDataServicePref); - } else { - android.util.Log.d(LOG_TAG, "keep ltePref"); - } - updateEnhanced4gLteState(); updatePreferredNetworkType(); updateCallingCategory(); @@ -686,38 +533,8 @@ public class MobileNetworkFragment extends DashboardFragment implements } } - // Get the networkMode from Settings.System and displays it - mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); - mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); - UpdatePreferredNetworkModeSummary(settingsNetworkMode); - UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); - // Display preferred network type based on what modem returns b/18676277 - new SetPreferredNetworkAsyncTask( - mTelephonyManager, - mSubId, - settingsNetworkMode, - mHandler.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)) - .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); - - /** - * Enable/disable depending upon if there are any active subscriptions. - * - * I've decided to put this enable/disable code at the bottom as the - * code above works even when there are no active subscriptions, thus - * putting it afterwards is a smaller change. This can be refined later, - * but you do need to remember that this all needs to work when subscriptions - * change dynamically such as when hot swapping sims. - */ - boolean useVariant4glteTitle = carrierConfig.getBoolean( - CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_BOOL); - int enhanced4glteModeTitleId = useVariant4glteTitle ? - R.string.enhanced_4g_lte_mode_title_variant : - R.string.enhanced_4g_lte_mode_title; - mOnlyAutoSelectInHomeNW = carrierConfig.getBoolean( CarrierConfigManager.KEY_ONLY_AUTO_SELECT_IN_HOME_NETWORK_BOOL); - mButton4glte.setTitle(enhanced4glteModeTitleId); - mLteDataServicePref.setEnabled(hasActiveSubscriptions); Preference ps; ps = findPreference(BUTTON_CELL_BROADCAST_SETTINGS); if (ps != null) { @@ -759,105 +576,6 @@ public class MobileNetworkFragment extends DashboardFragment implements } } - // Requires that mSubId is up to date - void updateEnabledNetworksEntries() { - final int phoneType = mTelephonyManager.getPhoneType(); - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); - if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { - final int lteForced = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId, - 0); - final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode() - == PhoneConstants.LTE_ON_CDMA_TRUE; - final int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId, - preferredNetworkMode); - if (isLteOnCdma) { - if (lteForced == 0) { - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_cdma_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_cdma_values); - } else { - switch (settingsNetworkMode) { - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_cdma_no_lte_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_cdma_no_lte_values); - break; - case TelephonyManager.NETWORK_MODE_GLOBAL: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_cdma_only_lte_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_cdma_only_lte_values); - break; - default: - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_cdma_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_cdma_values); - break; - } - } - } - updateCdmaOptions(this, getPreferenceScreen(), mSubId); - - } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { - if (isSupportTdscdma()) { - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_tdscdma_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_tdscdma_values); - } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) - && !getResources().getBoolean(R.bool.config_enabled_lte)) { - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_except_gsm_lte_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_except_gsm_lte_values); - } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { - int select = mShow4GForLTE - ? R.array.enabled_networks_except_gsm_4g_choices - : R.array.enabled_networks_except_gsm_choices; - mButtonEnabledNetworks.setEntries(select); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_except_gsm_values); - } else if (!getResources().getBoolean(R.bool.config_enabled_lte)) { - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_except_lte_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_except_lte_values); - } else if (mIsGlobalCdma) { - mButtonEnabledNetworks.setEntries( - R.array.enabled_networks_cdma_choices); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_cdma_values); - } else { - int select = mShow4GForLTE ? R.array.enabled_networks_4g_choices - : R.array.enabled_networks_choices; - mButtonEnabledNetworks.setEntries(select); - mButtonEnabledNetworks.setEntryValues( - R.array.enabled_networks_values); - } - updateGsmUmtsOptions(this, getPreferenceScreen(), mSubId); - } else { - throw new IllegalStateException("Unexpected phone type: " + phoneType); - } - if (isWorldMode()) { - mButtonEnabledNetworks.setEntries( - R.array.preferred_network_mode_choices_world_mode); - mButtonEnabledNetworks.setEntryValues( - R.array.preferred_network_mode_values_world_mode); - } - } - @Override public void onPause() { super.onPause(); @@ -884,122 +602,7 @@ public class MobileNetworkFragment extends DashboardFragment implements */ public boolean onPreferenceChange(Preference preference, Object objValue) { sendMetricsEventPreferenceChanged(getPreferenceScreen(), preference, objValue); - - final int phoneSubId = mSubId; - if (preference == mButtonPreferredNetworkMode) { - //NOTE onPreferenceChange seems to be called even if there is no change - //Check if the button value is changed from the System.Setting - mButtonPreferredNetworkMode.setValue((String) objValue); - int buttonNetworkMode; - buttonNetworkMode = Integer.parseInt((String) objValue); - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - preferredNetworkMode); - if (buttonNetworkMode != settingsNetworkMode) { - int modemNetworkMode; - // if new mode is invalid ignore it - switch (buttonNetworkMode) { - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_GSM_UMTS: - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - case TelephonyManager.NETWORK_MODE_GLOBAL: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - case TelephonyManager.NETWORK_MODE_LTE_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - // This is one of the modes we recognize - modemNetworkMode = buttonNetworkMode; - break; - default: - loge("Invalid Network Mode (" +buttonNetworkMode+ ") chosen. Ignore."); - return true; - } - - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - buttonNetworkMode ); - //Set the modem network mode - new SetPreferredNetworkAsyncTask( - mTelephonyManager, - mSubId, - modemNetworkMode, - mHandler.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)) - .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); - } - } else if (preference == mButtonEnabledNetworks) { - mButtonEnabledNetworks.setValue((String) objValue); - int buttonNetworkMode; - buttonNetworkMode = Integer.parseInt((String) objValue); - if (DBG) log("buttonNetworkMode: " + buttonNetworkMode); - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - preferredNetworkMode); - if (buttonNetworkMode != settingsNetworkMode) { - int modemNetworkMode; - // if new mode is invalid ignore it - switch (buttonNetworkMode) { - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - // This is one of the modes we recognize - modemNetworkMode = buttonNetworkMode; - break; - default: - loge("Invalid Network Mode (" +buttonNetworkMode+ ") chosen. Ignore."); - return true; - } - - UpdateEnabledNetworksValueAndSummary(buttonNetworkMode); - - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - buttonNetworkMode ); - //Set the modem network mode - new SetPreferredNetworkAsyncTask( - mTelephonyManager, - mSubId, - modemNetworkMode, - mHandler.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)) - .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); - } - } else if (preference == mButton4glte) { - boolean enhanced4gMode = !mButton4glte.isChecked(); - mButton4glte.setChecked(enhanced4gMode); - mImsMgr.setEnhanced4gLteModeSetting(mButton4glte.isChecked()); - } else if (preference == mVideoCallingPref) { + if (preference == mVideoCallingPref) { // If mButton4glte is not checked, mVideoCallingPref should be disabled. // So it only makes sense to call phoneMgr.enableVideoCalling if it's checked. if (mButton4glte.isChecked()) { @@ -1026,317 +629,6 @@ public class MobileNetworkFragment extends DashboardFragment implements CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL); } - private class MyHandler extends Handler { - - static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 0; - - @Override - public void handleMessage(Message msg) { - switch (msg.what) { - case MESSAGE_SET_PREFERRED_NETWORK_TYPE: - handleSetPreferredNetworkTypeResponse(msg); - break; - } - } - - private void handleSetPreferredNetworkTypeResponse(Message msg) { - final FragmentActivity activity = getActivity(); - if (activity == null || activity.isDestroyed()) { - // Access preferences of activity only if it is not destroyed - // or if fragment is not attached to an activity. - return; - } - - boolean success = (boolean) msg.obj; - - if (success) { - int networkMode; - if (getPreferenceScreen().findPreference( - BUTTON_PREFERED_NETWORK_MODE) != null) { - networkMode = Integer.parseInt(mButtonPreferredNetworkMode.getValue()); - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE - + mSubId, - networkMode ); - } - if (getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { - networkMode = Integer.parseInt(mButtonEnabledNetworks.getValue()); - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE - + mSubId, - networkMode ); - } - } else { - Log.i(LOG_TAG, "handleSetPreferredNetworkTypeResponse:" + - "exception in setting network mode."); - updatePreferredNetworkUIFromDb(); - } - } - } - - private void updatePreferredNetworkUIFromDb() { - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId, - preferredNetworkMode); - - if (DBG) { - log("updatePreferredNetworkUIFromDb: settingsNetworkMode = " + - settingsNetworkMode); - } - - UpdatePreferredNetworkModeSummary(settingsNetworkMode); - UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); - // changes the mButtonPreferredNetworkMode accordingly to settingsNetworkMode - mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); - } - - private void UpdatePreferredNetworkModeSummary(int NetworkMode) { - switch(NetworkMode) { - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_gsm_summary); - break; - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_wcdma_perf_summary); - break; - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_gsm_only_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_wcdma_only_summary); - break; - case TelephonyManager.NETWORK_MODE_GSM_UMTS: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - switch (mTelephonyManager.getLteOnCdmaMode()) { - case PhoneConstants.LTE_ON_CDMA_TRUE: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_summary); - break; - case PhoneConstants.LTE_ON_CDMA_FALSE: - default: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_evdo_summary); - break; - } - break; - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_only_summary); - break; - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_evdo_only_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_gsm_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_cdma_evdo_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA - || mIsGlobalCdma - || isWorldMode()) { - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_global_summary); - } else { - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_summary); - } - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_GLOBAL: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_wcdma_summary); - break; - default: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_global_summary); - } - } - - private void UpdateEnabledNetworksValueAndSummary(int NetworkMode) { - switch (NetworkMode) { - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_3G); - break; - case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_GSM_UMTS: - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - if (!mIsGlobalCdma) { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_WCDMA_PREF)); - mButtonEnabledNetworks.setSummary(R.string.network_3G); - } else { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_global); - } - break; - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - if (!mIsGlobalCdma) { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_GSM_ONLY)); - mButtonEnabledNetworks.setSummary(R.string.network_2G); - } else { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_global); - } - break; - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - if (isWorldMode()) { - mButtonEnabledNetworks.setSummary( - R.string.preferred_network_mode_lte_gsm_umts_summary); - controlCdmaOptions(false); - controlGsmOptions(true); - break; - } - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - case TelephonyManager.NETWORK_MODE_LTE_WCDMA: - if (!mIsGlobalCdma) { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) - ? R.string.network_4G : R.string.network_lte); - } else { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_global); - } - break; - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - if (isWorldMode()) { - mButtonEnabledNetworks.setSummary( - R.string.preferred_network_mode_lte_cdma_summary); - controlCdmaOptions(true); - controlGsmOptions(false); - } else { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO)); - mButtonEnabledNetworks.setSummary(R.string.network_lte); - } - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_3G); - break; - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - case TelephonyManager.NETWORK_MODE_GLOBAL: - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_EVDO)); - mButtonEnabledNetworks.setSummary(R.string.network_3G); - break; - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO)); - mButtonEnabledNetworks.setSummary(R.string.network_1x); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY)); - mButtonEnabledNetworks.setSummary(R.string.network_3G); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - if (isSupportTdscdma()) { - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); - mButtonEnabledNetworks.setSummary(R.string.network_lte); - } else { - if (isWorldMode()) { - controlCdmaOptions(true); - controlGsmOptions(false); - } - mButtonEnabledNetworks.setValue( - Integer.toString(TelephonyManager - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA - || mIsGlobalCdma - || isWorldMode()) { - mButtonEnabledNetworks.setSummary(R.string.network_global); - } else { - mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) - ? R.string.network_4G : R.string.network_lte); - } - } - break; - default: - String errMsg = "Invalid Network Mode (" + NetworkMode + "). Ignore."; - loge(errMsg); - mButtonEnabledNetworks.setSummary(errMsg); - } - } - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { @@ -1414,29 +706,6 @@ public class MobileNetworkFragment extends DashboardFragment implements == TelephonyManager.CALL_STATE_IDLE && hasActiveSubscriptions()); } - private void updateEnhanced4gLteState() { - if (mButton4glte == null) { - return; - } - - PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); - - if ((mImsMgr == null - || !mImsMgr.isVolteEnabledByPlatform() - || !mImsMgr.isVolteProvisionedOnDevice() - || !MobileNetworkUtils.isImsServiceStateReady(mImsMgr) - || carrierConfig.getBoolean( - CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL))) { - getPreferenceScreen().removePreference(mButton4glte); - } else { - mButton4glte.setEnabled(is4gLtePrefEnabled(carrierConfig) - && hasActiveSubscriptions()); - boolean enh4glteMode = mImsMgr.isEnhanced4gLteModeSettingEnabledByUser() - && mImsMgr.isNonTtyOrTtyOnVolteEnabled(); - mButton4glte.setChecked(enh4glteMode); - } - } - private void updateVideoCallState() { if (mVideoCallingPref == null || mCallingCategory == null) { return; @@ -1471,15 +740,6 @@ public class MobileNetworkFragment extends DashboardFragment implements mSubId) == TelephonyManager.CALL_STATE_IDLE && hasActiveSubscriptions(); Log.i(LOG_TAG, "updatePreferredNetworkType: " + enabled); - // TODO: Disentangle enabled networks vs preferred network mode, it looks like - // both buttons are shown to the user as "Preferred network type" and the options change - // based on what looks like World mode. - if (mButtonEnabledNetworks != null) { - mButtonEnabledNetworks.setEnabled(enabled); - } - if (mButtonPreferredNetworkMode != null) { - mButtonPreferredNetworkMode.setEnabled(enabled); - } } private void updateCallingCategory() { @@ -1620,10 +880,8 @@ public class MobileNetworkFragment extends DashboardFragment implements // For ListPreferences, we log it here without a value, only indicating it's clicked to // open the list dialog. When a value is chosen, another MetricsEvent is logged with // new value in onPreferenceChange. - if (preference == mLteDataServicePref - || preference == mEuiccSettingsPref - || preference == mWiFiCallingPref || preference == mButtonPreferredNetworkMode - || preference == mButtonEnabledNetworks + if (preference == mEuiccSettingsPref + || preference == mWiFiCallingPref || preference == preferenceScreen.findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY) || preference == preferenceScreen.findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY) || preference == preferenceScreen.findPreference(BUTTON_GSM_APN_EXPAND_KEY) @@ -1641,11 +899,9 @@ public class MobileNetworkFragment extends DashboardFragment implements } // MetricsEvent logging with new value, for SwitchPreferences and ListPreferences. - if (preference == mButton4glte || preference == mVideoCallingPref) { + if (preference == mVideoCallingPref) { MetricsLogger.action(getContext(), category, (Boolean) newValue); - } else if (preference == mButtonPreferredNetworkMode - || preference == mButtonEnabledNetworks - || preference == preferenceScreen + } else if (preference == preferenceScreen .findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY) || preference == preferenceScreen .findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY)) { @@ -1659,14 +915,6 @@ public class MobileNetworkFragment extends DashboardFragment implements if (preference == null) { return MetricsProto.MetricsEvent.VIEW_UNKNOWN; - } else if (preference == mLteDataServicePref) { - return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SET_UP_DATA_SERVICE; - } else if (preference == mButton4glte) { - return MetricsProto.MetricsEvent.ACTION_MOBILE_ENHANCED_4G_LTE_MODE_TOGGLE; - } else if (preference == mButtonPreferredNetworkMode) { - return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SELECT_PREFERRED_NETWORK; - } else if (preference == mButtonEnabledNetworks) { - return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SELECT_ENABLED_NETWORK; } else if (preference == mEuiccSettingsPref) { return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_EUICC_SETTING; } else if (preference == mWiFiCallingPref) { diff --git a/src/com/android/settings/network/telephony/MobileNetworkUtils.java b/src/com/android/settings/network/telephony/MobileNetworkUtils.java index 8950178dd40..fca523a5b24 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java +++ b/src/com/android/settings/network/telephony/MobileNetworkUtils.java @@ -318,6 +318,27 @@ public class MobileNetworkUtils { return worldModeOn; } + public static boolean isShow4GForLTE(Context context) { + //TODO(b/117882862): move this to framework + try { + Context con = context.createPackageContext("com.android.systemui", 0); + int id = con.getResources().getIdentifier("config_show4GForLTE", + "bool", "com.android.systemui"); + return con.getResources().getBoolean(id); + } catch (PackageManager.NameNotFoundException e) { + Log.e(TAG, "NameNotFoundException for show4GFotLTE"); + return false; + } + } + + /** + * Return {@code true} if Tdscdma is supported in current subscription + */ + public static boolean isTdscdmaSupported(Context context, int subId) { + return isTdscdmaSupported(context, + TelephonyManager.from(context).createForSubscriptionId(subId)); + } + //TODO(b/117651939): move it to telephony private static boolean isTdscdmaSupported(Context context, TelephonyManager telephonyManager) { if (context.getResources().getBoolean(R.bool.config_support_tdscdma)) { diff --git a/src/com/android/settings/network/telephony/MobileSettingsActivity.java b/src/com/android/settings/network/telephony/MobileSettingsActivity.java index 920b23d0722..ec740c91109 100644 --- a/src/com/android/settings/network/telephony/MobileSettingsActivity.java +++ b/src/com/android/settings/network/telephony/MobileSettingsActivity.java @@ -71,7 +71,7 @@ public class MobileSettingsActivity extends SettingsBaseActivity { super.onCreate(savedInstanceState); setContentView(R.layout.mobile_settings_container); - setActionBar(findViewById(R.id.action_bar)); + setActionBar(findViewById(R.id.mobile_action_bar)); mSubscriptionManager = getSystemService(SubscriptionManager.class); mSubscriptionInfos = mSubscriptionManager.getActiveSubscriptionInfoList(); mCurSubscriptionId = savedInstanceState != null diff --git a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java new file mode 100644 index 00000000000..f60f927a32e --- /dev/null +++ b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2018 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.telephony; + +import android.content.Context; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.ListPreference; +import androidx.preference.Preference; + +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneConstants; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; + +/** + * Preference controller for "Preferred network mode" + */ +public class PreferredNetworkModePreferenceController extends BasePreferenceController implements + ListPreference.OnPreferenceChangeListener { + + private CarrierConfigManager mCarrierConfigManager; + private TelephonyManager mTelephonyManager; + private PersistableBundle mPersistableBundle; + private int mSubId; + private boolean mIsGlobalCdma; + + public PreferredNetworkModePreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + boolean visible; + if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + visible = false; + } else if (mPersistableBundle == null) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) + && !mTelephonyManager.getServiceState().getRoaming() + && mTelephonyManager.getServiceState().getDataRegState() + == ServiceState.STATE_IN_SERVICE) { + visible = false; + } else if (mPersistableBundle.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { + visible = true; + } else { + visible = false; + } + + return visible ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + final ListPreference listPreference = (ListPreference) preference; + final int networkMode = getPreferredNetworkMode(); + listPreference.setValue(Integer.toString(networkMode)); + listPreference.setSummary(getPreferredNetworkModeSummaryResId(networkMode)); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object object) { + final int settingsMode = Integer.parseInt((String) object); + + if (mTelephonyManager.setPreferredNetworkType(mSubId, settingsMode)) { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + settingsMode); + return true; + } + + return false; + } + + public void init(int subId) { + mSubId = subId; + mPersistableBundle = mCarrierConfigManager.getConfigForSubId(mSubId); + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + + final boolean isLteOnCdma = + mTelephonyManager.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; + mIsGlobalCdma = isLteOnCdma + && mPersistableBundle.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); + } + + private int getPreferredNetworkMode() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + Phone.PREFERRED_NT_MODE); + } + + private int getPreferredNetworkModeSummaryResId(int NetworkMode) { + //TODO(b/114749736): refactor it to "Preferred network mode: ", instead of building + // string for each type... + switch (NetworkMode) { + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: + return R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: + return R.string.preferred_network_mode_tdscdma_gsm_summary; + case TelephonyManager.NETWORK_MODE_WCDMA_PREF: + return R.string.preferred_network_mode_wcdma_perf_summary; + case TelephonyManager.NETWORK_MODE_GSM_ONLY: + return R.string.preferred_network_mode_gsm_only_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: + return R.string.preferred_network_mode_tdscdma_wcdma_summary; + case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: + return R.string.preferred_network_mode_wcdma_only_summary; + case TelephonyManager.NETWORK_MODE_GSM_UMTS: + return R.string.preferred_network_mode_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_CDMA_EVDO: + switch (mTelephonyManager.getLteOnCdmaMode()) { + case PhoneConstants.LTE_ON_CDMA_TRUE: + return R.string.preferred_network_mode_cdma_summary; + default: + return R.string.preferred_network_mode_cdma_evdo_summary; + } + case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: + return R.string.preferred_network_mode_cdma_only_summary; + case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: + return R.string.preferred_network_mode_evdo_only_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: + return R.string.preferred_network_mode_lte_tdscdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_ONLY: + return R.string.preferred_network_mode_lte_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: + return R.string.preferred_network_mode_lte_tdscdma_gsm_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: + return R.string.preferred_network_mode_lte_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: + return R.string.preferred_network_mode_lte_cdma_evdo_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: + return R.string.preferred_network_mode_tdscdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA + || mIsGlobalCdma + || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + return R.string.preferred_network_mode_global_summary; + } else { + return R.string.preferred_network_mode_lte_summary; + } + case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + return R.string.preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_GLOBAL: + return R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_WCDMA: + return R.string.preferred_network_mode_lte_wcdma_summary; + default: + return R.string.preferred_network_mode_global_summary; + } + } +} diff --git a/src/com/android/settings/search/SearchFeatureProvider.java b/src/com/android/settings/search/SearchFeatureProvider.java index 27e8349c162..b2eb8bbb3fc 100644 --- a/src/com/android/settings/search/SearchFeatureProvider.java +++ b/src/com/android/settings/search/SearchFeatureProvider.java @@ -23,6 +23,7 @@ import android.app.Activity; import android.content.ComponentName; import android.content.Context; import android.content.Intent; +import android.provider.Settings; import android.view.View; import android.widget.Toolbar; @@ -35,7 +36,7 @@ import com.android.settingslib.search.SearchIndexableResources; */ public interface SearchFeatureProvider { - Intent SEARCH_UI_INTENT = new Intent("com.android.settings.action.SETTINGS_SEARCH"); + Intent SEARCH_UI_INTENT = new Intent(Settings.ACTION_APP_SEARCH_SETTINGS); int REQUEST_CODE = 0; /** diff --git a/src/com/android/settings/slices/CustomSliceable.java b/src/com/android/settings/slices/CustomSliceable.java index 48b5d161db0..e09cc7386f7 100644 --- a/src/com/android/settings/slices/CustomSliceable.java +++ b/src/com/android/settings/slices/CustomSliceable.java @@ -89,6 +89,16 @@ public interface CustomSliceable { return null; } + /** + * Settings Slices which can represent component lists that are updatable by the + * {@link SliceBackgroundWorker} returned here. + * + * @return a {@link SliceBackgroundWorker} for fetching the list of results in the background. + */ + default SliceBackgroundWorker getBackgroundWorker() { + return null; + } + /** * Standardize the intents returned to indicate actions by the Slice. *

diff --git a/src/com/android/settings/slices/SettingsSliceProvider.java b/src/com/android/settings/slices/SettingsSliceProvider.java index 8b975b4c518..08ed0d8bf15 100644 --- a/src/com/android/settings/slices/SettingsSliceProvider.java +++ b/src/com/android/settings/slices/SettingsSliceProvider.java @@ -28,6 +28,7 @@ import android.os.StrictMode; import android.provider.Settings; import android.provider.SettingsSlicesContract; import android.text.TextUtils; +import android.util.ArrayMap; import android.util.ArraySet; import android.util.KeyValueListParser; import android.util.Log; @@ -41,6 +42,7 @@ import com.android.settings.R; import com.android.settings.bluetooth.BluetoothSliceBuilder; import com.android.settings.core.BasePreferenceController; import com.android.settings.flashlight.FlashlightSliceBuilder; +import com.android.settings.homepage.deviceinfo.EmergencyInfoSlice; import com.android.settings.location.LocationSliceBuilder; import com.android.settings.network.telephony.Enhanced4gLteSliceHelper; import com.android.settings.notification.ZenModeSliceBuilder; @@ -131,6 +133,8 @@ public class SettingsSliceProvider extends SliceProvider { final Set mRegisteredUris = new ArraySet<>(); + final Map mWorkerMap = new ArrayMap<>(); + public SettingsSliceProvider() { super(READ_SEARCH_INDEXABLES); } @@ -165,6 +169,7 @@ public class SettingsSliceProvider extends SliceProvider { if (filter != null) { registerIntentToUri(filter, sliceUri); } + startBackgroundWorker(sliceable); return; } @@ -178,6 +183,8 @@ public class SettingsSliceProvider extends SliceProvider { registerIntentToUri(FlashlightSliceBuilder.INTENT_FILTER, sliceUri); mRegisteredUris.add(sliceUri); return; + } else if (EmergencyInfoSlice.EMERGENCY_INFO_CARD_URI.equals(sliceUri)) { + return; } // Start warming the slice, we expect someone will want it soon. @@ -191,6 +198,7 @@ public class SettingsSliceProvider extends SliceProvider { SliceBroadcastRelay.unregisterReceivers(getContext(), sliceUri); mRegisteredUris.remove(sliceUri); } + stopBackgroundWorker(sliceUri); mSliceDataCache.remove(sliceUri); } @@ -241,6 +249,8 @@ public class SettingsSliceProvider extends SliceProvider { .createWifiCallingPreferenceSlice(sliceUri); } else if (FlashlightSliceBuilder.FLASHLIGHT_URI.equals(sliceUri)) { return FlashlightSliceBuilder.getSlice(getContext()); + } else if (EmergencyInfoSlice.EMERGENCY_INFO_CARD_URI.equals(sliceUri)) { + return EmergencyInfoSlice.getSlice(getContext()); } SliceData cachedSliceData = mSliceWeakDataCache.get(sliceUri); @@ -348,6 +358,31 @@ public class SettingsSliceProvider extends SliceProvider { } } + private void startBackgroundWorker(CustomSliceable sliceable) { + final SliceBackgroundWorker worker = sliceable.getBackgroundWorker(); + if (worker == null) { + return; + } + + final Uri uri = sliceable.getUri(); + Log.d(TAG, "Starting background worker for: " + uri); + if (mWorkerMap.containsKey(uri)) { + return; + } + + mWorkerMap.put(uri, worker); + worker.onSlicePinned(); + } + + private void stopBackgroundWorker(Uri uri) { + final SliceBackgroundWorker worker = mWorkerMap.get(uri); + if (worker != null) { + Log.d(TAG, "Stopping background worker for: " + uri); + worker.onSliceUnpinned(); + mWorkerMap.remove(uri); + } + } + private List buildUrisFromKeys(List keys, String authority) { final List descendants = new ArrayList<>(); diff --git a/src/com/android/settings/slices/SliceBackgroundWorker.java b/src/com/android/settings/slices/SliceBackgroundWorker.java new file mode 100644 index 00000000000..7178eadbdc5 --- /dev/null +++ b/src/com/android/settings/slices/SliceBackgroundWorker.java @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2018 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.slices; + +import android.content.ContentResolver; +import android.net.Uri; + +import java.util.ArrayList; +import java.util.List; + +/** + * The Slice background worker is used to make Settings Slices be able to work with data that is + * changing continuously, e.g. available Wi-Fi networks. + * + * The background worker will be started at {@link SettingsSliceProvider#onSlicePinned(Uri)}, and be + * stopped at {@link SettingsSliceProvider#onSliceUnpinned(Uri)}. + * + * {@link SliceBackgroundWorker} caches the results, uses the cache to compare if there is any data + * changed, and then notifies the Slice {@link Uri} to update. + */ +public abstract class SliceBackgroundWorker { + + private final ContentResolver mContentResolver; + private final Uri mUri; + + private List mCachedResults; + + protected SliceBackgroundWorker(ContentResolver cr, Uri uri) { + mContentResolver = cr; + mUri = uri; + } + + /** + * Called when the Slice is pinned. This is the place to register callbacks or initialize scan + * tasks. + */ + protected abstract void onSlicePinned(); + + /** + * Called when the Slice is unpinned. This is the place to unregister callbacks or perform any + * final cleanup. + */ + protected abstract void onSliceUnpinned(); + + /** + * @return a {@link List} of cached results + */ + public final List getResults() { + return mCachedResults == null ? null : new ArrayList<>(mCachedResults); + } + + /** + * Update the results when data changes + */ + protected final void updateResults(List results) { + boolean needNotify = false; + + if (results == null) { + if (mCachedResults != null) { + needNotify = true; + } + } else { + needNotify = !results.equals(mCachedResults); + } + + if (needNotify) { + mCachedResults = results; + mContentResolver.notifyChange(mUri, null); + } + } +} diff --git a/src/com/android/settings/wifi/WifiDialogActivity.java b/src/com/android/settings/wifi/WifiDialogActivity.java index 63785e6902f..e3a03ad55c9 100644 --- a/src/com/android/settings/wifi/WifiDialogActivity.java +++ b/src/com/android/settings/wifi/WifiDialogActivity.java @@ -37,12 +37,6 @@ public class WifiDialogActivity extends Activity implements WifiDialog.WifiDialo private static final String TAG = "WifiDialogActivity"; - private static final int RESULT_CONNECTED = RESULT_FIRST_USER; - private static final int RESULT_FORGET = RESULT_FIRST_USER + 1; - - private static final String KEY_ACCESS_POINT_STATE = "access_point_state"; - private static final String KEY_WIFI_CONFIGURATION = "wifi_configuration"; - /** * Boolean extra indicating whether this activity should connect to an access point on the * caller's behalf. If this is set to false, the caller should check @@ -51,6 +45,11 @@ public class WifiDialogActivity extends Activity implements WifiDialog.WifiDialo */ @VisibleForTesting static final String KEY_CONNECT_FOR_CALLER = "connect_for_caller"; + static final String KEY_ACCESS_POINT_STATE = "access_point_state"; + private static final String KEY_WIFI_CONFIGURATION = "wifi_configuration"; + + private static final int RESULT_CONNECTED = RESULT_FIRST_USER; + private static final int RESULT_FORGET = RESULT_FIRST_USER + 1; private WifiDialog mDialog; diff --git a/src/com/android/settings/wifi/WifiSlice.java b/src/com/android/settings/wifi/WifiSlice.java index d0b14e383c7..536be6f3862 100644 --- a/src/com/android/settings/wifi/WifiSlice.java +++ b/src/com/android/settings/wifi/WifiSlice.java @@ -29,6 +29,9 @@ import android.net.Uri; import android.net.wifi.WifiInfo; import android.net.wifi.WifiManager; import android.net.wifi.WifiSsid; +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; import android.provider.SettingsSlicesContract; import android.text.TextUtils; @@ -42,8 +45,16 @@ import com.android.internal.logging.nano.MetricsProto.MetricsEvent; import com.android.settings.R; import com.android.settings.SubSettings; import com.android.settings.Utils; +import com.android.settings.core.SubSettingLauncher; import com.android.settings.slices.CustomSliceable; +import com.android.settings.slices.SliceBackgroundWorker; import com.android.settings.slices.SliceBuilderUtils; +import com.android.settings.wifi.details.WifiNetworkDetailsFragment; +import com.android.settingslib.wifi.AccessPoint; +import com.android.settingslib.wifi.WifiTracker; + +import java.util.ArrayList; +import java.util.List; /** * Utility class to build a Wifi Slice, and handle all associated actions. @@ -96,14 +107,73 @@ public class WifiSlice implements CustomSliceable { final SliceAction toggleSliceAction = new SliceAction(toggleAction, null /* actionTitle */, isWifiEnabled); - return new ListBuilder(mContext, WIFI_URI, ListBuilder.INFINITY) + final ListBuilder listBuilder = new ListBuilder(mContext, WIFI_URI, ListBuilder.INFINITY) .setAccentColor(color) .addRow(new RowBuilder() .setTitle(title) .setSubtitle(summary) .addEndItem(toggleSliceAction) - .setPrimaryAction(primarySliceAction)) - .build(); + .setPrimaryAction(primarySliceAction)); + + if (isWifiEnabled) { + final List result = getBackgroundWorker().getResults(); + if (result != null && !result.isEmpty()) { + for (AccessPoint ap : result) { + listBuilder.addRow(getAccessPointRow(ap)); + } + listBuilder.setSeeMoreAction(primaryAction); + } + } + return listBuilder.build(); + } + + private RowBuilder getAccessPointRow(AccessPoint accessPoint) { + final String title = accessPoint.getConfigName(); + final IconCompat levelIcon = IconCompat.createWithResource(mContext, + com.android.settingslib.Utils.getWifiIconResource(accessPoint.getLevel())); + final RowBuilder rowBuilder = new RowBuilder() + .setTitleItem(levelIcon, ListBuilder.ICON_IMAGE) + .setTitle(title) + .setSubtitle(accessPoint.getSettingsSummary()) + .setPrimaryAction(new SliceAction( + getAccessPointAction(accessPoint), levelIcon, title)); + + final IconCompat endIcon = getEndIcon(accessPoint); + if (endIcon != null) { + rowBuilder.addEndItem(endIcon, ListBuilder.ICON_IMAGE); + } + return rowBuilder; + } + + private IconCompat getEndIcon(AccessPoint accessPoint) { + if (accessPoint.isActive()) { + return IconCompat.createWithResource(mContext, R.drawable.ic_settings); + } else if (accessPoint.getSecurity() != AccessPoint.SECURITY_NONE) { + return IconCompat.createWithResource(mContext, R.drawable.ic_friction_lock_closed); + } else if (accessPoint.isMetered()) { + return IconCompat.createWithResource(mContext, R.drawable.ic_friction_money); + } + return null; + } + + private PendingIntent getAccessPointAction(AccessPoint accessPoint) { + final Bundle extras = new Bundle(); + accessPoint.saveWifiState(extras); + + Intent intent; + if (accessPoint.isActive()) { + intent = new SubSettingLauncher(mContext) + .setTitleRes(R.string.pref_title_network_details) + .setDestination(WifiNetworkDetailsFragment.class.getName()) + .setArguments(extras) + .setSourceMetricsCategory(MetricsEvent.WIFI) + .toIntent(); + } else { + intent = new Intent(mContext, WifiDialogActivity.class); + intent.putExtra(WifiDialogActivity.KEY_ACCESS_POINT_STATE, extras); + } + return PendingIntent.getActivity(mContext, accessPoint.hashCode() /* requestCode */, + intent, 0 /* flags */); } /** @@ -176,4 +246,75 @@ public class WifiSlice implements CustomSliceable { return PendingIntent.getActivity(mContext, 0 /* requestCode */, intent, 0 /* flags */); } + + @Override + public SliceBackgroundWorker getBackgroundWorker() { + return WifiScanWorker.getInstance(mContext, WIFI_URI); + } + + private static class WifiScanWorker extends SliceBackgroundWorker + implements WifiTracker.WifiListener { + + private static WifiScanWorker mWifiScanWorker; + + private final Context mContext; + + private WifiTracker mWifiTracker; + private WifiManager mWifiManager; + + private WifiScanWorker(Context context, Uri uri) { + super(context.getContentResolver(), uri); + mContext = context; + } + + public static WifiScanWorker getInstance(Context context, Uri uri) { + if (mWifiScanWorker == null) { + mWifiScanWorker = new WifiScanWorker(context, uri); + } + return mWifiScanWorker; + } + + @Override + protected void onSlicePinned() { + new Handler(Looper.getMainLooper()).post(() -> { + mWifiTracker = new WifiTracker(mContext, this, true, true); + mWifiManager = mWifiTracker.getManager(); + mWifiTracker.onStart(); + onAccessPointsChanged(); + }); + } + + @Override + protected void onSliceUnpinned() { + mWifiTracker.onStop(); + mWifiTracker.onDestroy(); + mWifiScanWorker = null; + } + + @Override + public void onWifiStateChanged(int state) { + } + + @Override + public void onConnectedChanged() { + } + + @Override + public void onAccessPointsChanged() { + // in case state has changed + if (!mWifiManager.isWifiEnabled()) { + updateResults(null); + return; + } + // AccessPoints are sorted by the WifiTracker + final List accessPoints = mWifiTracker.getAccessPoints(); + final List resultList = new ArrayList<>(); + for (AccessPoint ap : accessPoints) { + if (ap.isReachable()) { + resultList.add(ap); + } + } + updateResults(resultList); + } + } } diff --git a/tests/robotests/src/com/android/settings/homepage/CardContentLoaderTest.java b/tests/robotests/src/com/android/settings/homepage/CardContentLoaderTest.java index defe0d9f759..a7527f37b1f 100644 --- a/tests/robotests/src/com/android/settings/homepage/CardContentLoaderTest.java +++ b/tests/robotests/src/com/android/settings/homepage/CardContentLoaderTest.java @@ -57,15 +57,14 @@ public class CardContentLoaderTest { public void createStaticCards_shouldReturnTwoCards() { final List defaultData = mCardContentLoader.createStaticCards(); - assertThat(defaultData).hasSize(3); + assertThat(defaultData).hasSize(2); } @Test public void createStaticCards_shouldContainDataUsageAndDeviceInfo() { final Uri dataUsage = DataUsageSlice.DATA_USAGE_CARD_URI; final Uri deviceInfo = DeviceInfoSlice.DEVICE_INFO_CARD_URI; - final Uri storageInfo = StorageSlice.STORAGE_CARD_URI; - final List expectedUris = Arrays.asList(dataUsage, deviceInfo, storageInfo); + final List expectedUris = Arrays.asList(dataUsage, deviceInfo); final List actualCardUris = mCardContentLoader.createStaticCards().stream().map( ContextualCard::getSliceUri).collect(Collectors.toList()); @@ -105,7 +104,7 @@ public class CardContentLoaderTest { return new ContextualCard.Builder() .setName("test_card") .setCardType(ContextualCard.CardType.SLICE) - .setSliceUri(sliceUri) + .setSliceUri(Uri.parse(sliceUri)) .build(); } } diff --git a/tests/robotests/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProviderTest.java b/tests/robotests/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProviderTest.java index a80b963c594..2c42379f86e 100644 --- a/tests/robotests/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProviderTest.java +++ b/tests/robotests/src/com/android/settings/homepage/contextualcards/SettingsContextualCardProviderTest.java @@ -32,6 +32,7 @@ import com.google.android.settings.intelligence.libs.contextualcards.ContextualC import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.robolectric.Robolectric; import org.robolectric.RuntimeEnvironment; @RunWith(SettingsRobolectricTestRunner.class) @@ -40,6 +41,7 @@ public class SettingsContextualCardProviderTest { private Context mContext; private ContentResolver mResolver; private Uri mUri; + private SettingsContextualCardProvider mProvider; @Before public void setUp() { @@ -49,15 +51,18 @@ public class SettingsContextualCardProviderTest { .scheme(ContentResolver.SCHEME_CONTENT) .authority(SettingsContextualCardProvider.CARD_AUTHORITY) .build(); + mProvider = Robolectric.setupContentProvider(SettingsContextualCardProvider.class); } @Test public void contentProviderCall_returnCorrectSize() throws Exception { + final int actualNo = mProvider.getContextualCards().getCardCount(); + final Bundle returnValue = mResolver.call(mUri, ContextualCardProvider.METHOD_GET_CARD_LIST, "", null); final ContextualCardList cards = - ContextualCardList.parseFrom( - returnValue.getByteArray(ContextualCardProvider.BUNDLE_CARD_LIST)); - assertThat(cards.getCardCount()).isEqualTo(2); + ContextualCardList.parseFrom( + returnValue.getByteArray(ContextualCardProvider.BUNDLE_CARD_LIST)); + assertThat(cards.getCardCount()).isEqualTo(actualNo); } } \ No newline at end of file diff --git a/tests/robotests/src/com/android/settings/homepage/slices/SliceContextualCardRendererTest.java b/tests/robotests/src/com/android/settings/homepage/slices/SliceContextualCardRendererTest.java index c597a6e4fb0..c5ca8d79487 100644 --- a/tests/robotests/src/com/android/settings/homepage/slices/SliceContextualCardRendererTest.java +++ b/tests/robotests/src/com/android/settings/homepage/slices/SliceContextualCardRendererTest.java @@ -21,6 +21,7 @@ import static com.google.common.truth.Truth.assertThat; import static org.mockito.Mockito.spy; import android.content.Context; +import android.net.Uri; import android.view.LayoutInflater; import android.view.View; @@ -108,7 +109,7 @@ public class SliceContextualCardRendererTest { private ContextualCard buildContextualCard(String sliceUri) { return new ContextualCard.Builder() .setName("test_name") - .setSliceUri(sliceUri) + .setSliceUri(Uri.parse(sliceUri)) .build(); } } diff --git a/tests/robotests/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java new file mode 100644 index 00000000000..644a5bc0c34 --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/DataServiceSetupPreferenceControllerTest.java @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2018 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.telephony; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +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.verify; + +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.text.TextUtils; + +import androidx.preference.Preference; + +import com.android.internal.telephony.PhoneConstants; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settingslib.RestrictedPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class DataServiceSetupPreferenceControllerTest { + private static final int SUB_ID = 2; + + private static final String SETUP_URL = "url://tmp_url:^1"; + + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private TelephonyManager mInvalidTelephonyManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mCarrierConfig; + private DataServiceSetupPreferenceController mController; + private Preference mPreference; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); + doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); + doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); + Settings.Global.putString(mContext.getContentResolver(), + Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL, SETUP_URL); + + mCarrierConfig = new PersistableBundle(); + doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + + mPreference = new RestrictedPreference(mContext); + mController = new DataServiceSetupPreferenceController(mContext, "data_service_setup"); + mController.init(SUB_ID); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void getAvailabilityStatus_allConfigOn_returnAvailable() { + doReturn(PhoneConstants.LTE_ON_CDMA_TRUE).when(mTelephonyManager).getLteOnCdmaMode(); + mCarrierConfig.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void getAvailabilityStatus_missUrl_returnUnavailable() { + Settings.Global.putString(mContext.getContentResolver(), + Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL, ""); + doReturn(PhoneConstants.LTE_ON_CDMA_TRUE).when(mTelephonyManager).getLteOnCdmaMode(); + mCarrierConfig.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + + mController = new DataServiceSetupPreferenceController(mContext, "data_service_setup"); + mController.init(SUB_ID); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_notCdma_returnUnavailable() { + doReturn(PhoneConstants.LTE_ON_CDMA_FALSE).when(mTelephonyManager).getLteOnCdmaMode(); + mCarrierConfig.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void handlePreferenceTreeClick_startActivity() { + ArgumentCaptor captor = ArgumentCaptor.forClass(Intent.class); + + mController.handlePreferenceTreeClick(mPreference); + + verify(mContext).startActivity(captor.capture()); + + final Intent intent = captor.getValue(); + assertThat(intent.getAction()).isEqualTo(Intent.ACTION_VIEW); + assertThat(intent.getData()).isEqualTo( + Uri.parse(TextUtils.expandTemplate(SETUP_URL, "").toString())); + } +} diff --git a/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java new file mode 100644 index 00000000000..71df401dcb3 --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java @@ -0,0 +1,145 @@ +/* + * Copyright (C) 2018 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.telephony; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.doNothing; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.ListPreference; + +import com.android.settings.R; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class EnabledNetworkModePreferenceControllerTest { + private static final int SUB_ID = 2; + + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private TelephonyManager mInvalidTelephonyManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mPersistableBundle; + private EnabledNetworkModePreferenceController mController; + private ListPreference mPreference; + private Context mContext; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); + doReturn(mTelephonyManager).when(mContext).getSystemService(TelephonyManager.class); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); + doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); + doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt()); + mPersistableBundle = new PersistableBundle(); + doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + + mPreference = new ListPreference(mContext); + mPreference.setEntries(R.array.enabled_networks_choices); + mPreference.setEntryValues(R.array.enabled_networks_values); + mController = spy(new EnabledNetworkModePreferenceController(mContext, "enabled_network")); + doNothing().when(mController).initShow4GForLTE(); + mController.init(SUB_ID); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_notWorldPhone_returnAvailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL, false); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void updateState_updateByNetworkMode() { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); + assertThat(mPreference.getSummary()).isEqualTo("3G"); + } + + @Test + public void onPreferenceChange_updateSuccess() { + doReturn(true).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isEqualTo( + TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA); + } + + @Test + public void onPreferenceChange_updateFail() { + doReturn(false).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isNotEqualTo( + TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA); + } + +} diff --git a/tests/robotests/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceControllerTest.java new file mode 100644 index 00000000000..dee4c5ec6db --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/Enhanced4gLtePreferenceControllerTest.java @@ -0,0 +1,138 @@ +/* + * Copyright (C) 2018 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.telephony; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.SwitchPreference; + +import com.android.ims.ImsManager; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; +import com.android.settings.testutils.SettingsRobolectricTestRunner; +import com.android.settingslib.RestrictedSwitchPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class Enhanced4gLtePreferenceControllerTest { + private static final int SUB_ID = 2; + + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private TelephonyManager mInvalidTelephonyManager; + @Mock + private SubscriptionManager mSubscriptionManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + @Mock + private ImsManager mImsManager; + + private Enhanced4gLtePreferenceController mController; + private SwitchPreference mPreference; + private PersistableBundle mCarrierConfig; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); + doReturn(mSubscriptionManager).when(mContext).getSystemService(SubscriptionManager.class); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); + 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); + + mPreference = new RestrictedSwitchPreference(mContext); + mController = new Enhanced4gLtePreferenceController(mContext, "roaming"); + mController.mImsManager = mImsManager; + mController.init(SUB_ID); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void getAvailabilityStatus_invalidSubId_returnUnavailable() { + mController.init(SubscriptionManager.INVALID_SUBSCRIPTION_ID); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_volteDisabled_returnUnavailable() { + doReturn(false).when(mImsManager).isVolteEnabledByPlatform(); + doReturn(true).when(mImsManager).isVolteProvisionedOnDevice(); + + assertThat(mController.getAvailabilityStatus()).isEqualTo( + BasePreferenceController.CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void updateState_variant4gLte_useVariantTitle() { + mCarrierConfig.putInt(CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT, 1); + + mController.updateState(mPreference); + + assertThat(mPreference.getTitle()).isEqualTo( + mContext.getString(R.string.enhanced_4g_lte_mode_title_variant)); + } + + @Test + public void updateState_configEnabled_prefEnabled() { + mPreference.setEnabled(false); + mCarrierConfig.putInt(CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_INT, 1); + doReturn(TelephonyManager.CALL_STATE_IDLE).when(mTelephonyManager).getCallState(SUB_ID); + doReturn(true).when(mImsManager).isNonTtyOrTtyOnVolteEnabled(); + mCarrierConfig.putBoolean(CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL, true); + + mController.updateState(mPreference); + + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void updateState_configOn_prefChecked() { + mPreference.setChecked(false); + doReturn(true).when(mImsManager).isEnhanced4gLteModeSettingEnabledByUser(); + doReturn(true).when(mImsManager).isNonTtyOrTtyOnVolteEnabled(); + + mController.updateState(mPreference); + + assertThat(mPreference.isChecked()).isTrue(); + } + +} diff --git a/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java new file mode 100644 index 00000000000..d11e11c185b --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2018 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.telephony; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.fragment.app.FragmentManager; +import androidx.preference.ListPreference; + +import com.android.settings.R; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class PreferredNetworkModePreferenceControllerTest { + private static final int SUB_ID = 2; + + @Mock + private FragmentManager mFragmentManager; + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private TelephonyManager mInvalidTelephonyManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mPersistableBundle; + private PreferredNetworkModePreferenceController mController; + private ListPreference mPreference; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); + doReturn(mTelephonyManager).when(mContext).getSystemService(TelephonyManager.class); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); + 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); + + mPreference = new ListPreference(mContext); + mPreference.setEntries(R.array.preferred_network_mode_choices); + mPreference.setEntryValues(R.array.preferred_network_mode_values); + mController = new PreferredNetworkModePreferenceController(mContext, "mobile_data"); + mController.init(SUB_ID); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_worldPhone_returnAvailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL, true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void updateState_updateByNetworkMode() { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); + assertThat(mPreference.getSummary()).isEqualTo( + mContext.getString(R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary)); + } + + @Test + public void onPreferenceChange_updateSuccess() { + doReturn(true).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_TDSCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isEqualTo( + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + } + + @Test + public void onPreferenceChange_updateFail() { + doReturn(false).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_TDSCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isNotEqualTo( + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + } + +} diff --git a/tests/robotests/src/com/android/settings/search/SearchFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/search/SearchFeatureProviderImplTest.java index adb5e43b17f..ba29ea1a9e3 100644 --- a/tests/robotests/src/com/android/settings/search/SearchFeatureProviderImplTest.java +++ b/tests/robotests/src/com/android/settings/search/SearchFeatureProviderImplTest.java @@ -24,6 +24,7 @@ import static org.mockito.Mockito.spy; import android.app.Activity; import android.content.ComponentName; import android.content.Intent; +import android.provider.Settings; import android.widget.Toolbar; import com.android.settings.testutils.FakeFeatureFactory; @@ -63,7 +64,7 @@ public class SearchFeatureProviderImplTest { final Intent launchIntent = Shadows.shadowOf(mActivity).getNextStartedActivity(); assertThat(launchIntent.getAction()) - .isEqualTo("com.android.settings.action.SETTINGS_SEARCH"); + .isEqualTo(Settings.ACTION_APP_SEARCH_SETTINGS); } @Test(expected = IllegalArgumentException.class) diff --git a/tests/robotests/src/com/android/settings/slices/SettingsSliceProviderTest.java b/tests/robotests/src/com/android/settings/slices/SettingsSliceProviderTest.java index f7c6bba76e2..19f3d329b1d 100644 --- a/tests/robotests/src/com/android/settings/slices/SettingsSliceProviderTest.java +++ b/tests/robotests/src/com/android/settings/slices/SettingsSliceProviderTest.java @@ -118,7 +118,7 @@ public class SettingsSliceProviderTest { mProvider.mSliceWeakDataCache = new HashMap<>(); mProvider.mSliceDataCache = new HashMap<>(); mProvider.mSlicesDatabaseAccessor = new SlicesDatabaseAccessor(mContext); - mProvider.mCustomSliceManager = new CustomSliceManager(mContext); + mProvider.mCustomSliceManager = spy(new CustomSliceManager(mContext)); when(mProvider.getContext()).thenReturn(mContext); mDb = SlicesDatabaseHelper.getInstance(mContext).getWritableDatabase(); @@ -481,6 +481,44 @@ public class SettingsSliceProviderTest { mProvider.onSlicePinned(uri); } + private SliceBackgroundWorker initBackgroundWorker(Uri uri) { + final SliceBackgroundWorker worker = spy(new SliceBackgroundWorker( + mContext.getContentResolver(), uri) { + @Override + public void onSlicePinned() { + } + + @Override + public void onSliceUnpinned() { + } + }); + final WifiSlice wifiSlice = spy(new WifiSlice(mContext)); + when(wifiSlice.getBackgroundWorker()).thenReturn(worker); + when(mProvider.mCustomSliceManager.getSliceableFromUri(uri)).thenReturn(wifiSlice); + return worker; + } + + @Test + public void onSlicePinned_backgroundWorker_started() { + final Uri uri = WifiSlice.WIFI_URI; + final SliceBackgroundWorker worker = initBackgroundWorker(uri); + + mProvider.onSlicePinned(uri); + + verify(worker).onSlicePinned(); + } + + @Test + public void onSlicePinned_backgroundWorker_stopped() { + final Uri uri = WifiSlice.WIFI_URI; + final SliceBackgroundWorker worker = initBackgroundWorker(uri); + + mProvider.onSlicePinned(uri); + mProvider.onSliceUnpinned(uri); + + verify(worker).onSliceUnpinned(); + } + @Test public void grantWhitelistedPackagePermissions_noWhitelist_shouldNotGrant() { final List uris = new ArrayList<>(); diff --git a/tests/unit/src/com/android/settings/homepage/CardContentLoaderTest.java b/tests/unit/src/com/android/settings/homepage/CardContentLoaderTest.java index 1f762bbf0ec..38a1f5a65b0 100644 --- a/tests/unit/src/com/android/settings/homepage/CardContentLoaderTest.java +++ b/tests/unit/src/com/android/settings/homepage/CardContentLoaderTest.java @@ -19,6 +19,7 @@ package com.android.settings.homepage; import static com.google.common.truth.Truth.assertThat; import android.content.Context; +import android.net.Uri; import android.support.test.InstrumentationRegistry; import android.support.test.runner.AndroidJUnit4; @@ -61,7 +62,7 @@ public class CardContentLoaderTest { return new ContextualCard.Builder() .setName("test_card") .setCardType(ContextualCard.CardType.SLICE) - .setSliceUri(sliceUri) + .setSliceUri(Uri.parse(sliceUri)) .build(); } }