Examples with NetworkRequest android.net.NetworkRequest used on opensource projects

Example 86 with NetworkRequest

use of android.net.NetworkRequest in project platform_frameworks_base by android.

the class ConnectivityServiceTest method testRegisterDefaultNetworkCallback.

@SmallTest
public void testRegisterDefaultNetworkCallback() throws Exception {
    final TestNetworkCallback defaultNetworkCallback = new TestNetworkCallback();
    mCm.registerDefaultNetworkCallback(defaultNetworkCallback);
    defaultNetworkCallback.assertNoCallback();
    // Create a TRANSPORT_CELLULAR request to keep the mobile interface up
    // whenever Wi-Fi is up. Without this, the mobile network agent is
    // reaped before any other activity can take place.
    final TestNetworkCallback cellNetworkCallback = new TestNetworkCallback();
    final NetworkRequest cellRequest = new NetworkRequest.Builder().addTransportType(TRANSPORT_CELLULAR).build();
    mCm.requestNetwork(cellRequest, cellNetworkCallback);
    cellNetworkCallback.assertNoCallback();
    // Bring up cell and expect CALLBACK_AVAILABLE.
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    mCellNetworkAgent.connect(true);
    cellNetworkCallback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    defaultNetworkCallback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    // Bring up wifi and expect CALLBACK_AVAILABLE.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(true);
    cellNetworkCallback.assertNoCallback();
    defaultNetworkCallback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    // Bring down cell. Expect no default network callback, since it wasn't the default.
    mCellNetworkAgent.disconnect();
    cellNetworkCallback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
    defaultNetworkCallback.assertNoCallback();
    // Bring up cell. Expect no default network callback, since it won't be the default.
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    mCellNetworkAgent.connect(true);
    cellNetworkCallback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    defaultNetworkCallback.assertNoCallback();
    // Bring down wifi. Expect the default network callback to notified of LOST wifi
    // followed by AVAILABLE cell.
    mWiFiNetworkAgent.disconnect();
    cellNetworkCallback.assertNoCallback();
    defaultNetworkCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultNetworkCallback.expectAvailableCallbacks(mCellNetworkAgent);
    mCellNetworkAgent.disconnect();
    cellNetworkCallback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
    defaultNetworkCallback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
}

Example 87 with NetworkRequest

use of android.net.NetworkRequest in project platform_frameworks_base by android.

the class ConnectivityServiceTest method tryNetworkFactoryRequests.

