From 5236df9ddf5ee750eeb47dc38535559771a4a7ef Mon Sep 17 00:00:00 2001 From: Chalard Jean Date: Fri, 19 Mar 2021 13:49:56 +0900 Subject: [PATCH] [NS07] Add the rest of the scoring policy Bug: 167544279 Test: FrameworksNetTests Change-Id: I5ea44a94ac6f16486274e9091f15a84734db2341 --- framework/src/android/net/NetworkScore.java | 148 +++++++++++++++++++- 1 file changed, 144 insertions(+), 4 deletions(-) diff --git a/framework/src/android/net/NetworkScore.java b/framework/src/android/net/NetworkScore.java index 9786b09e35..22663e5800 100644 --- a/framework/src/android/net/NetworkScore.java +++ b/framework/src/android/net/NetworkScore.java @@ -52,11 +52,27 @@ public final class NetworkScore implements Parcelable { public static final int KEEP_CONNECTED_FOR_HANDOVER = 1; // Agent-managed policies - // TODO : add them here, starting from 1 + // This network should lose to a wifi that has ever been validated + // NOTE : temporarily this policy is managed by ConnectivityService, because of legacy. The + // legacy design has this bit global to the system and tacked on WiFi which means it will affect + // networks from carriers who don't want it and non-carrier networks, which is bad for users. + // The S design has this on mobile networks only, so this can be fixed eventually ; as CS + // doesn't know what carriers need this bit, the initial S implementation will continue to + // affect other carriers but will at least leave non-mobile networks alone. Eventually Telephony + // should set this on networks from carriers that require it. /** @hide */ - public static final int MIN_AGENT_MANAGED_POLICY = 0; + public static final int POLICY_YIELD_TO_BAD_WIFI = 1; + // This network is primary for this transport. /** @hide */ - public static final int MAX_AGENT_MANAGED_POLICY = -1; + public static final int POLICY_TRANSPORT_PRIMARY = 2; + // This network is exiting : it will likely disconnect in a few seconds. + /** @hide */ + public static final int POLICY_EXITING = 3; + + /** @hide */ + public static final int MIN_AGENT_MANAGED_POLICY = POLICY_YIELD_TO_BAD_WIFI; + /** @hide */ + public static final int MAX_AGENT_MANAGED_POLICY = POLICY_EXITING; // Bitmask of all the policies applied to this score. private final long mPolicies; @@ -98,6 +114,60 @@ public final class NetworkScore implements Parcelable { return 0 != (mPolicies & (1L << policy)); } + /** + * To the exclusive usage of FullScore + * @hide + */ + public long getPolicies() { + return mPolicies; + } + + /** + * Whether this network should yield to a previously validated wifi gone bad. + * + * If this policy is set, other things being equal, the device will prefer a previously + * validated WiFi even if this network is validated and the WiFi is not. + * If this policy is not set, the device prefers the validated network. + * + * @hide + */ + // TODO : Unhide this for telephony and have telephony call it on the relevant carriers. + // In the mean time this is handled by Connectivity in a backward-compatible manner. + public boolean shouldYieldToBadWifi() { + return hasPolicy(POLICY_YIELD_TO_BAD_WIFI); + } + + /** + * Whether this network is primary for this transport. + * + * When multiple networks of the same transport are active, the device prefers the ones that + * are primary. This is meant in particular for DS-DA devices with a user setting to choose the + * default SIM card, or for WiFi STA+STA and make-before-break cases. + * + * @hide + */ + // TODO : @SystemApi + public boolean isTransportPrimary() { + return hasPolicy(POLICY_TRANSPORT_PRIMARY); + } + + /** + * Whether this network is exiting. + * + * If this policy is set, the device will expect this network to disconnect within seconds. + * It will try to migrate to some other network if any is available, policy permitting, to + * avoid service disruption. + * This is useful in particular when a good cellular network is available and WiFi is getting + * weak and risks disconnecting soon. The WiFi network should be marked as exiting so that + * the device will prefer the reliable mobile network over this soon-to-be-lost WiFi. + * + * @hide + */ + // TODO : @SystemApi + public boolean isExiting() { + return hasPolicy(POLICY_EXITING); + } + @Override public String toString() { return "Score(" + mLegacyInt + ")"; @@ -137,6 +207,7 @@ public final class NetworkScore implements Parcelable { private static final int INVALID_LEGACY_INT = Integer.MIN_VALUE; private int mLegacyInt = INVALID_LEGACY_INT; private int mKeepConnectedReason = KEEP_CONNECTED_NONE; + private int mPolicies = 0; /** * Sets the legacy int for this score. @@ -152,6 +223,75 @@ public final class NetworkScore implements Parcelable { return this; } + + /** + * Set for a network that should never be preferred to a wifi that has ever been validated + * + * If this policy is set, other things being equal, the device will prefer a previously + * validated WiFi even if this network is validated and the WiFi is not. + * If this policy is not set, the device prefers the validated network. + * + * @return this builder + * @hide + */ + // TODO : Unhide this for telephony and have telephony call it on the relevant carriers. + // In the mean time this is handled by Connectivity in a backward-compatible manner. + @NonNull + public Builder setShouldYieldToBadWifi(final boolean val) { + if (val) { + mPolicies |= (1L << POLICY_YIELD_TO_BAD_WIFI); + } else { + mPolicies &= ~(1L << POLICY_YIELD_TO_BAD_WIFI); + } + return this; + } + + /** + * Set for a network that is primary for this transport. + * + * When multiple networks of the same transport are active, the device prefers the ones that + * are primary. This is meant in particular for DS-DA devices with a user setting to choose + * the default SIM card, or for WiFi STA+STA and make-before-break cases. + * + * @return this builder + * @hide + */ + // TODO : @SystemApi + @NonNull + public Builder setTransportPrimary(final boolean val) { + if (val) { + mPolicies |= (1L << POLICY_TRANSPORT_PRIMARY); + } else { + mPolicies &= ~(1L << POLICY_TRANSPORT_PRIMARY); + } + return this; + } + + /** + * Set for a network that will likely disconnect in a few seconds. + * + * If this policy is set, the device will expect this network to disconnect within seconds. + * It will try to migrate to some other network if any is available, policy permitting, to + * avoid service disruption. + * This is useful in particular when a good cellular network is available and WiFi is + * getting weak and risks disconnecting soon. The WiFi network should be marked as exiting + * so that the device will prefer the reliable mobile network over this soon-to-be-lost + * WiFi. + * + * @return this builder + * @hide + */ + // TODO : @SystemApi + @NonNull + public Builder setExiting(final boolean val) { + if (val) { + mPolicies |= (1L << POLICY_EXITING); + } else { + mPolicies &= ~(1L << POLICY_EXITING); + } + return this; + } + /** * Set the keep-connected reason. * @@ -169,7 +309,7 @@ public final class NetworkScore implements Parcelable { */ @NonNull public NetworkScore build() { - return new NetworkScore(mLegacyInt, POLICY_NONE, mKeepConnectedReason); + return new NetworkScore(mLegacyInt, mPolicies, mKeepConnectedReason); } } }