xref: /packages/modules/Wifi/framework/java/android/net/wifi/WifiNetworkSelectionConfig.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();
    }
}