804 lines
34 KiB
Java
804 lines
34 KiB
Java
/*
|
|
* Copyright (C) 2019 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 com.android.server.wifi;
|
|
|
|
import static com.android.server.wifi.util.InformationElementUtil.BssLoad.CHANNEL_UTILIZATION_SCALE;
|
|
|
|
import android.content.Context;
|
|
import android.os.Handler;
|
|
import android.provider.DeviceConfig;
|
|
import android.util.ArraySet;
|
|
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
|
|
import java.util.Collections;
|
|
import java.util.Set;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/**
|
|
* This class allows getting all configurable flags from DeviceConfig.
|
|
*/
|
|
public class DeviceConfigFacade {
|
|
private Context mContext;
|
|
private final WifiMetrics mWifiMetrics;
|
|
|
|
private static final String NAMESPACE = "wifi";
|
|
|
|
// Default values of fields
|
|
@VisibleForTesting
|
|
protected static final int DEFAULT_ABNORMAL_CONNECTION_DURATION_MS =
|
|
(int) TimeUnit.SECONDS.toMillis(30);
|
|
// Default duration for evaluating Wifi condition to trigger a data stall
|
|
// measured in milliseconds
|
|
public static final int DEFAULT_DATA_STALL_DURATION_MS = 1500;
|
|
// Default threshold of Tx throughput below which to trigger a data stall measured in Kbps
|
|
public static final int DEFAULT_DATA_STALL_TX_TPUT_THR_KBPS = 2000;
|
|
// Default threshold of Rx throughput below which to trigger a data stall measured in Kbps
|
|
public static final int DEFAULT_DATA_STALL_RX_TPUT_THR_KBPS = 2000;
|
|
// Default threshold of Tx packet error rate above which to trigger a data stall in percentage
|
|
public static final int DEFAULT_DATA_STALL_TX_PER_THR = 90;
|
|
// Default threshold of CCA level above which to trigger a data stall
|
|
public static final int DEFAULT_DATA_STALL_CCA_LEVEL_THR = CHANNEL_UTILIZATION_SCALE;
|
|
// Default low threshold of L2 sufficient Tx throughput in Kbps
|
|
public static final int DEFAULT_TX_TPUT_SUFFICIENT_THR_LOW_KBPS = 2000;
|
|
// Default high threshold of L2 sufficient Tx throughput in Kbps
|
|
public static final int DEFAULT_TX_TPUT_SUFFICIENT_THR_HIGH_KBPS = 8000;
|
|
// Default low threshold of L2 sufficient Rx throughput in Kbps
|
|
public static final int DEFAULT_RX_TPUT_SUFFICIENT_THR_LOW_KBPS = 2000;
|
|
// Default high threshold of L2 sufficient Rx throughput in Kbps
|
|
public static final int DEFAULT_RX_TPUT_SUFFICIENT_THR_HIGH_KBPS = 8000;
|
|
// Numerator part of default threshold of L2 throughput over L3 throughput ratio
|
|
public static final int DEFAULT_TPUT_SUFFICIENT_RATIO_THR_NUM = 2;
|
|
// Denominator part of default threshold of L2 throughput over L3 throughput ratio
|
|
public static final int DEFAULT_TPUT_SUFFICIENT_RATIO_THR_DEN = 1;
|
|
// Default threshold of Tx packet per second
|
|
public static final int DEFAULT_TX_PACKET_PER_SECOND_THR = 2;
|
|
// Default threshold of Rx packet per second
|
|
public static final int DEFAULT_RX_PACKET_PER_SECOND_THR = 2;
|
|
// Default high threshold values for various connection/disconnection cases
|
|
// All of them are in percent with respect to connection attempts
|
|
static final int DEFAULT_CONNECTION_FAILURE_HIGH_THR_PERCENT = 40;
|
|
static final int DEFAULT_CONNECTION_FAILURE_DISCONNECTION_HIGH_THR_PERCENT = 30;
|
|
static final int DEFAULT_ASSOC_REJECTION_HIGH_THR_PERCENT = 30;
|
|
static final int DEFAULT_ASSOC_TIMEOUT_HIGH_THR_PERCENT = 30;
|
|
static final int DEFAULT_AUTH_FAILURE_HIGH_THR_PERCENT = 30;
|
|
static final int DEFAULT_SHORT_CONNECTION_NONLOCAL_HIGH_THR_PERCENT = 20;
|
|
static final int DEFAULT_DISCONNECTION_NONLOCAL_HIGH_THR_PERCENT = 25;
|
|
// Default health monitor abnormal count minimum for various cases
|
|
static final int DEFAULT_CONNECTION_FAILURE_COUNT_MIN = 6;
|
|
static final int DEFAULT_CONNECTION_FAILURE_DISCONNECTION_COUNT_MIN = 5;
|
|
static final int DEFAULT_ASSOC_REJECTION_COUNT_MIN = 3;
|
|
static final int DEFAULT_ASSOC_TIMEOUT_COUNT_MIN = 3;
|
|
static final int DEFAULT_AUTH_FAILURE_COUNT_MIN = 3;
|
|
static final int DEFAULT_SHORT_CONNECTION_NONLOCAL_COUNT_MIN = 3;
|
|
static final int DEFAULT_DISCONNECTION_NONLOCAL_COUNT_MIN = 3;
|
|
// Numerator part of default ratio threshold values for all cases
|
|
static final int DEFAULT_HEALTH_MONITOR_RATIO_THR_NUMERATOR = 4;
|
|
// Denominator part of ratio threshold for all cases
|
|
static final int HEALTH_MONITOR_RATIO_THR_DENOMINATOR = 2;
|
|
// Minimum RSSI in dBm for connection stats collection
|
|
// Connection or disconnection events with RSSI below this threshold are not
|
|
// included in connection stats collection.
|
|
static final int DEFAULT_HEALTH_MONITOR_MIN_RSSI_THR_DBM = -68;
|
|
// Default minimum number of connection attempts to qualify daily detection
|
|
static final int DEFAULT_HEALTH_MONITOR_MIN_NUM_CONNECTION_ATTEMPT = 10;
|
|
// Default minimum wait time between two bug report captures
|
|
static final int DEFAULT_BUG_REPORT_MIN_WINDOW_MS = 3_600_000;
|
|
// Default report-high threshold to take-bug-report threshold ratio.
|
|
// It should be larger than 1 since the bar to take bugreport should be higher.
|
|
static final int DEFAULT_BUG_REPORT_THRESHOLD_EXTRA_RATIO = 2;
|
|
// Default overlapping connection duration threshold in ms to trigger bug report
|
|
static final int DEFAULT_OVERLAPPING_CONNECTION_DURATION_THRESHOLD_MS = 75_000;
|
|
// At low traffic, Tx link speed values below the following threshold
|
|
// are ignored because it could be due to low rate management frames
|
|
static final int DEFAULT_TX_LINK_SPEED_LOW_THRESHOLD_MBPS = 9;
|
|
// At low traffic, Rx link speed values below the following threshold
|
|
// are ignored because it could be due to low rate management frames
|
|
static final int DEFAULT_RX_LINK_SPEED_LOW_THRESHOLD_MBPS = 9;
|
|
// Default health monitor short connection duration threshold in ms
|
|
static final int DEFAULT_HEALTH_MONITOR_SHORT_CONNECTION_DURATION_THR_MS = 20_000;
|
|
|
|
// Default mask for abnormal disconnection reason codes.
|
|
// Each bit of mask corresponds to a reason code defined in 802.11 standard section 9.4.1.7
|
|
// For example, b0 for reason code 0, b1 for reason code 1, etc.
|
|
// Bits below are abnormal disconnection reasons and thus are set to 1
|
|
// b0: reserved (e.g., STA heartbeat failure)
|
|
// b2: invalid auth
|
|
// b4: disassociated due to inactivity
|
|
// b6 and b7: invalid class 2 and 3 frames
|
|
// b34: disassociated due to missing ACKs
|
|
static final long DEFAULT_ABNORMAL_DISCONNECTION_REASON_CODE_MASK = 0x4_0000_00d5L;
|
|
// Default maximum interval between last RSSI poll and disconnection
|
|
static final int DEFAULT_HEALTH_MONITOR_RSSI_POLL_VALID_TIME_MS = 2_100;
|
|
// Default maximum interval between scan and connection attempt in non-stationary state
|
|
static final int DEFAULT_NONSTATIONARY_SCAN_RSSI_VALID_TIME_MS = 5_000;
|
|
// Default maximum interval between scan and connection attempt in stationary state
|
|
static final int DEFAULT_STATIONARY_SCAN_RSSI_VALID_TIME_MS = 8_000;
|
|
// Default health monitor firmware alert valid time.
|
|
// -1 disables firmware alert time check
|
|
static final int DEFAULT_HEALTH_MONITOR_FW_ALERT_VALID_TIME_MS = -1;
|
|
// Default minimum confirmation duration for sending network score to connectivity service
|
|
// when score breaches low. The actual confirmation duration is longer in general and it
|
|
// depends on the score evaluation period normally controlled by
|
|
// 'com.android.wifi.resources.R' config_wifiPollRssiIntervalMilliseconds.
|
|
static final int DEFAULT_MIN_CONFIRMATION_DURATION_SEND_LOW_SCORE_MS = 5000;
|
|
// Default minimum confirmation duration for sending network score to connectivity service
|
|
// when score breaches high. The actual confirmation duration is longer in general and it
|
|
// depends on the score evaluation period normally controlled by
|
|
// 'com.android.wifi.resources.R' config_wifiPollRssiIntervalMilliseconds.
|
|
static final int DEFAULT_MIN_CONFIRMATION_DURATION_SEND_HIGH_SCORE_MS = 0;
|
|
// Default RSSI threshold in dBm above which low score is not sent to connectivity service
|
|
// when external scorer takes action.
|
|
static final int DEFAULT_RSSI_THRESHOLD_NOT_SEND_LOW_SCORE_TO_CS_DBM = -67;
|
|
// Maximum traffic stats threshold for link bandwidth estimator
|
|
static final int DEFAULT_TRAFFIC_STATS_THRESHOLD_MAX_KB = 8000;
|
|
static final int DEFAULT_BANDWIDTH_ESTIMATOR_TIME_CONSTANT_LARGE_SEC = 6;
|
|
// Cached values of fields updated via updateDeviceConfigFlags()
|
|
private boolean mIsAbnormalConnectionBugreportEnabled;
|
|
private int mAbnormalConnectionDurationMs;
|
|
private int mDataStallDurationMs;
|
|
private int mDataStallTxTputThrKbps;
|
|
private int mDataStallRxTputThrKbps;
|
|
private int mDataStallTxPerThr;
|
|
private int mDataStallCcaLevelThr;
|
|
private int mTxTputSufficientLowThrKbps;
|
|
private int mTxTputSufficientHighThrKbps;
|
|
private int mRxTputSufficientLowThrKbps;
|
|
private int mRxTputSufficientHighThrKbps;
|
|
private int mTputSufficientRatioThrNum;
|
|
private int mTputSufficientRatioThrDen;
|
|
private int mTxPktPerSecondThr;
|
|
private int mRxPktPerSecondThr;
|
|
private int mConnectionFailureHighThrPercent;
|
|
private int mConnectionFailureCountMin;
|
|
private int mConnectionFailureDisconnectionHighThrPercent;
|
|
private int mConnectionFailureDisconnectionCountMin;
|
|
private int mAssocRejectionHighThrPercent;
|
|
private int mAssocRejectionCountMin;
|
|
private int mAssocTimeoutHighThrPercent;
|
|
private int mAssocTimeoutCountMin;
|
|
private int mAuthFailureHighThrPercent;
|
|
private int mAuthFailureCountMin;
|
|
private int mShortConnectionNonlocalHighThrPercent;
|
|
private int mShortConnectionNonlocalCountMin;
|
|
private int mDisconnectionNonlocalHighThrPercent;
|
|
private int mDisconnectionNonlocalCountMin;
|
|
private int mHealthMonitorRatioThrNumerator;
|
|
private int mHealthMonitorMinRssiThrDbm;
|
|
private Set<String> mRandomizationFlakySsidHotlist;
|
|
private Set<String> mNonPersistentMacRandomizationSsidAllowlist;
|
|
private Set<String> mNonPersistentMacRandomizationSsidBlocklist;
|
|
private boolean mIsAbnormalConnectionFailureBugreportEnabled;
|
|
private boolean mIsAbnormalDisconnectionBugreportEnabled;
|
|
private int mHealthMonitorMinNumConnectionAttempt;
|
|
private int mBugReportMinWindowMs;
|
|
private int mBugReportThresholdExtraRatio;
|
|
private boolean mWifiBatterySaverEnabled;
|
|
private boolean mIsOverlappingConnectionBugreportEnabled;
|
|
private int mOverlappingConnectionDurationThresholdMs;
|
|
private int mTxLinkSpeedLowThresholdMbps;
|
|
private int mRxLinkSpeedLowThresholdMbps;
|
|
private int mHealthMonitorShortConnectionDurationThrMs;
|
|
private long mAbnormalDisconnectionReasonCodeMask;
|
|
private int mHealthMonitorRssiPollValidTimeMs;
|
|
private int mNonstationaryScanRssiValidTimeMs;
|
|
private int mStationaryScanRssiValidTimeMs;
|
|
private int mHealthMonitorFwAlertValidTimeMs;
|
|
private int mMinConfirmationDurationSendLowScoreMs;
|
|
private int mMinConfirmationDurationSendHighScoreMs;
|
|
private int mRssiThresholdNotSendLowScoreToCsDbm;
|
|
private boolean mAllowNonPersistentMacRandomizationOnOpenSsids;
|
|
private int mTrafficStatsThresholdMaxKbyte;
|
|
private int mBandwidthEstimatorLargeTimeConstantSec;
|
|
private boolean mInterfaceFailureBugreportEnabled;
|
|
|
|
public DeviceConfigFacade(Context context, Handler handler, WifiMetrics wifiMetrics) {
|
|
mContext = context;
|
|
mWifiMetrics = wifiMetrics;
|
|
|
|
updateDeviceConfigFlags();
|
|
DeviceConfig.addOnPropertiesChangedListener(
|
|
NAMESPACE,
|
|
command -> handler.post(command),
|
|
properties -> {
|
|
updateDeviceConfigFlags();
|
|
});
|
|
}
|
|
|
|
private void updateDeviceConfigFlags() {
|
|
mIsAbnormalConnectionBugreportEnabled = DeviceConfig.getBoolean(NAMESPACE,
|
|
"abnormal_connection_bugreport_enabled", false);
|
|
mAbnormalConnectionDurationMs = DeviceConfig.getInt(NAMESPACE,
|
|
"abnormal_connection_duration_ms",
|
|
DEFAULT_ABNORMAL_CONNECTION_DURATION_MS);
|
|
|
|
mDataStallDurationMs = DeviceConfig.getInt(NAMESPACE,
|
|
"data_stall_duration_ms", DEFAULT_DATA_STALL_DURATION_MS);
|
|
mDataStallTxTputThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"data_stall_tx_tput_thr_kbps", DEFAULT_DATA_STALL_TX_TPUT_THR_KBPS);
|
|
mDataStallRxTputThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"data_stall_rx_tput_thr_kbps", DEFAULT_DATA_STALL_RX_TPUT_THR_KBPS);
|
|
mDataStallTxPerThr = DeviceConfig.getInt(NAMESPACE,
|
|
"data_stall_tx_per_thr", DEFAULT_DATA_STALL_TX_PER_THR);
|
|
mDataStallCcaLevelThr = DeviceConfig.getInt(NAMESPACE,
|
|
"data_stall_cca_level_thr", DEFAULT_DATA_STALL_CCA_LEVEL_THR);
|
|
mWifiMetrics.setDataStallDurationMs(mDataStallDurationMs);
|
|
mWifiMetrics.setDataStallTxTputThrKbps(mDataStallTxTputThrKbps);
|
|
mWifiMetrics.setDataStallRxTputThrKbps(mDataStallRxTputThrKbps);
|
|
mWifiMetrics.setDataStallTxPerThr(mDataStallTxPerThr);
|
|
mWifiMetrics.setDataStallCcaLevelThr(mDataStallCcaLevelThr);
|
|
|
|
mTxTputSufficientLowThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"tput_sufficient_low_thr_kbps", DEFAULT_TX_TPUT_SUFFICIENT_THR_LOW_KBPS);
|
|
mTxTputSufficientHighThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"tput_sufficient_high_thr_kbps", DEFAULT_TX_TPUT_SUFFICIENT_THR_HIGH_KBPS);
|
|
mRxTputSufficientLowThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"rx_tput_sufficient_low_thr_kbps", DEFAULT_RX_TPUT_SUFFICIENT_THR_LOW_KBPS);
|
|
mRxTputSufficientHighThrKbps = DeviceConfig.getInt(NAMESPACE,
|
|
"rx_tput_sufficient_high_thr_kbps", DEFAULT_RX_TPUT_SUFFICIENT_THR_HIGH_KBPS);
|
|
mTputSufficientRatioThrNum = DeviceConfig.getInt(NAMESPACE,
|
|
"tput_sufficient_ratio_thr_num", DEFAULT_TPUT_SUFFICIENT_RATIO_THR_NUM);
|
|
mTputSufficientRatioThrDen = DeviceConfig.getInt(NAMESPACE,
|
|
"tput_sufficient_ratio_thr_den", DEFAULT_TPUT_SUFFICIENT_RATIO_THR_DEN);
|
|
mTxPktPerSecondThr = DeviceConfig.getInt(NAMESPACE,
|
|
"tx_pkt_per_second_thr", DEFAULT_TX_PACKET_PER_SECOND_THR);
|
|
mRxPktPerSecondThr = DeviceConfig.getInt(NAMESPACE,
|
|
"rx_pkt_per_second_thr", DEFAULT_RX_PACKET_PER_SECOND_THR);
|
|
|
|
mConnectionFailureHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"connection_failure_high_thr_percent",
|
|
DEFAULT_CONNECTION_FAILURE_HIGH_THR_PERCENT);
|
|
mConnectionFailureCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"connection_failure_count_min",
|
|
DEFAULT_CONNECTION_FAILURE_COUNT_MIN);
|
|
mConnectionFailureDisconnectionHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"connection_failure_disconnection_high_thr_percent",
|
|
DEFAULT_CONNECTION_FAILURE_DISCONNECTION_HIGH_THR_PERCENT);
|
|
mConnectionFailureDisconnectionCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"connection_failure_disconnection_count_min",
|
|
DEFAULT_CONNECTION_FAILURE_DISCONNECTION_COUNT_MIN);
|
|
mAssocRejectionHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"assoc_rejection_high_thr_percent",
|
|
DEFAULT_ASSOC_REJECTION_HIGH_THR_PERCENT);
|
|
mAssocRejectionCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"assoc_rejection_count_min",
|
|
DEFAULT_ASSOC_REJECTION_COUNT_MIN);
|
|
mAssocTimeoutHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"assoc_timeout_high_thr_percent",
|
|
DEFAULT_ASSOC_TIMEOUT_HIGH_THR_PERCENT);
|
|
mAssocTimeoutCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"assoc_timeout_count_min",
|
|
DEFAULT_ASSOC_TIMEOUT_COUNT_MIN);
|
|
mAuthFailureHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"auth_failure_high_thr_percent",
|
|
DEFAULT_AUTH_FAILURE_HIGH_THR_PERCENT);
|
|
mAuthFailureCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"auth_failure_count_min",
|
|
DEFAULT_AUTH_FAILURE_COUNT_MIN);
|
|
mShortConnectionNonlocalHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"short_connection_nonlocal_high_thr_percent",
|
|
DEFAULT_SHORT_CONNECTION_NONLOCAL_HIGH_THR_PERCENT);
|
|
mShortConnectionNonlocalCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"short_connection_nonlocal_count_min",
|
|
DEFAULT_SHORT_CONNECTION_NONLOCAL_COUNT_MIN);
|
|
mDisconnectionNonlocalHighThrPercent = DeviceConfig.getInt(NAMESPACE,
|
|
"disconnection_nonlocal_high_thr_percent",
|
|
DEFAULT_DISCONNECTION_NONLOCAL_HIGH_THR_PERCENT);
|
|
mDisconnectionNonlocalCountMin = DeviceConfig.getInt(NAMESPACE,
|
|
"disconnection_nonlocal_count_min",
|
|
DEFAULT_DISCONNECTION_NONLOCAL_COUNT_MIN);
|
|
mHealthMonitorRatioThrNumerator = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_ratio_thr_numerator",
|
|
DEFAULT_HEALTH_MONITOR_RATIO_THR_NUMERATOR);
|
|
mHealthMonitorMinRssiThrDbm = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_min_rssi_thr_dbm",
|
|
DEFAULT_HEALTH_MONITOR_MIN_RSSI_THR_DBM);
|
|
|
|
mRandomizationFlakySsidHotlist =
|
|
getUnmodifiableSetQuoted("randomization_flaky_ssid_hotlist");
|
|
mNonPersistentMacRandomizationSsidAllowlist =
|
|
getUnmodifiableSetQuoted("aggressive_randomization_ssid_allowlist");
|
|
mNonPersistentMacRandomizationSsidBlocklist =
|
|
getUnmodifiableSetQuoted("aggressive_randomization_ssid_blocklist");
|
|
|
|
mIsAbnormalConnectionFailureBugreportEnabled = DeviceConfig.getBoolean(NAMESPACE,
|
|
"abnormal_connection_failure_bugreport_enabled", false);
|
|
mIsAbnormalDisconnectionBugreportEnabled = DeviceConfig.getBoolean(NAMESPACE,
|
|
"abnormal_disconnection_bugreport_enabled", false);
|
|
mHealthMonitorMinNumConnectionAttempt = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_min_num_connection_attempt",
|
|
DEFAULT_HEALTH_MONITOR_MIN_NUM_CONNECTION_ATTEMPT);
|
|
mBugReportMinWindowMs = DeviceConfig.getInt(NAMESPACE,
|
|
"bug_report_min_window_ms",
|
|
DEFAULT_BUG_REPORT_MIN_WINDOW_MS);
|
|
mBugReportThresholdExtraRatio = DeviceConfig.getInt(NAMESPACE,
|
|
"report_bug_report_threshold_extra_ratio",
|
|
DEFAULT_BUG_REPORT_THRESHOLD_EXTRA_RATIO);
|
|
mIsOverlappingConnectionBugreportEnabled = DeviceConfig.getBoolean(NAMESPACE,
|
|
"overlapping_connection_bugreport_enabled", false);
|
|
mOverlappingConnectionDurationThresholdMs = DeviceConfig.getInt(NAMESPACE,
|
|
"overlapping_connection_duration_threshold_ms",
|
|
DEFAULT_OVERLAPPING_CONNECTION_DURATION_THRESHOLD_MS);
|
|
mTxLinkSpeedLowThresholdMbps = DeviceConfig.getInt(NAMESPACE,
|
|
"tx_link_speed_low_threshold_mbps",
|
|
DEFAULT_TX_LINK_SPEED_LOW_THRESHOLD_MBPS);
|
|
mRxLinkSpeedLowThresholdMbps = DeviceConfig.getInt(NAMESPACE,
|
|
"rx_link_speed_low_threshold_mbps",
|
|
DEFAULT_RX_LINK_SPEED_LOW_THRESHOLD_MBPS);
|
|
mWifiBatterySaverEnabled = DeviceConfig.getBoolean(NAMESPACE, "battery_saver_enabled",
|
|
false);
|
|
mHealthMonitorShortConnectionDurationThrMs = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_short_connection_duration_thr_ms",
|
|
DEFAULT_HEALTH_MONITOR_SHORT_CONNECTION_DURATION_THR_MS);
|
|
mAbnormalDisconnectionReasonCodeMask = DeviceConfig.getLong(NAMESPACE,
|
|
"abnormal_disconnection_reason_code_mask",
|
|
DEFAULT_ABNORMAL_DISCONNECTION_REASON_CODE_MASK);
|
|
mHealthMonitorRssiPollValidTimeMs = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_rssi_poll_valid_time_ms",
|
|
DEFAULT_HEALTH_MONITOR_RSSI_POLL_VALID_TIME_MS);
|
|
mNonstationaryScanRssiValidTimeMs = DeviceConfig.getInt(NAMESPACE,
|
|
"nonstationary_scan_rssi_valid_time_ms",
|
|
DEFAULT_NONSTATIONARY_SCAN_RSSI_VALID_TIME_MS);
|
|
mStationaryScanRssiValidTimeMs = DeviceConfig.getInt(NAMESPACE,
|
|
"stationary_scan_rssi_valid_time_ms",
|
|
DEFAULT_STATIONARY_SCAN_RSSI_VALID_TIME_MS);
|
|
mHealthMonitorFwAlertValidTimeMs = DeviceConfig.getInt(NAMESPACE,
|
|
"health_monitor_fw_alert_valid_time_ms",
|
|
DEFAULT_HEALTH_MONITOR_FW_ALERT_VALID_TIME_MS);
|
|
mWifiMetrics.setHealthMonitorRssiPollValidTimeMs(mHealthMonitorRssiPollValidTimeMs);
|
|
mMinConfirmationDurationSendLowScoreMs = DeviceConfig.getInt(NAMESPACE,
|
|
"min_confirmation_duration_send_low_score_ms",
|
|
DEFAULT_MIN_CONFIRMATION_DURATION_SEND_LOW_SCORE_MS);
|
|
mMinConfirmationDurationSendHighScoreMs = DeviceConfig.getInt(NAMESPACE,
|
|
"min_confirmation_duration_send_high_score_ms",
|
|
DEFAULT_MIN_CONFIRMATION_DURATION_SEND_HIGH_SCORE_MS);
|
|
mRssiThresholdNotSendLowScoreToCsDbm = DeviceConfig.getInt(NAMESPACE,
|
|
"rssi_threshold_not_send_low_score_to_cs_dbm",
|
|
DEFAULT_RSSI_THRESHOLD_NOT_SEND_LOW_SCORE_TO_CS_DBM);
|
|
mAllowNonPersistentMacRandomizationOnOpenSsids = DeviceConfig.getBoolean(NAMESPACE,
|
|
"allow_enhanced_mac_randomization_on_open_ssids", false);
|
|
mTrafficStatsThresholdMaxKbyte = DeviceConfig.getInt(NAMESPACE,
|
|
"traffic_stats_threshold_max_kbyte", DEFAULT_TRAFFIC_STATS_THRESHOLD_MAX_KB);
|
|
mBandwidthEstimatorLargeTimeConstantSec = DeviceConfig.getInt(NAMESPACE,
|
|
"bandwidth_estimator_time_constant_large_sec",
|
|
DEFAULT_BANDWIDTH_ESTIMATOR_TIME_CONSTANT_LARGE_SEC);
|
|
mInterfaceFailureBugreportEnabled = DeviceConfig.getBoolean(NAMESPACE,
|
|
"interface_failure_bugreport_enabled", false);
|
|
|
|
}
|
|
|
|
private Set<String> getUnmodifiableSetQuoted(String key) {
|
|
String rawList = DeviceConfig.getString(NAMESPACE, key, "");
|
|
Set<String> result = new ArraySet<>();
|
|
String[] list = rawList.split(",");
|
|
for (String cur : list) {
|
|
if (cur.length() == 0) {
|
|
continue;
|
|
}
|
|
result.add("\"" + cur + "\"");
|
|
}
|
|
return Collections.unmodifiableSet(result);
|
|
}
|
|
|
|
/**
|
|
* Gets the feature flag for reporting abnormally long connections.
|
|
*/
|
|
public boolean isAbnormalConnectionBugreportEnabled() {
|
|
return mIsAbnormalConnectionBugreportEnabled;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold for classifying abnormally long connections.
|
|
*/
|
|
public int getAbnormalConnectionDurationMs() {
|
|
return mAbnormalConnectionDurationMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the duration of evaluating Wifi condition to trigger a data stall.
|
|
*/
|
|
public int getDataStallDurationMs() {
|
|
return mDataStallDurationMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of Tx throughput below which to trigger a data stall.
|
|
*/
|
|
public int getDataStallTxTputThrKbps() {
|
|
return mDataStallTxTputThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of Rx throughput below which to trigger a data stall.
|
|
*/
|
|
public int getDataStallRxTputThrKbps() {
|
|
return mDataStallRxTputThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of Tx packet error rate above which to trigger a data stall.
|
|
*/
|
|
public int getDataStallTxPerThr() {
|
|
return mDataStallTxPerThr;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of CCA level above which to trigger a data stall.
|
|
*/
|
|
public int getDataStallCcaLevelThr() {
|
|
return mDataStallCcaLevelThr;
|
|
}
|
|
|
|
/**
|
|
* Gets the low threshold of L2 throughput below which L2 throughput is always insufficient
|
|
*/
|
|
public int getTxTputSufficientLowThrKbps() {
|
|
return mTxTputSufficientLowThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of L2 throughput above which L2 throughput is always sufficient
|
|
*/
|
|
public int getTxTputSufficientHighThrKbps() {
|
|
return mTxTputSufficientHighThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the low threshold of L2 throughput below which L2 Rx throughput is always insufficient
|
|
*/
|
|
public int getRxTputSufficientLowThrKbps() {
|
|
return mRxTputSufficientLowThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of L2 throughput above which L2 Rx throughput is always sufficient
|
|
*/
|
|
public int getRxTputSufficientHighThrKbps() {
|
|
return mRxTputSufficientHighThrKbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the numerator part of L2 throughput over L3 throughput ratio sufficiency threshold
|
|
* above which L2 throughput is sufficient
|
|
*/
|
|
public int getTputSufficientRatioThrNum() {
|
|
return mTputSufficientRatioThrNum;
|
|
}
|
|
|
|
/**
|
|
* Gets the denominator part of L2 throughput over L3 throughput ratio sufficiency threshold
|
|
* above which L2 throughput is sufficient
|
|
*/
|
|
public int getTputSufficientRatioThrDen() {
|
|
return mTputSufficientRatioThrDen;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of Tx packet per second
|
|
* below which Tx throughput sufficiency check will always pass
|
|
*/
|
|
public int getTxPktPerSecondThr() {
|
|
return mTxPktPerSecondThr;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of Rx packet per second
|
|
* below which Rx throughput sufficiency check will always pass
|
|
*/
|
|
public int getRxPktPerSecondThr() {
|
|
return mRxPktPerSecondThr;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of connection failure rate in percent
|
|
*/
|
|
public int getConnectionFailureHighThrPercent() {
|
|
return mConnectionFailureHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets connection-failure-due-to-disconnection min count
|
|
*/
|
|
public int getConnectionFailureDisconnectionCountMin() {
|
|
return mConnectionFailureDisconnectionCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of connection-failure-due-to-disconnection rate in percent
|
|
*/
|
|
public int getConnectionFailureDisconnectionHighThrPercent() {
|
|
return mConnectionFailureDisconnectionHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets connection failure min count
|
|
*/
|
|
public int getConnectionFailureCountMin() {
|
|
return mConnectionFailureCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of association rejection rate in percent
|
|
*/
|
|
public int getAssocRejectionHighThrPercent() {
|
|
return mAssocRejectionHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets association rejection min count
|
|
*/
|
|
public int getAssocRejectionCountMin() {
|
|
return mAssocRejectionCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of association timeout rate in percent
|
|
*/
|
|
public int getAssocTimeoutHighThrPercent() {
|
|
return mAssocTimeoutHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets association timeout min count
|
|
*/
|
|
public int getAssocTimeoutCountMin() {
|
|
return mAssocTimeoutCountMin;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the high threshold of authentication failure rate in percent
|
|
*/
|
|
public int getAuthFailureHighThrPercent() {
|
|
return mAuthFailureHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets authentication failure min count
|
|
*/
|
|
public int getAuthFailureCountMin() {
|
|
return mAuthFailureCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of nonlocal short connection rate in percent
|
|
*/
|
|
public int getShortConnectionNonlocalHighThrPercent() {
|
|
return mShortConnectionNonlocalHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets nonlocal short connection min count
|
|
*/
|
|
public int getShortConnectionNonlocalCountMin() {
|
|
return mShortConnectionNonlocalCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets the high threshold of nonlocal disconnection rate in percent
|
|
*/
|
|
public int getDisconnectionNonlocalHighThrPercent() {
|
|
return mDisconnectionNonlocalHighThrPercent;
|
|
}
|
|
|
|
/**
|
|
* Gets nonlocal disconnection min count
|
|
*/
|
|
public int getDisconnectionNonlocalCountMin() {
|
|
return mDisconnectionNonlocalCountMin;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor ratio threshold, numerator part
|
|
*/
|
|
public int getHealthMonitorRatioThrNumerator() {
|
|
return mHealthMonitorRatioThrNumerator;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor min RSSI threshold in dBm
|
|
*/
|
|
public int getHealthMonitorMinRssiThrDbm() {
|
|
return mHealthMonitorMinRssiThrDbm;
|
|
}
|
|
|
|
/**
|
|
* Gets the Set of SSIDs in the flaky SSID hotlist.
|
|
*/
|
|
public Set<String> getRandomizationFlakySsidHotlist() {
|
|
return mRandomizationFlakySsidHotlist;
|
|
}
|
|
|
|
/**
|
|
* Gets the list of SSIDs for non-persistent MAC randomization.
|
|
*/
|
|
public Set<String> getNonPersistentMacRandomizationSsidAllowlist() {
|
|
return mNonPersistentMacRandomizationSsidAllowlist;
|
|
}
|
|
|
|
/**
|
|
* Gets the list of SSIDs that non-persistent MAC randomization should not be used for.
|
|
*/
|
|
public Set<String> getNonPersistentMacRandomizationSsidBlocklist() {
|
|
return mNonPersistentMacRandomizationSsidBlocklist;
|
|
}
|
|
/**
|
|
* Gets the feature flag for reporting abnormal connection failure.
|
|
*/
|
|
public boolean isAbnormalConnectionFailureBugreportEnabled() {
|
|
return mIsAbnormalConnectionFailureBugreportEnabled;
|
|
}
|
|
|
|
/**
|
|
* Gets the feature flag for reporting abnormal disconnection.
|
|
*/
|
|
public boolean isAbnormalDisconnectionBugreportEnabled() {
|
|
return mIsAbnormalDisconnectionBugreportEnabled;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor min number of connection attempt threshold
|
|
*/
|
|
public int getHealthMonitorMinNumConnectionAttempt() {
|
|
return mHealthMonitorMinNumConnectionAttempt;
|
|
}
|
|
|
|
/**
|
|
* Gets minimum wait time between two bug report captures
|
|
*/
|
|
public int getBugReportMinWindowMs() {
|
|
return mBugReportMinWindowMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the extra ratio of threshold to trigger bug report.
|
|
*/
|
|
public int getBugReportThresholdExtraRatio() {
|
|
return mBugReportThresholdExtraRatio;
|
|
}
|
|
|
|
/**
|
|
* Gets the feature flag for reporting overlapping connection.
|
|
*/
|
|
public boolean isOverlappingConnectionBugreportEnabled() {
|
|
return mIsOverlappingConnectionBugreportEnabled;
|
|
}
|
|
|
|
/**
|
|
* Gets overlapping connection duration threshold in ms
|
|
*/
|
|
public int getOverlappingConnectionDurationThresholdMs() {
|
|
return mOverlappingConnectionDurationThresholdMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of link speed below which Tx link speed is ignored at low traffic
|
|
*/
|
|
public int getTxLinkSpeedLowThresholdMbps() {
|
|
return mTxLinkSpeedLowThresholdMbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the threshold of link speed below which Rx link speed is ignored at low traffic
|
|
*/
|
|
public int getRxLinkSpeedLowThresholdMbps() {
|
|
return mRxLinkSpeedLowThresholdMbps;
|
|
}
|
|
|
|
/**
|
|
* Gets the feature flag for Wifi battery saver.
|
|
*/
|
|
public boolean isWifiBatterySaverEnabled() {
|
|
return mWifiBatterySaverEnabled;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor short connection duration threshold in ms
|
|
*/
|
|
public int getHealthMonitorShortConnectionDurationThrMs() {
|
|
return mHealthMonitorShortConnectionDurationThrMs;
|
|
}
|
|
|
|
/**
|
|
* Gets abnormal disconnection reason code mask
|
|
*/
|
|
public long getAbnormalDisconnectionReasonCodeMask() {
|
|
return mAbnormalDisconnectionReasonCodeMask;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor RSSI poll valid time in ms
|
|
*/
|
|
public int getHealthMonitorRssiPollValidTimeMs() {
|
|
return mHealthMonitorRssiPollValidTimeMs;
|
|
}
|
|
|
|
/**
|
|
* Gets scan rssi valid time in ms when device is in non-stationary state
|
|
*/
|
|
public int getNonstationaryScanRssiValidTimeMs() {
|
|
return mNonstationaryScanRssiValidTimeMs;
|
|
}
|
|
|
|
/**
|
|
* Gets scan rssi valid time in ms when device is in stationary state
|
|
*/
|
|
public int getStationaryScanRssiValidTimeMs() {
|
|
return mStationaryScanRssiValidTimeMs;
|
|
}
|
|
|
|
/**
|
|
* Gets health monitor firmware alert valid time in ms,
|
|
* -1 disables firmware alert time check
|
|
*/
|
|
public int getHealthMonitorFwAlertValidTimeMs() {
|
|
return mHealthMonitorFwAlertValidTimeMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the minimum confirmation duration for sending network score to connectivity service
|
|
* when score breaches low.
|
|
*/
|
|
public int getMinConfirmationDurationSendLowScoreMs() {
|
|
return mMinConfirmationDurationSendLowScoreMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the minimum confirmation duration for sending network score to connectivity service
|
|
* when score breaches high.
|
|
*/
|
|
public int getMinConfirmationDurationSendHighScoreMs() {
|
|
return mMinConfirmationDurationSendHighScoreMs;
|
|
}
|
|
|
|
/**
|
|
* Gets the RSSI threshold above which low score is not sent to connectivity service when
|
|
* external scorer takes action.
|
|
*/
|
|
public int getRssiThresholdNotSendLowScoreToCsDbm() {
|
|
return mRssiThresholdNotSendLowScoreToCsDbm;
|
|
}
|
|
|
|
/**
|
|
* Gets whether non-persistent MAC randomization should be allowed on open networks.
|
|
*/
|
|
public boolean allowNonPersistentMacRandomizationOnOpenSsids() {
|
|
return mAllowNonPersistentMacRandomizationOnOpenSsids;
|
|
}
|
|
|
|
/**
|
|
* Gets traffic stats maximum threshold in KByte
|
|
*/
|
|
public int getTrafficStatsThresholdMaxKbyte() {
|
|
return mTrafficStatsThresholdMaxKbyte;
|
|
}
|
|
|
|
/**
|
|
* Gets bandwidth estimator large time constant in second
|
|
*/
|
|
public int getBandwidthEstimatorLargeTimeConstantSec() {
|
|
return mBandwidthEstimatorLargeTimeConstantSec;
|
|
}
|
|
|
|
/**
|
|
* Gets the feature flag for reporting interface setup failure
|
|
*/
|
|
public boolean isInterfaceFailureBugreportEnabled() {
|
|
return mInterfaceFailureBugreportEnabled;
|
|
}
|
|
}
|