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

Commit e0a3eadc authored by Kweku Adams's avatar Kweku Adams Committed by Automerger Merge Worker
Browse files

Merge "Migrate to the asynchronous version of getActiveNetworkForUid." into sc-dev am: 07b7ab4a 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/13975475

Change-Id: Ifc3cf5c933c1c668353269b296cd05fe51bd0893
parents 04e281a2 07b7ab4a

apex/jobscheduler/service/java/com/android/server/job/controllers/ConnectivityController.java

+472 −41

File changed.

Preview size limit exceeded, changes collapsed.

services/tests/mockingservicestests/src/com/android/server/job/controllers/ConnectivityControllerTest.java

+90 −39
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ package com.android.server.job.controllers; 
import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_CONGESTED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_SUSPENDED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED;

import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED;

import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR;
@@ -41,10 +42,11 @@ import static org.mockito.ArgumentMatchers.anyInt; 
import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;



import android.annotation.NonNull;

import android.annotation.Nullable;

import android.app.job.JobInfo;

import android.content.ComponentName;

import android.content.Context;
@@ -53,8 +55,6 @@ import android.net.ConnectivityManager; 
import android.net.ConnectivityManager.NetworkCallback;

import android.net.Network;

import android.net.NetworkCapabilities;

import android.net.NetworkInfo;

import android.net.NetworkInfo.DetailedState;

import android.net.NetworkPolicyManager;

import android.os.Build;

