From 7a56387e2c4d7e8c63733f2a18fb138e56668697 Mon Sep 17 00:00:00 2001 From: Chalard Jean Date: Fri, 14 Feb 2020 20:35:25 +0900 Subject: [PATCH] [NS D02] Mix in the ignore on wifi policy. Ultimately ConnectivityService and its satellites should mix in some measurements to NetworkScore, but in the immediate future they'll just use this to mix in at the new format the policy it used to managed in an ad-hoc way. As a first mix-in, this adds mixing in the IGNORE_ON_WIFI policy, which so far used to be handled in Connectivity as the avoidBadWifi bit. Ultimately this should move to Telephony. Bug: 113554781 Test: ConnectivityServiceTest Change-Id: I4869d5eb9ea74679e57c087005ed3d9b8119fed2 --- core/java/android/net/NetworkScore.java | 21 +++++++--- .../android/server/ConnectivityService.java | 41 ++++++++++++++++++- 2 files changed, 54 insertions(+), 8 deletions(-) diff --git a/core/java/android/net/NetworkScore.java b/core/java/android/net/NetworkScore.java index ae17378cfc..d2e59eb893 100644 --- a/core/java/android/net/NetworkScore.java +++ b/core/java/android/net/NetworkScore.java @@ -21,7 +21,6 @@ import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.SystemApi; import android.annotation.TestApi; -import android.os.Bundle; import android.os.Parcel; import android.os.Parcelable; @@ -87,7 +86,7 @@ public final class NetworkScore implements Parcelable { /** toString */ public String toString() { return "latency = " + latencyMs + " downlinkBandwidth = " + downlinkBandwidthKBps - + "uplinkBandwidth = " + uplinkBandwidthKBps; + + " uplinkBandwidth = " + uplinkBandwidthKBps; } @NonNull @@ -354,17 +353,27 @@ public final class NetworkScore implements Parcelable { private Metrics mLinkLayerMetrics = new Metrics(Metrics.LATENCY_UNKNOWN, Metrics.BANDWIDTH_UNKNOWN, Metrics.BANDWIDTH_UNKNOWN); @NonNull - private Metrics mEndToMetrics = new Metrics(Metrics.LATENCY_UNKNOWN, + private Metrics mEndToEndMetrics = new Metrics(Metrics.LATENCY_UNKNOWN, Metrics.BANDWIDTH_UNKNOWN, Metrics.BANDWIDTH_UNKNOWN); private int mSignalStrength = UNKNOWN_SIGNAL_STRENGTH; private int mRange = RANGE_UNKNOWN; private boolean mExiting = false; private int mLegacyScore = 0; - @NonNull private Bundle mExtensions = new Bundle(); /** Create a new builder. */ public Builder() { } + /** @hide */ + public Builder(@NonNull final NetworkScore source) { + mPolicy = source.mPolicy; + mLinkLayerMetrics = source.mLinkLayerMetrics; + mEndToEndMetrics = source.mEndToEndMetrics; + mSignalStrength = source.mSignalStrength; + mRange = source.mRange; + mExiting = source.mExiting; + mLegacyScore = source.mLegacyScore; + } + /** Add a policy flag. */ @NonNull public Builder addPolicy(@Policy final int policy) { mPolicy |= policy; @@ -385,7 +394,7 @@ public final class NetworkScore implements Parcelable { /** Set the end-to-end metrics. */ @NonNull public Builder setEndToEndMetrics(@NonNull final Metrics endToEndMetrics) { - mEndToMetrics = endToEndMetrics; + mEndToEndMetrics = endToEndMetrics; return this; } @@ -417,7 +426,7 @@ public final class NetworkScore implements Parcelable { /** Build the NetworkScore object represented by this builder. */ @NonNull public NetworkScore build() { - return new NetworkScore(mPolicy, mLinkLayerMetrics, mEndToMetrics, + return new NetworkScore(mPolicy, mLinkLayerMetrics, mEndToEndMetrics, mSignalStrength, mRange, mExiting, mLegacyScore); } } diff --git a/services/core/java/com/android/server/ConnectivityService.java b/services/core/java/com/android/server/ConnectivityService.java index c47cde34a9..f121cab85c 100644 --- a/services/core/java/com/android/server/ConnectivityService.java +++ b/services/core/java/com/android/server/ConnectivityService.java @@ -3787,8 +3787,9 @@ public class ConnectivityService extends IConnectivityManager.Stub return avoidBadWifi(); } - private void rematchForAvoidBadWifiUpdate() { + ensureRunningOnConnectivityServiceThread(); + mixInAllNetworkScores(); rematchAllNetworksAndRequests(); for (NetworkAgentInfo nai: mNetworkAgentInfos.values()) { if (nai.networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) { @@ -6992,9 +6993,45 @@ public class ConnectivityService extends IConnectivityManager.Stub } } + /** + * Re-mixin all network scores. + * This is called when some global setting like avoidBadWifi has changed. + * TODO : remove this when all usages have been removed. + */ + private void mixInAllNetworkScores() { + ensureRunningOnConnectivityServiceThread(); + for (final NetworkAgentInfo nai : mNetworkAgentInfos.values()) { + nai.setNetworkScore(mixInNetworkScore(nai, nai.getNetworkScore())); + } + } + + /** + * Mix in the Connectivity-managed parts of the NetworkScore. + * @param nai The NAI this score applies to. + * @param sourceScore the score sent by the network agent, or the previous score of this NAI. + * @return A new score with the Connectivity-managed parts mixed in. + */ + @NonNull + private NetworkScore mixInNetworkScore(@NonNull final NetworkAgentInfo nai, + @NonNull final NetworkScore sourceScore) { + final NetworkScore.Builder score = new NetworkScore.Builder(sourceScore); + + // TODO : this should be done in Telephony. It should be handled per-network because + // it's a carrier-dependent config. + if (nai.networkCapabilities.hasTransport(TRANSPORT_CELLULAR)) { + if (mMultinetworkPolicyTracker.getAvoidBadWifi()) { + score.clearPolicy(NetworkScore.POLICY_IGNORE_ON_WIFI); + } else { + score.addPolicy(NetworkScore.POLICY_IGNORE_ON_WIFI); + } + } + + return score.build(); + } + private void updateNetworkScore(NetworkAgentInfo nai, NetworkScore ns) { if (VDBG || DDBG) log("updateNetworkScore for " + nai.toShortString() + " to " + ns); - nai.setNetworkScore(ns); + nai.setNetworkScore(mixInNetworkScore(nai, ns)); rematchAllNetworksAndRequests(); sendUpdatedScoreToFactories(nai); }