private void tryNetworkFactoryRequests(int capability) throws Exception {
    // Verify NOT_RESTRICTED is set appropriately
    final NetworkCapabilities nc = new NetworkRequest.Builder().addCapability(capability).build().networkCapabilities;
    if (capability == NET_CAPABILITY_CBS || capability == NET_CAPABILITY_DUN || capability == NET_CAPABILITY_EIMS || capability == NET_CAPABILITY_FOTA || capability == NET_CAPABILITY_IA || capability == NET_CAPABILITY_IMS || capability == NET_CAPABILITY_RCS || capability == NET_CAPABILITY_XCAP) {
        assertFalse(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
    } else {
        assertTrue(nc.hasCapability(NET_CAPABILITY_NOT_RESTRICTED));
    }
    NetworkCapabilities filter = new NetworkCapabilities();
    filter.addCapability(capability);
    final HandlerThread handlerThread = new HandlerThread("testNetworkFactoryRequests");
    handlerThread.start();
    final MockNetworkFactory testFactory = new MockNetworkFactory(handlerThread.getLooper(), mServiceContext, "testFactory", filter);
    testFactory.setScoreFilter(40);
    ConditionVariable cv = testFactory.getNetworkStartedCV();
    testFactory.expectAddRequests(1);
    testFactory.register();
    testFactory.waitForNetworkRequests(1);
    int expectedRequestCount = 1;
    NetworkCallback networkCallback = null;
    // add one.
    if (capability != NET_CAPABILITY_INTERNET) {
        assertFalse(testFactory.getMyStartRequested());
        NetworkRequest request = new NetworkRequest.Builder().addCapability(capability).build();
        networkCallback = new NetworkCallback();
        testFactory.expectAddRequests(1);
        mCm.requestNetwork(request, networkCallback);
        expectedRequestCount++;
        testFactory.waitForNetworkRequests(expectedRequestCount);
    }
    waitFor(cv);
    assertEquals(expectedRequestCount, testFactory.getMyRequestCount());
    assertTrue(testFactory.getMyStartRequested());
    // Now bring in a higher scored network.
    MockNetworkAgent testAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    // Rather than create a validated network which complicates things by registering it's
    // own NetworkRequest during startup, just bump up the score to cancel out the
    // unvalidated penalty.
    testAgent.adjustScore(40);
    cv = testFactory.getNetworkStoppedCV();
    // When testAgent connects, ConnectivityService will re-send us all current requests with
    // the new score. There are expectedRequestCount such requests, and we must wait for all of
    // them.
    testFactory.expectAddRequests(expectedRequestCount);
    testAgent.connect(false);
    testAgent.addCapability(capability);
    waitFor(cv);
    testFactory.waitForNetworkRequests(expectedRequestCount);
    assertFalse(testFactory.getMyStartRequested());
    // Bring in a bunch of requests.
    testFactory.expectAddRequests(10);
    assertEquals(expectedRequestCount, testFactory.getMyRequestCount());
    ConnectivityManager.NetworkCallback[] networkCallbacks = new ConnectivityManager.NetworkCallback[10];
    for (int i = 0; i < networkCallbacks.length; i++) {
        networkCallbacks[i] = new ConnectivityManager.NetworkCallback();
        NetworkRequest.Builder builder = new NetworkRequest.Builder();
        builder.addCapability(capability);
        mCm.requestNetwork(builder.build(), networkCallbacks[i]);
    }
    testFactory.waitForNetworkRequests(10 + expectedRequestCount);
    assertFalse(testFactory.getMyStartRequested());
    // Remove the requests.
    testFactory.expectRemoveRequests(10);
    for (int i = 0; i < networkCallbacks.length; i++) {
        mCm.unregisterNetworkCallback(networkCallbacks[i]);
    }
    testFactory.waitForNetworkRequests(expectedRequestCount);
    assertFalse(testFactory.getMyStartRequested());
    // Drop the higher scored network.
    cv = testFactory.getNetworkStartedCV();
    testAgent.disconnect();
    waitFor(cv);
    assertEquals(expectedRequestCount, testFactory.getMyRequestCount());
    assertTrue(testFactory.getMyStartRequested());
    testFactory.unregister();
    if (networkCallback != null)
        mCm.unregisterNetworkCallback(networkCallback);
    handlerThread.quit();
}

Example 88 with NetworkRequest

use of android.net.NetworkRequest in project platform_frameworks_base by android.

the class ConnectivityServiceTest method testMultipleLingering.

@SmallTest
public void testMultipleLingering() {
    NetworkRequest request = new NetworkRequest.Builder().clearCapabilities().addCapability(NET_CAPABILITY_NOT_METERED).build();
    TestNetworkCallback callback = new TestNetworkCallback();
    mCm.registerNetworkCallback(request, callback);
    TestNetworkCallback defaultCallback = new TestNetworkCallback();
    mCm.registerDefaultNetworkCallback(defaultCallback);
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mEthernetNetworkAgent = new MockNetworkAgent(TRANSPORT_ETHERNET);
    mCellNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
    mWiFiNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
    mEthernetNetworkAgent.addCapability(NET_CAPABILITY_NOT_METERED);
    mCellNetworkAgent.connect(true);
    callback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    mWiFiNetworkAgent.connect(true);
    // We get AVAILABLE on wifi when wifi connects and satisfies our unmetered request.
    // We then get LOSING when wifi validates and cell is outscored.
    callback.expectAvailableCallbacks(mWiFiNetworkAgent);
    // TODO: Investigate sending validated before losing.
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    mEthernetNetworkAgent.connect(true);
    callback.expectAvailableCallbacks(mEthernetNetworkAgent);
    // TODO: Investigate sending validated before losing.
    callback.expectCallback(CallbackState.LOSING, mWiFiNetworkAgent);
    callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mEthernetNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mEthernetNetworkAgent);
    assertEquals(mEthernetNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    mEthernetNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mEthernetNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mEthernetNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mWiFiNetworkAgent);
    for (int i = 0; i < 4; i++) {
        MockNetworkAgent oldNetwork, newNetwork;
        if (i % 2 == 0) {
            mWiFiNetworkAgent.adjustScore(-15);
            oldNetwork = mWiFiNetworkAgent;
            newNetwork = mCellNetworkAgent;
        } else {
            mWiFiNetworkAgent.adjustScore(15);
            oldNetwork = mCellNetworkAgent;
            newNetwork = mWiFiNetworkAgent;
        }
        callback.expectCallback(CallbackState.LOSING, oldNetwork);
        // TODO: should we send an AVAILABLE callback to newNetwork, to indicate that it is no
        // longer lingering?
        defaultCallback.expectAvailableCallbacks(newNetwork);
        assertEquals(newNetwork.getNetwork(), mCm.getActiveNetwork());
    }
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Verify that if a network no longer satisfies a request, we send LOST and not LOSING, even
    // if the network is still up.
    mWiFiNetworkAgent.removeCapability(NET_CAPABILITY_NOT_METERED);
    // We expect a notification about the capabilities change, and nothing else.
    defaultCallback.expectCapabilitiesWithout(NET_CAPABILITY_NOT_METERED, mWiFiNetworkAgent);
    defaultCallback.assertNoCallback();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    // Wifi no longer satisfies our listen, which is for an unmetered network.
    // But because its score is 55, it's still up (and the default network).
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Disconnect our test networks.
    mWiFiNetworkAgent.disconnect();
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    mCellNetworkAgent.disconnect();
    defaultCallback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
    mCm.unregisterNetworkCallback(callback);
    mService.waitForIdle();
    // Check that a network is only lingered or torn down if it would not satisfy a request even
    // if it validated.
    request = new NetworkRequest.Builder().clearCapabilities().build();
    callback = new TestNetworkCallback();
    mCm.registerNetworkCallback(request, callback);
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    // Score: 10
    mCellNetworkAgent.connect(false);
    callback.expectAvailableCallbacks(mCellNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Bring up wifi with a score of 20.
    // Cell stays up because it would satisfy the default request if it validated.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    // Score: 20
    mWiFiNetworkAgent.connect(false);
    callback.expectAvailableCallbacks(mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mWiFiNetworkAgent);
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    mWiFiNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Bring up wifi with a score of 70.
    // Cell is lingered because it would not satisfy any request, even if it validated.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.adjustScore(50);
    // Score: 70
    mWiFiNetworkAgent.connect(false);
    callback.expectAvailableCallbacks(mWiFiNetworkAgent);
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mWiFiNetworkAgent);
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Tear down wifi.
    mWiFiNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    assertEquals(mCellNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    // Bring up wifi, then validate it. Previous versions would immediately tear down cell, but
    // it's arguably correct to linger it, since it was the default network before it validated.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(true);
    callback.expectAvailableCallbacks(mWiFiNetworkAgent);
    // TODO: Investigate sending validated before losing.
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    assertEquals(mWiFiNetworkAgent.getNetwork(), mCm.getActiveNetwork());
    mWiFiNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    mCellNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mCellNetworkAgent);
    // If a network is lingering, and we add and remove a request from it, resume lingering.
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    mCellNetworkAgent.connect(true);
    callback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mCellNetworkAgent);
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(true);
    defaultCallback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    callback.expectAvailableCallbacks(mWiFiNetworkAgent);
    // TODO: Investigate sending validated before losing.
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    callback.expectCapabilitiesWith(NET_CAPABILITY_VALIDATED, mWiFiNetworkAgent);
    NetworkRequest cellRequest = new NetworkRequest.Builder().addTransportType(TRANSPORT_CELLULAR).build();
    NetworkCallback noopCallback = new NetworkCallback();
    mCm.requestNetwork(cellRequest, noopCallback);
    // TODO: should this cause an AVAILABLE callback, to indicate that the network is no longer
    // lingering?
    mCm.unregisterNetworkCallback(noopCallback);
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    // Similar to the above: lingering can start even after the lingered request is removed.
    // Disconnect wifi and switch to cell.
    mWiFiNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectAvailableCallbacks(mCellNetworkAgent);
    // Cell is now the default network. Pin it with a cell-specific request.
    // Can't reuse NetworkCallbacks. http://b/20701525
    noopCallback = new NetworkCallback();
    mCm.requestNetwork(cellRequest, noopCallback);
    // Now connect wifi, and expect it to become the default network.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(true);
    callback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    defaultCallback.expectAvailableAndValidatedCallbacks(mWiFiNetworkAgent);
    // The default request is lingering on cell, but nothing happens to cell, and we send no
    // callbacks for it, because it's kept up by cellRequest.
    callback.assertNoCallback();
    // Now unregister cellRequest and expect cell to start lingering.
    mCm.unregisterNetworkCallback(noopCallback);
    callback.expectCallback(CallbackState.LOSING, mCellNetworkAgent);
    // Let linger run its course.
    callback.assertNoCallback();
    final int lingerTimeoutMs = TEST_LINGER_DELAY_MS + TEST_LINGER_DELAY_MS / 4;
    callback.expectCallback(CallbackState.LOST, mCellNetworkAgent, lingerTimeoutMs);
    // Clean up.
    mWiFiNetworkAgent.disconnect();
    callback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    defaultCallback.expectCallback(CallbackState.LOST, mWiFiNetworkAgent);
    mCm.unregisterNetworkCallback(callback);
    mCm.unregisterNetworkCallback(defaultCallback);
}

