PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Mainline: removed legacy UI for network selection mode.

Browse Source 
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
This commit is contained in:
SongFerngWang
2020-01-09 15:00:45 +08:00
parent 8b1b697711
commit 521ebeafd3
6 changed files with 30 additions and 282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
src/com/android/settings/network/telephony/CellInfoUtil.java
View File

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

5
src/com/android/settings/network/telephony/NetworkOperatorPreference.java
View File

@@ -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();

140
src/com/android/settings/network/telephony/NetworkScanHelper.java
View File

@@ -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);
}
}
}
}

7
src/com/android/settings/network/telephony/NetworkSelectSettings.java
View File

@@ -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();
}
}

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

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

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

@@ -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>();
expectedResult.add(CellInfoUtil.convertOperatorInfoToCellInfo(mOperatorInfo));
when(mCellInfos.size()).thenReturn(1);
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(
NetworkScanHelper.NETWORK_SCAN_TYPE_INCREMENTAL_RESULTS);
mNetworkScanHelper.startNetworkScan();
if (!waitForCompletion) {
mNetworkScanHelper.stopNetworkQuery();
}