595 lines
27 KiB
Java
595 lines
27 KiB
Java
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.net.wifi;
|
|
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.SystemApi;
|
|
import android.net.wifi.ScanResult.WifiBand;
|
|
import android.os.Build;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
import android.util.SparseArray;
|
|
|
|
import androidx.annotation.RequiresApi;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.Arrays;
|
|
import java.util.Objects;
|
|
import java.util.function.Consumer;
|
|
|
|
/**
|
|
* An Object used in {@link WifiManager#setNetworkSelectionConfig(WifiNetworkSelectionConfig)}.
|
|
* @hide
|
|
*/
|
|
@SystemApi
|
|
@RequiresApi(Build.VERSION_CODES.TIRAMISU)
|
|
public final class WifiNetworkSelectionConfig implements Parcelable {
|
|
/** @hide */
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(prefix = {"ASSOCIATED_NETWORK_SELECTION_OVERRIDE_"}, value = {
|
|
ASSOCIATED_NETWORK_SELECTION_OVERRIDE_NONE,
|
|
ASSOCIATED_NETWORK_SELECTION_OVERRIDE_ENABLED,
|
|
ASSOCIATED_NETWORK_SELECTION_OVERRIDE_DISABLED})
|
|
public @interface AssociatedNetworkSelectionOverride {}
|
|
/**
|
|
* A constant used in {@link Builder#setAssociatedNetworkSelectionOverride(int)}
|
|
* This is the default value which performs no override.
|
|
*/
|
|
public static final int ASSOCIATED_NETWORK_SELECTION_OVERRIDE_NONE = 0;
|
|
/**
|
|
* A constant used in {{@link Builder#setAssociatedNetworkSelectionOverride(int)}
|
|
* Overrides the config_wifi_framework_enable_associated_network_selection overlay to true to
|
|
* allow the wifi framework to automatically select and switch to a better wifi network while
|
|
* already connected.
|
|
*/
|
|
public static final int ASSOCIATED_NETWORK_SELECTION_OVERRIDE_ENABLED = 1;
|
|
/**
|
|
* A constant used in {@link Builder#setAssociatedNetworkSelectionOverride(int)}
|
|
* Overrides the config_wifi_framework_enable_associated_network_selection overlay to false to
|
|
* disallow the wifi framework to automatically select and connect to another network while
|
|
* already connected.
|
|
*/
|
|
public static final int ASSOCIATED_NETWORK_SELECTION_OVERRIDE_DISABLED = 2;
|
|
|
|
/** @hide */
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef(prefix = {"FREQUENCY_WEIGHT_"}, value = {
|
|
FREQUENCY_WEIGHT_LOW,
|
|
FREQUENCY_WEIGHT_HIGH})
|
|
public @interface FrequencyWeight {}
|
|
|
|
/**
|
|
* A constant used in {@link Builder#setFrequencyWeights(SparseArray)} to indicate a low
|
|
* preference for the frequency it's associated with.
|
|
*/
|
|
public static final int FREQUENCY_WEIGHT_LOW = 0;
|
|
/**
|
|
* A constant used in {@link Builder#setFrequencyWeights(SparseArray)} to indicate a high
|
|
* preference for the frequency it's associated with.
|
|
*/
|
|
public static final int FREQUENCY_WEIGHT_HIGH = 1;
|
|
|
|
private boolean mSufficiencyCheckEnabledWhenScreenOff = true;
|
|
private boolean mSufficiencyCheckEnabledWhenScreenOn = true;
|
|
private boolean mUserConnectChoiceOverrideEnabled = true;
|
|
private boolean mLastSelectionWeightEnabled = true;
|
|
private int mAssociatedNetworkSelectionOverride = ASSOCIATED_NETWORK_SELECTION_OVERRIDE_NONE;
|
|
|
|
/** RSSI thresholds for 2.4 GHz band (dBm) */
|
|
private int[] mRssi2Thresholds = new int[4];
|
|
|
|
/** RSSI thresholds for 5 GHz band (dBm) */
|
|
private int[] mRssi5Thresholds = new int[4];
|
|
|
|
/** RSSI thresholds for 6 GHz band (dBm) */
|
|
private int[] mRssi6Thresholds = new int[4];
|
|
|
|
/** Frequency weight list */
|
|
private SparseArray<Integer> mFrequencyWeights = new SparseArray<>();
|
|
|
|
// empty constructor
|
|
private WifiNetworkSelectionConfig() {
|
|
|
|
}
|
|
|
|
// copy constructor used by Builder
|
|
private WifiNetworkSelectionConfig(WifiNetworkSelectionConfig that) {
|
|
mSufficiencyCheckEnabledWhenScreenOff = that.mSufficiencyCheckEnabledWhenScreenOff;
|
|
mSufficiencyCheckEnabledWhenScreenOn = that.mSufficiencyCheckEnabledWhenScreenOn;
|
|
mAssociatedNetworkSelectionOverride = that.mAssociatedNetworkSelectionOverride;
|
|
mUserConnectChoiceOverrideEnabled = that.mUserConnectChoiceOverrideEnabled;
|
|
mLastSelectionWeightEnabled = that.mLastSelectionWeightEnabled;
|
|
mRssi2Thresholds = that.mRssi2Thresholds;
|
|
mRssi5Thresholds = that.mRssi5Thresholds;
|
|
mRssi6Thresholds = that.mRssi6Thresholds;
|
|
mFrequencyWeights = that.mFrequencyWeights;
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setSufficiencyCheckEnabledWhenScreenOff(boolean)}.
|
|
*/
|
|
public boolean isSufficiencyCheckEnabledWhenScreenOff() {
|
|
return mSufficiencyCheckEnabledWhenScreenOff;
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setSufficiencyCheckEnabledWhenScreenOn(boolean)}.
|
|
*/
|
|
public boolean isSufficiencyCheckEnabledWhenScreenOn() {
|
|
return mSufficiencyCheckEnabledWhenScreenOn;
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setUserConnectChoiceOverrideEnabled(boolean)}.
|
|
*/
|
|
public boolean isUserConnectChoiceOverrideEnabled() {
|
|
return mUserConnectChoiceOverrideEnabled;
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setLastSelectionWeightEnabled(boolean)}.
|
|
*/
|
|
public boolean isLastSelectionWeightEnabled() {
|
|
return mLastSelectionWeightEnabled;
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setAssociatedNetworkSelectionOverride(int)}.
|
|
*/
|
|
public @AssociatedNetworkSelectionOverride int getAssociatedNetworkSelectionOverride() {
|
|
return mAssociatedNetworkSelectionOverride;
|
|
}
|
|
|
|
private static boolean isValidAssociatedNetworkSelectionOverride(int override) {
|
|
return override >= ASSOCIATED_NETWORK_SELECTION_OVERRIDE_NONE
|
|
&& override <= ASSOCIATED_NETWORK_SELECTION_OVERRIDE_DISABLED;
|
|
}
|
|
|
|
private static boolean isValidBand(@WifiBand int band) {
|
|
switch (band) {
|
|
case ScanResult.WIFI_BAND_24_GHZ:
|
|
case ScanResult.WIFI_BAND_5_GHZ:
|
|
case ScanResult.WIFI_BAND_6_GHZ:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static boolean isValidRssiThresholdArray(int[] thresholds) {
|
|
if (thresholds == null || thresholds.length != 4) return false;
|
|
|
|
if (!isRssiThresholdResetArray(thresholds)) {
|
|
int low = WifiInfo.MIN_RSSI - 1;
|
|
int high = Math.min(WifiInfo.MAX_RSSI, -1);
|
|
for (int i = 0; i < thresholds.length; i++) {
|
|
if (thresholds[i] <= low || thresholds[i] > high) {
|
|
return false;
|
|
}
|
|
low = thresholds[i];
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static boolean isValidFrequencyWeightArray(SparseArray<Integer> weights) {
|
|
if (weights == null) return false;
|
|
|
|
for (int i = 0; i < weights.size(); i++) {
|
|
int value = weights.valueAt(i);
|
|
if (value < FREQUENCY_WEIGHT_LOW || value > FREQUENCY_WEIGHT_HIGH) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check whether the given RSSI threshold array contains all 0s.
|
|
* @hide
|
|
*/
|
|
public static boolean isRssiThresholdResetArray(@NonNull int[] thresholds) {
|
|
for (int value : thresholds) {
|
|
if (value != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Check whether the current configuration is valid.
|
|
* @hide
|
|
*/
|
|
public boolean isValid() {
|
|
return isValidAssociatedNetworkSelectionOverride(mAssociatedNetworkSelectionOverride)
|
|
&& isValidRssiThresholdArray(mRssi2Thresholds)
|
|
&& isValidRssiThresholdArray(mRssi5Thresholds)
|
|
&& isValidRssiThresholdArray(mRssi6Thresholds)
|
|
&& isValidFrequencyWeightArray(mFrequencyWeights);
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setRssiThresholds(int, int[])}.
|
|
* Returns RSSI thresholds for the input band.
|
|
*
|
|
* @throws IllegalArgumentException if the input band is not a supported {@link WifiBand}
|
|
*/
|
|
public @NonNull int[] getRssiThresholds(@WifiBand int band) {
|
|
if (!isValidBand(band)) {
|
|
throw new IllegalArgumentException("Invalid band=" + band);
|
|
}
|
|
switch (band) {
|
|
case ScanResult.WIFI_BAND_24_GHZ:
|
|
return mRssi2Thresholds;
|
|
case ScanResult.WIFI_BAND_5_GHZ:
|
|
return mRssi5Thresholds;
|
|
case ScanResult.WIFI_BAND_6_GHZ:
|
|
return mRssi6Thresholds;
|
|
}
|
|
throw new IllegalArgumentException("Did not find RSSI thresholds for band=" + band);
|
|
}
|
|
|
|
/**
|
|
* See {@link Builder#setFrequencyWeights(SparseArray)}.
|
|
*/
|
|
public @NonNull SparseArray<Integer> getFrequencyWeights() {
|
|
return mFrequencyWeights;
|
|
}
|
|
|
|
/**
|
|
* Used to create a {@link WifiNetworkSelectionConfig} Object.
|
|
*/
|
|
public static final class Builder {
|
|
WifiNetworkSelectionConfig mWifiNetworkSelectionConfig = new WifiNetworkSelectionConfig();
|
|
|
|
public Builder() {
|
|
mWifiNetworkSelectionConfig.mSufficiencyCheckEnabledWhenScreenOff = true;
|
|
mWifiNetworkSelectionConfig.mSufficiencyCheckEnabledWhenScreenOn = true;
|
|
mWifiNetworkSelectionConfig.mUserConnectChoiceOverrideEnabled = true;
|
|
mWifiNetworkSelectionConfig.mLastSelectionWeightEnabled = true;
|
|
mWifiNetworkSelectionConfig.mAssociatedNetworkSelectionOverride =
|
|
ASSOCIATED_NETWORK_SELECTION_OVERRIDE_NONE;
|
|
mWifiNetworkSelectionConfig.mRssi2Thresholds = new int[4];
|
|
mWifiNetworkSelectionConfig.mRssi5Thresholds = new int[4];
|
|
mWifiNetworkSelectionConfig.mRssi6Thresholds = new int[4];
|
|
mWifiNetworkSelectionConfig.mFrequencyWeights = new SparseArray<>();
|
|
}
|
|
|
|
public Builder(@NonNull WifiNetworkSelectionConfig config) {
|
|
mWifiNetworkSelectionConfig = config;
|
|
}
|
|
|
|
/**
|
|
* This setting affects wifi network selection behavior while already connected to a
|
|
* network, and is only relevant if associated network selection
|
|
* (see {@link #setAssociatedNetworkSelectionOverride(int)}) is enabled. Enable or disable
|
|
* network sufficiency check when wifi is connected and the screen is off.
|
|
* <p>
|
|
* If the sufficiency check is enabled, multiple parameters such as the RSSI and estimated
|
|
* throughput will be used to determine if the current network is sufficient. When the
|
|
* current network is found sufficient, the wifi framework will not attempt a network switch
|
|
* even if a potentially better network is available. When the current network is found
|
|
* insufficient, the wifi framework will keep trying to score other networks against the
|
|
* current network attempting to find and connect to a better alternative.
|
|
* <p>
|
|
* If the sufficiency check is disabled, then the currently connected network will always
|
|
* be considered insufficient. See the previous paragraph on the wifi framework's behavior
|
|
* when the current network is insufficient.
|
|
* <p>
|
|
* By default, network sufficiency check is enabled for both screen on and screen off cases.
|
|
* @param enabled Set to true to enable sufficiency check, and false to disable sufficiency
|
|
* check.
|
|
*/
|
|
public @NonNull Builder setSufficiencyCheckEnabledWhenScreenOff(boolean enabled) {
|
|
mWifiNetworkSelectionConfig.mSufficiencyCheckEnabledWhenScreenOff = enabled;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* This setting affects wifi network selection behavior while already connected to a
|
|
* network, and is only relevant if associated network selection
|
|
* (see {@link #setAssociatedNetworkSelectionOverride(int)}) is enabled. Enable or disable
|
|
* network sufficiency check when wifi is connected and the screen is on.
|
|
* <p>
|
|
* If the sufficiency check is enabled, multiple parameters such as the RSSI and estimated
|
|
* throughput will be used to determine if the current network is sufficient. When the
|
|
* current network is found sufficient, the wifi framework will not attempt a network switch
|
|
* even if a potentially better network is available. When the current network is found
|
|
* insufficient, the wifi framework will keep trying to score other networks against the
|
|
* current network attempting to find and connect to a better alternative.
|
|
* <p>
|
|
* If the sufficiency check is disabled, then the currently connected network will always
|
|
* be considered insufficient. See the previous paragraph on the wifi framework's behavior
|
|
* when the current network is insufficient.
|
|
* <p>
|
|
* By default, network sufficiency check is enabled for both screen on and screen off cases.
|
|
* @param enabled Set to true to enable sufficiency check, and false to disable sufficiency
|
|
* check.
|
|
*/
|
|
public @NonNull Builder setSufficiencyCheckEnabledWhenScreenOn(boolean enabled) {
|
|
mWifiNetworkSelectionConfig.mSufficiencyCheckEnabledWhenScreenOn = enabled;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Override the value programmed by the
|
|
* {@code config_wifi_framework_enable_associated_network_selection} overlay with one of the
|
|
* {@code ASSOCIATED_NETWORK_SELECTION_OVERRIDE_} values. When the overlay is enabled,
|
|
* the wifi framework is allowed to automatically select and switch to a better wifi
|
|
* network while already connected. When the overlay is disabled, the wifi framework will
|
|
* simply stay connected to the connected network and will not attempt to automatically
|
|
* switch to another network.
|
|
* <p>
|
|
* By default, there is no override, and the framework will use the value set in the
|
|
* overlay.
|
|
* @param override the value to override the overlay as.
|
|
* @throws IllegalArgumentException if the input is invalid.
|
|
*/
|
|
public @NonNull Builder setAssociatedNetworkSelectionOverride(
|
|
@AssociatedNetworkSelectionOverride int override) throws IllegalArgumentException {
|
|
if (!isValidAssociatedNetworkSelectionOverride(override)) {
|
|
throw new IllegalArgumentException("Invalid override=" + override);
|
|
}
|
|
mWifiNetworkSelectionConfig.mAssociatedNetworkSelectionOverride = override;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Enable or disable candidate override with the user connect choice.
|
|
* <p>
|
|
* If the override is enabled, the network selector overrides any selected candidate
|
|
* with a network previously chosen by the user over the candidate (i.e. when the
|
|
* candidate was connected the user explicitly selected another network), if one exists.
|
|
* <p>
|
|
* If the override is disabled, network selector uses the network nominator candidate
|
|
* and does not override it with the user chosen configuration.
|
|
* <p>
|
|
* By default, user connect choice override is enabled.
|
|
* @param enabled Set to true to enable candidate override with the user connect choice,
|
|
* and false to disable the override.
|
|
*/
|
|
public @NonNull Builder setUserConnectChoiceOverrideEnabled(boolean enabled) {
|
|
mWifiNetworkSelectionConfig.mUserConnectChoiceOverrideEnabled = enabled;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Enable or disable last selection weight.
|
|
* <p>
|
|
* If the last selection weight is enabled, network selector prefers the latest
|
|
* user selected network over all other networks for a limited duration.
|
|
* This duration is configurable via {@code config_wifiFrameworkLastSelectionMinutes}.
|
|
* <p>
|
|
* If the last selection weight is disabled, network selector does not prefer a
|
|
* recently selected network over other networks.
|
|
* <p>
|
|
* By default, last selection weight is enabled.
|
|
* @param enabled Set to true to enable the last selection weight,
|
|
* and false to disable it.
|
|
*/
|
|
public @NonNull Builder setLastSelectionWeightEnabled(boolean enabled) {
|
|
mWifiNetworkSelectionConfig.mLastSelectionWeightEnabled = enabled;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the RSSI thresholds for the input band.
|
|
* <p>
|
|
* If the RSSI thresholds are set, network selector uses these values over the
|
|
* following overlay configured values for the specified input band.
|
|
* For {@code ScanResult.WIFI_BAND_24_GHZ}:
|
|
* <ul>
|
|
* <li>{@code config_wifi_framework_wifi_score_bad_rssi_threshold_24GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_entry_rssi_threshold_24GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_low_rssi_threshold_24GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_good_rssi_threshold_24GHz}</li>
|
|
* </ul>
|
|
* For {@code ScanResult.WIFI_BAND_5_GHZ}:
|
|
* <ul>
|
|
* <li>{@code config_wifi_framework_wifi_score_bad_rssi_threshold_5GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_entry_rssi_threshold_5GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_low_rssi_threshold_5GHz}</li>
|
|
* <li>{@code config_wifi_framework_wifi_score_good_rssi_threshold_5GHz}</li>
|
|
* </ul>
|
|
* For {@code ScanResult.WIFI_BAND_6_GHZ}:
|
|
* <ul>
|
|
* <li>{@code config_wifiFrameworkScoreBadRssiThreshold6ghz}</li>
|
|
* <li>{@code config_wifiFrameworkScoreEntryRssiThreshold6ghz}</li>
|
|
* <li>{@code config_wifiFrameworkScoreLowRssiThreshold6ghz}</li>
|
|
* <li>{@code config_wifiFrameworkScoreGoodRssiThreshold6ghz}</li>
|
|
* </ul>
|
|
* <p>
|
|
* The input thresholds override the overlays listed above in the respective order
|
|
* so it must be an int array with 4 values.
|
|
* The values must be between -126 and -1 and the array must be strictly increasing.
|
|
* For example, [-80, -70, -60, -50] is a valid input while [-70, -70, -60, -50] is not
|
|
* since the array is not strictly increasing.
|
|
* The only exception to these rules is [0, 0, 0, 0], which is used to remove any
|
|
* RSSI thresholds set.
|
|
* <p>
|
|
* The input band must be one of the following {@link WifiBand}:
|
|
* <ul>
|
|
* <li>{@code ScanResult.WIFI_BAND_24_GHZ}</li>
|
|
* <li>{@code ScanResult.WIFI_BAND_5_GHZ}</li>
|
|
* <li>{@code ScanResult.WIFI_BAND_6_GHZ}</li>
|
|
* </ul>
|
|
* <p>
|
|
* To remove the RSSI thresholds set, pass in an array with 0s as the thresholds.
|
|
* The network selector will go back to using the overlay configured values.
|
|
* @param band {@link WifiBand} you want to set the RSSI thresholds for
|
|
* @param thresholds RSSI thresholds
|
|
* @throws IllegalArgumentException if the input is invalid.
|
|
*/
|
|
public @NonNull Builder setRssiThresholds(@WifiBand int band, @NonNull int[] thresholds)
|
|
throws IllegalArgumentException {
|
|
if (!isValidRssiThresholdArray(thresholds)) {
|
|
throw new IllegalArgumentException("Invalid RSSI thresholds="
|
|
+ Arrays.toString(thresholds));
|
|
}
|
|
if (!isValidBand(band)) {
|
|
throw new IllegalArgumentException("Invalid band=" + band);
|
|
}
|
|
switch (band) {
|
|
case ScanResult.WIFI_BAND_24_GHZ:
|
|
mWifiNetworkSelectionConfig.mRssi2Thresholds = thresholds;
|
|
break;
|
|
case ScanResult.WIFI_BAND_5_GHZ:
|
|
mWifiNetworkSelectionConfig.mRssi5Thresholds = thresholds;
|
|
break;
|
|
case ScanResult.WIFI_BAND_6_GHZ:
|
|
mWifiNetworkSelectionConfig.mRssi6Thresholds = thresholds;
|
|
break;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the frequency weights that will be used by the network selector to provide
|
|
* a bonus or penalty to the specified frequencies in the list.
|
|
* <p>
|
|
* The input SparseArray has to adhere to the following (key, value) format.
|
|
* Key: frequency the weight needs to be applied to in MHz (ex. 5201MHz -> 5201)
|
|
* Value: one of {@link FrequencyWeight}
|
|
* <ul>
|
|
* <li>{@link #FREQUENCY_WEIGHT_LOW}</li>
|
|
* <li>{@link #FREQUENCY_WEIGHT_HIGH}</li>
|
|
* </ul>
|
|
* <p>
|
|
* By default, all frequencies not present in the list will not have any frequency weight.
|
|
* <p>
|
|
* To removed the frequency weights set, pass in an empty SparseArray.
|
|
* The network selector will go back to treating all the frequencies with
|
|
* an equal preference.
|
|
* @param weights frequency weights
|
|
* @throws IllegalArgumentException if the input is invalid.
|
|
*/
|
|
public @NonNull Builder setFrequencyWeights(@NonNull SparseArray<Integer> weights)
|
|
throws IllegalArgumentException {
|
|
if (!isValidFrequencyWeightArray(weights)) {
|
|
if (weights == null) {
|
|
throw new IllegalArgumentException("Invalid frequency weights=null");
|
|
}
|
|
throw new IllegalArgumentException("Invalid frequency weights="
|
|
+ weights.toString());
|
|
}
|
|
mWifiNetworkSelectionConfig.mFrequencyWeights = weights;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Creates a WifiNetworkSelectionConfig for use in
|
|
* {@link WifiManager#setNetworkSelectionConfig(WifiNetworkSelectionConfig, Consumer)}
|
|
*/
|
|
public @NonNull WifiNetworkSelectionConfig build() {
|
|
return new WifiNetworkSelectionConfig(mWifiNetworkSelectionConfig);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mSufficiencyCheckEnabledWhenScreenOff,
|
|
mSufficiencyCheckEnabledWhenScreenOn, mAssociatedNetworkSelectionOverride,
|
|
mUserConnectChoiceOverrideEnabled, mLastSelectionWeightEnabled,
|
|
Arrays.hashCode(mRssi2Thresholds), Arrays.hashCode(mRssi5Thresholds),
|
|
Arrays.hashCode(mRssi6Thresholds), mFrequencyWeights.contentHashCode());
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (this == obj) {
|
|
return true;
|
|
}
|
|
if (!(obj instanceof WifiNetworkSelectionConfig)) {
|
|
return false;
|
|
}
|
|
WifiNetworkSelectionConfig lhs = (WifiNetworkSelectionConfig) obj;
|
|
return mSufficiencyCheckEnabledWhenScreenOff == lhs.mSufficiencyCheckEnabledWhenScreenOff
|
|
&& mSufficiencyCheckEnabledWhenScreenOn == lhs.mSufficiencyCheckEnabledWhenScreenOn
|
|
&& mAssociatedNetworkSelectionOverride == lhs.mAssociatedNetworkSelectionOverride
|
|
&& mUserConnectChoiceOverrideEnabled == lhs.mUserConnectChoiceOverrideEnabled
|
|
&& mLastSelectionWeightEnabled == lhs.mLastSelectionWeightEnabled
|
|
&& Arrays.equals(mRssi2Thresholds, lhs.mRssi2Thresholds)
|
|
&& Arrays.equals(mRssi5Thresholds, lhs.mRssi5Thresholds)
|
|
&& Arrays.equals(mRssi6Thresholds, lhs.mRssi6Thresholds)
|
|
&& mFrequencyWeights.contentEquals(lhs.mFrequencyWeights);
|
|
}
|
|
|
|
public static final @NonNull Creator<WifiNetworkSelectionConfig> CREATOR =
|
|
new Creator<WifiNetworkSelectionConfig>() {
|
|
@Override
|
|
public WifiNetworkSelectionConfig createFromParcel(Parcel in) {
|
|
WifiNetworkSelectionConfig config = new WifiNetworkSelectionConfig();
|
|
config.mSufficiencyCheckEnabledWhenScreenOff = in.readBoolean();
|
|
config.mSufficiencyCheckEnabledWhenScreenOn = in.readBoolean();
|
|
config.mAssociatedNetworkSelectionOverride = in.readInt();
|
|
config.mUserConnectChoiceOverrideEnabled = in.readBoolean();
|
|
config.mLastSelectionWeightEnabled = in.readBoolean();
|
|
in.readIntArray(config.mRssi2Thresholds);
|
|
in.readIntArray(config.mRssi5Thresholds);
|
|
in.readIntArray(config.mRssi6Thresholds);
|
|
config.mFrequencyWeights = in.readSparseArray(null, java.lang.Integer.class);
|
|
return config;
|
|
}
|
|
|
|
@Override
|
|
public WifiNetworkSelectionConfig[] newArray(int size) {
|
|
return new WifiNetworkSelectionConfig[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeBoolean(mSufficiencyCheckEnabledWhenScreenOff);
|
|
dest.writeBoolean(mSufficiencyCheckEnabledWhenScreenOn);
|
|
dest.writeInt(mAssociatedNetworkSelectionOverride);
|
|
dest.writeBoolean(mUserConnectChoiceOverrideEnabled);
|
|
dest.writeBoolean(mLastSelectionWeightEnabled);
|
|
dest.writeIntArray(mRssi2Thresholds);
|
|
dest.writeIntArray(mRssi5Thresholds);
|
|
dest.writeIntArray(mRssi6Thresholds);
|
|
dest.writeSparseArray(mFrequencyWeights);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("mSufficiencyCheckEnabledWhenScreenOff=")
|
|
.append(mSufficiencyCheckEnabledWhenScreenOff)
|
|
.append(", mSufficiencyCheckEnabledWhenScreenOn=")
|
|
.append(mSufficiencyCheckEnabledWhenScreenOn)
|
|
.append(", mAssociatedNetworkSelectionOverride=")
|
|
.append(mAssociatedNetworkSelectionOverride)
|
|
.append(", mUserConnectChoiceOverrideEnabled=")
|
|
.append(mUserConnectChoiceOverrideEnabled)
|
|
.append(", mLastSelectionWeightEnabled=")
|
|
.append(mLastSelectionWeightEnabled)
|
|
.append(", mRssi2Thresholds=")
|
|
.append(Arrays.toString(mRssi2Thresholds))
|
|
.append(", mRssi5Thresholds=")
|
|
.append(Arrays.toString(mRssi5Thresholds))
|
|
.append(", mRssi6Thresholds=")
|
|
.append(Arrays.toString(mRssi6Thresholds))
|
|
.append(", mFrequencyWeights=")
|
|
.append(mFrequencyWeights.toString());
|
|
return sb.toString();
|
|
}
|
|
}
|