Mainline: removed legacy UI for network selection mode.

Framework does not support getAvailableNetworks(), so legacy
UI does not work. Removed legacy UI for network selection mode.

Bug: 147404387
Test: 1.make RunSettingsRoboTests ROBOTEST_FILTER=\
NetworkScanHelperTest(PASS)
2.make RunSettingsRoboTests \
ROBOTEST_FILTER=NetworkSelectSettingsTest(PASS)
Change-Id: I421526e844100b08e0c39e6e993ca09d1fad8457

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

@@ -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

@@ -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

@@ -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,63 +121,38 @@ public class NetworkScanHelper {
     }
 
     /**
-     * Performs a network scan for the given type {@code type}.
+     * Request a network scan.
-     * {@link #NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS} is recommended if modem supports
-     * {@link TelephonyManager#requestNetworkScan(
-     * NetworkScanRequest, Executor, TelephonyScanManager.NetworkScanCallback)}.
      *
-     * @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) {
+    public void startNetworkScan() {
-        if (type == NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS) {
+        if (mNetworkScanRequester != null) {
-            mNetworkScanFuture = SettableFuture.create();
+            return;
-            Futures.addCallback(mNetworkScanFuture, new FutureCallback<List<CellInfo>>() {
+        }
-                @Override
+        mNetworkScanRequester = mTelephonyManager.requestNetworkScan(
-                public void onSuccess(List<CellInfo> result) {
+                NETWORK_SCAN_REQUEST,
-                    onResults(result);
+                mExecutor,
-                    onComplete();
+                mInternalNetworkScanCallback);
-                }
+        if (mNetworkScanRequester == null) {
-
+            onError(NetworkScan.ERROR_RADIO_INTERFACE_ERROR);
-                @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) {
-            if (mNetworkScanRequester != null) {
-                return;
-            }
-            mNetworkScanRequester = mTelephonyManager.requestNetworkScan(
-                    NETWORK_SCAN_REQUEST,
-                    mExecutor,
-                    mInternalNetworkScanCallback);
-            if (mNetworkScanRequester == null) {
-                onError(NetworkScan.ERROR_RADIO_INTERFACE_ERROR);
-            }
         }
     }
 
     /**
-     * The network scan of type {@link #NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS} can't be stopped,
+     * Stops the network scan.
-     * however, the result of the current network scan won't be returned to the callback after
+     *
-     * calling this method.
+     * 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

@@ -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(
+            mNetworkScanHelper.startNetworkScan();
-                    mUseNewApi
-                            ? NetworkScanHelper.NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS
-                            : NetworkScanHelper.NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS);
         }
     }
 

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

@@ -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
+    //TODO: add test cases.
-    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));
-    }
 }

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

@@ -33,9 +33,6 @@ import android.telephony.NetworkScanRequest;
 import android.telephony.TelephonyManager;
 import android.telephony.TelephonyScanManager;
 
-import com.android.internal.telephony.CellNetworkScanResult;
-import com.android.internal.telephony.OperatorInfo;
-
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -47,12 +44,10 @@ import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 import org.robolectric.RobolectricTestRunner;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
 
 @RunWith(RobolectricTestRunner.class)
 public class NetworkScanHelperTest {
@@ -61,7 +56,7 @@ public class NetworkScanHelperTest {
     private TelephonyManager mTelephonyManager;
 
     @Mock
-    private CellNetworkScanResult mCellNetworkScanResult;
+    private List<CellInfo> mCellInfos;
 
     @Mock
     private NetworkScanHelper.NetworkScanCallback mNetworkScanCallback;
@@ -75,7 +70,6 @@ public class NetworkScanHelperTest {
     private static final int SUB_ID = 1;
 
     private NetworkScan mNetworkScan;
-    private OperatorInfo mOperatorInfo;
 
     @Before
     public void setUp() {
@@ -87,62 +81,11 @@ public class NetworkScanHelperTest {
                 mNetworkScanCallback, mNetworkScanExecutor);
 
         mNetworkScan = spy(new NetworkScan(SCAN_ID, SUB_ID));
-        mOperatorInfo = new OperatorInfo("Testing", "Test", "12345", "unknown");
-    }
-
-    @Test
-    public void startNetworkScan_scanOnceAndSuccess_completionWithResult() {
-        ArrayList<OperatorInfo> expectedResult = new ArrayList<OperatorInfo>();
-        expectedResult.add(mOperatorInfo);
-
-        when(mTelephonyManager.getAvailableNetworks()).thenReturn(mCellNetworkScanResult);
-        when(mCellNetworkScanResult.getStatus()).thenReturn(
-                CellNetworkScanResult.STATUS_SUCCESS);
-        when(mCellNetworkScanResult.getOperators()).thenReturn(expectedResult);
-
-        ArgumentCaptor<List<CellInfo>> argument = ArgumentCaptor.forClass(List.class);
-
-        startNetworkScan_waitForAll(true);
-
-        verify(mNetworkScanCallback, times(1)).onResults(argument.capture());
-        List<CellInfo> actualResult = argument.getValue();
-        assertThat(actualResult.size()).isEqualTo(expectedResult.size());
-        verify(mNetworkScanCallback, times(1)).onComplete();
-    }
-
-    @Test
-    public void startNetworkScan_scanOnceAndFail_failureWithErrorCode() {
-        when(mTelephonyManager.getAvailableNetworks()).thenReturn(mCellNetworkScanResult);
-        when(mCellNetworkScanResult.getStatus()).thenReturn(
-                CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE);
-
-        startNetworkScan_waitForAll(true);
-
-        verify(mNetworkScanCallback, times(1)).onError(anyInt());
-    }
-
-    @Test
-    public void startNetworkScan_scanOnceAndAbort_withoutCrash() {
-        when(mCellNetworkScanResult.getStatus()).thenReturn(
-                CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE);
-
-        doAnswer(new Answer() {
-            @Override
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                Thread.sleep(THREAD_EXECUTION_TIMEOUT_MS);
-                return mCellNetworkScanResult;
-            }
-        }).when(mTelephonyManager).getAvailableNetworks();
-
-        startNetworkScan_waitForAll(false);
-
-        verify(mNetworkScanCallback, times(0)).onError(anyInt());
     }
 
     @Test
     public void startNetworkScan_incrementalAndSuccess_completionWithResult() {
-        ArrayList<CellInfo> expectedResult = new ArrayList<CellInfo>();
+        when(mCellInfos.size()).thenReturn(1);
-        expectedResult.add(CellInfoUtil.convertOperatorInfoToCellInfo(mOperatorInfo));
 
         doAnswer(new Answer() {
             @Override
@@ -150,7 +93,7 @@ public class NetworkScanHelperTest {
                 TelephonyScanManager.NetworkScanCallback callback =
                         (TelephonyScanManager.NetworkScanCallback)
                         (invocation.getArguments()[2]);
-                callback.onResults(expectedResult);
+                callback.onResults(mCellInfos);
                 callback.onComplete();
                 return mNetworkScan;
             }
@@ -164,7 +107,7 @@ public class NetworkScanHelperTest {
 
         verify(mNetworkScanCallback, times(1)).onResults(argument.capture());
         List<CellInfo> actualResult = argument.getValue();
-        assertThat(actualResult.size()).isEqualTo(expectedResult.size());
+        assertThat(actualResult.size()).isEqualTo(mCellInfos.size());
         verify(mNetworkScanCallback, times(1)).onComplete();
     }
 
@@ -187,7 +130,7 @@ public class NetworkScanHelperTest {
                 TelephonyScanManager.NetworkScanCallback callback =
                         (TelephonyScanManager.NetworkScanCallback)
                         (invocation.getArguments()[2]);
-                callback.onError(CellNetworkScanResult.STATUS_RADIO_GENERIC_FAILURE);
+                callback.onError(NetworkScan.ERROR_MODEM_ERROR);
                 return mNetworkScan;
             }
         }).when(mTelephonyManager).requestNetworkScan(
@@ -211,28 +154,8 @@ public class NetworkScanHelperTest {
         verify(mNetworkScan, times(1)).stopScan();
     }
 
-    private void startNetworkScan_waitForAll(boolean waitForCompletion) {
-        mNetworkScanHelper.startNetworkScan(
-                NetworkScanHelper.NETWORK_SCAN_TYPE_WAIT_FOR_ALL_RESULTS);
-        if (!waitForCompletion) {
-            mNetworkScanHelper.stopNetworkQuery();
-        }
-
-        mNetworkScanExecutor.shutdown();
-
-        boolean executorTerminate = false;
-        try {
-            executorTerminate = mNetworkScanExecutor.awaitTermination(
-                    THREAD_EXECUTION_TIMEOUT_MS, TimeUnit.MILLISECONDS);
-        } catch (Exception ex) {
-        }
-
-        assertThat(executorTerminate).isEqualTo(waitForCompletion);
-    }
-
     private void startNetworkScan_incremental(boolean waitForCompletion) {
-        mNetworkScanHelper.startNetworkScan(
+        mNetworkScanHelper.startNetworkScan();
-                NetworkScanHelper.NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS);
         if (!waitForCompletion) {
             mNetworkScanHelper.stopNetworkQuery();
         }