Example 89 with NetworkRequest

use of android.net.NetworkRequest in project platform_frameworks_base by android.

the class ConnectivityServiceTest method testNetworkPinner.

@SmallTest
public void testNetworkPinner() {
    NetworkRequest wifiRequest = new NetworkRequest.Builder().addTransportType(TRANSPORT_WIFI).build();
    assertNull(mCm.getBoundNetworkForProcess());
    TestNetworkPinner.pin(mServiceContext, wifiRequest);
    assertNull(mCm.getBoundNetworkForProcess());
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
    mCellNetworkAgent.connect(true);
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(false);
    // When wi-fi connects, expect to be pinned.
    assertTrue(TestNetworkPinner.awaitPin(100));
    assertPinnedToWifiWithCellDefault();
    // Disconnect and expect the pin to drop.
    mWiFiNetworkAgent.disconnect();
    assertTrue(TestNetworkPinner.awaitUnpin(100));
    assertNotPinnedToWifi();
    // Reconnecting does not cause the pin to come back.
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(false);
    assertFalse(TestNetworkPinner.awaitPin(100));
    assertNotPinnedToWifi();
    // Pinning while connected causes the pin to take effect immediately.
    TestNetworkPinner.pin(mServiceContext, wifiRequest);
    assertTrue(TestNetworkPinner.awaitPin(100));
    assertPinnedToWifiWithCellDefault();
    // Explicitly unpin and expect to use the default network again.
    TestNetworkPinner.unpin();
    assertNotPinnedToWifi();
    // Disconnect cell and wifi.
    // cell down, wifi up, wifi down.
    ConditionVariable cv = waitForConnectivityBroadcasts(3);
    mCellNetworkAgent.disconnect();
    mWiFiNetworkAgent.disconnect();
    waitFor(cv);
    // Pinning takes effect even if the pinned network is the default when the pin is set...
    TestNetworkPinner.pin(mServiceContext, wifiRequest);
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(false);
    assertTrue(TestNetworkPinner.awaitPin(100));
    assertPinnedToWifiWithWifiDefault();
    // ... and is maintained even when that network is no longer the default.
    cv = waitForConnectivityBroadcasts(1);
    mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mCellNetworkAgent.connect(true);
    waitFor(cv);
    assertPinnedToWifiWithCellDefault();
}

Example 90 with NetworkRequest

use of android.net.NetworkRequest in project platform_frameworks_base by android.

the class ConnectivityServiceTest method testTimedoutAfterUnregisteredNetworkRequest.

/**
     * Validate that when a network request is unregistered (cancelled) the time-out for that
     * request doesn't trigger the onUnavailable() callback.
     */
@SmallTest
public void testTimedoutAfterUnregisteredNetworkRequest() {
    NetworkRequest nr = new NetworkRequest.Builder().addTransportType(NetworkCapabilities.TRANSPORT_WIFI).build();
    final TestNetworkCallback networkCallback = new TestNetworkCallback();
    final int timeoutMs = 10;
    mCm.requestNetwork(nr, networkCallback, timeoutMs);
    // remove request
    mCm.unregisterNetworkCallback(networkCallback);
    // pass timeout and validate that no callbacks
    // Note: doesn't validate that nothing called from CS since even if called the CM already
    // unregisters the callback and won't pass it through!
    sleepFor(15);
    networkCallback.assertNoCallback();
    // create a network satisfying request - validate that request not triggered
    mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
    mWiFiNetworkAgent.connect(false);
    networkCallback.assertNoCallback();
}