Merge "Mainline: removed legacy UI for network selection mode." (92e7009d) · Commits · e / os / android_packages_apps_Settings

src/com/android/settings/network/telephony/CellInfoUtil.java

+0 −30

Original line number	Diff line number	Diff line
		@@ -33,8 +33,6 @@ import android.text.BidiFormatter;
		import android.text.TextDirectionHeuristics;
		import android.text.TextUtils;

		import com.android.internal.telephony.OperatorInfo;

		import java.util.List;
		import java.util.Objects;
		import java.util.stream.Collectors;
		@@ -101,34 +99,6 @@ public final class CellInfoUtil {
		return cellId;
		}

		/**
		* Creates a CellInfo object from OperatorInfo. GsmCellInfo is used here only because
		* operatorInfo does not contain technology type while CellInfo is an abstract object that
		* requires to specify technology type. It doesn't matter which CellInfo type to use here, since
		* we only want to wrap the operator info and PLMN to a CellInfo object.
		*/
		public static CellInfo convertOperatorInfoToCellInfo(OperatorInfo operatorInfo) {
		final String operatorNumeric = operatorInfo.getOperatorNumeric();
		String mcc = null;
		String mnc = null;
		if (operatorNumeric != null && operatorNumeric.matches("^[0-9]{5,6}$")) {
		mcc = operatorNumeric.substring(0, 3);
		mnc = operatorNumeric.substring(3);
		}
		final CellIdentityGsm cig = new CellIdentityGsm(
		Integer.MAX_VALUE /* lac */,
		Integer.MAX_VALUE /* cid */,
		Integer.MAX_VALUE /* arfcn */,
		Integer.MAX_VALUE /* bsic */,
		mcc,
		mnc,
		operatorInfo.getOperatorAlphaLong(),
		operatorInfo.getOperatorAlphaShort());

		final CellInfoGsm ci = new CellInfoGsm();
		ci.setCellIdentity(cig);
		return ci;
		}

		/** Convert a list of cellInfos to readable string without sensitive info. */
		public static String cellInfoListToString(List<CellInfo> cellInfos) {

src/com/android/settings/network/telephony/NetworkOperatorPreference.java

+1 −4

Original line number	Diff line number	Diff line
		@@ -57,7 +57,6 @@ public class NetworkOperatorPreference extends Preference {
		private List<String> mForbiddenPlmns;
		private int mLevel = LEVEL_NONE;
		private boolean mShow4GForLTE;
		private boolean mUseNewApi;

		public NetworkOperatorPreference(Context context, CellInfo cellinfo,
		List<String> forbiddenPlmns, boolean show4GForLTE) {
		@@ -76,8 +75,6 @@ public class NetworkOperatorPreference extends Preference {
		super(context);
		mForbiddenPlmns = forbiddenPlmns;
		mShow4GForLTE = show4GForLTE;
		mUseNewApi = context.getResources().getBoolean(
		com.android.internal.R.bool.config_enableNewAutoSelectNetworkUI);
		}

		/**
		@@ -218,7 +215,7 @@ public class NetworkOperatorPreference extends Preference {
		}

		private void updateIcon(int level) {
		if (!mUseNewApi \|\| level < 0 \|\| level >= NUM_SIGNAL_STRENGTH_BINS) {
		if (level < 0 \|\| level >= NUM_SIGNAL_STRENGTH_BINS) {
		return;
		}
		final Context context = getContext();

src/com/android/settings/network/telephony/NetworkScanHelper.java

+21 −137

Original line number	Diff line number	Diff line
		@@ -16,7 +16,6 @@

		package com.android.settings.network.telephony;

		import android.annotation.IntDef;
		import android.telephony.AccessNetworkConstants.AccessNetworkType;
		import android.telephony.CellInfo;
		import android.telephony.NetworkScan;
		@@ -26,20 +25,8 @@ import android.telephony.TelephonyManager;
		import android.telephony.TelephonyScanManager;
		import android.util.Log;

		import com.android.internal.telephony.CellNetworkScanResult;

		import com.google.common.util.concurrent.FutureCallback;
		import com.google.common.util.concurrent.Futures;
		import com.google.common.util.concurrent.ListenableFuture;
		import com.google.common.util.concurrent.MoreExecutors;
		import com.google.common.util.concurrent.SettableFuture;

		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;
		import java.util.List;
		import java.util.concurrent.CancellationException;
		import java.util.concurrent.Executor;
		import java.util.stream.Collectors;

		/**
		* A helper class that builds the common interface and performs the network scan for two different
		@@ -82,33 +69,6 @@ public class NetworkScanHelper {
		void onError(int errorCode);
		}

		@Retention(RetentionPolicy.SOURCE)
		@IntDef({NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS, NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS})
		public @interface NetworkQueryType {}

		/**
		* Performs the network scan using {@link TelephonyManager#getAvailableNetworks()}. The network
		* scan results won't be returned to the caller until the network scan is completed.
		*
		* <p> This is typically used when the modem doesn't support the new network scan api
		* {@link TelephonyManager#requestNetworkScan(
		* NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)}.
		*/
		public static final int NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS = 1;

		/**
		* Performs the network scan using {@link TelephonyManager#requestNetworkScan(
		* NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)} The network scan
		* results will be returned to the caller periodically in a small time window until the network
		* scan is completed. The complete results should be returned in the last called of
		* {@link NetworkScanCallback#onResults(List)}.
		*
		* <p> This is recommended to be used if modem supports the new network scan api
		* {@link TelephonyManager#requestNetworkScan(
		* NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)}
		*/
		public static final int NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS = 2;

		/** The constants below are used in the async network scan. */
		private static final boolean INCREMENTAL_RESULTS = true;
		private static final int SEARCH_PERIODICITY_SEC = 5;
		@@ -138,7 +98,7 @@ public class NetworkScanHelper {
		new RadioAccessSpecifier(
		AccessNetworkType.NGRAN,
		null /* bands */,
		null /* channels */),
		null /* channels */)
		},
		SEARCH_PERIODICITY_SEC,
		MAX_SEARCH_TIME_SEC,
		@@ -153,9 +113,6 @@ public class NetworkScanHelper {

		private NetworkScan mNetworkScanRequester;

		/** Callbacks for sync network scan */
		private ListenableFuture<List<CellInfo>> mNetworkScanFuture;

		public NetworkScanHelper(TelephonyManager tm, NetworkScanCallback callback, Executor executor) {
		mTelephonyManager = tm;
		mNetworkScanCallback = callback;
		@@ -164,35 +121,15 @@ public class NetworkScanHelper {
		}

		/**
		* Performs a network scan for the given type {@code type}.
		* {@link #NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS} is recommended if modem supports
		* {@link TelephonyManager#requestNetworkScan(
		* NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)}.
		* Request a network scan.
		*
		* @param type used to tell which network scan API should be used.
		* Performs the network scan using {@link TelephonyManager#requestNetworkScan(
		* NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)} The network scan
		* results will be returned to the caller periodically in a small time window until the network
		* scan is completed. The complete results should be returned in the last called of
		* {@link NetworkScanCallback#onResults(List)}.
		*/
		public void startNetworkScan(@NetworkQueryType int type) {
		if (type == NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS) {
		mNetworkScanFuture = SettableFuture.create();
		Futures.addCallback(mNetworkScanFuture, new FutureCallback<List<CellInfo>>() {
		@Override
		public void onSuccess(List<CellInfo> result) {
		onResults(result);
		onComplete();
		}

		@Override
		public void onFailure(Throwable t) {
		if (t instanceof CancellationException) {
		return;
		}
		int errCode = Integer.parseInt(t.getMessage());
		onError(errCode);
		}
		}, MoreExecutors.directExecutor());
		mExecutor.execute(new NetworkScanSyncTask(
		mTelephonyManager, (SettableFuture) mNetworkScanFuture));
		} else if (type == NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS) {
		public void startNetworkScan() {
		if (mNetworkScanRequester != null) {
		return;
		}
		@@ -204,23 +141,18 @@ public class NetworkScanHelper {
		onError(NetworkScan.ERROR_RADIO_INTERFACE_ERROR);
		}
		}
		}

		/**
		* The network scan of type {@link #NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS} can't be stopped,
		* however, the result of the current network scan won't be returned to the callback after
		* calling this method.
		* Stops the network scan.
		*
		* Use this method to stop an ongoing scan. When user requests a new scan, a {@link NetworkScan}
		* object will be returned, and the user can stop the scan by calling this method.
		*/
		public void stopNetworkQuery() {
		if (mNetworkScanRequester != null) {
		mNetworkScanRequester.stopScan();
		mNetworkScanRequester = null;
		}

		if (mNetworkScanFuture != null) {
		mNetworkScanFuture.cancel(true /* mayInterruptIfRunning */);
		mNetworkScanFuture = null;
		}
		}

		private void onResults(List<CellInfo> cellInfos) {
		@@ -235,23 +167,6 @@ public class NetworkScanHelper {
		mNetworkScanCallback.onError(errCode);
		}

		/**
		* Converts the status code of {@link CellNetworkScanResult} to one of the
		* {@link NetworkScan.ScanErrorCode}.
		* @param errCode status code from {@link CellNetworkScanResult}.
		*
		* @return one of the scan error code from {@link NetworkScan.ScanErrorCode}.
		*/
		private static int convertToScanErrorCode(int errCode) {
		switch (errCode) {
		case CellNetworkScanResult.STATUS_RADIO_NOT_AVAILABLE:
		return NetworkScan.ERROR_RADIO_INTERFACE_ERROR;
		case CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE:
		default:
		return NetworkScan.ERROR_MODEM_ERROR;
		}
		}

		private final class NetworkScanCallbackImpl extends TelephonyScanManager.NetworkScanCallback {
		public void onResults(List<CellInfo> results) {
		Log.d(TAG, "Async scan onResults() results = "
		@@ -269,35 +184,4 @@ public class NetworkScanHelper {
		NetworkScanHelper.this.onError(errCode);
		}
		}

		private static final class NetworkScanSyncTask implements Runnable {
		private final SettableFuture<List<CellInfo>> mCallback;
		private final TelephonyManager mTelephonyManager;

		NetworkScanSyncTask(
		TelephonyManager telephonyManager, SettableFuture<List<CellInfo>> callback) {
		mTelephonyManager = telephonyManager;
		mCallback = callback;
		}

		@Override
		public void run() {
		final CellNetworkScanResult result = mTelephonyManager.getAvailableNetworks();
		if (result.getStatus() == CellNetworkScanResult.STATUS_SUCCESS) {
		final List<CellInfo> cellInfos = result.getOperators()
		.stream()
		.map(operatorInfo
		-> CellInfoUtil.convertOperatorInfoToCellInfo(operatorInfo))
		.collect(Collectors.toList());
		Log.d(TAG, "Sync network scan completed, cellInfos = "
		+ CellInfoUtil.cellInfoListToString(cellInfos));
		mCallback.set(cellInfos);
		} else {
		final Throwable error = new Throwable(
		Integer.toString(convertToScanErrorCode(result.getStatus())));
		mCallback.setException(error);
		Log.d(TAG, "Sync network scan error, ex = " + error);
		}
		}
		}
		}

src/com/android/settings/network/telephony/NetworkSelectSettings.java

+1 −6

Original line number	Diff line number	Diff line
		@@ -93,8 +93,6 @@ public class NetworkSelectSettings extends DashboardFragment {
		public void onCreate(Bundle icicle) {
		super.onCreate(icicle);

		mUseNewApi = getContext().getResources().getBoolean(
		com.android.internal.R.bool.config_enableNewAutoSelectNetworkUI);
		mSubId = getArguments().getInt(Settings.EXTRA_SUB_ID);

		mPreferenceCategory = findPreference(PREF_KEY_NETWORK_OPERATORS);
		@@ -468,10 +466,7 @@ public class NetworkSelectSettings extends DashboardFragment {
		if (mNetworkScanHelper != null) {
		mRequestIdManualNetworkScan = getNewRequestId();
		mWaitingForNumberOfScanResults = MIN_NUMBER_OF_SCAN_REQUIRED;
		mNetworkScanHelper.startNetworkScan(
		mUseNewApi
		? NetworkScanHelper.NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS
		: NetworkScanHelper.NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS);
		mNetworkScanHelper.startNetworkScan();
		}
		}

tests/robotests/src/com/android/settings/network/telephony/NetworkOperatorPreferenceTest.java

+1 −22

Original line number	Diff line number	Diff line
		@@ -16,35 +16,25 @@

		package com.android.settings.network.telephony;

		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.Mockito.never;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.content.Context;
		import android.content.res.Resources;
		import android.graphics.drawable.Drawable;
		import android.telephony.CellInfo;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;
		import org.robolectric.RobolectricTestRunner;
		import org.robolectric.RuntimeEnvironment;

		import java.util.ArrayList;

		@RunWith(RobolectricTestRunner.class)
		public class NetworkOperatorPreferenceTest {
		private static final int LEVEL = 2;

		@Mock
		private Resources mResources;
		@Mock
		private CellInfo mCellInfo;
		private Context mContext;

		@Before
		@@ -55,16 +45,5 @@ public class NetworkOperatorPreferenceTest {
		when(mContext.getResources()).thenReturn(mResources);
		}

		@Test
		public void setIcon_useOldApi_doNothing() {
		when(mResources.getBoolean(com.android.internal.R.bool.config_enableNewAutoSelectNetworkUI))
		.thenReturn(false);
		final NetworkOperatorPreference preference = spy(
		new NetworkOperatorPreference(mContext, mCellInfo,
		new ArrayList<>() /* forbiddenPlmns /, false / show4GForLTE */));

		preference.setIcon(LEVEL);

		verify(preference, never()).setIcon(any(Drawable.class));
		}
		//TODO: add test cases.
		}