diff --git a/res/xml/gsm_umts_options.xml b/res/xml/gsm_umts_options.xml index 1d1d4f3aa6f..cf565959e8a 100644 --- a/res/xml/gsm_umts_options.xml +++ b/res/xml/gsm_umts_options.xml @@ -16,28 +16,6 @@ --> - - - - - - - - - - - - + android:key="network_operators_category_key" + android:title="@string/network_operator_category" + settings:controller="com.android.settings.widget.PreferenceCategoryController"> + + + + + + + { - mTelephonyManager.setNetworkSelectionModeAutomatic(); - // Because TelephonyManager#setNetworkSelectionModeAutomatic doesn't have a - // return value, we query the current network selection mode to tell if the - // TelephonyManager#setNetworkSelectionModeAutomatic is successed. - int networkSelectionMode = mTelephonyManager.getNetworkSelectionMode(); - Message msg = mHandler.obtainMessage(EVENT_AUTO_SELECT_DONE); - msg.obj = networkSelectionMode == TelephonyManager.NETWORK_SELECTION_MODE_AUTO; - msg.sendToTarget(); - }); - } - } else { - if (mEnableNewManualSelectNetworkUI) { - if (mChooseNetwork != null) { - // Open the choose Network page automatically when user turn off the auto-select - openChooseNetworkPage(); - } - } else { - if (mNetworkSelect != null) { - mNetworkSelect.onClick(); - } - } - } - } - - protected void getNetworkSelectionMode() { - if (DBG) logd("getting network selection mode..."); - ThreadUtils.postOnBackgroundThread(() -> { - int networkSelectionMode = mTelephonyManager.getNetworkSelectionMode(); - Message msg = mHandler.obtainMessage(EVENT_GET_NETWORK_SELECTION_MODE_DONE); - msg.arg1 = networkSelectionMode; - msg.sendToTarget(); - }); - } - - private void dismissProgressBar() { - if (mProgressDialog != null && mProgressDialog.isShowing()) { - mProgressDialog.dismiss(); - } - } - - private void showAutoSelectProgressBar() { - mProgressDialog.setMessage( - getContext().getResources().getString(R.string.register_automatically)); - mProgressDialog.setCanceledOnTouchOutside(false); - mProgressDialog.setCancelable(false); - mProgressDialog.setIndeterminate(true); - mProgressDialog.show(); - } - - /** - * Open the Choose network page via {@alink NetworkSelectSettingActivity} - */ - public void openChooseNetworkPage() { - //TODO(b/114749736): Build intent without calling static method - Intent intent = new Intent(); - getContext().startActivity(intent); - } - - protected boolean preferenceTreeClick(Preference preference) { - if (mEnableNewManualSelectNetworkUI) { - if (DBG) logd("enable New AutoSelectNetwork UI"); - if (preference == mChooseNetwork) { - openChooseNetworkPage(); - } - return (preference == mAutoSelect || preference == mChooseNetwork); - } else { - return (preference == mAutoSelect || preference == mNetworkSelect); - } - } - - private void logd(String msg) { - Log.d(LOG_TAG, "[NetworksList] " + msg); - } - - private void loge(String msg) { - Log.e(LOG_TAG, "[NetworksList] " + msg); - } -} diff --git a/src/com/android/settings/network/telephony/NetworkSelectListPreference.java b/src/com/android/settings/network/telephony/NetworkSelectListPreference.java deleted file mode 100644 index ceb0efad661..00000000000 --- a/src/com/android/settings/network/telephony/NetworkSelectListPreference.java +++ /dev/null @@ -1,506 +0,0 @@ -/* - * 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.app.ProgressDialog; -import android.content.Context; -import android.content.DialogInterface; -import android.os.AsyncTask; -import android.os.Handler; -import android.os.Message; -import android.os.Parcel; -import android.os.Parcelable; -import android.telephony.CellInfo; -import android.telephony.CellInfoCdma; -import android.telephony.CellInfoGsm; -import android.telephony.CellInfoLte; -import android.telephony.CellInfoWcdma; -import android.telephony.SubscriptionManager; -import android.telephony.TelephonyManager; -import android.text.BidiFormatter; -import android.text.TextDirectionHeuristics; -import android.text.TextUtils; -import android.util.AttributeSet; -import android.util.Log; -import android.widget.Toast; - -import com.android.internal.logging.MetricsLogger; -import com.android.internal.logging.nano.MetricsProto.MetricsEvent; -import com.android.internal.telephony.OperatorInfo; -import com.android.settings.R; -import com.android.settingslib.utils.ThreadUtils; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; - -import androidx.preference.ListPreference; -import androidx.preference.Preference; - - -/** - * "Networks" preference in "Mobile network" settings UI for the Phone app. - * It's used to manually search and choose mobile network. Enabled only when - * autoSelect preference is turned off. - */ -public class NetworkSelectListPreference extends ListPreference - implements DialogInterface.OnCancelListener, - Preference.OnPreferenceChangeListener{ - - private static final String LOG_TAG = "networkSelect"; - private static final boolean DBG = true; - - private static final int EVENT_MANUALLY_NETWORK_SELECTION_DONE = 1; - private static final int EVENT_NETWORK_SCAN_RESULTS = 2; - private static final int EVENT_NETWORK_SCAN_COMPLETED = 3; - private static final int EVENT_NETWORK_SCAN_ERROR = 4; - - //dialog ids - private static final int DIALOG_NETWORK_SELECTION = 100; - private static final int DIALOG_NETWORK_LIST_LOAD = 200; - - private final ExecutorService mNetworkScanExecutor = Executors.newFixedThreadPool(1); - - private List mCellInfoList; - private CellInfo mCellInfo; - - private int mSubId; - private TelephonyManager mTelephonyManager; - private NetworkScanHelper mNetworkScanHelper; - private NetworkOperators mNetworkOperators; - private List mForbiddenPlmns; - - private ProgressDialog mProgressDialog; - public NetworkSelectListPreference(Context context, AttributeSet attrs) { - super(context, attrs); - } - - public NetworkSelectListPreference(Context context, AttributeSet attrs, int defStyleAttr, - int defStyleRes) { - super(context, attrs, defStyleAttr, defStyleRes); - } - - @Override - protected void onClick() { - showProgressDialog(DIALOG_NETWORK_LIST_LOAD); - TelephonyManager telephonyManager = (TelephonyManager) - getContext().getSystemService(Context.TELEPHONY_SERVICE); - new AsyncTask>() { - @Override - protected List doInBackground(Void... voids) { - String[] forbiddenPlmns = telephonyManager.getForbiddenPlmns(); - return forbiddenPlmns != null ? Arrays.asList(forbiddenPlmns) : null; - } - - @Override - protected void onPostExecute(List result) { - mForbiddenPlmns = result; - loadNetworksList(); - } - }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); - } - - private final Handler mHandler = new Handler() { - @Override - public void handleMessage(Message msg) { - switch (msg.what) { - case EVENT_MANUALLY_NETWORK_SELECTION_DONE: - if (DBG) logd("hideProgressPanel"); - dismissProgressDialog(); - - boolean isSuccessed = (boolean) msg.obj; - if (isSuccessed) { - if (DBG) { - logd("manual network selection: succeeded! " - + getNetworkTitle(mCellInfo)); - } - mNetworkOperators.displayNetworkSelectionSucceeded(); - } else { - if (DBG) logd("manual network selection: failed!"); - mNetworkOperators.displayNetworkSelectionFailed(); - } - mNetworkOperators.getNetworkSelectionMode(); - break; - - case EVENT_NETWORK_SCAN_RESULTS: - List results = (List) msg.obj; - results.removeIf(cellInfo -> cellInfo == null); - mCellInfoList = new ArrayList<>(results); - if (DBG) logd("CALLBACK_SCAN_RESULTS" + mCellInfoList.toString()); - break; - - case EVENT_NETWORK_SCAN_COMPLETED: - if (DBG) logd("scan complete, load the cellInfosList"); - dismissProgressDialog(); - networksListLoaded(); - break; - case EVENT_NETWORK_SCAN_ERROR: - dismissProgressDialog(); - displayNetworkQueryFailed(); - mNetworkOperators.getNetworkSelectionMode(); - break; - } - return; - } - }; - - private final NetworkScanHelper.NetworkScanCallback mCallback = - new NetworkScanHelper.NetworkScanCallback() { - public void onResults(List results) { - if (DBG) logd("get scan results: " + results.toString()); - Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_RESULTS, results); - msg.sendToTarget(); - } - - public void onComplete() { - if (DBG) logd("network scan completed."); - Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_COMPLETED); - msg.sendToTarget(); - } - - public void onError(int error) { - if (DBG) logd("network scan error."); - Message msg = mHandler.obtainMessage(EVENT_NETWORK_SCAN_ERROR); - msg.sendToTarget(); - } - }; - - @Override - //implemented for DialogInterface.OnCancelListener - public void onCancel(DialogInterface dialog) { - if (DBG) logd("user manually close the dialog"); - mNetworkScanHelper.stopNetworkQuery(); - - // If cancelled, we query NetworkSelectMode and update states of AutoSelect button. - mNetworkOperators.getNetworkSelectionMode(); - } - - //TODO(b/114749736): move this logic to preference controller - protected void onDialogClosed(boolean positiveResult) { - // If dismissed, we query NetworkSelectMode and update states of AutoSelect button. - if (!positiveResult) { - mNetworkOperators.getNetworkSelectionMode(); - } - } - - // This initialize method needs to be called for this preference to work properly. - protected void initialize(int subId, NetworkOperators networkOperators, - ProgressDialog progressDialog) { - mSubId = subId; - mNetworkOperators = networkOperators; - // This preference should share the same progressDialog with networkOperators category. - mProgressDialog = progressDialog; - - mTelephonyManager = TelephonyManager.from(getContext()).createForSubscriptionId(mSubId); - mNetworkScanHelper = new NetworkScanHelper( - mTelephonyManager, mCallback, mNetworkScanExecutor); - - setSummary(mTelephonyManager.getNetworkOperatorName()); - - setOnPreferenceChangeListener(this); - } - - @Override - protected void onPrepareForRemoval() { - destroy(); - super.onPrepareForRemoval(); - } - - private void destroy() { - dismissProgressDialog(); - - if (mNetworkScanHelper != null) { - mNetworkScanHelper.stopNetworkQuery(); - } - - mNetworkScanExecutor.shutdown(); - } - - private void displayEmptyNetworkList() { - Toast.makeText(getContext(), R.string.empty_networks_list, Toast.LENGTH_LONG).show(); - } - - private void displayNetworkQueryFailed() { - Toast.makeText(getContext(), R.string.network_query_error, Toast.LENGTH_LONG).show(); - } - - private void loadNetworksList() { - if (DBG) logd("load networks list..."); - mNetworkScanHelper.startNetworkScan( - NetworkScanHelper.NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS); - } - - private void networksListLoaded() { - if (DBG) logd("networks list loaded"); - - mNetworkOperators.getNetworkSelectionMode(); - if (mCellInfoList != null) { - // create a preference for each item in the list. - // just use the operator name instead of the mildly - // confusing mcc/mnc. - List networkEntriesList = new ArrayList<>(); - List networkEntryValuesList = new ArrayList<>(); - for (CellInfo cellInfo: mCellInfoList) { - // Display each operator name only once. - String networkTitle = getNetworkTitle(cellInfo); - if (CellInfoUtil.isForbidden(cellInfo, mForbiddenPlmns)) { - networkTitle += " " - + getContext().getResources().getString(R.string.forbidden_network); - } - networkEntriesList.add(networkTitle); - networkEntryValuesList.add(getOperatorNumeric(cellInfo)); - } - setEntries(networkEntriesList.toArray(new CharSequence[networkEntriesList.size()])); - setEntryValues(networkEntryValuesList.toArray( - new CharSequence[networkEntryValuesList.size()])); - - super.onClick(); - } else { - displayEmptyNetworkList(); - } - } - - private void dismissProgressDialog() { - if (mProgressDialog != null && mProgressDialog.isShowing()) { - try { - mProgressDialog.dismiss(); - } catch (IllegalArgumentException ex) { - loge("Can't close the progress dialog " + ex); - } - } - } - - private void showProgressDialog(int id) { - if (mProgressDialog == null) { - mProgressDialog = new ProgressDialog(getContext()); - } else { - // Dismiss progress bar if it's showing now. - dismissProgressDialog(); - } - - switch (id) { - case DIALOG_NETWORK_SELECTION: - final String networkSelectMsg = getContext().getResources() - .getString(R.string.register_on_network, - getNetworkTitle(mCellInfo)); - mProgressDialog.setMessage(networkSelectMsg); - mProgressDialog.setCanceledOnTouchOutside(false); - mProgressDialog.setCancelable(false); - mProgressDialog.setIndeterminate(true); - break; - case DIALOG_NETWORK_LIST_LOAD: - mProgressDialog.setMessage( - getContext().getResources().getString(R.string.load_networks_progress)); - mProgressDialog.setCanceledOnTouchOutside(false); - mProgressDialog.setCancelable(true); - mProgressDialog.setIndeterminate(false); - mProgressDialog.setOnCancelListener(this); - break; - default: - } - mProgressDialog.show(); - } - - /** - * Implemented to support onPreferenceChangeListener to look for preference - * changes specifically on this button. - * - * @param preference is the preference to be changed, should be network select button. - * @param newValue should be the value of the selection as index of operators. - */ - @Override - public boolean onPreferenceChange(Preference preference, Object newValue) { - int operatorIndex = findIndexOfValue((String) newValue); - mCellInfo = mCellInfoList.get(operatorIndex); - if (DBG) logd("selected network: " + mCellInfo.toString()); - - MetricsLogger.action(getContext(), - MetricsEvent.ACTION_MOBILE_NETWORK_MANUAL_SELECT_NETWORK); - - if (SubscriptionManager.isValidSubscriptionId(mSubId)) { - ThreadUtils.postOnBackgroundThread(() -> { - final OperatorInfo operatorInfo = getOperatorInfoFromCellInfo(mCellInfo); - if (DBG) logd("manually selected network: " + operatorInfo.toString()); - boolean isSuccessed = mTelephonyManager.setNetworkSelectionModeManual( - operatorInfo, true /* persistSelection */); - Message msg = mHandler.obtainMessage(EVENT_MANUALLY_NETWORK_SELECTION_DONE); - msg.obj = isSuccessed; - msg.sendToTarget(); - }); - } else { - loge("Error selecting network, subscription Id is invalid " + mSubId); - } - - return true; - } - - /** - * Returns the title of the network obtained in the manual search. - * - * @param cellInfo contains the information of the network. - * @return Long Name if not null/empty, otherwise Short Name if not null/empty, - * else MCCMNC string. - */ - private String getNetworkTitle(CellInfo cellInfo) { - OperatorInfo ni = getOperatorInfoFromCellInfo(cellInfo); - - if (!TextUtils.isEmpty(ni.getOperatorAlphaLong())) { - return ni.getOperatorAlphaLong(); - } else if (!TextUtils.isEmpty(ni.getOperatorAlphaShort())) { - return ni.getOperatorAlphaShort(); - } else { - BidiFormatter bidiFormatter = BidiFormatter.getInstance(); - return bidiFormatter.unicodeWrap(ni.getOperatorNumeric(), TextDirectionHeuristics.LTR); - } - } - - /** - * Returns the operator numeric (MCCMNC) obtained in the manual search. - * - * @param cellInfo contains the information of the network. - * @return MCCMNC string. - */ - private String getOperatorNumeric(CellInfo cellInfo) { - return getOperatorInfoFromCellInfo(cellInfo).getOperatorNumeric(); - } - - /** - * Wrap a cell info into an operator info. - */ - private OperatorInfo getOperatorInfoFromCellInfo(CellInfo cellInfo) { - OperatorInfo oi; - if (cellInfo instanceof CellInfoLte) { - CellInfoLte lte = (CellInfoLte) cellInfo; - oi = new OperatorInfo( - (String) lte.getCellIdentity().getOperatorAlphaLong(), - (String) lte.getCellIdentity().getOperatorAlphaShort(), - lte.getCellIdentity().getMobileNetworkOperator()); - } else if (cellInfo instanceof CellInfoWcdma) { - CellInfoWcdma wcdma = (CellInfoWcdma) cellInfo; - oi = new OperatorInfo( - (String) wcdma.getCellIdentity().getOperatorAlphaLong(), - (String) wcdma.getCellIdentity().getOperatorAlphaShort(), - wcdma.getCellIdentity().getMobileNetworkOperator()); - } else if (cellInfo instanceof CellInfoGsm) { - CellInfoGsm gsm = (CellInfoGsm) cellInfo; - oi = new OperatorInfo( - (String) gsm.getCellIdentity().getOperatorAlphaLong(), - (String) gsm.getCellIdentity().getOperatorAlphaShort(), - gsm.getCellIdentity().getMobileNetworkOperator()); - } else if (cellInfo instanceof CellInfoCdma) { - CellInfoCdma cdma = (CellInfoCdma) cellInfo; - oi = new OperatorInfo( - (String) cdma.getCellIdentity().getOperatorAlphaLong(), - (String) cdma.getCellIdentity().getOperatorAlphaShort(), - "" /* operator numeric */); - } else { - oi = new OperatorInfo("", "", ""); - } - return oi; - } - - @Override - protected Parcelable onSaveInstanceState() { - final Parcelable superState = super.onSaveInstanceState(); - if (isPersistent()) { - // No need to save instance state since it's persistent - return superState; - } - - final SavedState myState = new SavedState(superState); - myState.mDialogListEntries = getEntries(); - myState.mDialogListEntryValues = getEntryValues(); - myState.mCellInfoList = mCellInfoList; - return myState; - } - - @Override - protected void onRestoreInstanceState(Parcelable state) { - if (state == null || !state.getClass().equals(SavedState.class)) { - // Didn't save state for us in onSaveInstanceState - super.onRestoreInstanceState(state); - return; - } - - SavedState myState = (SavedState) state; - - if (getEntries() == null && myState.mDialogListEntries != null) { - setEntries(myState.mDialogListEntries); - } - if (getEntryValues() == null && myState.mDialogListEntryValues != null) { - setEntryValues(myState.mDialogListEntryValues); - } - if (mCellInfoList == null && myState.mCellInfoList != null) { - mCellInfoList = myState.mCellInfoList; - } - - super.onRestoreInstanceState(myState.getSuperState()); - } - - /** - * We save entries, entryValues and operatorInfoList into bundle. - * At onCreate of fragment, dialog will be restored if it was open. In this case, - * we need to restore entries, entryValues and operatorInfoList. Without those information, - * onPreferenceChange will fail if user select network from the dialog. - */ - private static class SavedState extends BaseSavedState { - CharSequence[] mDialogListEntries; - CharSequence[] mDialogListEntryValues; - List mCellInfoList; - - SavedState(Parcel source) { - super(source); - final ClassLoader boot = Object.class.getClassLoader(); - mDialogListEntries = source.readCharSequenceArray(); - mDialogListEntryValues = source.readCharSequenceArray(); - mCellInfoList = source.readParcelableList(mCellInfoList, boot); - } - - @Override - public void writeToParcel(Parcel dest, int flags) { - super.writeToParcel(dest, flags); - dest.writeCharSequenceArray(mDialogListEntries); - dest.writeCharSequenceArray(mDialogListEntryValues); - dest.writeParcelableList(mCellInfoList, flags); - } - - SavedState(Parcelable superState) { - super(superState); - } - - public static final Parcelable.Creator CREATOR = - new Parcelable.Creator() { - public SavedState createFromParcel(Parcel in) { - return new SavedState(in); - } - - public SavedState[] newArray(int size) { - return new SavedState[size]; - } - }; - } - - private void logd(String msg) { - Log.d(LOG_TAG, "[NetworksList] " + msg); - } - - private void loge(String msg) { - Log.e(LOG_TAG, "[NetworksList] " + msg); - } -} \ No newline at end of file diff --git a/src/com/android/settings/network/telephony/NetworkSelectSettings.java b/src/com/android/settings/network/telephony/NetworkSelectSettings.java index 830964bb43f..3e42c70198c 100644 --- a/src/com/android/settings/network/telephony/NetworkSelectSettings.java +++ b/src/com/android/settings/network/telephony/NetworkSelectSettings.java @@ -81,7 +81,7 @@ public class NetworkSelectSettings extends DashboardFragment { @VisibleForTesting TelephonyManager mTelephonyManager; private List mForbiddenPlmns; - private boolean mShow4GForLTE = true; + private boolean mShow4GForLTE = false; private NetworkScanHelper mNetworkScanHelper; private final ExecutorService mNetworkScanExecutor = Executors.newFixedThreadPool(1); private MetricsFeatureProvider mMetricsFeatureProvider; @@ -95,7 +95,6 @@ public class NetworkSelectSettings extends DashboardFragment { com.android.internal.R.bool.config_enableNewAutoSelectNetworkUI); mSubId = getArguments().getInt(MobileSettingsActivity.KEY_SUBSCRIPTION_ID); - addPreferencesFromResource(R.xml.choose_network); mConnectedPreferenceCategory = (PreferenceCategory) findPreference(PREF_KEY_CONNECTED_NETWORK_OPERATOR); mPreferenceCategory = @@ -389,6 +388,7 @@ public class NetworkSelectSettings extends DashboardFragment { } private void stopNetworkQuery() { + setProgressBarVisible(false); if (mNetworkScanHelper != null) { mNetworkScanHelper.stopNetworkQuery(); } diff --git a/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceController.java b/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceController.java deleted file mode 100644 index eaacdb2f0ec..00000000000 --- a/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceController.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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.cdma; - -import android.content.Context; -import android.content.Intent; -import android.os.PersistableBundle; -import android.provider.Settings; -import android.telephony.CarrierConfigManager; - -import androidx.annotation.VisibleForTesting; -import androidx.preference.Preference; -import androidx.preference.PreferenceScreen; - -import com.android.settings.SettingsActivity; -import com.android.settings.network.ApnSettings; -import com.android.settings.network.telephony.MobileNetworkUtils; -import com.android.settingslib.RestrictedLockUtilsInternal; -import com.android.settingslib.RestrictedPreference; - -/** - * Preference controller for "CDMA Apn" - */ -public class CdmaApnPreferenceController extends CdmaBasePreferenceController { - - private static final String CATEGORY_KEY = "category_cdma_apn_key"; - @VisibleForTesting - CarrierConfigManager mCarrierConfigManager; - - public CdmaApnPreferenceController(Context context, String key) { - super(context, key); - mCarrierConfigManager = new CarrierConfigManager(context); - } - - @Override - public int getAvailabilityStatus() { - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); - - return carrierConfig != null - && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_APN_SETTING_CDMA_BOOL) - && MobileNetworkUtils.isCdmaOptions(mContext, mSubId) - ? AVAILABLE - : CONDITIONALLY_UNAVAILABLE; - } - - @Override - public void displayPreference(PreferenceScreen screen) { - super.displayPreference(screen); - if (isAvailable()) { - ((RestrictedPreference) mPreference).setDisabledByAdmin( - MobileNetworkUtils.isDpcApnEnforced(mContext) - ? RestrictedLockUtilsInternal.getDeviceOwner(mContext) - : null); - } else { - screen.findPreference(CATEGORY_KEY).setVisible(false); - } - } - - @Override - public boolean handlePreferenceTreeClick(Preference preference) { - if (getPreferenceKey().equals(preference.getKey())) { - // This activity runs in phone process, we must use intent to start - final Intent intent = new Intent(Settings.ACTION_APN_SETTINGS); - // This will setup the Home and Search affordance - intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_AS_SUBSETTING, true); - intent.putExtra(ApnSettings.SUB_ID, mSubId); - mContext.startActivity(intent); - return true; - } - - return false; - } -} diff --git a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java new file mode 100644 index 00000000000..72f69cd7310 --- /dev/null +++ b/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java @@ -0,0 +1,135 @@ +/* + * 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.gsm; + +import android.content.Context; +import android.os.Bundle; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.Preference; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.R; +import com.android.settings.core.SubSettingLauncher; +import com.android.settings.core.TogglePreferenceController; +import com.android.settings.network.telephony.MobileNetworkUtils; +import com.android.settings.network.telephony.MobileSettingsActivity; +import com.android.settings.network.telephony.NetworkSelectSettings; + +import java.util.ArrayList; +import java.util.List; + +/** + * Preference controller for "Auto Select Network" + */ +public class AutoSelectPreferenceController extends TogglePreferenceController { + + private int mSubId; + private TelephonyManager mTelephonyManager; + private boolean mOnlyAutoSelectInHome; + private List mListeners; + + public AutoSelectPreferenceController(Context context, String key) { + super(context, key); + mTelephonyManager = context.getSystemService(TelephonyManager.class); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + mListeners = new ArrayList<>(); + } + + @Override + public int getAvailabilityStatus() { + return MobileNetworkUtils.shouldDisplayNetworkSelectOptions(mContext,mSubId) + ? AVAILABLE + : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public boolean isChecked() { + return mTelephonyManager.getNetworkSelectionMode() + == TelephonyManager.NETWORK_SELECTION_MODE_AUTO; + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + + preference.setSummary(null); + if (mTelephonyManager.getServiceState().getRoaming()) { + preference.setEnabled(true); + } else { + preference.setEnabled(!mOnlyAutoSelectInHome); + if (mOnlyAutoSelectInHome) { + preference.setSummary(mContext.getString( + R.string.manual_mode_disallowed_summary, + mTelephonyManager.getSimOperatorName())); + } + } + } + + @Override + public boolean setChecked(boolean isChecked) { + if (isChecked) { + mTelephonyManager.setNetworkSelectionModeAutomatic(); + + for (OnNetworkSelectModeListener lsn : mListeners) { + lsn.onNetworkSelectModeChanged(); + } + // Manually check whether it is successfully + return mTelephonyManager.getNetworkSelectionMode() + == TelephonyManager.NETWORK_SELECTION_MODE_AUTO; + } else { + final Bundle bundle = new Bundle(); + bundle.putInt(MobileSettingsActivity.KEY_SUBSCRIPTION_ID, mSubId); + new SubSettingLauncher(mContext) + .setDestination(NetworkSelectSettings.class.getName()) + .setSourceMetricsCategory(MetricsProto.MetricsEvent.MOBILE_NETWORK_SELECT) + .setTitleRes(R.string.choose_network_title) + .setArguments(bundle) + .launch(); + return false; + } + } + + public AutoSelectPreferenceController init(int subId) { + mSubId = subId; + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + final PersistableBundle carrierConfig = mContext.getSystemService( + CarrierConfigManager.class).getConfigForSubId(mSubId); + mOnlyAutoSelectInHome = carrierConfig.getBoolean( + CarrierConfigManager.KEY_ONLY_AUTO_SELECT_IN_HOME_NETWORK_BOOL); + + return this; + } + + public AutoSelectPreferenceController addListener(OnNetworkSelectModeListener lsn) { + mListeners.add(lsn); + + return this; + } + + /** + * Callback when network select mode is changed + * + * @see TelephonyManager#getNetworkSelectionMode() + */ + public interface OnNetworkSelectModeListener { + void onNetworkSelectModeChanged(); + } +} \ No newline at end of file diff --git a/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceController.java b/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceController.java new file mode 100644 index 00000000000..9ea977ca36b --- /dev/null +++ b/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceController.java @@ -0,0 +1,110 @@ +/* + * 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.gsm; + +import android.content.Context; +import android.os.Bundle; +import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.text.TextUtils; + +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.internal.logging.nano.MetricsProto; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; +import com.android.settings.core.SubSettingLauncher; +import com.android.settings.network.telephony.MobileNetworkUtils; +import com.android.settings.network.telephony.MobileSettingsActivity; +import com.android.settings.network.telephony.NetworkSelectSettings; + +/** + * Preference controller for "Open network select" + */ +public class OpenNetworkSelectPagePreferenceController extends BasePreferenceController implements + AutoSelectPreferenceController.OnNetworkSelectModeListener { + + private int mSubId; + private TelephonyManager mTelephonyManager; + private Preference mPreference; + + public OpenNetworkSelectPagePreferenceController(Context context, String key) { + super(context, key); + mTelephonyManager = context.getSystemService(TelephonyManager.class); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + return MobileNetworkUtils.shouldDisplayNetworkSelectOptions(mContext, mSubId) + ? AVAILABLE + : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + preference.setEnabled(mTelephonyManager.getNetworkSelectionMode() + != TelephonyManager.NETWORK_SELECTION_MODE_AUTO); + } + + @Override + public CharSequence getSummary() { + final ServiceState ss = mTelephonyManager.getServiceState(); + if (ss != null && ss.getState() == ServiceState.STATE_IN_SERVICE) { + return mTelephonyManager.getNetworkOperatorName(); + } else { + return mContext.getString(R.string.network_disconnected); + } + } + + @Override + public boolean handlePreferenceTreeClick(Preference preference) { + if (TextUtils.equals(preference.getKey(), getPreferenceKey())) { + final Bundle bundle = new Bundle(); + bundle.putInt(MobileSettingsActivity.KEY_SUBSCRIPTION_ID, mSubId); + new SubSettingLauncher(mContext) + .setDestination(NetworkSelectSettings.class.getName()) + .setSourceMetricsCategory(MetricsProto.MetricsEvent.MOBILE_NETWORK_SELECT) + .setTitleRes(R.string.choose_network_title) + .setArguments(bundle) + .launch(); + return true; + } + + return false; + } + + public OpenNetworkSelectPagePreferenceController init(int subId) { + mSubId = subId; + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + return this; + } + + @Override + public void onNetworkSelectModeChanged() { + updateState(mPreference); + } +} \ No newline at end of file diff --git a/tests/robotests/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java similarity index 83% rename from tests/robotests/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceControllerTest.java rename to tests/robotests/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java index 2aceda7286b..0fda51f3d49 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/cdma/CdmaApnPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/ApnPreferenceControllerTest.java @@ -14,7 +14,7 @@ * limitations under the License. */ -package com.android.settings.network.telephony.cdma; +package com.android.settings.network.telephony; import static com.android.settings.core.BasePreferenceController.AVAILABLE; import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; @@ -47,7 +47,7 @@ import org.mockito.MockitoAnnotations; import org.robolectric.RuntimeEnvironment; @RunWith(SettingsRobolectricTestRunner.class) -public class CdmaApnPreferenceControllerTest { +public class ApnPreferenceControllerTest { private static final int SUB_ID = 2; @Mock @@ -59,7 +59,7 @@ public class CdmaApnPreferenceControllerTest { @Mock private CarrierConfigManager mCarrierConfigManager; - private CdmaApnPreferenceController mController; + private ApnPreferenceController mController; private RestrictedPreference mPreference; private Context mContext; @@ -73,11 +73,12 @@ public class CdmaApnPreferenceControllerTest { doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); mPreference = new RestrictedPreference(mContext); - mController = new CdmaApnPreferenceController(mContext, "mobile_data"); + mController = new ApnPreferenceController(mContext, "mobile_data"); mController.init(SUB_ID); - mController.mPreference = mPreference; + mController.setPreference(mPreference); mController.mCarrierConfigManager = mCarrierConfigManager; mPreference.setKey(mController.getPreferenceKey()); } @@ -102,6 +103,16 @@ public class CdmaApnPreferenceControllerTest { assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); } + @Test + public void getAvailabilityStatus_apnSettingsSupportedWithGsm_returnAvailable() { + doReturn(PhoneConstants.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); + final PersistableBundle bundle = new PersistableBundle(); + bundle.putBoolean(CarrierConfigManager.KEY_APN_EXPAND_BOOL, true); + doReturn(bundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + @Test public void handPreferenceTreeClick_fireIntent() { ArgumentCaptor captor = ArgumentCaptor.forClass(Intent.class); diff --git a/tests/robotests/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java index e119e8990e0..8673de86701 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/CarrierPreferenceControllerTest.java @@ -68,6 +68,7 @@ public class CarrierPreferenceControllerTest { doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( SubscriptionManager.INVALID_SUBSCRIPTION_ID); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); mPreference = new RestrictedPreference(mContext); mController = new CarrierPreferenceController(mContext, "mobile_data"); diff --git a/tests/robotests/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java new file mode 100644 index 00000000000..5f652419821 --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceControllerTest.java @@ -0,0 +1,114 @@ +/* + * 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.gsm; + +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 static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.Preference; + +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.Answers; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class AutoSelectPreferenceControllerTest { + private static final int SUB_ID = 2; + private static final String OPERATOR_NAME = "T-mobile"; + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + private TelephonyManager mTelephonyManager; + @Mock + private SubscriptionManager mSubscriptionManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mCarrierConfig; + private AutoSelectPreferenceController mController; + private Preference mPreference; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); + when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); + when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( + mCarrierConfigManager); + when(mTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(mTelephonyManager); + + mCarrierConfig = new PersistableBundle(); + mCarrierConfig.putBoolean(CarrierConfigManager.KEY_ONLY_AUTO_SELECT_IN_HOME_NETWORK_BOOL, + true); + when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig); + + mPreference = new Preference(mContext); + mController = new AutoSelectPreferenceController(mContext, "auto_select"); + mController.init(SUB_ID); + } + + @Test + public void setChecked_isChecked_updateValue() { + when(mTelephonyManager.getNetworkSelectionMode()).thenReturn( + TelephonyManager.NETWORK_SELECTION_MODE_AUTO); + + assertThat(mController.setChecked(true)).isTrue(); + + verify(mTelephonyManager).setNetworkSelectionModeAutomatic(); + } + + @Test + public void updateState_isRoaming_enabled() { + when(mTelephonyManager.getServiceState().getRoaming()).thenReturn(true); + + mController.updateState(mPreference); + + assertThat(mPreference.isEnabled()).isTrue(); + } + + @Test + public void updateState_notRoamingWithAutoSelectOn_disabled() { + when(mTelephonyManager.getServiceState().getRoaming()).thenReturn(false); + doReturn(OPERATOR_NAME).when(mTelephonyManager).getSimOperatorName(); + + mController.updateState(mPreference); + + assertThat(mPreference.isEnabled()).isFalse(); + assertThat(mPreference.getSummary()).isEqualTo( + mContext.getString(R.string.manual_mode_disallowed_summary, + mTelephonyManager.getSimOperatorName())); + } +} diff --git a/tests/robotests/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceControllerTest.java new file mode 100644 index 00000000000..d5fc6e045d6 --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceControllerTest.java @@ -0,0 +1,110 @@ +/* + * 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.gsm; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.PersistableBundle; +import android.telephony.CarrierConfigManager; +import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.Preference; + +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 OpenNetworkSelectPagePreferenceControllerTest { + private static final int SUB_ID = 2; + private static final String OPERATOR_NAME = "T-mobile"; + + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private SubscriptionManager mSubscriptionManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + @Mock + private ServiceState mServiceState; + + private PersistableBundle mCarrierConfig; + private OpenNetworkSelectPagePreferenceController mController; + private Preference mPreference; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager); + when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager); + when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn( + mCarrierConfigManager); + when(mTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(mTelephonyManager); + when(mTelephonyManager.getServiceState()).thenReturn(mServiceState); + + mCarrierConfig = new PersistableBundle(); + when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig); + + mPreference = new Preference(mContext); + mController = new OpenNetworkSelectPagePreferenceController(mContext, + "open_network_select"); + mController.init(SUB_ID); + } + + @Test + public void updateState_modeAuto_disabled() { + when(mTelephonyManager.getNetworkSelectionMode()).thenReturn( + TelephonyManager.NETWORK_SELECTION_MODE_AUTO); + + mController.updateState(mPreference); + + assertThat(mPreference.isEnabled()).isFalse(); + } + + @Test + public void getSummary_inService_returnOperatorName() { + when(mServiceState.getState()).thenReturn(ServiceState.STATE_IN_SERVICE); + doReturn(OPERATOR_NAME).when(mTelephonyManager).getNetworkOperatorName(); + + assertThat(mController.getSummary()).isEqualTo(OPERATOR_NAME); + } + + @Test + public void getSummary_notInService_returnDisconnect() { + when(mServiceState.getState()).thenReturn(ServiceState.STATE_OUT_OF_SERVICE); + doReturn(OPERATOR_NAME).when(mTelephonyManager).getNetworkOperatorName(); + + assertThat(mController.getSummary()).isEqualTo( + mContext.getString(R.string.network_disconnected)); + } +}