mDefaultInetConditionPublished = 0;
}
notifyIfacesChanged();
+ // TODO - we shouldn't send CALLBACK_LOST to requests that can be satisfied
+ // by other networks that are already connected. Perhaps that can be done by
+ // sending all CALLBACK_LOST messages (for requests, not listens) at the end
+ // of rematchAllNetworksAndRequests
notifyNetworkCallbacks(nai, ConnectivityManager.CALLBACK_LOST);
nai.networkMonitor.sendMessage(NetworkMonitor.CMD_NETWORK_DISCONNECTED);
mNetworkAgentInfos.remove(msg.replyTo);
// is currently satisfying the request. This is desirable when
// cellular ends up validating but WiFi does not.
// 2. Unvalidated WiFi will not be reaped when validated cellular
- // is currently satsifying the request. This is desirable when
+ // is currently satisfying the request. This is desirable when
// WiFi ends up validating and out scoring cellular.
mNetworkForRequestId.get(nri.request.requestId).getCurrentScore() <
nai.getCurrentScoreAsValidated())) {
// TODO: Instead of passing mDefaultRequest, provide an API to determine whether a Network
// satisfies mDefaultRequest.
- NetworkAgentInfo nai = new NetworkAgentInfo(messenger, new AsyncChannel(),
+ final NetworkAgentInfo nai = new NetworkAgentInfo(messenger, new AsyncChannel(),
new Network(reserveNetId()), new NetworkInfo(networkInfo), new LinkProperties(
linkProperties), new NetworkCapabilities(networkCapabilities), currentScore,
- mContext, mTrackerHandler, new NetworkMisc(networkMisc), mDefaultRequest);
+ mContext, mTrackerHandler, new NetworkMisc(networkMisc), mDefaultRequest, this);
synchronized (this) {
nai.networkMonitor.systemReady = mSystemReady;
}
ArrayList<NetworkRequestInfo> addedRequests = new ArrayList<NetworkRequestInfo>();
if (VDBG) log(" network has: " + newNetwork.networkCapabilities);
for (NetworkRequestInfo nri : mNetworkRequests.values()) {
- NetworkAgentInfo currentNetwork = mNetworkForRequestId.get(nri.request.requestId);
- if (newNetwork == currentNetwork) {
+ final NetworkAgentInfo currentNetwork = mNetworkForRequestId.get(nri.request.requestId);
+ final boolean satisfies = newNetwork.satisfies(nri.request);
+ if (newNetwork == currentNetwork && satisfies) {
if (VDBG) {
log("Network " + newNetwork.name() + " was already satisfying" +
" request " + nri.request.requestId + ". No change.");
// check if it satisfies the NetworkCapabilities
if (VDBG) log(" checking if request is satisfied: " + nri.request);
- if (newNetwork.satisfies(nri.request)) {
+ if (satisfies) {
if (!nri.isRequest) {
// This is not a request, it's a callback listener.
// Add it to newNetwork regardless of score.
oldDefaultNetwork = currentNetwork;
}
}
+ } else if (newNetwork.networkRequests.get(nri.request.requestId) != null) {
+ // If "newNetwork" is listed as satisfying "nri" but no longer satisfies "nri",
+ // mark it as no longer satisfying "nri". Because networks are processed by
+ // rematchAllNetworkAndRequests() in descending score order, "currentNetwork" will
+ // match "newNetwork" before this loop will encounter a "currentNetwork" with higher
+ // score than "newNetwork" and where "currentNetwork" no longer satisfies "nri".
+ // This means this code doesn't have to handle the case where "currentNetwork" no
+ // longer satisfies "nri" when "currentNetwork" does not equal "newNetwork".
+ if (DBG) {
+ log("Network " + newNetwork.name() + " stopped satisfying" +
+ " request " + nri.request.requestId);
+ }
+ newNetwork.networkRequests.remove(nri.request.requestId);
+ if (currentNetwork == newNetwork) {
+ mNetworkForRequestId.remove(nri.request.requestId);
+ sendUpdatedScoreToFactories(nri.request, 0);
+ } else {
+ if (nri.isRequest == true) {
+ Slog.wtf(TAG, "BUG: Removing request " + nri.request.requestId + " from " +
+ newNetwork.name() +
+ " without updating mNetworkForRequestId or factories!");
+ }
+ }
+ // TODO: technically, sending CALLBACK_LOST here is
+ // incorrect if nri is a request (not a listen) and there
+ // is a replacement network currently connected that can
+ // satisfy it. However, the only capability that can both
+ // a) be requested and b) change is NET_CAPABILITY_TRUSTED,
+ // so this code is only incorrect for a network that loses
+ // the TRUSTED capability, which is a rare case.
+ callCallbackForRequest(nri, newNetwork, ConnectivityManager.CALLBACK_LOST);
}
}
// Linger any networks that are no longer needed.
unlinger(nai);
}
}
- if (keep) {
- if (isNewDefault) {
- // Notify system services that this network is up.
- makeDefault(newNetwork);
- synchronized (ConnectivityService.this) {
- // have a new default network, release the transition wakelock in
- // a second if it's held. The second pause is to allow apps
- // to reconnect over the new network
- if (mNetTransitionWakeLock.isHeld()) {
- mHandler.sendMessageDelayed(mHandler.obtainMessage(
- EVENT_CLEAR_NET_TRANSITION_WAKELOCK,
- mNetTransitionWakeLockSerialNumber, 0),
- 1000);
- }
+ if (isNewDefault) {
+ // Notify system services that this network is up.
+ makeDefault(newNetwork);
+ synchronized (ConnectivityService.this) {
+ // have a new default network, release the transition wakelock in
+ // a second if it's held. The second pause is to allow apps
+ // to reconnect over the new network
+ if (mNetTransitionWakeLock.isHeld()) {
+ mHandler.sendMessageDelayed(mHandler.obtainMessage(
+ EVENT_CLEAR_NET_TRANSITION_WAKELOCK,
+ mNetTransitionWakeLockSerialNumber, 0),
+ 1000);
}
}
+ }
- // do this after the default net is switched, but
- // before LegacyTypeTracker sends legacy broadcasts
- for (NetworkRequestInfo nri : addedRequests) notifyNetworkCallback(newNetwork, nri);
+ // do this after the default net is switched, but
+ // before LegacyTypeTracker sends legacy broadcasts
+ for (NetworkRequestInfo nri : addedRequests) notifyNetworkCallback(newNetwork, nri);
- if (isNewDefault) {
- // Maintain the illusion: since the legacy API only
- // understands one network at a time, we must pretend
- // that the current default network disconnected before
- // the new one connected.
- if (oldDefaultNetwork != null) {
- mLegacyTypeTracker.remove(oldDefaultNetwork.networkInfo.getType(),
- oldDefaultNetwork, true);
- }
- mDefaultInetConditionPublished = newNetwork.lastValidated ? 100 : 0;
- mLegacyTypeTracker.add(newNetwork.networkInfo.getType(), newNetwork);
- notifyLockdownVpn(newNetwork);
+ if (isNewDefault) {
+ // Maintain the illusion: since the legacy API only
+ // understands one network at a time, we must pretend
+ // that the current default network disconnected before
+ // the new one connected.
+ if (oldDefaultNetwork != null) {
+ mLegacyTypeTracker.remove(oldDefaultNetwork.networkInfo.getType(),
+ oldDefaultNetwork, true);
}
+ mDefaultInetConditionPublished = newNetwork.lastValidated ? 100 : 0;
+ mLegacyTypeTracker.add(newNetwork.networkInfo.getType(), newNetwork);
+ notifyLockdownVpn(newNetwork);
+ }
+ if (keep) {
// Notify battery stats service about this network, both the normal
// interface and any stacked links.
// TODO: Avoid redoing this; this must only be done once when a network comes online.
}
}
}
+
+ @VisibleForTesting
+ public NetworkMonitor createNetworkMonitor(Context context, Handler handler,
+ NetworkAgentInfo nai, NetworkRequest defaultRequest) {
+ return new NetworkMonitor(context, handler, nai, defaultRequest);
+ }
+
}
import android.util.Log;
import android.util.LogPrinter;
+import com.android.server.connectivity.NetworkAgentInfo;
import com.android.server.connectivity.NetworkMonitor;
import org.mockito.ArgumentCaptor;
private INetworkPolicyManager mPolicyService;
private BroadcastInterceptingContext mServiceContext;
- private ConnectivityService mService;
+ private WrappedConnectivityService mService;
private ConnectivityManager mCm;
private MockNetworkAgent mWiFiNetworkAgent;
private MockNetworkAgent mCellNetworkAgent;
}
private class MockNetworkAgent {
+ private final WrappedNetworkMonitor mWrappedNetworkMonitor;
private final NetworkInfo mNetworkInfo;
private final NetworkCapabilities mNetworkCapabilities;
private final Thread mThread;
throw new UnsupportedOperationException("unimplemented network type");
}
final ConditionVariable initComplete = new ConditionVariable();
+ final ConditionVariable networkMonitorAvailable = mService.getNetworkMonitorCreatedCV();
mThread = new Thread() {
public void run() {
Looper.prepare();
};
mThread.start();
waitFor(initComplete);
+ waitFor(networkMonitorAvailable);
+ mWrappedNetworkMonitor = mService.getLastCreatedWrappedNetworkMonitor();
}
public void adjustScore(int change) {
assertEquals(mNetworkInfo.getDetailedState(), DetailedState.IDLE);
assertFalse(mNetworkCapabilities.hasCapability(NET_CAPABILITY_INTERNET));
- // To pretend network is validated, we transition it to the CONNECTED state without
- // NET_CAPABILITY_INTERNET so NetworkMonitor doesn't bother trying to validate and
- // just rubber stamps it as validated. Afterwards we add NET_CAPABILITY_INTERNET so
- // the network can satisfy the default request.
NetworkCallback callback = null;
final ConditionVariable validatedCv = new ConditionVariable();
if (validated) {
- // If we connect a network without INTERNET capability, it'll get reaped.
- // Prevent the reaping by adding a NetworkRequest.
+ mWrappedNetworkMonitor.gen204ProbeResult = 204;
NetworkRequest request = new NetworkRequest.Builder()
.addTransportType(mNetworkCapabilities.getTransportTypes()[0])
.build();
callback = new NetworkCallback() {
public void onCapabilitiesChanged(Network network,
NetworkCapabilities networkCapabilities) {
- if (networkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED)) {
+ if (network.equals(getNetwork()) &&
+ networkCapabilities.hasCapability(NET_CAPABILITY_VALIDATED)) {
validatedCv.open();
}
}
};
- mCm.requestNetwork(request, callback);
- } else {
- mNetworkCapabilities.addCapability(NET_CAPABILITY_INTERNET);
- mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities);
+ mCm.registerNetworkCallback(request, callback);
}
+ addCapability(NET_CAPABILITY_INTERNET);
connectWithoutInternet();
if (validated) {
// Wait for network to validate.
waitFor(validatedCv);
- mNetworkCapabilities.addCapability(NET_CAPABILITY_INTERNET);
- mNetworkAgent.sendNetworkCapabilities(mNetworkCapabilities);
+ mWrappedNetworkMonitor.gen204ProbeResult = 500;
}
if (callback != null) mCm.unregisterNetworkCallback(callback);
}
+ public void connectWithCaptivePortal() {
+ mWrappedNetworkMonitor.gen204ProbeResult = 200;
+ connect(false);
+ waitFor(new Criteria() { public boolean get() {
+ NetworkCapabilities caps = mCm.getNetworkCapabilities(getNetwork());
+ return caps != null && caps.hasCapability(NET_CAPABILITY_CAPTIVE_PORTAL);} });
+ mWrappedNetworkMonitor.gen204ProbeResult = 500;
+ }
+
public void disconnect() {
mNetworkInfo.setDetailedState(DetailedState.DISCONNECTED, null, null);
mNetworkAgent.sendNetworkInfo(mNetworkInfo);
public ConditionVariable getDisconnectedCV() {
return mDisconnected;
}
+
+ public WrappedNetworkMonitor getWrappedNetworkMonitor() {
+ return mWrappedNetworkMonitor;
+ }
}
private static class MockNetworkFactory extends NetworkFactory {
- final ConditionVariable mNetworkStartedCV = new ConditionVariable();
- final ConditionVariable mNetworkStoppedCV = new ConditionVariable();
- final ConditionVariable mNetworkRequestedCV = new ConditionVariable();
- final ConditionVariable mNetworkReleasedCV = new ConditionVariable();
- final AtomicBoolean mNetworkStarted = new AtomicBoolean(false);
+ private final ConditionVariable mNetworkStartedCV = new ConditionVariable();
+ private final ConditionVariable mNetworkStoppedCV = new ConditionVariable();
+ private final ConditionVariable mNetworkRequestedCV = new ConditionVariable();
+ private final ConditionVariable mNetworkReleasedCV = new ConditionVariable();
+ private final AtomicBoolean mNetworkStarted = new AtomicBoolean(false);
public MockNetworkFactory(Looper looper, Context context, String logTag,
NetworkCapabilities filter) {
}
}
+ // NetworkMonitor implementation allowing overriding of Internet connectivity probe result.
+ private class WrappedNetworkMonitor extends NetworkMonitor {
+ // HTTP response code fed back to NetworkMonitor for Internet connectivity probe.
+ public int gen204ProbeResult = 500;
+
+ public WrappedNetworkMonitor(Context context, Handler handler,
+ NetworkAgentInfo networkAgentInfo, NetworkRequest defaultRequest) {
+ super(context, handler, networkAgentInfo, defaultRequest);
+ }
+
+ @Override
+ protected int isCaptivePortal() {
+ return gen204ProbeResult;
+ }
+ }
+
private class WrappedConnectivityService extends ConnectivityService {
+ private final ConditionVariable mNetworkMonitorCreated = new ConditionVariable();
+ private WrappedNetworkMonitor mLastCreatedNetworkMonitor;
+
public WrappedConnectivityService(Context context, INetworkManagementService netManager,
INetworkStatsService statsService, INetworkPolicyManager policyManager) {
super(context, netManager, statsService, policyManager);
return netId;
}
}
+
+ @Override
+ public NetworkMonitor createNetworkMonitor(Context context, Handler handler,
+ NetworkAgentInfo nai, NetworkRequest defaultRequest) {
+ final WrappedNetworkMonitor monitor = new WrappedNetworkMonitor(context, handler, nai,
+ defaultRequest);
+ mLastCreatedNetworkMonitor = monitor;
+ mNetworkMonitorCreated.open();
+ return monitor;
+ }
+
+ public WrappedNetworkMonitor getLastCreatedWrappedNetworkMonitor() {
+ return mLastCreatedNetworkMonitor;
+ }
+
+ public ConditionVariable getNetworkMonitorCreatedCV() {
+ mNetworkMonitorCreated.close();
+ return mNetworkMonitorCreated;
+ }
}
private interface Criteria {
@LargeTest
public void testUnlingeringDoesNotValidate() throws Exception {
- // Test bringing up unvalidated cellular.
- mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
+ // Test bringing up unvalidated WiFi.
+ mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
ConditionVariable cv = waitForConnectivityBroadcasts(1);
- mCellNetworkAgent.connect(false);
+ mWiFiNetworkAgent.connect(false);
waitFor(cv);
- verifyActiveNetwork(TRANSPORT_CELLULAR);
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ verifyActiveNetwork(TRANSPORT_WIFI);
+ assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- // Test bringing up validated WiFi.
- mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
+ // Test bringing up validated cellular.
+ mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
cv = waitForConnectivityBroadcasts(2);
- mWiFiNetworkAgent.connect(true);
+ mCellNetworkAgent.connect(true);
waitFor(cv);
- verifyActiveNetwork(TRANSPORT_WIFI);
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ verifyActiveNetwork(TRANSPORT_CELLULAR);
+ assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
- // Test WiFi disconnect.
+ // Test cellular disconnect.
cv = waitForConnectivityBroadcasts(2);
- mWiFiNetworkAgent.disconnect();
+ mCellNetworkAgent.disconnect();
waitFor(cv);
- verifyActiveNetwork(TRANSPORT_CELLULAR);
+ verifyActiveNetwork(TRANSPORT_WIFI);
// Unlingering a network should not cause it to be marked as validated.
- assertFalse(mCm.getNetworkCapabilities(mCellNetworkAgent.getNetwork()).hasCapability(
+ assertFalse(mCm.getNetworkCapabilities(mWiFiNetworkAgent.getNetwork()).hasCapability(
NET_CAPABILITY_VALIDATED));
}
cellCv = cellNetworkCallback.getConditionVariable();
wifiCv = wifiNetworkCallback.getConditionVariable();
- // Our method for faking successful validation generates an additional callback, so wait
- // for broadcast instead.
- cv = waitForConnectivityBroadcasts(1);
mCellNetworkAgent = new MockNetworkAgent(TRANSPORT_CELLULAR);
mCellNetworkAgent.connect(true);
- waitFor(cv);
waitFor(cellCv);
assertEquals(CallbackState.AVAILABLE, cellNetworkCallback.getLastCallback());
assertEquals(CallbackState.NONE, wifiNetworkCallback.getLastCallback());
cellCv = cellNetworkCallback.getConditionVariable();
wifiCv = wifiNetworkCallback.getConditionVariable();
- // Our method for faking successful validation generates an additional callback, so wait
- // for broadcast instead.
- cv = waitForConnectivityBroadcasts(1);
mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
mWiFiNetworkAgent.connect(true);
- waitFor(cv);
waitFor(wifiCv);
assertEquals(CallbackState.AVAILABLE, wifiNetworkCallback.getLastCallback());
waitFor(cellCv);
verifyActiveNetwork(TRANSPORT_CELLULAR);
}
+ @LargeTest
+ public void testCaptivePortal() {
+ final TestNetworkCallback captivePortalCallback = new TestNetworkCallback();
+ final NetworkRequest captivePortalRequest = new NetworkRequest.Builder()
+ .addCapability(NET_CAPABILITY_CAPTIVE_PORTAL).build();
+ mCm.registerNetworkCallback(captivePortalRequest, captivePortalCallback);
+
+ final TestNetworkCallback validatedCallback = new TestNetworkCallback();
+ final NetworkRequest validatedRequest = new NetworkRequest.Builder()
+ .addCapability(NET_CAPABILITY_VALIDATED).build();
+ mCm.registerNetworkCallback(validatedRequest, validatedCallback);
+ ConditionVariable validatedCv = validatedCallback.getConditionVariable();
+
+ // Bring up a network with a captive portal.
+ // Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
+ ConditionVariable cv = captivePortalCallback.getConditionVariable();
+ mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
+ mWiFiNetworkAgent.connectWithCaptivePortal();
+ waitFor(cv);
+ assertEquals(CallbackState.AVAILABLE, captivePortalCallback.getLastCallback());
+
+ // Take down network.
+ // Expect onLost callback.
+ cv = captivePortalCallback.getConditionVariable();
+ mWiFiNetworkAgent.disconnect();
+ waitFor(cv);
+ assertEquals(CallbackState.LOST, captivePortalCallback.getLastCallback());
+
+ // Bring up a network with a captive portal.
+ // Expect onAvailable callback of listen for NET_CAPABILITY_CAPTIVE_PORTAL.
+ cv = captivePortalCallback.getConditionVariable();
+ mWiFiNetworkAgent = new MockNetworkAgent(TRANSPORT_WIFI);
+ mWiFiNetworkAgent.connectWithCaptivePortal();
+ waitFor(cv);
+ assertEquals(CallbackState.AVAILABLE, captivePortalCallback.getLastCallback());
+
+ // Make captive portal disappear then revalidate.
+ // Expect onLost callback because network no longer provides NET_CAPABILITY_CAPTIVE_PORTAL.
+ cv = captivePortalCallback.getConditionVariable();
+ mWiFiNetworkAgent.getWrappedNetworkMonitor().gen204ProbeResult = 204;
+ mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), true);
+ waitFor(cv);
+ assertEquals(CallbackState.LOST, captivePortalCallback.getLastCallback());
+
+ // Expect NET_CAPABILITY_VALIDATED onAvailable callback.
+ waitFor(validatedCv);
+ assertEquals(CallbackState.AVAILABLE, validatedCallback.getLastCallback());
+
+ // Break network connectivity.
+ // Expect NET_CAPABILITY_VALIDATED onLost callback.
+ validatedCv = validatedCallback.getConditionVariable();
+ mWiFiNetworkAgent.getWrappedNetworkMonitor().gen204ProbeResult = 500;
+ mCm.reportNetworkConnectivity(mWiFiNetworkAgent.getNetwork(), false);
+ waitFor(validatedCv);
+ assertEquals(CallbackState.LOST, validatedCallback.getLastCallback());
+ }
+
// @Override
// public void tearDown() throws Exception {
// super.tearDown();
OSDN Git Service
