Snap for 5670726 from e69b95ad5fc8715ee9889617e658aeeb838af87c to qt-c2f2-release (714b9b01) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/CellularNetworkValidator.java

+31 −6

Original line number	Diff line number	Diff line
		@@ -25,6 +25,7 @@ import android.os.Handler;
		import android.telephony.SubscriptionManager;
		import android.util.Log;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.telephony.metrics.TelephonyMetrics;
		import com.android.internal.telephony.nano.TelephonyProto.TelephonyEvent;

		@@ -58,8 +59,12 @@ public class CellularNetworkValidator {
		private ValidationCallback mValidationCallback;
		private Context mContext;
		private ConnectivityManager mConnectivityManager;
		private Handler mHandler = new Handler();
		private ConnectivityNetworkCallback mNetworkCallback;
		@VisibleForTesting
		public Handler mHandler = new Handler();
		@VisibleForTesting
		public ConnectivityNetworkCallback mNetworkCallback;
		@VisibleForTesting
		public Runnable mTimeoutCallback;

		/**
		* Callback to pass in when starting validation.
		@@ -99,7 +104,8 @@ public class CellularNetworkValidator {
		.validationBeforeSwitchSupported;
		}

		private CellularNetworkValidator(Context context) {
		@VisibleForTesting
		public CellularNetworkValidator(Context context) {
		mContext = context;
		mConnectivityManager = (ConnectivityManager)
		mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
		@@ -136,8 +142,22 @@ public class CellularNetworkValidator {

		mNetworkCallback = new ConnectivityNetworkCallback(subId);

		mConnectivityManager.requestNetwork(
		mNetworkRequest, mNetworkCallback, mHandler, mTimeoutInMs);
		mConnectivityManager.requestNetwork(mNetworkRequest, mNetworkCallback, mHandler);

		mTimeoutCallback = () -> {
		logd("timeout on subId " + subId + " validation.");
		reportValidationResult(false, subId);
		};

		mHandler.postDelayed(mTimeoutCallback, mTimeoutInMs);
		}

		private void removeTimeoutCallback() {
		// Remove timeout callback.
		if (mTimeoutCallback != null) {
		mHandler.removeCallbacks(mTimeoutCallback);
		mTimeoutCallback = null;
		}
		}

		/**
		@@ -150,6 +170,8 @@ public class CellularNetworkValidator {
		mConnectivityManager.unregisterNetworkCallback(mNetworkCallback);
		mState = STATE_IDLE;
		}

		removeTimeoutCallback();
		mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
		}

		@@ -179,6 +201,8 @@ public class CellularNetworkValidator {
		// If the validation result is not for current subId, do nothing.
		if (mSubId != subId) return;

		removeTimeoutCallback();

		// Deal with the result only when state is still VALIDATING. This is to avoid
		// receiving multiple callbacks in queue.
		if (mState == STATE_VALIDATING) {
		@@ -198,7 +222,8 @@ public class CellularNetworkValidator {
		mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
		}

		class ConnectivityNetworkCallback extends ConnectivityManager.NetworkCallback {
		@VisibleForTesting
		public class ConnectivityNetworkCallback extends ConnectivityManager.NetworkCallback {
		private final int mSubId;

		ConnectivityNetworkCallback(int subId) {

tests/telephonytests/src/com/android/internal/telephony/CellularNetworkValidatorTest.java

0 → 100644

+232 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.internal.telephony;


		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.Matchers.eq;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.verify;

		import android.net.Network;
		import android.net.NetworkCapabilities;
		import android.net.NetworkRequest;
		import android.os.HandlerThread;
		import android.telephony.PhoneCapability;
		import android.telephony.SubscriptionManager;
		import android.test.suitebuilder.annotation.SmallTest;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Test;

		public class CellularNetworkValidatorTest extends TelephonyTest {
		private boolean mValidated = false;
		private CellularNetworkValidator mValidatorUT;
		private int mValidatedSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
		private static final PhoneCapability CAPABILITY_WITH_VALIDATION_SUPPORTED =
		new PhoneCapability(1, 1, 0, null, true);
		private static final PhoneCapability CAPABILITY_WITHOUT_VALIDATION_SUPPORTED =
		new PhoneCapability(1, 1, 0, null, false);
		private HandlerThread mHandlerThread;

		CellularNetworkValidator.ValidationCallback mCallback = (validated, subId) -> {
		mValidated = validated;
		mValidatedSubId = subId;
		};

		@Before
		public void setUp() throws Exception {
		super.setUp(getClass().getSimpleName());

		doReturn(CAPABILITY_WITH_VALIDATION_SUPPORTED).when(mPhoneConfigurationManager)
		.getCurrentPhoneCapability();

		mHandlerThread = new HandlerThread("PhoneSwitcherTestThread") {
		@Override
		public void onLooperPrepared() {
		mValidatorUT = new CellularNetworkValidator(mContext);
		}
		};

		mHandlerThread.start();
		waitABit();

		}

		@After
		public void tearDown() throws Exception {
		super.tearDown();
		}

		/**
		* Test that a single phone case results in our phone being active and the RIL called
		*/
		@Test
		@SmallTest
		public void testValidationSupported() throws Exception {
		doReturn(CAPABILITY_WITH_VALIDATION_SUPPORTED).when(mPhoneConfigurationManager)
		.getCurrentPhoneCapability();
		assertTrue(mValidatorUT.isValidationFeatureSupported());

		doReturn(CAPABILITY_WITHOUT_VALIDATION_SUPPORTED).when(mPhoneConfigurationManager)
		.getCurrentPhoneCapability();
		assertFalse(mValidatorUT.isValidationFeatureSupported());
		}

		/**
		* Test that a single phone case results in our phone being active and the RIL called
		*/
		@Test
		@SmallTest
		public void testValidateSuccess() throws Exception {
		int subId = 1;
		int timeout = 1000;
		NetworkRequest expectedRequest = new NetworkRequest.Builder()
		.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.setNetworkSpecifier(String.valueOf(subId))
		.build();

		mValidatorUT.validate(subId, timeout, true, mCallback);

		assertTrue(mValidatorUT.isValidating());
		assertEquals(subId, mValidatorUT.getSubIdInValidation());
		verify(mConnectivityManager).requestNetwork(
		eq(expectedRequest), eq(mValidatorUT.mNetworkCallback), any());

		mValidatorUT.mNetworkCallback.onCapabilitiesChanged(null, new NetworkCapabilities()
		.addCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED));

		assertTrue(mValidated);
		assertEquals(subId, mValidatedSubId);
		verify(mConnectivityManager).unregisterNetworkCallback(eq(mValidatorUT.mNetworkCallback));
		assertFalse(mValidatorUT.mHandler.hasCallbacks(mValidatorUT.mTimeoutCallback));
		assertFalse(mValidatorUT.isValidating());
		assertEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID,
		mValidatorUT.getSubIdInValidation());
		}

		/**
		* Test that a single phone case results in our phone being active and the RIL called
		*/
		@Test
		@SmallTest
		public void testValidateTimeout() throws Exception {
		int subId = 1;
		int timeout = 100;
		NetworkRequest expectedRequest = new NetworkRequest.Builder()
		.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.setNetworkSpecifier(String.valueOf(subId))
		.build();

		mValidatorUT.validate(subId, timeout, true, mCallback);

		assertTrue(mValidatorUT.isValidating());
		assertEquals(subId, mValidatorUT.getSubIdInValidation());
		verify(mConnectivityManager).requestNetwork(
		eq(expectedRequest), eq(mValidatorUT.mNetworkCallback), any());

		// Wait for timeout.
		waitABit();

		assertFalse(mValidated);
		assertEquals(subId, mValidatedSubId);
		verify(mConnectivityManager).unregisterNetworkCallback(eq(mValidatorUT.mNetworkCallback));
		assertFalse(mValidatorUT.mHandler.hasCallbacks(mValidatorUT.mTimeoutCallback));
		assertFalse(mValidatorUT.isValidating());
		assertEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID,
		mValidatorUT.getSubIdInValidation());
		}

		/**
		* Test that a single phone case results in our phone being active and the RIL called
		*/
		@Test
		@SmallTest
		public void testValidateFailure() throws Exception {
		int subId = 1;
		int timeout = 100;
		NetworkRequest expectedRequest = new NetworkRequest.Builder()
		.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.setNetworkSpecifier(String.valueOf(subId))
		.build();

		mValidatorUT.validate(subId, timeout, true, mCallback);

		assertTrue(mValidatorUT.isValidating());
		assertEquals(subId, mValidatorUT.getSubIdInValidation());
		verify(mConnectivityManager).requestNetwork(
		eq(expectedRequest), eq(mValidatorUT.mNetworkCallback), any());

		mValidatorUT.mNetworkCallback.onUnavailable();

		assertFalse(mValidated);
		assertEquals(subId, mValidatedSubId);
		verify(mConnectivityManager).unregisterNetworkCallback(eq(mValidatorUT.mNetworkCallback));
		assertFalse(mValidatorUT.mHandler.hasCallbacks(mValidatorUT.mTimeoutCallback));
		assertFalse(mValidatorUT.isValidating());
		assertEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID,
		mValidatorUT.getSubIdInValidation());
		}

		/**
		* Test that a single phone case results in our phone being active and the RIL called
		*/
		@Test
		@SmallTest
		public void testNetworkAvailableNotValidated() throws Exception {
		int subId = 1;
		int timeout = 100;
		NetworkRequest expectedRequest = new NetworkRequest.Builder()
		.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
		.addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)
		.setNetworkSpecifier(String.valueOf(subId))
		.build();

		mValidatorUT.validate(subId, timeout, true, mCallback);

		assertTrue(mValidatorUT.isValidating());
		assertEquals(subId, mValidatorUT.getSubIdInValidation());
		verify(mConnectivityManager).requestNetwork(
		eq(expectedRequest), eq(mValidatorUT.mNetworkCallback), any());

		mValidatorUT.mNetworkCallback.onAvailable(new Network(100));
		// Wait for timeout.
		waitABit();

		assertFalse(mValidated);
		assertEquals(subId, mValidatedSubId);
		verify(mConnectivityManager).unregisterNetworkCallback(eq(mValidatorUT.mNetworkCallback));
		assertFalse(mValidatorUT.mHandler.hasCallbacks(mValidatorUT.mTimeoutCallback));
		assertFalse(mValidatorUT.isValidating());
		assertEquals(SubscriptionManager.INVALID_SUBSCRIPTION_ID,
		mValidatorUT.getSubIdInValidation());
		}

		private void waitABit() {
		try {
		Thread.sleep(250);
		} catch (Exception e) {
		}
		}
		}

tests/telephonytests/src/com/android/internal/telephony/TelephonyTest.java

+4 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,7 @@ import android.content.SharedPreferences;
		import android.content.pm.ApplicationInfo;
		import android.content.pm.PackageInfo;
		import android.content.pm.PackageManager;
		import android.net.ConnectivityManager;
		import android.os.Build;
		import android.os.Bundle;
		import android.os.Handler;
		@@ -250,6 +251,7 @@ public abstract class TelephonyTest {
		protected SubscriptionManager mSubscriptionManager;
		protected EuiccManager mEuiccManager;
		protected PackageManager mPackageManager;
		protected ConnectivityManager mConnectivityManager;
		protected SimulatedCommands mSimulatedCommands;
		protected ContextFixture mContextFixture;
		protected Context mContext;
		@@ -375,6 +377,8 @@ public abstract class TelephonyTest {
		mSubscriptionManager = (SubscriptionManager) mContext.getSystemService(
		Context.TELEPHONY_SUBSCRIPTION_SERVICE);
		mEuiccManager = (EuiccManager) mContext.getSystemService(Context.EUICC_SERVICE);
		mConnectivityManager = (ConnectivityManager)
		mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
		mPackageManager = mContext.getPackageManager();

		//mTelephonyComponentFactory