Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e69b95ad authored by Malcolm Chen's avatar Malcolm Chen Committed by Xiangyu/Malcolm Chen
Browse files

In NetworkValidator, make sure timeout happens for available but 

unvalidated network.

We used to rely on ConnectivityManager's API to do timeout. But problem
is, if a network becomes available but never validated, there's no
timeout and we fail to send any result. So now we are doing timeout
ourselves.

Bug: 134526729
Test: manual and unittests
Change-Id: If47def80a7176b1a45a0490561b473e16d19d945
parent ad505a8f

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