import android.os.Looper;
@@ -136,7 +136,7 @@ public class ConnectivityControllerTest { 
    }



    @Test

    public void testInsane() throws Exception {

    public void testUsable() throws Exception {

        final Network net = new Network(101);

        final JobInfo.Builder job = createJob()

                .setEstimatedNetworkBytes(DataUnit.MEBIBYTES.toBytes(1),
@@ -191,6 +191,30 @@ public class ConnectivityControllerTest { 
                        .setLinkDownstreamBandwidthKbps(130), mConstants));

    }



    @Test

    public void testInsane() throws Exception {

        final Network net = new Network(101);

        final JobInfo.Builder job = createJob()

                .setEstimatedNetworkBytes(DataUnit.MEBIBYTES.toBytes(1),

                        DataUnit.MEBIBYTES.toBytes(1))

                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);



        final ConnectivityController controller = new ConnectivityController(mService);

        when(mService.getMaxJobExecutionTimeMs(any())).thenReturn(10 * 60_000L);





        // Suspended networks aren't usable.

        assertFalse(controller.isSatisfied(createJobStatus(job), net,

                createCapabilities().removeCapability(NET_CAPABILITY_NOT_SUSPENDED)

                        .setLinkUpstreamBandwidthKbps(1024).setLinkDownstreamBandwidthKbps(1024),

                mConstants));



        // Not suspended networks are usable.

        assertTrue(controller.isSatisfied(createJobStatus(job), net,

                createCapabilities().setLinkUpstreamBandwidthKbps(1024)

                        .setLinkDownstreamBandwidthKbps(1024), mConstants));

    }



    @Test

    public void testCongestion() throws Exception {

        final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
@@ -263,9 +287,17 @@ public class ConnectivityControllerTest { 


    @Test

    public void testUpdates() throws Exception {

        final ArgumentCaptor<NetworkCallback> callback = ArgumentCaptor

                .forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerNetworkCallback(any(), callback.capture());

        final ArgumentCaptor<NetworkCallback> callbackCaptor =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerNetworkCallback(any(), callbackCaptor.capture());

        final ArgumentCaptor<NetworkCallback> redCallbackCaptor =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerDefaultNetworkCallbackAsUid(

                eq(UID_RED), redCallbackCaptor.capture(), any());

        final ArgumentCaptor<NetworkCallback> blueCallbackCaptor =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerDefaultNetworkCallbackAsUid(

                eq(UID_BLUE), blueCallbackCaptor.capture(), any());



        final ConnectivityController controller = new ConnectivityController(mService);
@@ -281,15 +313,16 @@ public class ConnectivityControllerTest { 
        final JobStatus blue = createJobStatus(createJob()

                .setEstimatedNetworkBytes(DataUnit.MEBIBYTES.toBytes(1), 0)

                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY), UID_BLUE);

        controller.maybeStartTrackingJobLocked(red, null);

        controller.maybeStartTrackingJobLocked(blue, null);

        final NetworkCallback generalCallback = callbackCaptor.getValue();

        final NetworkCallback redCallback = redCallbackCaptor.getValue();

        final NetworkCallback blueCallback = blueCallbackCaptor.getValue();



        // Pretend we're offline when job is added

        {

            reset(mConnManager);

            answerNetwork(UID_RED, null, null);

            answerNetwork(UID_BLUE, null, null);



            controller.maybeStartTrackingJobLocked(red, null);

            controller.maybeStartTrackingJobLocked(blue, null);

            answerNetwork(generalCallback, redCallback, null, null, null);

            answerNetwork(generalCallback, blueCallback, null, null, null);



            assertFalse(red.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

            assertFalse(blue.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -297,11 +330,10 @@ public class ConnectivityControllerTest { 


        // Metered network

        {

            reset(mConnManager);

            answerNetwork(UID_RED, meteredNet, meteredCaps);

            answerNetwork(UID_BLUE, meteredNet, meteredCaps);

            answerNetwork(generalCallback, redCallback, null, meteredNet, meteredCaps);

            answerNetwork(generalCallback, blueCallback, null, meteredNet, meteredCaps);



            callback.getValue().onCapabilitiesChanged(meteredNet, meteredCaps);

            generalCallback.onCapabilitiesChanged(meteredNet, meteredCaps);



            assertFalse(red.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

            assertTrue(blue.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -309,11 +341,10 @@ public class ConnectivityControllerTest { 


        // Unmetered network background

        {

            reset(mConnManager);

            answerNetwork(UID_RED, meteredNet, meteredCaps);

            answerNetwork(UID_BLUE, meteredNet, meteredCaps);

            answerNetwork(generalCallback, redCallback, meteredNet, meteredNet, meteredCaps);

            answerNetwork(generalCallback, blueCallback, meteredNet, meteredNet, meteredCaps);



            callback.getValue().onCapabilitiesChanged(unmeteredNet, unmeteredCaps);

            generalCallback.onCapabilitiesChanged(unmeteredNet, unmeteredCaps);



            assertFalse(red.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

            assertTrue(blue.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -321,11 +352,10 @@ public class ConnectivityControllerTest { 


        // Lost metered network

        {

            reset(mConnManager);

            answerNetwork(UID_RED, unmeteredNet, unmeteredCaps);

            answerNetwork(UID_BLUE, unmeteredNet, unmeteredCaps);

            answerNetwork(generalCallback, redCallback, meteredNet, unmeteredNet, unmeteredCaps);

            answerNetwork(generalCallback, blueCallback, meteredNet, unmeteredNet, unmeteredCaps);



            callback.getValue().onLost(meteredNet);

            generalCallback.onLost(meteredNet);



            assertTrue(red.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

            assertTrue(blue.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -333,11 +363,10 @@ public class ConnectivityControllerTest { 


        // Specific UID was blocked

        {

            reset(mConnManager);

            answerNetwork(UID_RED, null, null);

            answerNetwork(UID_BLUE, unmeteredNet, unmeteredCaps);

            answerNetwork(generalCallback, redCallback, unmeteredNet, null, null);

            answerNetwork(generalCallback, blueCallback, unmeteredNet, unmeteredNet, unmeteredCaps);



            callback.getValue().onCapabilitiesChanged(unmeteredNet, unmeteredCaps);

            generalCallback.onCapabilitiesChanged(unmeteredNet, unmeteredCaps);



            assertFalse(red.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

            assertTrue(blue.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -404,6 +433,8 @@ public class ConnectivityControllerTest { 
        final JobStatus blue = createJobStatus(createJob()

                .setEstimatedNetworkBytes(DataUnit.MEBIBYTES.toBytes(1), 0)

                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY), UID_BLUE);

        controller.maybeStartTrackingJobLocked(red, null);

        controller.maybeStartTrackingJobLocked(blue, null);



        InOrder inOrder = inOrder(mNetPolicyManagerInternal);
@@ -560,6 +591,18 @@ public class ConnectivityControllerTest { 


    @Test

    public void testRestrictedJobTracking() {

        final ArgumentCaptor<NetworkCallback> callback =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerNetworkCallback(any(), callback.capture());

        final ArgumentCaptor<NetworkCallback> redCallback =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerDefaultNetworkCallbackAsUid(

                eq(UID_RED), redCallback.capture(), any());

        final ArgumentCaptor<NetworkCallback> blueCallback =

                ArgumentCaptor.forClass(NetworkCallback.class);

        doNothing().when(mConnManager).registerDefaultNetworkCallbackAsUid(

                eq(UID_BLUE), blueCallback.capture(), any());



        final JobStatus networked = createJobStatus(createJob()

                .setEstimatedNetworkBytes(DataUnit.MEBIBYTES.toBytes(1), 0)

                .setRequiredNetworkType(JobInfo.NETWORK_TYPE_CELLULAR), UID_RED);
@@ -570,13 +613,11 @@ public class ConnectivityControllerTest { 
        final Network cellularNet = new Network(101);

        final NetworkCapabilities cellularCaps =

                createCapabilities().addTransportType(TRANSPORT_CELLULAR);

        reset(mConnManager);

        answerNetwork(UID_RED, cellularNet, cellularCaps);

        answerNetwork(UID_BLUE, cellularNet, cellularCaps);



        final ConnectivityController controller = new ConnectivityController(mService);

        controller.maybeStartTrackingJobLocked(networked, null);

        controller.maybeStartTrackingJobLocked(unnetworked, null);

        answerNetwork(callback.getValue(), redCallback.getValue(), null, cellularNet, cellularCaps);



        assertTrue(networked.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

        assertFalse(unnetworked.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));
@@ -600,18 +641,28 @@ public class ConnectivityControllerTest { 
        assertFalse(unnetworked.isConstraintSatisfied(JobStatus.CONSTRAINT_CONNECTIVITY));

    }



    private void answerNetwork(int uid, Network net, NetworkCapabilities caps) {

        when(mConnManager.getActiveNetworkForUid(eq(uid), anyBoolean())).thenReturn(net);

        when(mConnManager.getNetworkCapabilities(eq(net))).thenReturn(caps);

        if (net != null) {

            final NetworkInfo ni = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, null, null);

            ni.setDetailedState(DetailedState.CONNECTED, null, null);

            when(mConnManager.getNetworkInfoForUid(eq(net), eq(uid), anyBoolean())).thenReturn(ni);

    private void answerNetwork(@NonNull NetworkCallback generalCallback,

            @Nullable NetworkCallback uidCallback, @Nullable Network lastNetwork,

            @Nullable Network net, @Nullable NetworkCapabilities caps) {

        if (net == null) {

            generalCallback.onLost(lastNetwork);

            if (uidCallback != null) {

                uidCallback.onLost(lastNetwork);

            }

        } else {

            generalCallback.onAvailable(net);

            generalCallback.onCapabilitiesChanged(net, caps);

            if (uidCallback != null) {

                uidCallback.onAvailable(net);

                uidCallback.onBlockedStatusChanged(net, false);

                uidCallback.onCapabilitiesChanged(net, caps);

            }

        }

    }



    private static NetworkCapabilities createCapabilities() {

        return new NetworkCapabilities().addCapability(NET_CAPABILITY_INTERNET)

                .addCapability(NET_CAPABILITY_NOT_SUSPENDED)

                .addCapability(NET_CAPABILITY_NOT_VCN_MANAGED)

                .addCapability(NET_CAPABILITY_VALIDATED);

    }