xref: /packages/modules/Wifi/service/java/com/android/server/wifi/ClientModeImpl.java

/*
 * Copyright (C) 2010 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 android.net.util.KeepalivePacketDataUtil.parseTcpKeepalivePacketData;
import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_NO_INTERNET_PERMANENT;
import static android.net.wifi.WifiConfiguration.NetworkSelectionStatus.DISABLED_NO_INTERNET_TEMPORARY;
import static android.net.wifi.WifiManager.WIFI_FEATURE_FILS_SHA256;
import static android.net.wifi.WifiManager.WIFI_FEATURE_FILS_SHA384;
import static android.net.wifi.WifiManager.WIFI_FEATURE_TRUST_ON_FIRST_USE;

import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_LOCAL_ONLY;
import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_PRIMARY;
import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_SECONDARY_LONG_LIVED;
import static com.android.server.wifi.ActiveModeManager.ROLE_CLIENT_SECONDARY_TRANSIENT;
import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_STA_FACTORY_MAC_ADDRESS;
import static com.android.server.wifi.proto.WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__SUPPLICANT_DISCONNECTED;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.app.ActivityManager;
import android.app.admin.SecurityLog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.CaptivePortalData;
import android.net.ConnectivityManager;
import android.net.DhcpResultsParcelable;
import android.net.InvalidPacketException;
import android.net.IpConfiguration;
import android.net.KeepalivePacketData;
import android.net.Layer2PacketParcelable;
import android.net.LinkProperties;
import android.net.MacAddress;
import android.net.NattKeepalivePacketData;
import android.net.Network;
import android.net.NetworkAgent;
import android.net.NetworkAgentConfig;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkInfo.DetailedState;
import android.net.RouteInfo;
import android.net.SocketKeepalive;
import android.net.StaticIpConfiguration;
import android.net.TcpKeepalivePacketData;
import android.net.TcpKeepalivePacketDataParcelable;
import android.net.Uri;
import android.net.ip.IIpClient;
import android.net.ip.IpClientCallbacks;
import android.net.ip.IpClientManager;
import android.net.networkstack.aidl.dhcp.DhcpOption;
import android.net.networkstack.aidl.ip.ReachabilityLossInfoParcelable;
import android.net.networkstack.aidl.ip.ReachabilityLossReason;
import android.net.shared.Layer2Information;
import android.net.shared.ProvisioningConfiguration;
import android.net.shared.ProvisioningConfiguration.ScanResultInfo;
import android.net.vcn.VcnManager;
import android.net.vcn.VcnNetworkPolicyResult;
import android.net.wifi.IWifiConnectedNetworkScorer;
import android.net.wifi.MloLink;
import android.net.wifi.ScanResult;
import android.net.wifi.SecurityParams;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiAnnotations.WifiStandard;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiContext;
import android.net.wifi.WifiEnterpriseConfig;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiNetworkAgentSpecifier;
import android.net.wifi.WifiNetworkSpecifier;
import android.net.wifi.WifiSsid;
import android.net.wifi.hotspot2.IProvisioningCallback;
import android.net.wifi.hotspot2.OsuProvider;
import android.net.wifi.nl80211.DeviceWiphyCapabilities;
import android.net.wifi.nl80211.WifiNl80211Manager;
import android.net.wifi.util.ScanResultUtil;
import android.os.BatteryStatsManager;
import android.os.Build;
import android.os.ConditionVariable;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.os.PowerManager;
import android.os.Process;
import android.os.UserHandle;
import android.os.WorkSource;
import android.provider.Settings;
import android.system.OsConstants;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;
import android.util.Pair;
import android.util.Range;

import androidx.annotation.RequiresApi;

import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.IState;
import com.android.internal.util.Protocol;
import com.android.internal.util.State;
import com.android.internal.util.StateMachine;
import com.android.modules.utils.HandlerExecutor;
import com.android.modules.utils.build.SdkLevel;
import com.android.net.module.util.Inet4AddressUtils;
import com.android.net.module.util.MacAddressUtils;
import com.android.net.module.util.NetUtils;
import com.android.server.wifi.ActiveModeManager.ClientRole;
import com.android.server.wifi.MboOceController.BtmFrameData;
import com.android.server.wifi.SupplicantStaIfaceHal.QosPolicyRequest;
import com.android.server.wifi.SupplicantStaIfaceHal.StaIfaceReasonCode;
import com.android.server.wifi.SupplicantStaIfaceHal.StaIfaceStatusCode;
import com.android.server.wifi.SupplicantStaIfaceHal.SupplicantEventCode;
import com.android.server.wifi.WifiCarrierInfoManager.SimAuthRequestData;
import com.android.server.wifi.WifiCarrierInfoManager.SimAuthResponseData;
import com.android.server.wifi.WifiNative.RxFateReport;
import com.android.server.wifi.WifiNative.TxFateReport;
import com.android.server.wifi.hotspot2.AnqpEvent;
import com.android.server.wifi.hotspot2.IconEvent;
import com.android.server.wifi.hotspot2.NetworkDetail;
import com.android.server.wifi.hotspot2.PasspointManager;
import com.android.server.wifi.hotspot2.WnmData;
import com.android.server.wifi.p2p.WifiP2pServiceImpl;
import com.android.server.wifi.proto.WifiStatsLog;
import com.android.server.wifi.proto.nano.WifiMetricsProto;
import com.android.server.wifi.proto.nano.WifiMetricsProto.StaEvent;
import com.android.server.wifi.proto.nano.WifiMetricsProto.WifiIsUnusableEvent;
import com.android.server.wifi.proto.nano.WifiMetricsProto.WifiUsabilityStats;
import com.android.server.wifi.util.ActionListenerWrapper;
import com.android.server.wifi.util.InformationElementUtil;
import com.android.server.wifi.util.NativeUtil;
import com.android.server.wifi.util.RssiUtil;
import com.android.server.wifi.util.StateMachineObituary;
import com.android.server.wifi.util.WifiPermissionsUtil;
import com.android.wifi.resources.R;

import java.io.BufferedReader;
import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.URL;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Implementation of ClientMode.  Event handling for Client mode logic is done here,
 * and all changes in connectivity state are initiated here.
 *
 * Note: No external modules should be calling into {@link ClientModeImpl}. Please plumb it via
 * {@link ClientModeManager} until b/160014176 is fixed.
 */
public class ClientModeImpl extends StateMachine implements ClientMode {
    private static final String NETWORKTYPE = "WIFI";
    @VisibleForTesting public static final short NUM_LOG_RECS_VERBOSE_LOW_MEMORY = 200;
    @VisibleForTesting public static final short NUM_LOG_RECS_VERBOSE = 3000;

    private static final String TAG = "WifiClientModeImpl";

    private static final int IPCLIENT_STARTUP_TIMEOUT_MS = 2_000;
    private static final int IPCLIENT_SHUTDOWN_TIMEOUT_MS = 60_000; // 60 seconds
    private static final int NETWORK_AGENT_TEARDOWN_DELAY_MS = 5_000; // Max teardown delay.
    @VisibleForTesting public static final long CONNECTING_WATCHDOG_TIMEOUT_MS = 30_000; // 30 secs.
    @VisibleForTesting
    public static final short NETWORK_NOT_FOUND_EVENT_THRESHOLD = 3;
    public static final String ARP_TABLE_PATH = "/proc/net/arp";

    private boolean mVerboseLoggingEnabled = false;

    /**
     * Log with error attribute
     *
     * @param s is string log
     */
    @Override
    protected void loge(String s) {
        Log.e(getTag(), s);
    }
    @Override
    protected void logd(String s) {
        Log.d(getTag(), s);
    }
    @Override
    protected void log(String s) {
        Log.d(getTag(), s);
    }
    private final WifiContext mContext;
    private final WifiMetrics mWifiMetrics;
    private final WifiMonitor mWifiMonitor;
    private final WifiNative mWifiNative;
    private final WifiPermissionsUtil mWifiPermissionsUtil;
    private final WifiConfigManager mWifiConfigManager;
    private final WifiConnectivityManager mWifiConnectivityManager;
    private final WifiBlocklistMonitor mWifiBlocklistMonitor;
    private final WifiDiagnostics mWifiDiagnostics;
    private final Clock mClock;
    private final WifiScoreCard mWifiScoreCard;
    private final WifiHealthMonitor mWifiHealthMonitor;
    private final WifiScoreReport mWifiScoreReport;
    private final WifiTrafficPoller mWifiTrafficPoller;
    private final PasspointManager mPasspointManager;
    private final WifiDataStall mWifiDataStall;
    private final LinkProbeManager mLinkProbeManager;
    private final MboOceController mMboOceController;
    private final McastLockManagerFilterController mMcastLockManagerFilterController;
    private final ActivityManager mActivityManager;
    private final FrameworkFacade mFacade;
    private final WifiStateTracker mWifiStateTracker;
    private final WrongPasswordNotifier mWrongPasswordNotifier;
    private final EapFailureNotifier mEapFailureNotifier;
    private final SimRequiredNotifier mSimRequiredNotifier;
    private final ConnectionFailureNotifier mConnectionFailureNotifier;
    private final WifiNetworkSuggestionsManager mWifiNetworkSuggestionsManager;
    private final ThroughputPredictor mThroughputPredictor;
    private final DeviceConfigFacade mDeviceConfigFacade;
    private final ScoringParams mScoringParams;
    private final WifiThreadRunner mWifiThreadRunner;
    private final ScanRequestProxy mScanRequestProxy;
    private final WifiLastResortWatchdog mWifiLastResortWatchdog;
    private final WakeupController mWakeupController;
    private final WifiLockManager mWifiLockManager;
    private final WifiP2pConnection mWifiP2pConnection;
    private final WifiGlobals mWifiGlobals;
    private final ClientModeManagerBroadcastQueue mBroadcastQueue;
    private final TelephonyManager mTelephonyManager;
    private final WifiSettingsConfigStore mSettingsConfigStore;
    private final long mId;

    private boolean mScreenOn = false;

    private final String mInterfaceName;
    private final ConcreteClientModeManager mClientModeManager;

    private final WifiNotificationManager mNotificationManager;
    private final QosPolicyRequestHandler mQosPolicyRequestHandler;

    private boolean mFailedToResetMacAddress = false;
    private int mLastSignalLevel = -1;
    private int mLastTxKbps = -1;
    private int mLastRxKbps = -1;
    private int mLastScanRssi = WifiInfo.INVALID_RSSI;
    private String mLastBssid;
    // TODO (b/162942761): Ensure this is reset when mTargetNetworkId is set.
    private int mLastNetworkId; // The network Id we successfully joined
    // The subId used by WifiConfiguration with SIM credential which was connected successfully
    private int mLastSubId;
    private String mLastSimBasedConnectionCarrierName;
    private URL mTermsAndConditionsUrl; // Indicates that the Passpoint network is captive
    @Nullable
    private byte[] mCachedPacketFilter;
    @Nullable
    private WifiNative.ConnectionCapabilities mLastConnectionCapabilities;
    private int mPowerSaveDisableRequests = 0; // mask based on @PowerSaveClientType
    private boolean mIsUserSelected = false;
    private boolean mCurrentConnectionDetectedCaptivePortal;

    private String getTag() {
        return TAG + "[" + (mInterfaceName == null ? "unknown" : mInterfaceName) + "]";
    }

    private void processRssiThreshold(byte curRssi, int reason,
            WifiNative.WifiRssiEventHandler rssiHandler) {
        if (curRssi == Byte.MAX_VALUE || curRssi == Byte.MIN_VALUE) {
            Log.wtf(getTag(), "processRssiThreshold: Invalid rssi " + curRssi);
            return;
        }
        for (int i = 0; i < mRssiRanges.length; i++) {
            if (curRssi < mRssiRanges[i]) {
                // Assume sorted values(ascending order) for rssi,
                // bounded by high(127) and low(-128) at extremeties
                byte maxRssi = mRssiRanges[i];
                byte minRssi = mRssiRanges[i - 1];
                // This value of hw has to be believed as this value is averaged and has breached
                // the rssi thresholds and raised event to host. This would be eggregious if this
                // value is invalid
                mWifiInfo.setRssi(curRssi);
                updateCapabilities();
                int ret = startRssiMonitoringOffload(maxRssi, minRssi, rssiHandler);
                Log.d(getTag(), "Re-program RSSI thresholds for " + getWhatToString(reason)
                        + ": [" + minRssi + ", " + maxRssi + "], curRssi=" + curRssi
                        + " ret=" + ret);
                break;
            }
        }
    }

    private boolean mEnableRssiPolling = false;
    private int mRssiPollToken = 0;

    private PowerManager.WakeLock mSuspendWakeLock;

    /**
     * Value to set in wpa_supplicant "bssid" field when we don't want to restrict connection to
     * a specific AP.
     */
    public static final String SUPPLICANT_BSSID_ANY = "any";

    /**
     * The link properties of the wifi interface.
     * Do not modify this directly; use updateLinkProperties instead.
     */
    private LinkProperties mLinkProperties;

    private final Object mDhcpResultsParcelableLock = new Object();
    @NonNull
    private DhcpResultsParcelable mDhcpResultsParcelable = new DhcpResultsParcelable();

    // NOTE: Do not return to clients - see syncRequestConnectionInfo()
    private final ExtendedWifiInfo mWifiInfo;
    // TODO : remove this member. It should be possible to only call sendNetworkChangeBroadcast when
    // the state actually changed, and to deduce the state of the agent from the state of the
    // machine when generating the NetworkInfo for the broadcast.
    private DetailedState mNetworkAgentState;
    private final SupplicantStateTracker mSupplicantStateTracker;

    // Indicates that framework is attempting to roam, set true on CMD_START_ROAM, set false when
    // wifi connects or fails to connect
    private boolean mIsAutoRoaming = false;

    // Indicates that driver is attempting to allowlist roaming, set true on allowlist roam BSSID
    // associated, set false when wifi connects or fails to connect
    private boolean mIsLinkedNetworkRoaming = false;

    // Roaming failure count
    private int mRoamFailCount = 0;

    // This is the BSSID we are trying to associate to, it can be set to SUPPLICANT_BSSID_ANY
    // if we havent selected a BSSID for joining.
    private String mTargetBssid = SUPPLICANT_BSSID_ANY;
    private int mTargetBand = ScanResult.UNSPECIFIED;
    // This one is used to track the current target network ID. This is used for error
    // handling during connection setup since many error message from supplicant does not report
    // SSID. Once connected, it will be set to invalid
    // TODO (b/162942761): Ensure this is reset when mLastNetworkId is set.
    private int mTargetNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
    private WifiConfiguration mTargetWifiConfiguration = null;
    @Nullable private VcnManager mVcnManager = null;

    /**
     * Method to clear {@link #mTargetBssid} and reset the current connected network's
     * bssid in wpa_supplicant after a roam/connect attempt.
     */
    public boolean clearTargetBssid(String dbg) {
        WifiConfiguration config = mWifiConfigManager.getConfiguredNetwork(mTargetNetworkId);
        if (config == null) {
            return false;
        }
        String bssid = SUPPLICANT_BSSID_ANY;
        if (config.BSSID != null) {
            bssid = config.BSSID;
            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "force BSSID to " + bssid + "due to config");
            }
        }
        if (mVerboseLoggingEnabled) {
            logd(dbg + " clearTargetBssid " + bssid + " key=" + config.getProfileKey());
        }
        mTargetBssid = bssid;
        return mWifiNative.setNetworkBSSID(mInterfaceName, bssid);
    }

    /**
     * Set Config's default BSSID (for association purpose) and {@link #mTargetBssid}
     * @param config config need set BSSID
     * @param bssid  default BSSID to assocaite with when connect to this network
     * @return false -- does not change the current default BSSID of the configure
     *         true -- change the  current default BSSID of the configur
     */
    private boolean setTargetBssid(WifiConfiguration config, String bssid) {
        if (config == null || bssid == null) {
            return false;
        }
        if (config.BSSID != null) {
            bssid = config.BSSID;
            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "force BSSID to " + bssid + "due to config");
            }
        }
        if (mVerboseLoggingEnabled) {
            Log.d(getTag(), "setTargetBssid set to " + bssid + " key="
                    + config.getProfileKey());
        }
        mTargetBssid = bssid;
        config.getNetworkSelectionStatus().setNetworkSelectionBSSID(bssid);
        return true;
    }

    private volatile IpClientManager mIpClient;
    private IpClientCallbacksImpl mIpClientCallbacks;

    private final WifiNetworkFactory mNetworkFactory;
    private final UntrustedWifiNetworkFactory mUntrustedNetworkFactory;
    private final OemWifiNetworkFactory mOemWifiNetworkFactory;
    private final RestrictedWifiNetworkFactory mRestrictedWifiNetworkFactory;
    @VisibleForTesting
    InsecureEapNetworkHandler mInsecureEapNetworkHandler;
    boolean mLeafCertSent;
    @VisibleForTesting
    InsecureEapNetworkHandler.InsecureEapNetworkHandlerCallbacks
            mInsecureEapNetworkHandlerCallbacksImpl;
    private final MultiInternetManager mMultiInternetManager;

    @VisibleForTesting
    @Nullable
    WifiNetworkAgent mNetworkAgent;

    private byte[] mRssiRanges;

    // Used to filter out requests we couldn't possibly satisfy.
    private final NetworkCapabilities mNetworkCapabilitiesFilter;

    /* The base for wifi message types */
    static final int BASE = Protocol.BASE_WIFI;

    /* BT connection state changed, e.g., connected/disconnected */
    static final int CMD_BLUETOOTH_CONNECTION_STATE_CHANGE              = BASE + 31;

    /* Supplicant commands after driver start*/
    /* Disconnect from a network */
    static final int CMD_DISCONNECT                                     = BASE + 73;
    /* Reconnect to a network */
    static final int CMD_RECONNECT                                      = BASE + 74;
    /* Reassociate to a network */
    static final int CMD_REASSOCIATE                                    = BASE + 75;

    /* Enables RSSI poll */
    static final int CMD_ENABLE_RSSI_POLL                               = BASE + 82;
    /* RSSI poll */
    static final int CMD_RSSI_POLL                                      = BASE + 83;
    /** Runs RSSI poll once */
    static final int CMD_ONESHOT_RSSI_POLL                              = BASE + 84;
    /* Enable suspend mode optimizations in the driver */
    static final int CMD_SET_SUSPEND_OPT_ENABLED                        = BASE + 86;

    /**
     * Watchdog for protecting against b/16823537
     * Leave time for 4-way handshake to succeed
     */
    static final int ROAM_GUARD_TIMER_MSEC = 15000;

    int mRoamWatchdogCount = 0;
    /* Roam state watchdog */
    static final int CMD_ROAM_WATCHDOG_TIMER                            = BASE + 94;
    /* Screen change intent handling */
    static final int CMD_SCREEN_STATE_CHANGED                           = BASE + 95;

    /* Disconnecting state watchdog */
    static final int CMD_CONNECTING_WATCHDOG_TIMER                      = BASE + 96;

    /* SIM is removed; reset any cached data for it */
    static final int CMD_RESET_SIM_NETWORKS                             = BASE + 101;

    @Retention(RetentionPolicy.SOURCE)
    @IntDef(prefix = {"RESET_SIM_REASON_"},
            value = {
                    RESET_SIM_REASON_SIM_REMOVED,
                    RESET_SIM_REASON_SIM_INSERTED,
                    RESET_SIM_REASON_DEFAULT_DATA_SIM_CHANGED})
    @interface ResetSimReason {}
    static final int RESET_SIM_REASON_SIM_REMOVED              = 0;
    static final int RESET_SIM_REASON_SIM_INSERTED             = 1;
    static final int RESET_SIM_REASON_DEFAULT_DATA_SIM_CHANGED = 2;

    /** Connecting watchdog timeout counter */
    private int mConnectingWatchdogCount = 0;

    /* We now have a valid IP configuration. */
    static final int CMD_IP_CONFIGURATION_SUCCESSFUL                    = BASE + 138;
    /* We no longer have a valid IP configuration. */
    static final int CMD_IP_CONFIGURATION_LOST                          = BASE + 139;
    /* Link configuration (IP address, DNS, ...) changes notified via netlink */
    static final int CMD_UPDATE_LINKPROPERTIES                          = BASE + 140;

    static final int CMD_START_CONNECT                                  = BASE + 143;

    private static final int NETWORK_STATUS_UNWANTED_DISCONNECT         = 0;
    private static final int NETWORK_STATUS_UNWANTED_VALIDATION_FAILED  = 1;
    @VisibleForTesting
    public static final int NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN   = 2;

    static final int CMD_UNWANTED_NETWORK                               = BASE + 144;

    static final int CMD_START_ROAM                                     = BASE + 145;

    static final int CMD_NETWORK_STATUS                                 = BASE + 148;

    /* A layer 3 neighbor on the Wi-Fi link became unreachable. */
    static final int CMD_IP_REACHABILITY_LOST                           = BASE + 149;

    static final int CMD_IP_REACHABILITY_FAILURE                        = BASE + 150;

    static final int CMD_ACCEPT_UNVALIDATED                             = BASE + 153;

    /* used to offload sending IP packet */
    static final int CMD_START_IP_PACKET_OFFLOAD                        = BASE + 160;

    /* used to stop offload sending IP packet */
    static final int CMD_STOP_IP_PACKET_OFFLOAD                         = BASE + 161;

    /* used to start rssi monitoring in hw */
    static final int CMD_START_RSSI_MONITORING_OFFLOAD                  = BASE + 162;

    /* used to stop rssi moniroting in hw */
    static final int CMD_STOP_RSSI_MONITORING_OFFLOAD                   = BASE + 163;

    /* used to indicated RSSI threshold breach in hw */
    static final int CMD_RSSI_THRESHOLD_BREACHED                        = BASE + 164;

    /**
     * Used to handle messages bounced between ClientModeImpl and IpClient.
     */
    static final int CMD_IPV4_PROVISIONING_SUCCESS                      = BASE + 200;
    static final int CMD_IPV4_PROVISIONING_FAILURE                      = BASE + 201;

    /* Push a new APF program to the HAL */
    static final int CMD_INSTALL_PACKET_FILTER                          = BASE + 202;

    /* Enable/disable fallback packet filtering */
    static final int CMD_SET_FALLBACK_PACKET_FILTERING                  = BASE + 203;

    /* Enable/disable Neighbor Discovery offload functionality. */
    static final int CMD_CONFIG_ND_OFFLOAD                              = BASE + 204;

    /* Read the APF program & data buffer */
    static final int CMD_READ_PACKET_FILTER                             = BASE + 208;

    /** Used to add packet filter to apf. */
    static final int CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF = BASE + 209;

    /** Used to remove packet filter from apf. */
    static final int CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF = BASE + 210;

    /* Indicates that diagnostics should time out a connection start event. */
    static final int CMD_DIAGS_CONNECT_TIMEOUT                          = BASE + 252;

    @VisibleForTesting
    static final int CMD_PRE_DHCP_ACTION                                = BASE + 255;
    private static final int CMD_PRE_DHCP_ACTION_COMPLETE               = BASE + 256;
    private static final int CMD_POST_DHCP_ACTION                       = BASE + 257;

    private static final int CMD_CONNECT_NETWORK                        = BASE + 258;
    private static final int CMD_SAVE_NETWORK                           = BASE + 259;

    /* Start connection to FILS AP*/
    static final int CMD_START_FILS_CONNECTION                          = BASE + 262;

    static final int CMD_CONNECTABLE_STATE_SETUP                        = BASE + 300;

    @VisibleForTesting
    static final int CMD_ACCEPT_EAP_SERVER_CERTIFICATE                  = BASE + 301;

    @VisibleForTesting
    static final int CMD_REJECT_EAP_INSECURE_CONNECTION                 = BASE + 302;

    /* Tracks if suspend optimizations need to be disabled by DHCP,
     * screen or due to high perf mode.
     * When any of them needs to disable it, we keep the suspend optimizations
     * disabled
     */
    private int mSuspendOptNeedsDisabled = 0;

    private static final int SUSPEND_DUE_TO_DHCP = 1;
    private static final int SUSPEND_DUE_TO_HIGH_PERF = 1 << 1;
    private static final int SUSPEND_DUE_TO_SCREEN = 1 << 2;

    /** @see #isRecentlySelectedByTheUser */
    @VisibleForTesting
    public static final int LAST_SELECTED_NETWORK_EXPIRATION_AGE_MILLIS = 30 * 1000;

    /* Tracks if user has enabled Connected Mac Randomization through settings */

    int mRunningBeaconCount = 0;

    /* Parent state where connections are allowed */
    private State mConnectableState = new ConnectableState();
    /* Connecting/Connected to an access point */
    private State mConnectingOrConnectedState = new ConnectingOrConnectedState();
    /* Connecting to an access point */
    private State mL2ConnectingState = new L2ConnectingState();
    /* Connected at 802.11 (L2) level */
    private State mL2ConnectedState = new L2ConnectedState();
    /* fetching IP after connection to access point (assoc+auth complete) */
    private State mL3ProvisioningState = new L3ProvisioningState();
    /* Connected with IP addr */
    private State mL3ConnectedState = new L3ConnectedState();
    /* Roaming */
    private State mRoamingState = new RoamingState();
    /* Network is not connected, supplicant assoc+auth is not complete */
    private State mDisconnectedState = new DisconnectedState();

    /*
     * FILS connection related variables.
     */
    /* To indicate to IpClient whether HLP IEs were included or not in assoc request */
    private boolean mSentHLPs = false;
    /* Tracks IpClient start state until (FILS_)NETWORK_CONNECTION_EVENT event */
    private boolean mIpClientWithPreConnection = false;

    /**
     * Work source to use to blame usage on the WiFi service
     */
    public static final WorkSource WIFI_WORK_SOURCE = new WorkSource(Process.WIFI_UID);

    private final BatteryStatsManager mBatteryStatsManager;

    private final WifiCarrierInfoManager mWifiCarrierInfoManager;

    private final OnNetworkUpdateListener mOnNetworkUpdateListener;

    private final OnCarrierOffloadDisabledListener mOnCarrierOffloadDisabledListener;

    private final ClientModeImplMonitor mCmiMonitor;

    private final WifiNetworkSelector mWifiNetworkSelector;

    private final WifiInjector mWifiInjector;

    // Permanently disable a network due to no internet if the estimated probability of having
    // internet is less than this value.
    @VisibleForTesting
    public static final int PROBABILITY_WITH_INTERNET_TO_PERMANENTLY_DISABLE_NETWORK = 60;
    // Disable a network permanently due to wrong password even if the network had successfully
    // connected before wrong password failure on this network reached this threshold.
    public static final int THRESHOLD_TO_PERM_WRONG_PASSWORD = 3;

    // Maximum duration to continue to log Wifi usability stats after a data stall is triggered.
    @VisibleForTesting
    public static final long DURATION_TO_WAIT_ADD_STATS_AFTER_DATA_STALL_MS = 30 * 1000;
    private long mDataStallTriggerTimeMs = -1;
    private int mLastStatusDataStall = WifiIsUnusableEvent.TYPE_UNKNOWN;

    @Nullable
    private StateMachineObituary mObituary = null;

    @Nullable
    private WifiVcnNetworkPolicyChangeListener mVcnPolicyChangeListener;

    /** NETWORK_NOT_FOUND_EVENT event counter */
    private int mNetworkNotFoundEventCount = 0;

    /** Note that this constructor will also start() the StateMachine. */
    public ClientModeImpl(
            @NonNull WifiContext context,
            @NonNull WifiMetrics wifiMetrics,
            @NonNull Clock clock,
            @NonNull WifiScoreCard wifiScoreCard,
            @NonNull WifiStateTracker wifiStateTracker,
            @NonNull WifiPermissionsUtil wifiPermissionsUtil,
            @NonNull WifiConfigManager wifiConfigManager,
            @NonNull PasspointManager passpointManager,
            @NonNull WifiMonitor wifiMonitor,
            @NonNull WifiDiagnostics wifiDiagnostics,
            @NonNull WifiDataStall wifiDataStall,
            @NonNull ScoringParams scoringParams,
            @NonNull WifiThreadRunner wifiThreadRunner,
            @NonNull WifiNetworkSuggestionsManager wifiNetworkSuggestionsManager,
            @NonNull WifiHealthMonitor wifiHealthMonitor,
            @NonNull ThroughputPredictor throughputPredictor,
            @NonNull DeviceConfigFacade deviceConfigFacade,
            @NonNull ScanRequestProxy scanRequestProxy,
            @NonNull ExtendedWifiInfo wifiInfo,
            @NonNull WifiConnectivityManager wifiConnectivityManager,
            @NonNull WifiBlocklistMonitor wifiBlocklistMonitor,
            @NonNull ConnectionFailureNotifier connectionFailureNotifier,
            @NonNull NetworkCapabilities networkCapabilitiesFilter,
            @NonNull WifiNetworkFactory networkFactory,
            @NonNull UntrustedWifiNetworkFactory untrustedWifiNetworkFactory,
            @NonNull OemWifiNetworkFactory oemPaidWifiNetworkFactory,
            @NonNull RestrictedWifiNetworkFactory restrictedWifiNetworkFactory,
            @NonNull MultiInternetManager multiInternetManager,
            @NonNull WifiLastResortWatchdog wifiLastResortWatchdog,
            @NonNull WakeupController wakeupController,
            @NonNull WifiLockManager wifiLockManager,
            @NonNull FrameworkFacade facade,
            @NonNull Looper looper,
            @NonNull WifiNative wifiNative,
            @NonNull WrongPasswordNotifier wrongPasswordNotifier,
            @NonNull WifiTrafficPoller wifiTrafficPoller,
            @NonNull LinkProbeManager linkProbeManager,
            long id,
            @NonNull BatteryStatsManager batteryStatsManager,
            @NonNull SupplicantStateTracker supplicantStateTracker,
            @NonNull MboOceController mboOceController,
            @NonNull WifiCarrierInfoManager wifiCarrierInfoManager,
            @NonNull EapFailureNotifier eapFailureNotifier,
            @NonNull SimRequiredNotifier simRequiredNotifier,
            @NonNull WifiScoreReport wifiScoreReport,
            @NonNull WifiP2pConnection wifiP2pConnection,
            @NonNull WifiGlobals wifiGlobals,
            @NonNull String ifaceName,
            @NonNull ConcreteClientModeManager clientModeManager,
            @NonNull ClientModeImplMonitor cmiMonitor,
            @NonNull ClientModeManagerBroadcastQueue broadcastQueue,
            @NonNull WifiNetworkSelector wifiNetworkSelector,
            @NonNull TelephonyManager telephonyManager,
            @NonNull WifiInjector wifiInjector,
            @NonNull WifiSettingsConfigStore settingsConfigStore,
            boolean verboseLoggingEnabled,
            @NonNull WifiNotificationManager wifiNotificationManager) {
        super(TAG, looper);
        mWifiMetrics = wifiMetrics;
        mClock = clock;
        mWifiScoreCard = wifiScoreCard;
        mContext = context;
        mFacade = facade;
        mWifiNative = wifiNative;
        mWrongPasswordNotifier = wrongPasswordNotifier;
        mId = id;
        mEapFailureNotifier = eapFailureNotifier;
        mSimRequiredNotifier = simRequiredNotifier;
        mWifiTrafficPoller = wifiTrafficPoller;
        mLinkProbeManager = linkProbeManager;
        mMboOceController = mboOceController;
        mWifiCarrierInfoManager = wifiCarrierInfoManager;
        mBroadcastQueue = broadcastQueue;
        mNetworkAgentState = DetailedState.DISCONNECTED;

        mBatteryStatsManager = batteryStatsManager;
        mWifiStateTracker = wifiStateTracker;

        mWifiPermissionsUtil = wifiPermissionsUtil;
        mWifiConfigManager = wifiConfigManager;

        mPasspointManager = passpointManager;

        mWifiMonitor = wifiMonitor;
        mWifiDiagnostics = wifiDiagnostics;
        mWifiDataStall = wifiDataStall;
        mThroughputPredictor = throughputPredictor;
        mDeviceConfigFacade = deviceConfigFacade;

        mWifiInfo = wifiInfo;
        mSupplicantStateTracker = supplicantStateTracker;
        mWifiConnectivityManager = wifiConnectivityManager;
        mWifiBlocklistMonitor = wifiBlocklistMonitor;
        mConnectionFailureNotifier = connectionFailureNotifier;

        mLinkProperties = new LinkProperties();
        mMcastLockManagerFilterController = new McastLockManagerFilterController();
        mActivityManager = context.getSystemService(ActivityManager.class);

        mLastBssid = null;
        mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
        mLastSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
        mLastSimBasedConnectionCarrierName = null;
        mLastSignalLevel = -1;

        mScoringParams = scoringParams;
        mWifiThreadRunner = wifiThreadRunner;
        mScanRequestProxy = scanRequestProxy;
        mWifiScoreReport = wifiScoreReport;

        mNetworkCapabilitiesFilter = networkCapabilitiesFilter;
        mNetworkFactory = networkFactory;

        mUntrustedNetworkFactory = untrustedWifiNetworkFactory;
        mOemWifiNetworkFactory = oemPaidWifiNetworkFactory;
        mRestrictedWifiNetworkFactory = restrictedWifiNetworkFactory;
        mMultiInternetManager = multiInternetManager;

        mWifiLastResortWatchdog = wifiLastResortWatchdog;
        mWakeupController = wakeupController;
        mWifiLockManager = wifiLockManager;

        mWifiNetworkSuggestionsManager = wifiNetworkSuggestionsManager;
        mWifiHealthMonitor = wifiHealthMonitor;
        mWifiP2pConnection = wifiP2pConnection;
        mWifiGlobals = wifiGlobals;

        mInterfaceName = ifaceName;
        mClientModeManager = clientModeManager;
        mCmiMonitor = cmiMonitor;
        mTelephonyManager = telephonyManager;
        mSettingsConfigStore = settingsConfigStore;
        updateInterfaceCapabilities();

        PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);

        mSuspendWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "WifiSuspend");
        mSuspendWakeLock.setReferenceCounted(false);

        mOnNetworkUpdateListener = new OnNetworkUpdateListener();
        mWifiConfigManager.addOnNetworkUpdateListener(mOnNetworkUpdateListener);

        mOnCarrierOffloadDisabledListener = new OnCarrierOffloadDisabledListener();
        mWifiCarrierInfoManager.addOnCarrierOffloadDisabledListener(
                mOnCarrierOffloadDisabledListener);

        mWifiNetworkSelector = wifiNetworkSelector;
        mWifiInjector = wifiInjector;
        mQosPolicyRequestHandler = new QosPolicyRequestHandler(mInterfaceName, mWifiNative, this,
                mWifiInjector.getWifiHandlerThread());

        enableVerboseLogging(verboseLoggingEnabled);

        mNotificationManager = wifiNotificationManager;

        mInsecureEapNetworkHandlerCallbacksImpl =
                new InsecureEapNetworkHandler.InsecureEapNetworkHandlerCallbacks() {
                @Override
                public void onAccept(String ssid, int networkId) {
                    log("Accept Root CA cert for " + ssid);
                    sendMessage(CMD_ACCEPT_EAP_SERVER_CERTIFICATE, networkId);
                }

                @Override
                public void onReject(String ssid, boolean disconnectRequired) {
                    log("Reject Root CA cert for " + ssid);
                    sendMessage(CMD_REJECT_EAP_INSECURE_CONNECTION,
                            WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_REJECTED_BY_USER,
                            disconnectRequired ? 1 : 0, ssid);
                }

                @Override
                public void onError(String ssid) {
                    log("Insecure EAP network error for " + ssid);
                    sendMessage(CMD_REJECT_EAP_INSECURE_CONNECTION,
                            WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_EAP_FAILURE,
                            0, ssid);
                }};
        mInsecureEapNetworkHandler = new InsecureEapNetworkHandler(
                mContext,
                mWifiConfigManager,
                mWifiNative,
                mFacade,
                mNotificationManager,
                mWifiInjector.getWifiDialogManager(),
                isTrustOnFirstUseSupported(),
                mWifiGlobals.isInsecureEnterpriseConfigurationAllowed(),
                mInsecureEapNetworkHandlerCallbacksImpl,
                mInterfaceName,
                getHandler());

        addState(mConnectableState); {
            addState(mConnectingOrConnectedState, mConnectableState); {
                addState(mL2ConnectingState, mConnectingOrConnectedState);
                addState(mL2ConnectedState, mConnectingOrConnectedState); {
                    addState(mL3ProvisioningState, mL2ConnectedState);
                    addState(mL3ConnectedState, mL2ConnectedState);
                    addState(mRoamingState, mL2ConnectedState);
                }
            }
            addState(mDisconnectedState, mConnectableState);
        }

        setInitialState(mDisconnectedState);

        setLogOnlyTransitions(false);

        // Start the StateMachine
        start();

        // update with initial role for ConcreteClientModeManager
        onRoleChanged();
    }

    private static final int[] WIFI_MONITOR_EVENTS = {
            WifiMonitor.TARGET_BSSID_EVENT,
            WifiMonitor.ASSOCIATED_BSSID_EVENT,
            WifiMonitor.ANQP_DONE_EVENT,
            WifiMonitor.ASSOCIATION_REJECTION_EVENT,
            WifiMonitor.AUTHENTICATION_FAILURE_EVENT,
            WifiMonitor.GAS_QUERY_DONE_EVENT,
            WifiMonitor.GAS_QUERY_START_EVENT,
            WifiMonitor.HS20_REMEDIATION_EVENT,
            WifiMonitor.HS20_DEAUTH_IMMINENT_EVENT,
            WifiMonitor.HS20_TERMS_AND_CONDITIONS_ACCEPTANCE_REQUIRED_EVENT,
            WifiMonitor.NETWORK_CONNECTION_EVENT,
            WifiMonitor.NETWORK_DISCONNECTION_EVENT,
            WifiMonitor.RX_HS20_ANQP_ICON_EVENT,
            WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT,
            WifiMonitor.SUP_REQUEST_IDENTITY,
            WifiMonitor.SUP_REQUEST_SIM_AUTH,
            WifiMonitor.MBO_OCE_BSS_TM_HANDLING_DONE,
            WifiMonitor.TRANSITION_DISABLE_INDICATION,
            WifiMonitor.NETWORK_NOT_FOUND_EVENT,
            WifiMonitor.TOFU_CERTIFICATE_EVENT,
            WifiMonitor.AUXILIARY_SUPPLICANT_EVENT,
            WifiMonitor.QOS_POLICY_RESET_EVENT,
            WifiMonitor.QOS_POLICY_REQUEST_EVENT,
    };

    private void registerForWifiMonitorEvents()  {
        for (int event : WIFI_MONITOR_EVENTS) {
            mWifiMonitor.registerHandler(mInterfaceName, event, getHandler());
        }

        mWifiMetrics.registerForWifiMonitorEvents(mInterfaceName);
        mWifiLastResortWatchdog.registerForWifiMonitorEvents(mInterfaceName);
    }

    private void deregisterForWifiMonitorEvents()  {
        for (int event : WIFI_MONITOR_EVENTS) {
            mWifiMonitor.deregisterHandler(mInterfaceName, event, getHandler());
        }

        mWifiMetrics.deregisterForWifiMonitorEvents(mInterfaceName);
        mWifiLastResortWatchdog.deregisterForWifiMonitorEvents(mInterfaceName);
    }

    private static boolean isValidBssid(String bssidStr) {
        try {
            MacAddress bssid = MacAddress.fromString(bssidStr);
            return !Objects.equals(bssid, WifiManager.ALL_ZEROS_MAC_ADDRESS);
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    private void setMulticastFilter(boolean enabled) {
        if (mIpClient != null) {
            mIpClient.setMulticastFilter(enabled);
        }
    }

    /*
     * Log wifi event to SecurityLog if the event occurred on a managed network.
     */
    private void logEventIfManagedNetwork(@Nullable WifiConfiguration config,
            @SupplicantEventCode int eventCode, MacAddress bssid, String reasonString) {
        if (!SdkLevel.isAtLeastT() || config == null
                || !mWifiPermissionsUtil.isAdmin(config.creatorUid, config.creatorName)) {
            return;
        }

        int numRedactedOctets = mContext.getResources()
                .getInteger(R.integer.config_wifiNumMaskedBssidOctetsInSecurityLog);
        String redactedBssid = ScanResultUtil.redactBssid(bssid, numRedactedOctets);
        if (eventCode == SupplicantStaIfaceHal.SUPPLICANT_EVENT_DISCONNECTED) {
            SecurityLog.writeEvent(SecurityLog.TAG_WIFI_DISCONNECTION, redactedBssid, reasonString);
        } else {
            SecurityLog.writeEvent(SecurityLog.TAG_WIFI_CONNECTION,
                    SupplicantStaIfaceHal.supplicantEventCodeToString(eventCode),
                    redactedBssid, reasonString);
        }
    }

    protected void clearQueuedQosMessages() {
        removeMessages(WifiMonitor.QOS_POLICY_RESET_EVENT);
        removeMessages(WifiMonitor.QOS_POLICY_REQUEST_EVENT);
    }

    /**
     * Class to implement the MulticastLockManager.FilterController callback.
     */
    class McastLockManagerFilterController implements WifiMulticastLockManager.FilterController {
        /**
         * Start filtering Multicast v4 packets
         */
        public void startFilteringMulticastPackets() {
            setMulticastFilter(true);
        }

        /**
         * Stop filtering Multicast v4 packets
         */
        public void stopFilteringMulticastPackets() {
            setMulticastFilter(false);
        }
    }

    class IpClientCallbacksImpl extends IpClientCallbacks {
        private final ConditionVariable mWaitForCreationCv = new ConditionVariable(false);
        private final ConditionVariable mWaitForStopCv = new ConditionVariable(false);

        @Override
        public void onIpClientCreated(IIpClient ipClient) {
            // IpClient may take a very long time (many minutes) to start at boot time. But after
            // that IpClient should start pretty quickly (a few seconds).
            // Blocking wait for 5 seconds first (for when the wait is short)
            // If IpClient is still not ready after blocking wait, async wait (for when wait is
            // long). Will drop all connection requests until IpClient is ready. Other requests
            // will still be processed.
            sendMessageAtFrontOfQueue(CMD_CONNECTABLE_STATE_SETUP,
                    new IpClientManager(ipClient, getName()));
            mWaitForCreationCv.open();
        }

        @Override
        public void onPreDhcpAction() {
            sendMessage(CMD_PRE_DHCP_ACTION);
        }

        @Override
        public void onPostDhcpAction() {
            sendMessage(CMD_POST_DHCP_ACTION);
        }

        @Override
        public void onNewDhcpResults(DhcpResultsParcelable dhcpResults) {
            if (dhcpResults != null) {
                sendMessage(CMD_IPV4_PROVISIONING_SUCCESS, dhcpResults);
            } else {
                sendMessage(CMD_IPV4_PROVISIONING_FAILURE);
            }
        }

        @Override
        public void onProvisioningSuccess(LinkProperties newLp) {
            addPasspointInfoToLinkProperties(newLp);
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CMD_IP_CONFIGURATION_SUCCESSFUL);
            sendMessage(CMD_UPDATE_LINKPROPERTIES, newLp);
            sendMessage(CMD_IP_CONFIGURATION_SUCCESSFUL);
        }

        @Override
        public void onProvisioningFailure(LinkProperties newLp) {
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CMD_IP_CONFIGURATION_LOST);
            sendMessage(CMD_IP_CONFIGURATION_LOST);
        }

        @Override
        public void onLinkPropertiesChange(LinkProperties newLp) {
            addPasspointInfoToLinkProperties(newLp);
            sendMessage(CMD_UPDATE_LINKPROPERTIES, newLp);
        }

        @Override
        public void onReachabilityLost(String logMsg) {
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CMD_IP_REACHABILITY_LOST);
            sendMessage(CMD_IP_REACHABILITY_LOST, logMsg);
        }

        @Override
        public void onReachabilityFailure(ReachabilityLossInfoParcelable lossInfo) {
            sendMessage(CMD_IP_REACHABILITY_FAILURE, lossInfo);
        }

        @Override
        public void installPacketFilter(byte[] filter) {
            sendMessage(CMD_INSTALL_PACKET_FILTER, filter);
        }

        @Override
        public void startReadPacketFilter() {
            sendMessage(CMD_READ_PACKET_FILTER);
        }

        @Override
        public void setFallbackMulticastFilter(boolean enabled) {
            sendMessage(CMD_SET_FALLBACK_PACKET_FILTERING, enabled);
        }

        @Override
        public void setNeighborDiscoveryOffload(boolean enabled) {
            sendMessage(CMD_CONFIG_ND_OFFLOAD, (enabled ? 1 : 0));
        }

        @Override
        public void onPreconnectionStart(List<Layer2PacketParcelable> packets) {
            sendMessage(CMD_START_FILS_CONNECTION, 0, 0, packets);
        }

        @Override
        public void onQuit() {
            mWaitForStopCv.open();
        }

        boolean awaitCreation() {
            return mWaitForCreationCv.block(IPCLIENT_STARTUP_TIMEOUT_MS);
        }

        boolean awaitShutdown() {
            return mWaitForStopCv.block(IPCLIENT_SHUTDOWN_TIMEOUT_MS);
        }
    }

    private void stopIpClient() {
        if (mVerboseLoggingEnabled) {
            Log.v(getTag(), "stopIpClient IpClientWithPreConnection: "
                    + mIpClientWithPreConnection);
        }
        if (mIpClient != null) {
            if (mIpClientWithPreConnection) {
                mIpClient.notifyPreconnectionComplete(false);
            }
            mIpClient.stop();
        }
        mIpClientWithPreConnection = false;
        mSentHLPs = false;
    }

    private void stopDhcpSetup() {
        /* Restore power save and suspend optimizations */
        handlePostDhcpSetup();
        stopIpClient();
    }

    private List<DhcpOption> convertToInternalDhcpOptions(List<android.net.DhcpOption> options) {
        List<DhcpOption> internalOptions = new ArrayList<DhcpOption>();
        for (android.net.DhcpOption option : options) {
            DhcpOption internalOption = new DhcpOption();
            internalOption.type = option.getType();
            if (option.getValue() != null) {
                byte[] value = option.getValue();
                internalOption.value = Arrays.copyOf(value, value.length);
            }
            internalOptions.add(internalOption);
        }
        return internalOptions;
    }

    /**
     * Listener for config manager network config related events.
     * TODO (b/117601161) : Move some of the existing handling in WifiConnectivityManager's listener
     * for the same events.
     */
    private class OnNetworkUpdateListener implements
            WifiConfigManager.OnNetworkUpdateListener {
        @Override
        public void onNetworkRemoved(WifiConfiguration config) {
            // The current connected or connecting network has been removed, trigger a disconnect.
            if (config.networkId == mTargetNetworkId || config.networkId == mLastNetworkId) {
                // Disconnect and let autojoin reselect a new network
                sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_REMOVED);
            } else {
                WifiConfiguration currentConfig = getConnectedWifiConfiguration();
                if (currentConfig != null && currentConfig.isLinked(config)) {
                    logi("current network linked config removed, update allowlist networks");
                    updateLinkedNetworks(currentConfig);
                }
            }
            mWifiNative.removeNetworkCachedData(config.networkId);
        }

        @Override
        public void onNetworkUpdated(WifiConfiguration newConfig, WifiConfiguration oldConfig) {
            // Clear invalid cached data.
            mWifiNative.removeNetworkCachedData(oldConfig.networkId);

            if (WifiConfigurationUtil.hasCredentialChanged(oldConfig, newConfig)) {
                mWifiBlocklistMonitor.handleNetworkRemoved(newConfig.SSID);
            }

            if (newConfig.networkId != mLastNetworkId)  {
                // nothing to do.
                return;
            }
            boolean isMetered = WifiConfiguration.isMetered(newConfig, mWifiInfo);
            boolean wasMetered = WifiConfiguration.isMetered(oldConfig, mWifiInfo);
            // Check if user/app change meteredOverride or trusted for connected network.
            if (isMetered == wasMetered
                    && (!SdkLevel.isAtLeastT() || newConfig.trusted == oldConfig.trusted)) {
                return;
            }

            if (SdkLevel.isAtLeastT()) {
                mWifiInfo.setTrusted(newConfig.trusted);
                if (!newConfig.trusted) {
                    Log.w(getTag(), "Network marked untrusted, triggering disconnect");
                    sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_UNTRUSTED);
                    return;
                }
            }

            if (isMetered) {
                Log.w(getTag(), "Network marked metered, triggering disconnect");
                sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_METERED);
                return;
            }

            Log.i(getTag(), "Network marked metered=" + isMetered
                    + " trusted=" + newConfig.trusted + ", triggering capabilities update");
            updateCapabilities(newConfig);
        }

        @Override
        public void onNetworkTemporarilyDisabled(WifiConfiguration config, int disableReason) {
            if (disableReason == DISABLED_NO_INTERNET_TEMPORARY) return;
            if (config.networkId == mTargetNetworkId || config.networkId == mLastNetworkId) {
                // Disconnect and let autojoin reselect a new network
                sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_TEMPORARY_DISABLED);
            }

        }

        @Override
        public void onNetworkPermanentlyDisabled(WifiConfiguration config, int disableReason) {
            // For DISABLED_NO_INTERNET_PERMANENT we do not need to remove the network
            // because supplicant won't be trying to reconnect. If this is due to a
            // preventAutomaticReconnect request from ConnectivityService, that service
            // will disconnect as appropriate.
            if (disableReason == DISABLED_NO_INTERNET_PERMANENT) return;
            if (config.networkId == mTargetNetworkId || config.networkId == mLastNetworkId) {
                // Disconnect and let autojoin reselect a new network
                sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_PERMANENT_DISABLED);
            }
        }
    }

    private class OnCarrierOffloadDisabledListener implements
            WifiCarrierInfoManager.OnCarrierOffloadDisabledListener {

        @Override
        public void onCarrierOffloadDisabled(int subscriptionId, boolean merged) {
            int networkId = mTargetNetworkId == WifiConfiguration.INVALID_NETWORK_ID
                    ? mLastNetworkId : mTargetNetworkId;
            if (networkId == WifiConfiguration.INVALID_NETWORK_ID) {
                return;
            }
            WifiConfiguration configuration = mWifiConfigManager.getConfiguredNetwork(networkId);
            if (configuration.subscriptionId == subscriptionId
                    && configuration.carrierMerged == merged) {
                Log.i(getTag(), "Carrier network offload disabled, triggering disconnect");
                sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_CARRIER_OFFLOAD_DISABLED);
            }
            mWifiConnectivityManager.clearCachedCandidates();
        }
    }

    /**
     * Method to update logging level in wifi service related classes.
     *
     * @param verbose int logging level to use
     */
    public void enableVerboseLogging(boolean verbose) {
        if (verbose) {
            mVerboseLoggingEnabled = true;
            setLogRecSize(mActivityManager.isLowRamDevice()
                    ? NUM_LOG_RECS_VERBOSE_LOW_MEMORY : NUM_LOG_RECS_VERBOSE);
        } else {
            mVerboseLoggingEnabled = false;
            setLogRecSize(mWifiGlobals.getClientModeImplNumLogRecs());
        }

        mWifiScoreReport.enableVerboseLogging(mVerboseLoggingEnabled);
        mSupplicantStateTracker.enableVerboseLogging(mVerboseLoggingEnabled);
        mQosPolicyRequestHandler.enableVerboseLogging(mVerboseLoggingEnabled);
    }

    /**
     * If there is only SAE-only networks with this auto-upgrade type,
     * this auto-upgrade SAE type is considered to be added explicitly.
     *
     * For R, Settings/WifiTrackerLib maps WPA3 SAE to WPA2, so there is
     * no chance to add or update a WPA3 SAE configuration to update
     * the auto-upgrade flag.
     */
    private void updateSaeAutoUpgradeFlagForUserSelectNetwork(int networkId) {
        if (SdkLevel.isAtLeastS()) return;
        if (mWifiGlobals.isWpa3SaeUpgradeEnabled()) return;

        WifiConfiguration config = mWifiConfigManager.getConfiguredNetwork(networkId);
        if (null == config) return;
        SecurityParams params = config.getSecurityParams(WifiConfiguration.SECURITY_TYPE_SAE);
        if (null == params || !params.isAddedByAutoUpgrade()) return;

        if (!mScanRequestProxy.isWpa3PersonalOnlyNetworkInRange(config.SSID)) return;
        if (mScanRequestProxy.isWpa2PersonalOnlyNetworkInRange(config.SSID)) return;
        if (mScanRequestProxy.isWpa2Wpa3PersonalTransitionNetworkInRange(config.SSID)) return;

        logd("update auto-upgrade flag for SAE");
        mWifiConfigManager.updateIsAddedByAutoUpgradeFlag(
                config.networkId, WifiConfiguration.SECURITY_TYPE_SAE, false);
    }

    /**
     * Initiates connection to a network specified by the user/app. This method checks if the
     * requesting app holds the NETWORK_SETTINGS permission.
     *
     * @param netId Id network to initiate connection.
     * @param uid UID of the app requesting the connection.
     * @param forceReconnect Whether to force a connection even if we're connected to the same
     *                       network currently.
     * @param packageName package name of the app requesting the connection.
     */
    private void connectToUserSelectNetwork(int netId, int uid, boolean forceReconnect,
            @NonNull String packageName) {
        if (mWifiPermissionsUtil.checkNetworkSettingsPermission(uid)
                || mWifiPermissionsUtil.checkNetworkSetupWizardPermission(uid)) {
            mIsUserSelected = true;
        }
        logd("connectToUserSelectNetwork netId " + netId + ", uid " + uid + ", package "
                + packageName + ", forceReconnect = " + forceReconnect + ", isUserSelected = "
                + mIsUserSelected);
        updateSaeAutoUpgradeFlagForUserSelectNetwork(netId);
        if (!forceReconnect && (mLastNetworkId == netId || mTargetNetworkId == netId)) {
            // We're already connecting/connected to the user specified network, don't trigger a
            // reconnection unless it was forced.
            logi("connectToUserSelectNetwork already connecting/connected=" + netId);
        } else {
            mWifiConnectivityManager.prepareForForcedConnection(netId);
            if (UserHandle.getAppId(uid) == Process.SYSTEM_UID) {
                mWifiMetrics.setNominatorForNetwork(netId,
                        WifiMetricsProto.ConnectionEvent.NOMINATOR_MANUAL);
            }
            startConnectToNetwork(netId, uid, SUPPLICANT_BSSID_ANY);
        }
    }

    /**
     * ******************************************************
     * Methods exposed for public use
     * ******************************************************
     */

    /**
     * Retrieve a Messenger for the ClientModeImpl Handler
     *
     * @return Messenger
     */
    public Messenger getMessenger() {
        return new Messenger(getHandler());
    }

    // For debugging, keep track of last message status handling
    // TODO, find an equivalent mechanism as part of parent class
    private static final int MESSAGE_HANDLING_STATUS_PROCESSED = 2;
    private static final int MESSAGE_HANDLING_STATUS_OK = 1;
    private static final int MESSAGE_HANDLING_STATUS_UNKNOWN = 0;
    private static final int MESSAGE_HANDLING_STATUS_REFUSED = -1;
    private static final int MESSAGE_HANDLING_STATUS_FAIL = -2;
    private static final int MESSAGE_HANDLING_STATUS_OBSOLETE = -3;
    private static final int MESSAGE_HANDLING_STATUS_DEFERRED = -4;
    private static final int MESSAGE_HANDLING_STATUS_DISCARD = -5;
    private static final int MESSAGE_HANDLING_STATUS_LOOPED = -6;
    private static final int MESSAGE_HANDLING_STATUS_HANDLING_ERROR = -7;

    private int mMessageHandlingStatus = 0;

    private int mOnTime = 0;
    private int mTxTime = 0;
    private int mRxTime = 0;

    private int mOnTimeScreenStateChange = 0;
    private long mLastOntimeReportTimeStamp = 0;
    private long mLastScreenStateChangeTimeStamp = 0;
    private int mOnTimeLastReport = 0;
    private int mTxTimeLastReport = 0;
    private int mRxTimeLastReport = 0;

    private WifiLinkLayerStats mLastLinkLayerStats;
    private long mLastLinkLayerStatsUpdate = 0;

    String reportOnTime() {
        long now = mClock.getWallClockMillis();
        StringBuilder sb = new StringBuilder();
        // Report stats since last report
        int on = mOnTime - mOnTimeLastReport;
        mOnTimeLastReport = mOnTime;
        int tx = mTxTime - mTxTimeLastReport;
        mTxTimeLastReport = mTxTime;
        int rx = mRxTime - mRxTimeLastReport;
        mRxTimeLastReport = mRxTime;
        int period = (int) (now - mLastOntimeReportTimeStamp);
        mLastOntimeReportTimeStamp = now;
        sb.append("[on:" + on + " tx:" + tx + " rx:" + rx + " period:" + period + "]");
        // Report stats since Screen State Changed
        on = mOnTime - mOnTimeScreenStateChange;
        period = (int) (now - mLastScreenStateChangeTimeStamp);
        sb.append(" from screen [on:" + on + " period:" + period + "]");
        return sb.toString();
    }

    /**
     * receives changes in the interface up/down events for the interface associated with this
     * ClientModeImpl. This is expected to be called from the ClientModeManager running on the
     * wifi handler thread.
     */
    public void onUpChanged(boolean isUp) {
        if (isUp && mFailedToResetMacAddress) {
            // When the firmware does a subsystem restart, wifi will disconnect but we may fail to
            // re-randomize the MAC address of the interface since it's undergoing recovery. Thus,
            // check every time the interface goes up and re-randomize if the failure was detected.
            if (mWifiGlobals.isConnectedMacRandomizationEnabled()) {
                mFailedToResetMacAddress = !mWifiNative.setStaMacAddress(
                        mInterfaceName, MacAddressUtils.createRandomUnicastAddress());
                if (mFailedToResetMacAddress) {
                    Log.e(getTag(), "Failed to set random MAC address on interface up");
                }
            }
        }
        // No need to handle interface down since it's already handled in the ClientModeManager.
    }

    public WifiLinkLayerStats getWifiLinkLayerStats() {
        if (mInterfaceName == null) {
            loge("getWifiLinkLayerStats called without an interface");
            return null;
        }
        mLastLinkLayerStatsUpdate = mClock.getWallClockMillis();
        WifiLinkLayerStats stats = null;
        if (isPrimary()) {
            stats = mWifiNative.getWifiLinkLayerStats(mInterfaceName);
        } else {
            if (mVerboseLoggingEnabled) {
                Log.w(getTag(), "Can't getWifiLinkLayerStats on secondary iface");
            }
        }
        if (stats != null) {
            mOnTime = stats.on_time;
            mTxTime = stats.tx_time;
            mRxTime = stats.rx_time;
            mRunningBeaconCount = stats.beacon_rx;
            mWifiInfo.updatePacketRates(stats, mLastLinkLayerStatsUpdate);
        } else {
            long mTxPkts = mFacade.getTxPackets(mInterfaceName);
            long mRxPkts = mFacade.getRxPackets(mInterfaceName);
            mWifiInfo.updatePacketRates(mTxPkts, mRxPkts, mLastLinkLayerStatsUpdate);
        }
        mWifiMetrics.incrementWifiLinkLayerUsageStats(mInterfaceName, stats);
        return stats;
    }

    /**
     * Update interface capabilities
     * This method is used to update some of interface capabilities defined in overlay
     */
    private void updateInterfaceCapabilities() {
        DeviceWiphyCapabilities cap = getDeviceWiphyCapabilities();
        if (cap != null) {
            // Some devices don't have support of 11ax/be indicated by the chip,
            // so an override config value is used
            if (mContext.getResources().getBoolean(R.bool.config_wifi11beSupportOverride)) {
                cap.setWifiStandardSupport(ScanResult.WIFI_STANDARD_11BE, true);
            }
            if (mContext.getResources().getBoolean(R.bool.config_wifi11axSupportOverride)) {
                cap.setWifiStandardSupport(ScanResult.WIFI_STANDARD_11AX, true);
            }

            mWifiNative.setDeviceWiphyCapabilities(mInterfaceName, cap);
        }
    }

    @Override
    public DeviceWiphyCapabilities getDeviceWiphyCapabilities() {
        return mWifiNative.getDeviceWiphyCapabilities(mInterfaceName);
    }

    /**
     * Check if a Wi-Fi standard is supported
     *
     * @param standard A value from {@link ScanResult}'s {@code WIFI_STANDARD_}
     * @return {@code true} if standard is supported, {@code false} otherwise.
     */
    public boolean isWifiStandardSupported(@WifiStandard int standard) {
        return mWifiNative.isWifiStandardSupported(mInterfaceName, standard);
    }

    private byte[] getDstMacForKeepalive(KeepalivePacketData packetData)
            throws InvalidPacketException {
        try {
            InetAddress gateway = NetUtils.selectBestRoute(
                    mLinkProperties.getRoutes(), packetData.getDstAddress()).getGateway();
            String dstMacStr = macAddressFromRoute(gateway.getHostAddress());
            return NativeUtil.macAddressToByteArray(dstMacStr);
        } catch (NullPointerException | IllegalArgumentException e) {
            throw new InvalidPacketException(InvalidPacketException.ERROR_INVALID_IP_ADDRESS);
        }
    }

    private static int getEtherProtoForKeepalive(KeepalivePacketData packetData)
            throws InvalidPacketException {
        if (packetData.getDstAddress() instanceof Inet4Address) {
            return OsConstants.ETH_P_IP;
        } else if (packetData.getDstAddress() instanceof Inet6Address) {
            return OsConstants.ETH_P_IPV6;
        } else {
            throw new InvalidPacketException(InvalidPacketException.ERROR_INVALID_IP_ADDRESS);
        }
    }

    private int startWifiIPPacketOffload(int slot, KeepalivePacketData packetData,
            int intervalSeconds) {
        byte[] packet = null;
        byte[] dstMac = null;
        int proto = 0;

        try {
            packet = packetData.getPacket();
            dstMac = getDstMacForKeepalive(packetData);
            proto = getEtherProtoForKeepalive(packetData);
        } catch (InvalidPacketException e) {
            return e.getError();
        }

        int ret = mWifiNative.startSendingOffloadedPacket(
                mInterfaceName, slot, dstMac, packet, proto, intervalSeconds * 1000);
        if (ret != 0) {
            loge("startWifiIPPacketOffload(" + slot + ", " + intervalSeconds
                    + "): hardware error " + ret);
            return SocketKeepalive.ERROR_HARDWARE_ERROR;
        } else {
            return SocketKeepalive.SUCCESS;
        }
    }

    private int stopWifiIPPacketOffload(int slot) {
        int ret = mWifiNative.stopSendingOffloadedPacket(mInterfaceName, slot);
        if (ret != 0) {
            loge("stopWifiIPPacketOffload(" + slot + "): hardware error " + ret);
            return SocketKeepalive.ERROR_HARDWARE_ERROR;
        } else {
            return SocketKeepalive.SUCCESS;
        }
    }

    private int startRssiMonitoringOffload(byte maxRssi, byte minRssi,
            WifiNative.WifiRssiEventHandler rssiHandler) {
        return mWifiNative.startRssiMonitoring(mInterfaceName, maxRssi, minRssi, rssiHandler);
    }

    private int stopRssiMonitoringOffload() {
        return mWifiNative.stopRssiMonitoring(mInterfaceName);
    }

    @Override
    public boolean isConnected() {
        return getCurrentState() == mL3ConnectedState;
    }

    @Override
    public boolean isConnecting() {
        IState state = getCurrentState();
        return state == mL2ConnectingState || state == mL2ConnectedState
                || state == mL3ProvisioningState;
    }

    @Override
    public boolean isRoaming() {
        return getCurrentState() == mRoamingState;
    }

    @Override
    public boolean isDisconnected() {
        return getCurrentState() == mDisconnectedState;
    }

    /**
     * Method checking if supplicant is in a transient state
     *
     * @return boolean true if in transient state
     */
    public boolean isSupplicantTransientState() {
        SupplicantState supplicantState = mWifiInfo.getSupplicantState();
        if (supplicantState == SupplicantState.ASSOCIATING
                || supplicantState == SupplicantState.AUTHENTICATING
                || supplicantState == SupplicantState.FOUR_WAY_HANDSHAKE
                || supplicantState == SupplicantState.GROUP_HANDSHAKE) {

            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "Supplicant is under transient state: " + supplicantState);
            }
            return true;
        } else {
            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "Supplicant is under steady state: " + supplicantState);
            }
        }

        return false;
    }

    /**
     * Get status information for the current connection, if any.
     * Note: This call is synchronized and hence safe to call from any thread (if called from wifi
     * thread, will execute synchronously).
     *
     * @return a {@link WifiInfo} object containing information about the current connection
     * TODO (b/173551144): Change to direct call. Let callers use WifiThreadRunner if necessary.
     */
    @Override
    public WifiInfo syncRequestConnectionInfo() {
        return mWifiThreadRunner.call(() -> new WifiInfo(mWifiInfo), new WifiInfo());
    }

    /**
     * Blocking call to get the current DHCP results
     *
     * @return DhcpResultsParcelable current results
     */
    @NonNull
    public DhcpResultsParcelable syncGetDhcpResultsParcelable() {
        synchronized (mDhcpResultsParcelableLock) {
            return mDhcpResultsParcelable;
        }
    }

    /**
     * When the underlying interface is destroyed, we must immediately tell connectivity service to
     * mark network agent as disconnected and stop the ip client.
     */
    public void handleIfaceDestroyed() {
        handleNetworkDisconnect(false,
                WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__IFACE_DESTROYED);
    }

    /** Stop this ClientModeImpl. Do not interact with ClientModeImpl after it has been stopped. */
    public void stop() {
        mSupplicantStateTracker.stop();
        mWifiScoreCard.noteWifiDisabled(mWifiInfo);
        // capture StateMachine LogRecs since we will lose them after we call quitNow()
        // This is used for debugging.
        mObituary = new StateMachineObituary(this);

        // quit discarding all unprocessed messages - this is to preserve the legacy behavior of
        // using sendMessageAtFrontOfQueue(CMD_SET_OPERATIONAL_MODE) which would force a state
        // transition immediately
        quitNow();

        mWifiConfigManager.removeOnNetworkUpdateListener(mOnNetworkUpdateListener);
        mWifiCarrierInfoManager
                .removeOnCarrierOffloadDisabledListener(mOnCarrierOffloadDisabledListener);
        if (mVcnPolicyChangeListener != null) {
            mVcnManager.removeVcnNetworkPolicyChangeListener(mVcnPolicyChangeListener);
            mVcnPolicyChangeListener = null;
        }
    }

    private void checkAbnormalConnectionFailureAndTakeBugReport(String ssid) {
        if (mDeviceConfigFacade.isAbnormalConnectionFailureBugreportEnabled()) {
            int reasonCode = mWifiScoreCard.detectAbnormalConnectionFailure(ssid);
            if (reasonCode != WifiHealthMonitor.REASON_NO_FAILURE) {
                String bugTitle = "Wi-Fi BugReport";
                String bugDetail = "Detect abnormal "
                        + WifiHealthMonitor.FAILURE_REASON_NAME[reasonCode];
                mWifiDiagnostics.takeBugReport(bugTitle, bugDetail);
            }
        }
    }

    private void checkAbnormalDisconnectionAndTakeBugReport() {
        if (mDeviceConfigFacade.isAbnormalDisconnectionBugreportEnabled()) {
            int reasonCode = mWifiScoreCard.detectAbnormalDisconnection(mInterfaceName);
            if (reasonCode != WifiHealthMonitor.REASON_NO_FAILURE) {
                String bugTitle = "Wi-Fi BugReport";
                String bugDetail = "Detect abnormal "
                        + WifiHealthMonitor.FAILURE_REASON_NAME[reasonCode];
                mWifiDiagnostics.takeBugReport(bugTitle, bugDetail);
            }
        }
    }

    /**
     * Retrieve the WifiMulticastLockManager.FilterController callback for registration.
     */
    public WifiMulticastLockManager.FilterController getMcastLockManagerFilterController() {
        return mMcastLockManagerFilterController;
    }

    /**
     * Blocking method to retrieve the passpoint icon.
     *
     * @param bssid representation of the bssid as a long
     * @param fileName name of the file
     *
     * @return boolean returning the result of the call
     */
    public boolean syncQueryPasspointIcon(long bssid, String fileName) {
        return mWifiThreadRunner.call(
                () -> mPasspointManager.queryPasspointIcon(bssid, fileName), false);
    }

    @Override
    public boolean requestAnqp(String bssid, Set<Integer> anqpIds, Set<Integer> hs20Subtypes) {
        return mWifiNative.requestAnqp(mInterfaceName, bssid, anqpIds, hs20Subtypes);
    }

    @Override
    public boolean requestVenueUrlAnqp(String bssid) {
        return mWifiNative.requestVenueUrlAnqp(mInterfaceName, bssid);
    }

    @Override
    public boolean requestIcon(String bssid, String fileName) {
        return mWifiNative.requestIcon(mInterfaceName, bssid, fileName);
    }

    /**
     * Disconnect from Access Point
     */
    public void disconnect() {
        sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_GENERIC);
    }

    /**
     * Initiate a reconnection to AP
     */
    public void reconnect(WorkSource workSource) {
        sendMessage(CMD_RECONNECT, workSource);
    }

    /**
     * Initiate a re-association to AP
     */
    public void reassociate() {
        sendMessage(CMD_REASSOCIATE);
    }

    /**
     * Start subscription provisioning synchronously
     *
     * @param provider {@link OsuProvider} the provider to provision with
     * @param callback {@link IProvisioningCallback} callback for provisioning status
     * @return boolean true indicates provisioning was started, false otherwise
     */
    public boolean syncStartSubscriptionProvisioning(int callingUid, OsuProvider provider,
            IProvisioningCallback callback) {
        return mWifiThreadRunner.call(
                () -> mPasspointManager.startSubscriptionProvisioning(
                        callingUid, provider, callback), false);
    }

    /**
     * Get the supported feature set synchronously
     */
    public long getSupportedFeatures() {
        return mWifiNative.getSupportedFeatureSet(mInterfaceName);
    }

    /**
     * Method to enable/disable RSSI polling
     * @param enabled boolean idicating if polling should start
     */
    @VisibleForTesting
    public void enableRssiPolling(boolean enabled) {
        sendMessage(CMD_ENABLE_RSSI_POLL, enabled ? 1 : 0, 0);
    }

    /**
     * reset cached SIM credential data
     */
    public void resetSimAuthNetworks(@ResetSimReason int resetReason) {
        sendMessage(CMD_RESET_SIM_NETWORKS, resetReason);
    }

    /**
     * Should only be used internally.
     * External callers should use {@link #syncGetCurrentNetwork()}.
     */
    private Network getCurrentNetwork() {
        if (mNetworkAgent != null) {
            return mNetworkAgent.getNetwork();
        } else {
            return null;
        }
    }

    /**
     * Get Network object of currently connected wifi network, or null if not connected.
     * @return Network object of current wifi network
     */
    public Network syncGetCurrentNetwork() {
        return mWifiThreadRunner.call(
                () -> {
                    if (getCurrentState() == mL3ConnectedState
                            || getCurrentState() == mRoamingState) {
                        return getCurrentNetwork();
                    }
                    return null;
                }, null);
    }

    /**
     * Enable TDLS for a specific MAC address
     */
    public void enableTdls(String remoteMacAddress, boolean enable) {
        mWifiNative.startTdls(mInterfaceName, remoteMacAddress, enable);
    }

    /** Send a message indicating bluetooth connection state changed, e.g. connected/disconnected */
    public void onBluetoothConnectionStateChanged() {
        sendMessage(CMD_BLUETOOTH_CONNECTION_STATE_CHANGE);
    }

    /**
     * Trigger dump on the class IpClient object.
     */
    public void dumpIpClient(FileDescriptor fd, PrintWriter pw, String[] args) {
        if (mIpClient != null) {
            // All dumpIpClient does is print this log message.
            // TODO: consider deleting this, since it's not useful.
            pw.println("IpClient logs have moved to dumpsys network_stack");
        }
    }

    private static String dhcpResultsParcelableToString(DhcpResultsParcelable dhcpResults) {
        return new StringBuilder()
                .append("baseConfiguration ").append(dhcpResults.baseConfiguration)
                .append("leaseDuration ").append(dhcpResults.leaseDuration)
                .append("mtu ").append(dhcpResults.mtu)
                .append("serverAddress ").append(dhcpResults.serverAddress)
                .append("serverHostName ").append(dhcpResults.serverHostName)
                .append("vendorInfo ").append(dhcpResults.vendorInfo)
                .toString();
    }

    @Override
    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
        pw.println("Dump of ClientModeImpl id=" + mId);
        if (mObituary == null) {
            // StateMachine hasn't quit yet, dump `this` via StateMachineObituary's dump()
            // method for consistency with `else` branch.
            new StateMachineObituary(this).dump(fd, pw, args);
        } else {
            // StateMachine has quit and cleared all LogRecs.
            // Get them from the obituary instead.
            mObituary.dump(fd, pw, args);
        }
        mSupplicantStateTracker.dump(fd, pw, args);
        // Polls link layer stats and RSSI. This allows the stats to show up in
        // WifiScoreReport's dump() output when taking a bug report even if the screen is off.
        updateLinkLayerStatsRssiAndScoreReport();
        pw.println("mLinkProperties " + mLinkProperties);
        pw.println("mWifiInfo " + mWifiInfo);
        pw.println("mDhcpResultsParcelable "
                + dhcpResultsParcelableToString(mDhcpResultsParcelable));
        pw.println("mLastSignalLevel " + mLastSignalLevel);
        pw.println("mLastTxKbps " + mLastTxKbps);
        pw.println("mLastRxKbps " + mLastRxKbps);
        pw.println("mLastBssid " + mLastBssid);
        pw.println("mLastNetworkId " + mLastNetworkId);
        pw.println("mLastSubId " + mLastSubId);
        pw.println("mLastSimBasedConnectionCarrierName " + mLastSimBasedConnectionCarrierName);
        pw.println("mSuspendOptimizationsEnabled " + mContext.getResources().getBoolean(
                R.bool.config_wifiSuspendOptimizationsEnabled));
        pw.println("mSuspendOptNeedsDisabled " + mSuspendOptNeedsDisabled);
        pw.println("mPowerSaveDisableRequests " + mPowerSaveDisableRequests);
        dumpIpClient(fd, pw, args);
        pw.println("WifiScoreReport:");
        mWifiScoreReport.dump(fd, pw, args);
        pw.println("QosPolicyRequestHandler:");
        mQosPolicyRequestHandler.dump(fd, pw, args);
        pw.println();
    }

    /**
     * ******************************************************
     * Internal private functions
     * ******************************************************
     */

    private void logStateAndMessage(Message message, State state) {
        mMessageHandlingStatus = 0;
        if (mVerboseLoggingEnabled) {
            logd(" " + state.getClass().getSimpleName() + " " + getLogRecString(message));
        }
    }

    @Override
    protected boolean recordLogRec(Message msg) {
        switch (msg.what) {
            case CMD_RSSI_POLL:
                return mVerboseLoggingEnabled;
            default:
                return true;
        }
    }

    /**
     * Return the additional string to be logged by LogRec, default
     *
     * @param msg that was processed
     * @return information to be logged as a String
     */
    @Override
    protected String getLogRecString(Message msg) {
        WifiConfiguration config;
        Long now;
        String report;
        String key;
        StringBuilder sb = new StringBuilder();
        sb.append("screen=").append(mScreenOn ? "on" : "off");
        if (mMessageHandlingStatus != MESSAGE_HANDLING_STATUS_UNKNOWN) {
            sb.append("(").append(mMessageHandlingStatus).append(")");
        }
        if (msg.sendingUid > 0 && msg.sendingUid != Process.WIFI_UID) {
            sb.append(" uid=" + msg.sendingUid);
        }
        switch (msg.what) {
            case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                StateChangeResult stateChangeResult = (StateChangeResult) msg.obj;
                if (stateChangeResult != null) {
                    sb.append(stateChangeResult.toString());
                }
                break;
            case CMD_CONNECT_NETWORK:
            case CMD_SAVE_NETWORK: {
                ConnectNetworkMessage cnm = (ConnectNetworkMessage) msg.obj;
                sb.append(" ");
                sb.append(cnm.result.getNetworkId());
                config = mWifiConfigManager.getConfiguredNetwork(cnm.result.getNetworkId());
                if (config != null) {
                    sb.append(" ").append(config.getProfileKey());
                    sb.append(" nid=").append(config.networkId);
                    if (config.hiddenSSID) {
                        sb.append(" hidden");
                    }
                    if (config.preSharedKey != null
                            && !config.preSharedKey.equals("*")) {
                        sb.append(" hasPSK");
                    }
                    if (config.ephemeral) {
                        sb.append(" ephemeral");
                    }
                    sb.append(" cuid=").append(config.creatorUid);
                    sb.append(" suid=").append(config.lastUpdateUid);
                }
                break;
            }
            case WifiMonitor.ASSOCIATION_REJECTION_EVENT:
                if (msg.obj != null) {
                    sb.append(" ").append((AssocRejectEventInfo) msg.obj);
                }
                break;
            case WifiMonitor.NETWORK_CONNECTION_EVENT: {
                NetworkConnectionEventInfo connectionInfo = (NetworkConnectionEventInfo) msg.obj;
                sb.append(" ");
                sb.append(connectionInfo.networkId);
                sb.append(" ");
                sb.append(connectionInfo.isFilsConnection);
                sb.append(" ").append(mLastBssid);
                sb.append(" nid=").append(mLastNetworkId);
                config = getConnectedWifiConfigurationInternal();
                if (config != null) {
                    sb.append(" ").append(config.getProfileKey());
                }
                key = mWifiConfigManager.getLastSelectedNetworkConfigKey();
                if (key != null) {
                    sb.append(" last=").append(key);
                }
                break;
            }
            case WifiMonitor.TARGET_BSSID_EVENT:
            case WifiMonitor.ASSOCIATED_BSSID_EVENT:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                if (msg.obj != null) {
                    sb.append(" BSSID=").append((String) msg.obj);
                }
                if (mTargetBssid != null) {
                    sb.append(" Target=").append(mTargetBssid);
                }
                sb.append(" roam=").append(Boolean.toString(mIsAutoRoaming));
                break;
            case WifiMonitor.NETWORK_DISCONNECTION_EVENT:
                if (msg.obj != null) {
                    sb.append(" ").append((DisconnectEventInfo) msg.obj);
                }
                if (mLastBssid != null) {
                    sb.append(" lastbssid=").append(mLastBssid);
                }
                if (mWifiInfo.getFrequency() != -1) {
                    sb.append(" freq=").append(mWifiInfo.getFrequency());
                    sb.append(" rssi=").append(mWifiInfo.getRssi());
                }
                break;
            case CMD_RSSI_POLL:
            case CMD_ONESHOT_RSSI_POLL:
            case CMD_UNWANTED_NETWORK:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                if (mWifiInfo.getSSID() != null) {
                    if (mWifiInfo.getSSID() != null) {
                        sb.append(" ").append(mWifiInfo.getSSID());
                    }
                }
                if (mWifiInfo.getBSSID() != null) {
                    sb.append(" ").append(mWifiInfo.getBSSID());
                }
                sb.append(" rssi=").append(mWifiInfo.getRssi());
                sb.append(" f=").append(mWifiInfo.getFrequency());
                sb.append(" sc=").append(mWifiInfo.getScore());
                sb.append(" link=").append(mWifiInfo.getLinkSpeed());
                sb.append(" tx=").append(
                        ((int) (mWifiInfo.getSuccessfulTxPacketsPerSecond() * 10)) / 10.0);
                sb.append(", ").append(
                        ((int) (mWifiInfo.getRetriedTxPacketsPerSecond() * 10)) / 10.0);
                sb.append(", ").append(((int) (mWifiInfo.getLostTxPacketsPerSecond() * 10)) / 10.0);
                sb.append(" rx=").append(
                        ((int) (mWifiInfo.getSuccessfulRxPacketsPerSecond() * 10)) / 10.0);
                sb.append(" bcn=" + mRunningBeaconCount);
                report = reportOnTime();
                if (report != null) {
                    sb.append(" ").append(report);
                }
                sb.append(" score=" + mWifiInfo.getScore());
                break;
            case CMD_START_CONNECT:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                config = mWifiConfigManager.getConfiguredNetwork(msg.arg1);
                if (config != null) {
                    sb.append(" targetConfigKey=").append(config.getProfileKey());
                    sb.append(" BSSID=" + config.BSSID);
                }
                if (mTargetBssid != null) {
                    sb.append(" targetBssid=").append(mTargetBssid);
                }
                sb.append(" roam=").append(Boolean.toString(mIsAutoRoaming));
                config = getConnectedWifiConfigurationInternal();
                if (config != null) {
                    sb.append(" currentConfigKey=").append(config.getProfileKey());
                }
                break;
            case CMD_START_ROAM:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                String bssid = (String) msg.obj;
                sb.append(" bssid=").append(bssid);
                if (mTargetBssid != null) {
                    sb.append(" ").append(mTargetBssid);
                }
                sb.append(" roam=").append(Boolean.toString(mIsAutoRoaming));
                sb.append(" fail count=").append(Integer.toString(mRoamFailCount));
                break;
            case CMD_PRE_DHCP_ACTION:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                sb.append(" txpkts=").append(mWifiInfo.txSuccess);
                sb.append(",").append(mWifiInfo.txBad);
                sb.append(",").append(mWifiInfo.txRetries);
                break;
            case CMD_POST_DHCP_ACTION:
                if (mLinkProperties != null) {
                    sb.append(" ");
                    sb.append(getLinkPropertiesSummary(mLinkProperties));
                }
                break;
            case WifiP2pServiceImpl.P2P_CONNECTION_CHANGED:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                if (msg.obj != null) {
                    NetworkInfo info = (NetworkInfo) msg.obj;
                    NetworkInfo.State state = info.getState();
                    NetworkInfo.DetailedState detailedState = info.getDetailedState();
                    if (state != null) {
                        sb.append(" st=").append(state);
                    }
                    if (detailedState != null) {
                        sb.append("/").append(detailedState);
                    }
                }
                break;
            case CMD_IP_CONFIGURATION_LOST:
                int count = -1;
                WifiConfiguration c = getConnectedWifiConfigurationInternal();
                if (c != null) {
                    count = c.getNetworkSelectionStatus().getDisableReasonCounter(
                            WifiConfiguration.NetworkSelectionStatus.DISABLED_DHCP_FAILURE);
                }
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                sb.append(" failures: ");
                sb.append(Integer.toString(count));
                sb.append("/");
                sb.append(Integer.toString(mFacade.getIntegerSetting(
                        mContext, Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT, 0)));
                if (mWifiInfo.getBSSID() != null) {
                    sb.append(" ").append(mWifiInfo.getBSSID());
                }
                sb.append(" bcn=" + mRunningBeaconCount);
                break;
            case CMD_UPDATE_LINKPROPERTIES:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                if (mLinkProperties != null) {
                    sb.append(" ");
                    sb.append(getLinkPropertiesSummary(mLinkProperties));
                }
                break;
            case CMD_IP_REACHABILITY_LOST:
                if (msg.obj != null) {
                    sb.append(" ").append((String) msg.obj);
                }
                break;
            case CMD_IP_REACHABILITY_FAILURE:
                if (msg.obj != null) {
                    sb.append(" ").append(/* ReachabilityLossInfoParcelable */ msg.obj);
                }
                break;
            case CMD_INSTALL_PACKET_FILTER:
                sb.append(" len=" + ((byte[]) msg.obj).length);
                break;
            case CMD_SET_FALLBACK_PACKET_FILTERING:
                sb.append(" enabled=" + (boolean) msg.obj);
                break;
            case CMD_ROAM_WATCHDOG_TIMER:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                sb.append(" cur=").append(mRoamWatchdogCount);
                break;
            case CMD_CONNECTING_WATCHDOG_TIMER:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                sb.append(" cur=").append(mConnectingWatchdogCount);
                break;
            case CMD_START_RSSI_MONITORING_OFFLOAD:
            case CMD_STOP_RSSI_MONITORING_OFFLOAD:
            case CMD_RSSI_THRESHOLD_BREACHED:
                sb.append(" rssi=");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" thresholds=");
                sb.append(Arrays.toString(mRssiRanges));
                break;
            case CMD_IPV4_PROVISIONING_SUCCESS:
                sb.append(" ");
                sb.append(/* DhcpResultsParcelable */ msg.obj);
                break;
            case WifiMonitor.MBO_OCE_BSS_TM_HANDLING_DONE:
                BtmFrameData frameData = (BtmFrameData) msg.obj;
                if (frameData != null) {
                    sb.append(" ").append(frameData.toString());
                }
                break;
            case WifiMonitor.NETWORK_NOT_FOUND_EVENT:
                sb.append(" ssid=" + msg.obj);
                break;
            default:
                sb.append(" ");
                sb.append(Integer.toString(msg.arg1));
                sb.append(" ");
                sb.append(Integer.toString(msg.arg2));
                break;
        }

        return sb.toString();
    }

    @Override
    protected String getWhatToString(int what) {
        switch (what) {
            case CMD_ACCEPT_UNVALIDATED:
                return "CMD_ACCEPT_UNVALIDATED";
            case CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF:
                return "CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF";
            case CMD_BLUETOOTH_CONNECTION_STATE_CHANGE:
                return "CMD_BLUETOOTH_CONNECTION_STATE_CHANGE";
            case CMD_CONFIG_ND_OFFLOAD:
                return "CMD_CONFIG_ND_OFFLOAD";
            case CMD_CONNECTING_WATCHDOG_TIMER:
                return "CMD_CONNECTING_WATCHDOG_TIMER";
            case CMD_CONNECT_NETWORK:
                return "CMD_CONNECT_NETWORK";
            case CMD_DIAGS_CONNECT_TIMEOUT:
                return "CMD_DIAGS_CONNECT_TIMEOUT";
            case CMD_DISCONNECT:
                return "CMD_DISCONNECT";
            case CMD_ENABLE_RSSI_POLL:
                return "CMD_ENABLE_RSSI_POLL";
            case CMD_INSTALL_PACKET_FILTER:
                return "CMD_INSTALL_PACKET_FILTER";
            case CMD_IP_CONFIGURATION_LOST:
                return "CMD_IP_CONFIGURATION_LOST";
            case CMD_IP_CONFIGURATION_SUCCESSFUL:
                return "CMD_IP_CONFIGURATION_SUCCESSFUL";
            case CMD_IP_REACHABILITY_LOST:
                return "CMD_IP_REACHABILITY_LOST";
            case CMD_IP_REACHABILITY_FAILURE:
                return "CMD_IP_REACHABILITY_FAILURE";
            case CMD_IPV4_PROVISIONING_FAILURE:
                return "CMD_IPV4_PROVISIONING_FAILURE";
            case CMD_IPV4_PROVISIONING_SUCCESS:
                return "CMD_IPV4_PROVISIONING_SUCCESS";
            case CMD_NETWORK_STATUS:
                return "CMD_NETWORK_STATUS";
            case CMD_ONESHOT_RSSI_POLL:
                return "CMD_ONESHOT_RSSI_POLL";
            case CMD_POST_DHCP_ACTION:
                return "CMD_POST_DHCP_ACTION";
            case CMD_PRE_DHCP_ACTION:
                return "CMD_PRE_DHCP_ACTION";
            case CMD_PRE_DHCP_ACTION_COMPLETE:
                return "CMD_PRE_DHCP_ACTION_COMPLETE";
            case CMD_READ_PACKET_FILTER:
                return "CMD_READ_PACKET_FILTER";
            case CMD_REASSOCIATE:
                return "CMD_REASSOCIATE";
            case CMD_RECONNECT:
                return "CMD_RECONNECT";
            case CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF:
                return "CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF";
            case CMD_RESET_SIM_NETWORKS:
                return "CMD_RESET_SIM_NETWORKS";
            case CMD_ROAM_WATCHDOG_TIMER:
                return "CMD_ROAM_WATCHDOG_TIMER";
            case CMD_RSSI_POLL:
                return "CMD_RSSI_POLL";
            case CMD_RSSI_THRESHOLD_BREACHED:
                return "CMD_RSSI_THRESHOLD_BREACHED";
            case CMD_SAVE_NETWORK:
                return "CMD_SAVE_NETWORK";
            case CMD_SCREEN_STATE_CHANGED:
                return "CMD_SCREEN_STATE_CHANGED";
            case CMD_SET_FALLBACK_PACKET_FILTERING:
                return "CMD_SET_FALLBACK_PACKET_FILTERING";
            case CMD_SET_SUSPEND_OPT_ENABLED:
                return "CMD_SET_SUSPEND_OPT_ENABLED";
            case CMD_START_CONNECT:
                return "CMD_START_CONNECT";
            case CMD_START_FILS_CONNECTION:
                return "CMD_START_FILS_CONNECTION";
            case CMD_START_IP_PACKET_OFFLOAD:
                return "CMD_START_IP_PACKET_OFFLOAD";
            case CMD_START_ROAM:
                return "CMD_START_ROAM";
            case CMD_START_RSSI_MONITORING_OFFLOAD:
                return "CMD_START_RSSI_MONITORING_OFFLOAD";
            case CMD_STOP_IP_PACKET_OFFLOAD:
                return "CMD_STOP_IP_PACKET_OFFLOAD";
            case CMD_STOP_RSSI_MONITORING_OFFLOAD:
                return "CMD_STOP_RSSI_MONITORING_OFFLOAD";
            case CMD_UNWANTED_NETWORK:
                return "CMD_UNWANTED_NETWORK";
            case CMD_UPDATE_LINKPROPERTIES:
                return "CMD_UPDATE_LINKPROPERTIES";
            case CMD_ACCEPT_EAP_SERVER_CERTIFICATE:
                return "CMD_ACCEPT_EAP_SERVER_CERTIFICATE";
            case CMD_REJECT_EAP_INSECURE_CONNECTION:
                return "CMD_REJECT_EAP_SERVER_CERTIFICATE";
            case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:
                return "SUPPLICANT_STATE_CHANGE_EVENT";
            case WifiMonitor.AUTHENTICATION_FAILURE_EVENT:
                return "AUTHENTICATION_FAILURE_EVENT";
            case WifiMonitor.SUP_REQUEST_IDENTITY:
                return "SUP_REQUEST_IDENTITY";
            case WifiMonitor.NETWORK_CONNECTION_EVENT:
                return "NETWORK_CONNECTION_EVENT";
            case WifiMonitor.NETWORK_DISCONNECTION_EVENT:
                return "NETWORK_DISCONNECTION_EVENT";
            case WifiMonitor.ASSOCIATION_REJECTION_EVENT:
                return "ASSOCIATION_REJECTION_EVENT";
            case WifiMonitor.ANQP_DONE_EVENT:
                return "ANQP_DONE_EVENT";
            case WifiMonitor.RX_HS20_ANQP_ICON_EVENT:
                return "RX_HS20_ANQP_ICON_EVENT";
            case WifiMonitor.GAS_QUERY_DONE_EVENT:
                return "GAS_QUERY_DONE_EVENT";
            case WifiMonitor.HS20_REMEDIATION_EVENT:
                return "HS20_REMEDIATION_EVENT";
            case WifiMonitor.HS20_DEAUTH_IMMINENT_EVENT:
                return "HS20_DEAUTH_IMMINENT_EVENT";
            case WifiMonitor.HS20_TERMS_AND_CONDITIONS_ACCEPTANCE_REQUIRED_EVENT:
                return "HS20_TERMS_AND_CONDITIONS_ACCEPTANCE_REQUIRED_EVENT";
            case WifiMonitor.GAS_QUERY_START_EVENT:
                return "GAS_QUERY_START_EVENT";
            case WifiMonitor.MBO_OCE_BSS_TM_HANDLING_DONE:
                return "MBO_OCE_BSS_TM_HANDLING_DONE";
            case WifiMonitor.TRANSITION_DISABLE_INDICATION:
                return "TRANSITION_DISABLE_INDICATION";
            case WifiP2pServiceImpl.GROUP_CREATING_TIMED_OUT:
                return "GROUP_CREATING_TIMED_OUT";
            case WifiP2pServiceImpl.P2P_CONNECTION_CHANGED:
                return "P2P_CONNECTION_CHANGED";
            case WifiP2pServiceImpl.DISCONNECT_WIFI_REQUEST:
                return "DISCONNECT_WIFI_REQUEST";
            case WifiP2pServiceImpl.DISCONNECT_WIFI_RESPONSE:
                return "DISCONNECT_WIFI_RESPONSE";
            case WifiP2pServiceImpl.SET_MIRACAST_MODE:
                return "SET_MIRACAST_MODE";
            case WifiP2pServiceImpl.BLOCK_DISCOVERY:
                return "BLOCK_DISCOVERY";
            case WifiMonitor.NETWORK_NOT_FOUND_EVENT:
                return "NETWORK_NOT_FOUND_EVENT";
            case WifiMonitor.TOFU_CERTIFICATE_EVENT:
                return "TOFU_CERTIFICATE_EVENT";
            default:
                return "what:" + what;
        }
    }

    /** Check whether this connection is the primary connection on the device. */
    private boolean isPrimary() {
        return mClientModeManager.getRole() == ROLE_CLIENT_PRIMARY;
    }

    /** Check whether this connection is the secondary internet wifi connection. */
    private boolean isSecondaryInternet() {
        return mClientModeManager.getRole() == ROLE_CLIENT_SECONDARY_LONG_LIVED
                && mClientModeManager.isSecondaryInternet();
    }

    /** Check whether this connection is for local only network. */
    private boolean isLocalOnly() {
        return mClientModeManager.getRole() == ROLE_CLIENT_LOCAL_ONLY;
    }

    /**
     * Check if originaly requested as local only for ClientModeManager before fallback.
     * A secondary role could fallback to primary due to hardware support limit.
     * @return true if the original request for ClientModeManager is local only.
     */
    public boolean isRequestedForLocalOnly(WifiConfiguration currentWifiConfiguration,
            String currentBssid) {
        Set<Integer> uids =
                mNetworkFactory.getSpecificNetworkRequestUids(
                        currentWifiConfiguration, currentBssid);
        // Check if there is an active specific request in WifiNetworkFactory for local only.
        return !uids.isEmpty();
    }

    private void handleScreenStateChanged(boolean screenOn) {
        mScreenOn = screenOn;
        if (mVerboseLoggingEnabled) {
            logd(" handleScreenStateChanged Enter: screenOn=" + screenOn
                    + " mSuspendOptimizationsEnabled="
                    + mContext.getResources().getBoolean(
                            R.bool.config_wifiSuspendOptimizationsEnabled)
                    + " state " + getCurrentState().getName());
        }
        if (isPrimary() || isSecondaryInternet()) {
            // Only enable RSSI polling on primary STA, none of the secondary STA use-cases
            // can become the default route when other networks types that provide internet
            // connectivity (e.g. cellular) are available. So, no point in scoring
            // these connections for the purpose of switching between wifi and other network
            // types.
            // TODO(b/179518316): Enable this for secondary transient STA also if external scorer
            // is in charge of MBB.
            enableRssiPolling(screenOn);
        }
        if (mContext.getResources().getBoolean(R.bool.config_wifiSuspendOptimizationsEnabled)) {
            int shouldReleaseWakeLock = 0;
            if (screenOn) {
                sendMessage(CMD_SET_SUSPEND_OPT_ENABLED, 0, shouldReleaseWakeLock);
            } else {
                if (isConnected()) {
                    // Allow 2s for suspend optimizations to be set
                    mSuspendWakeLock.acquire(2000);
                    shouldReleaseWakeLock = 1;
                }
                sendMessage(CMD_SET_SUSPEND_OPT_ENABLED, 1, shouldReleaseWakeLock);
            }
        }

        if (isConnected()) {
            getWifiLinkLayerStats();
        }
        mOnTimeScreenStateChange = mOnTime;
        mLastScreenStateChangeTimeStamp = mLastLinkLayerStatsUpdate;

        if (mVerboseLoggingEnabled) log("handleScreenStateChanged Exit: " + screenOn);
    }

    private void setSuspendOptimizationsNative(int reason, boolean enabled) {
        if (mVerboseLoggingEnabled) {
            log("setSuspendOptimizationsNative: " + reason + " " + enabled
                    + " -want " + mContext.getResources().getBoolean(
                            R.bool.config_wifiSuspendOptimizationsEnabled)
                    + " stack:" + Thread.currentThread().getStackTrace()[2].getMethodName()
                    + " - " + Thread.currentThread().getStackTrace()[3].getMethodName()
                    + " - " + Thread.currentThread().getStackTrace()[4].getMethodName()
                    + " - " + Thread.currentThread().getStackTrace()[5].getMethodName());
        }
        //mWifiNative.setSuspendOptimizations(enabled);

        if (enabled) {
            mSuspendOptNeedsDisabled &= ~reason;
            /* None of dhcp, screen or highperf need it disabled and user wants it enabled */
            if (mSuspendOptNeedsDisabled == 0
                    && mContext.getResources().getBoolean(
                            R.bool.config_wifiSuspendOptimizationsEnabled)) {
                if (mVerboseLoggingEnabled) {
                    log("setSuspendOptimizationsNative do it " + reason + " " + enabled
                            + " stack:" + Thread.currentThread().getStackTrace()[2].getMethodName()
                            + " - " + Thread.currentThread().getStackTrace()[3].getMethodName()
                            + " - " + Thread.currentThread().getStackTrace()[4].getMethodName()
                            + " - " + Thread.currentThread().getStackTrace()[5].getMethodName());
                }
                mWifiNative.setSuspendOptimizations(mInterfaceName, true);
            }
        } else {
            mSuspendOptNeedsDisabled |= reason;
            mWifiNative.setSuspendOptimizations(mInterfaceName, false);
        }
    }

    /**
     * Makes a record of the user intent about suspend optimizations.
     */
    private void setSuspendOptimizations(int reason, boolean enabled) {
        if (mVerboseLoggingEnabled) log("setSuspendOptimizations: " + reason + " " + enabled);
        if (enabled) {
            mSuspendOptNeedsDisabled &= ~reason;
        } else {
            mSuspendOptNeedsDisabled |= reason;
        }
        if (mVerboseLoggingEnabled) log("mSuspendOptNeedsDisabled " + mSuspendOptNeedsDisabled);
    }

    /*
     * Fetch link layer stats, RSSI, linkspeed, and frequency on current connection
     * and update Network capabilities
     */
    private WifiLinkLayerStats updateLinkLayerStatsRssiSpeedFrequencyCapabilities(long txBytes,
            long rxBytes) {
        WifiLinkLayerStats stats = getWifiLinkLayerStats();
        WifiNl80211Manager.SignalPollResult pollResult = mWifiNative.signalPoll(mInterfaceName);
        if (pollResult == null) {
            return stats;
        }

        int newRssi = pollResult.currentRssiDbm;
        int newTxLinkSpeed = pollResult.txBitrateMbps;
        int newFrequency = pollResult.associationFrequencyMHz;
        int newRxLinkSpeed = pollResult.rxBitrateMbps;

        if (mVerboseLoggingEnabled) {
            logd("updateLinkLayerStatsRssiSpeedFrequencyCapabilities rssi=" + newRssi
                    + " TxLinkspeed=" + newTxLinkSpeed + " freq=" + newFrequency
                    + " RxLinkSpeed=" + newRxLinkSpeed);
        }

        /*
         * set Tx link speed only if it is valid
         */
        if (newTxLinkSpeed > 0) {
            mWifiInfo.setLinkSpeed(newTxLinkSpeed);
            mWifiInfo.setTxLinkSpeedMbps(newTxLinkSpeed);
        }
        /*
         * set Rx link speed only if it is valid
         */
        if (newRxLinkSpeed > 0) {
            mWifiInfo.setRxLinkSpeedMbps(newRxLinkSpeed);
        }
        if (newFrequency > 0) {
            mWifiInfo.setFrequency(newFrequency);
        }
        // updateLinkBandwidth() requires the latest frequency information
        if (newRssi > WifiInfo.INVALID_RSSI && newRssi < WifiInfo.MAX_RSSI) {
            /*
             * Positive RSSI is possible when devices are close(~0m apart) to each other.
             * And there are some driver/firmware implementation, where they avoid
             * reporting large negative rssi values by adding 256.
             * so adjust the valid rssi reports for such implementations.
             */
            if (newRssi > (WifiInfo.INVALID_RSSI + 256)) {
                Log.wtf(getTag(), "Error! +ve value RSSI: " + newRssi);
                newRssi -= 256;
            }
            mWifiInfo.setRssi(newRssi);
            /*
             * Rather then sending the raw RSSI out every time it
             * changes, we precalculate the signal level that would
             * be displayed in the status bar, and only send the
             * broadcast if that much more coarse-grained number
             * changes. This cuts down greatly on the number of
             * broadcasts, at the cost of not informing others
             * interested in RSSI of all the changes in signal
             * level.
             */
            int newSignalLevel = RssiUtil.calculateSignalLevel(mContext, newRssi);
            if (newSignalLevel != mLastSignalLevel) {
                // TODO (b/162602799): Do we need to change the update frequency?
                sendRssiChangeBroadcast(newRssi);
            }
            updateLinkBandwidthAndCapabilities(stats, newSignalLevel != mLastSignalLevel, txBytes,
                    rxBytes);
            mLastSignalLevel = newSignalLevel;
        } else {
            mWifiInfo.setRssi(WifiInfo.INVALID_RSSI);
            updateCapabilities();
            mLastSignalLevel = -1;
        }
        mWifiConfigManager.updateScanDetailCacheFromWifiInfo(mWifiInfo);
        /*
         * Increment various performance metrics
         */
        mWifiMetrics.handlePollResult(mInterfaceName, mWifiInfo);
        return stats;
    }

    // Update the link bandwidth. If the link bandwidth changes by a large amount or signal level
    // changes, also update network capabilities.
    private void updateLinkBandwidthAndCapabilities(WifiLinkLayerStats stats,
            boolean hasSignalLevelChanged, long txBytes, long rxBytes) {
        WifiScoreCard.PerNetwork network = mWifiScoreCard.lookupNetwork(mWifiInfo.getSSID());
        network.updateLinkBandwidth(mLastLinkLayerStats, stats, mWifiInfo, txBytes, rxBytes);
        int newTxKbps = network.getTxLinkBandwidthKbps();
        int newRxKbps = network.getRxLinkBandwidthKbps();
        int txDeltaKbps = Math.abs(newTxKbps - mLastTxKbps);
        int rxDeltaKbps = Math.abs(newRxKbps - mLastRxKbps);
        int bwUpdateThresholdPercent = mContext.getResources().getInteger(
                R.integer.config_wifiLinkBandwidthUpdateThresholdPercent);
        if ((txDeltaKbps * 100  >  bwUpdateThresholdPercent * mLastTxKbps)
                || (rxDeltaKbps * 100  >  bwUpdateThresholdPercent * mLastRxKbps)
                || hasSignalLevelChanged) {
            mLastTxKbps = newTxKbps;
            mLastRxKbps = newRxKbps;
            updateCapabilities();
        }

        int l2TxKbps = mWifiDataStall.getTxThroughputKbps();
        int l2RxKbps = mWifiDataStall.getRxThroughputKbps();
        if (l2RxKbps < 0 && l2TxKbps > 0) {
            l2RxKbps = l2TxKbps;
        }
        int [] reportedKbps = {mLastTxKbps, mLastRxKbps};
        int [] l2Kbps = {l2TxKbps, l2RxKbps};
        network.updateBwMetrics(reportedKbps, l2Kbps);
    }

    // Polling has completed, hence we won't have a score anymore
    private void cleanWifiScore() {
        mWifiInfo.setLostTxPacketsPerSecond(0);
        mWifiInfo.setSuccessfulTxPacketsPerSecond(0);
        mWifiInfo.setRetriedTxPacketsRate(0);
        mWifiInfo.setSuccessfulRxPacketsPerSecond(0);
        mWifiScoreReport.reset();
        mLastLinkLayerStats = null;
    }

    private void updateLinkProperties(LinkProperties newLp) {
        if (mVerboseLoggingEnabled) {
            log("Link configuration changed for netId: " + mLastNetworkId
                    + " old: " + mLinkProperties + " new: " + newLp);
        }
        // We own this instance of LinkProperties because IpClient passes us a copy.
        mLinkProperties = newLp;

        if (mNetworkAgent != null) {
            mNetworkAgent.sendLinkProperties(mLinkProperties);
        }

        if (mNetworkAgentState == DetailedState.CONNECTED) {
            // If anything has changed and we're already connected, send out a notification.
            // TODO: Update all callers to use NetworkCallbacks and delete this.
            sendLinkConfigurationChangedBroadcast();
        }

        if (mVerboseLoggingEnabled) {
            StringBuilder sb = new StringBuilder();
            sb.append("updateLinkProperties nid: " + mLastNetworkId);
            sb.append(" state: " + mNetworkAgentState);

            if (mLinkProperties != null) {
                sb.append(" ");
                sb.append(getLinkPropertiesSummary(mLinkProperties));
            }
            logd(sb.toString());
        }
    }

    /**
     * Clears all our link properties.
     */
    private void clearLinkProperties() {
        // Clear the link properties obtained from DHCP. The only caller of this
        // function has already called IpClient#stop(), which clears its state.
        synchronized (mDhcpResultsParcelableLock) {
            mDhcpResultsParcelable = new DhcpResultsParcelable();
        }

        // Now clear the merged link properties.
        mLinkProperties.clear();
        if (mNetworkAgent != null) mNetworkAgent.sendLinkProperties(mLinkProperties);
    }

    private void sendRssiChangeBroadcast(final int newRssi) {
        mBatteryStatsManager.reportWifiRssiChanged(newRssi);
        WifiStatsLog.write(WifiStatsLog.WIFI_SIGNAL_STRENGTH_CHANGED,
                RssiUtil.calculateSignalLevel(mContext, newRssi));

        Intent intent = new Intent(WifiManager.RSSI_CHANGED_ACTION);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        intent.putExtra(WifiManager.EXTRA_NEW_RSSI, newRssi);
        mBroadcastQueue.queueOrSendBroadcast(
                mClientModeManager,
                () -> mContext.sendBroadcastAsUser(intent, UserHandle.ALL,
                        android.Manifest.permission.ACCESS_WIFI_STATE));
    }

    private void sendLinkConfigurationChangedBroadcast() {
        Intent intent = new Intent(WifiManager.ACTION_LINK_CONFIGURATION_CHANGED);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        String summary = "broadcast=ACTION_LINK_CONFIGURATION_CHANGED";
        if (mVerboseLoggingEnabled) Log.d(getTag(), "Queuing " + summary);
        mBroadcastQueue.queueOrSendBroadcast(
                mClientModeManager,
                () -> {
                    if (mVerboseLoggingEnabled) Log.d(getTag(), "Sending " + summary);
                    mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
                });
    }

    /**
     * Helper method used to send state about supplicant - This is NOT information about the current
     * wifi connection state.
     *
     * TODO: b/79504296 This broadcast has been deprecated and should be removed
     */
    private void sendSupplicantConnectionChangedBroadcast(boolean connected) {
        Intent intent = new Intent(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        intent.putExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, connected);
        String summary = "broadcast=SUPPLICANT_CONNECTION_CHANGE_ACTION"
                + " EXTRA_SUPPLICANT_CONNECTED=" + connected;
        if (mVerboseLoggingEnabled) Log.d(getTag(), "Queuing " + summary);
        mBroadcastQueue.queueOrSendBroadcast(
                mClientModeManager,
                () -> {
                    if (mVerboseLoggingEnabled) Log.d(getTag(), "Sending " + summary);
                    mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
                });
    }

    /**
     * Record the detailed state of a network.
     *
     * @param state the new {@code DetailedState}
     */
    private void sendNetworkChangeBroadcast(NetworkInfo.DetailedState state) {
        boolean hidden = false;

        if (mIsAutoRoaming) {
            // There is generally a confusion in the system about colluding
            // WiFi Layer 2 state (as reported by supplicant) and the Network state
            // which leads to multiple confusion.
            //
            // If link is roaming, we already have an IP address
            // as well we were connected and are doing L2 cycles of
            // reconnecting or renewing IP address to check that we still have it
            // This L2 link flapping should not be reflected into the Network state
            // which is the state of the WiFi Network visible to Layer 3 and applications
            // Note that once roaming is completed, we will
            // set the Network state to where it should be, or leave it as unchanged
            //
            hidden = true;
        }
        if (mVerboseLoggingEnabled) {
            log("sendNetworkChangeBroadcast"
                    + " oldState=" + mNetworkAgentState
                    + " newState=" + state
                    + " hidden=" + hidden);
        }
        if (hidden || state == mNetworkAgentState) return;
        mNetworkAgentState = state;
        sendNetworkChangeBroadcastWithCurrentState();
    }

    private void sendNetworkChangeBroadcastWithCurrentState() {
        // copy into local variables to force lambda to capture by value and not reference, since
        // mNetworkAgentState is mutable and can change
        final DetailedState networkAgentState = mNetworkAgentState;
        if (mVerboseLoggingEnabled) {
            Log.d(getTag(), "Queueing broadcast=NETWORK_STATE_CHANGED_ACTION"
                    + " networkAgentState=" + networkAgentState);
        }
        mBroadcastQueue.queueOrSendBroadcast(
                mClientModeManager,
                () -> sendNetworkChangeBroadcast(
                        mContext, networkAgentState, mVerboseLoggingEnabled));
    }

    /** Send a NETWORK_STATE_CHANGED_ACTION broadcast. */
    public static void sendNetworkChangeBroadcast(
            Context context, DetailedState networkAgentState, boolean verboseLoggingEnabled) {
        Intent intent = new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
        NetworkInfo networkInfo = makeNetworkInfo(networkAgentState);
        intent.putExtra(WifiManager.EXTRA_NETWORK_INFO, networkInfo);
        if (verboseLoggingEnabled) {
            Log.d(TAG, "Sending broadcast=NETWORK_STATE_CHANGED_ACTION"
                    + " networkAgentState=" + networkAgentState);
        }
        //TODO(b/69974497) This should be non-sticky, but settings needs fixing first.
        context.sendStickyBroadcastAsUser(intent, UserHandle.ALL);
    }

    private static NetworkInfo makeNetworkInfo(DetailedState networkAgentState) {
        final NetworkInfo ni = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, NETWORKTYPE, "");
        ni.setDetailedState(networkAgentState, null, null);
        return ni;
    }

    private List<ScanResult.InformationElement> findMatchingInfoElements(@Nullable String bssid) {
        if (bssid == null) return null;
        ScanResult matchingScanResult = mScanRequestProxy.getScanResult(bssid);
        if (matchingScanResult == null || matchingScanResult.informationElements == null) {
            return null;
        }
        return Arrays.asList(matchingScanResult.informationElements);
    }

    private void setMultiLinkInfo(@Nullable String bssid) {
        if (bssid == null) return;
        ScanResult matchingScanResult = mScanRequestProxy.getScanResult(bssid);
        if (matchingScanResult == null) return;
        if (matchingScanResult.getApMldMacAddress() != null) {
            mWifiInfo.setApMldMacAddress(matchingScanResult.getApMldMacAddress());
            mWifiInfo.setApMloLinkId(matchingScanResult.getApMloLinkId());
            mWifiInfo.setAffiliatedMloLinks(matchingScanResult.getAffiliatedMloLinks());
        } else {
            mWifiInfo.setApMldMacAddress(null);
            mWifiInfo.setApMloLinkId(MloLink.INVALID_MLO_LINK_ID);
            mWifiInfo.setAffiliatedMloLinks(Collections.emptyList());
        }
    }

    private SupplicantState handleSupplicantStateChange(StateChangeResult stateChangeResult) {
        SupplicantState state = stateChangeResult.state;
        mWifiScoreCard.noteSupplicantStateChanging(mWifiInfo, state);
        // Supplicant state change
        // [31-13] Reserved for future use
        // [8 - 0] Supplicant state (as defined in SupplicantState.java)
        // 50023 supplicant_state_changed (custom|1|5)
        mWifiInfo.setSupplicantState(state);
        // Network id and SSID are only valid when we start connecting
        if (SupplicantState.isConnecting(state)) {
            mWifiInfo.setNetworkId(stateChangeResult.networkId);
            mWifiInfo.setBSSID(stateChangeResult.bssid);
            mWifiInfo.setSSID(stateChangeResult.wifiSsid);
            setMultiLinkInfo(stateChangeResult.bssid);
            if (state == SupplicantState.ASSOCIATED) {
                updateWifiInfoLinkParamsAfterAssociation();
            }
            mWifiInfo.setInformationElements(findMatchingInfoElements(stateChangeResult.bssid));
        } else {
            // Reset parameters according to WifiInfo.reset()
            mWifiInfo.setNetworkId(WifiConfiguration.INVALID_NETWORK_ID);
            mWifiInfo.setBSSID(null);
            mWifiInfo.setSSID(null);
            mWifiInfo.setWifiStandard(ScanResult.WIFI_STANDARD_UNKNOWN);
            mWifiInfo.setInformationElements(null);
            mWifiInfo.clearCurrentSecurityType();
            mWifiInfo.resetMultiLinkInfo();
        }
        updateLayer2Information();
        // SSID might have been updated, so call updateCapabilities
        updateCapabilities();

        WifiConfiguration config = getConnectedWifiConfigurationInternal();
        if (config == null) {
            // If not connected, this should be non-null.
            config = getConnectingWifiConfigurationInternal();
        }
        if (config != null && config.networkId == mWifiInfo.getNetworkId()) {
            updateWifiInfoWhenConnected(config);

            // Set meteredHint if scan result says network is expensive
            ScanDetailCache scanDetailCache = mWifiConfigManager.getScanDetailCacheForNetwork(
                    config.networkId);
            if (scanDetailCache != null) {
                ScanDetail scanDetail = scanDetailCache.getScanDetail(stateChangeResult.bssid);
                if (scanDetail != null) {
                    mWifiInfo.setFrequency(scanDetail.getScanResult().frequency);
                    NetworkDetail networkDetail = scanDetail.getNetworkDetail();
                    if (networkDetail != null
                            && networkDetail.getAnt() == NetworkDetail.Ant.ChargeablePublic) {
                        mWifiInfo.setMeteredHint(true);
                    }
                }
            }
        }
        mWifiScoreCard.noteSupplicantStateChanged(mWifiInfo);
        return state;
    }

    private void updateWifiInfoWhenConnected(@NonNull WifiConfiguration config) {
        mWifiInfo.setEphemeral(config.ephemeral);
        mWifiInfo.setTrusted(config.trusted);
        mWifiInfo.setOemPaid(config.oemPaid);
        mWifiInfo.setOemPrivate(config.oemPrivate);
        mWifiInfo.setCarrierMerged(config.carrierMerged);
        mWifiInfo.setSubscriptionId(config.subscriptionId);
        mWifiInfo.setOsuAp(config.osu);
        mWifiInfo.setRestricted(config.restricted);
        if (config.fromWifiNetworkSpecifier || config.fromWifiNetworkSuggestion) {
            mWifiInfo.setRequestingPackageName(config.creatorName);
        }
        mWifiInfo.setIsPrimary(isPrimary());
        SecurityParams securityParams = config.getNetworkSelectionStatus()
                .getLastUsedSecurityParams();
        if (securityParams != null) {
            mWifiInfo.setCurrentSecurityType(securityParams.getSecurityType());
        } else {
            mWifiInfo.clearCurrentSecurityType();
            Log.e(TAG, "Network connection candidate with no security parameters");
        }
    }

    private void updateWifiInfoLinkParamsAfterAssociation() {
        mLastConnectionCapabilities = mWifiNative.getConnectionCapabilities(mInterfaceName);
        int maxTxLinkSpeedMbps = mThroughputPredictor.predictMaxTxThroughput(
                mLastConnectionCapabilities);
        int maxRxLinkSpeedMbps = mThroughputPredictor.predictMaxRxThroughput(
                mLastConnectionCapabilities);
        mWifiInfo.setWifiStandard(mLastConnectionCapabilities.wifiStandard);
        mWifiInfo.setMaxSupportedTxLinkSpeedMbps(maxTxLinkSpeedMbps);
        mWifiInfo.setMaxSupportedRxLinkSpeedMbps(maxRxLinkSpeedMbps);
        mWifiMetrics.setConnectionMaxSupportedLinkSpeedMbps(mInterfaceName,
                maxTxLinkSpeedMbps, maxRxLinkSpeedMbps);
        if (mLastConnectionCapabilities.wifiStandard == ScanResult.WIFI_STANDARD_11BE) {
            WifiNative.ConnectionMloLinksInfo info =
                    mWifiNative.getConnectionMloLinksInfo(mInterfaceName);
            if (info != null) {
                for (int i = 0; i < info.links.length; i++) {
                    mWifiInfo.updateMloLinkStaAddress(info.links[i].linkId,
                            info.links[i].staMacAddress);
                    mWifiInfo.updateMloLinkState(
                            info.links[i].linkId, MloLink.MLO_LINK_STATE_ACTIVE);
                }
            }
        }
        if (mVerboseLoggingEnabled) {
            StringBuilder sb = new StringBuilder();
            logd(sb.append("WifiStandard: ").append(mLastConnectionCapabilities.wifiStandard)
                    .append(" maxTxSpeed: ").append(maxTxLinkSpeedMbps)
                    .append(" maxRxSpeed: ").append(maxRxLinkSpeedMbps)
                    .toString());
        }
    }

    /**
     * Tells IpClient what BSSID, L2Key and GroupHint to use for IpMemoryStore.
     */
    private void updateLayer2Information() {
        if (mIpClient != null) {
            Pair<String, String> p = mWifiScoreCard.getL2KeyAndGroupHint(mWifiInfo);
            if (!p.equals(mLastL2KeyAndGroupHint)) {
                final MacAddress currentBssid = getMacAddressFromBssidString(mWifiInfo.getBSSID());
                final Layer2Information l2Information = new Layer2Information(
                        p.first, p.second, currentBssid);
                // Update current BSSID on IpClient side whenever l2Key and groupHint
                // pair changes (i.e. the initial connection establishment or L2 roaming
                // happened). If we have COMPLETED the roaming to a different BSSID, start
                // doing DNAv4/DNAv6 -style probing for on-link neighbors of interest (e.g.
                // routers/DNS servers/default gateway).
                if (mIpClient.updateLayer2Information(l2Information)) {
                    mLastL2KeyAndGroupHint = p;
                } else {
                    mLastL2KeyAndGroupHint = null;
                }
            }
        }
    }
    private @Nullable Pair<String, String> mLastL2KeyAndGroupHint = null;

    /**
     * Resets the Wi-Fi Connections by clearing any state, resetting any sockets
     * using the interface, stopping DHCP & disabling interface
     *
     * @param disconnectReason must be one of WifiDisconnectReported.FailureReason values
     *                         defined in /frameworks/proto_logging/stats/atoms.proto
     */
    private void handleNetworkDisconnect(boolean newConnectionInProgress, int disconnectReason) {
        mWifiMetrics.reportNetworkDisconnect(mInterfaceName, disconnectReason,
                mWifiInfo.getRssi(),
                mWifiInfo.getLinkSpeed());

        if (mVerboseLoggingEnabled) {
            Log.v(getTag(), "handleNetworkDisconnect: newConnectionInProgress: "
                    + newConnectionInProgress, new Throwable());
        }

        WifiConfiguration wifiConfig = getConnectedWifiConfigurationInternal();
        if (wifiConfig != null) {
            ScanResultMatchInfo matchInfo = ScanResultMatchInfo.fromWifiConfiguration(wifiConfig);
            // WakeupController should only care about the primary, internet providing network
            if (isPrimary()) {
                mWakeupController.setLastDisconnectInfo(matchInfo);
            }
        }
        stopRssiMonitoringOffload();

        clearTargetBssid("handleNetworkDisconnect");

        // Don't stop DHCP if Fils connection is in progress.
        if (newConnectionInProgress && mIpClientWithPreConnection) {
            if (mVerboseLoggingEnabled) {
                log("handleNetworkDisconnect: Don't stop IpClient as fils connection in progress: "
                        + " mLastNetworkId: " + mLastNetworkId
                        + " mTargetNetworkId" + mTargetNetworkId);
            }
        } else {
            stopDhcpSetup();
        }

        // DISASSOC_AP_BUSY could be received in both after L3 connection is successful or right
        // after BSSID association if the AP can't accept more stations.
        if (disconnectReason == StaIfaceReasonCode.DISASSOC_AP_BUSY) {
            mWifiConfigManager.setRecentFailureAssociationStatus(
                    mWifiInfo.getNetworkId(),
                    WifiConfiguration.RECENT_FAILURE_DISCONNECTION_AP_BUSY);
        }

        mWifiScoreReport.stopConnectedNetworkScorer();
        /* Reset data structures */
        mWifiScoreReport.reset();
        mWifiInfo.reset();
        /* Reset roaming parameters */
        mIsAutoRoaming = false;

        sendNetworkChangeBroadcast(DetailedState.DISCONNECTED);
        if (mNetworkAgent != null) {
            mNetworkAgent.unregister();
            mNetworkAgent = null;
            mQosPolicyRequestHandler.setNetworkAgent(null);
        }

        /* Clear network properties */
        clearLinkProperties();

        mLastBssid = null;
        mLastLinkLayerStats = null;
        registerDisconnected();
        mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
        mLastSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
        mCurrentConnectionDetectedCaptivePortal = false;
        mLastSimBasedConnectionCarrierName = null;
        checkAbnormalDisconnectionAndTakeBugReport();
        mWifiScoreCard.resetConnectionState(mInterfaceName);
        updateLayer2Information();
        // If there is new connection in progress, this is for the new connection, so keept it.
        if (!newConnectionInProgress) {
            mIsUserSelected = false;
        }
    }

    void handlePreDhcpSetup() {
        if (!mWifiGlobals.isBluetoothConnected()) {
            /*
             * There are problems setting the Wi-Fi driver's power
             * mode to active when bluetooth coexistence mode is
             * enabled or sense.
             * <p>
             * We set Wi-Fi to active mode when
             * obtaining an IP address because we've found
             * compatibility issues with some routers with low power
             * mode.
             * <p>
             * In order for this active power mode to properly be set,
             * we disable coexistence mode until we're done with
             * obtaining an IP address.  One exception is if we
             * are currently connected to a headset, since disabling
             * coexistence would interrupt that connection.
             */
            // Disable the coexistence mode
            mWifiNative.setBluetoothCoexistenceMode(
                    mInterfaceName, WifiNative.BLUETOOTH_COEXISTENCE_MODE_DISABLED);
        }

        // Disable power save and suspend optimizations during DHCP
        // Note: The order here is important for now. Brcm driver changes
        // power settings when we control suspend mode optimizations.
        // TODO: Remove this comment when the driver is fixed.
        setSuspendOptimizationsNative(SUSPEND_DUE_TO_DHCP, false);
        setPowerSave(POWER_SAVE_CLIENT_DHCP, false);

        // Update link layer stats
        getWifiLinkLayerStats();

        if (mWifiP2pConnection.isConnected()) {
            // P2P discovery breaks DHCP, so shut it down in order to get through this.
            // Once P2P service receives this message and processes it accordingly, it is supposed
            // to send arg2 (i.e. CMD_PRE_DHCP_ACTION_COMPLETE) in a new Message.what back to
            // ClientModeImpl so that we can continue.
            // TODO(b/159060934): Need to ensure that CMD_PRE_DHCP_ACTION_COMPLETE is sent back to
            //  the ClientModeImpl instance that originally sent it. Right now it is sent back to
            //  all ClientModeImpl instances by WifiP2pConnection.
            mWifiP2pConnection.sendMessage(
                    WifiP2pServiceImpl.BLOCK_DISCOVERY,
                    WifiP2pServiceImpl.ENABLED,
                    CMD_PRE_DHCP_ACTION_COMPLETE);
        } else {
            // If the p2p service is not running, we can proceed directly.
            sendMessage(CMD_PRE_DHCP_ACTION_COMPLETE);
        }
    }

    void addLayer2PacketsToHlpReq(List<Layer2PacketParcelable> packets) {
        List<Layer2PacketParcelable> mLayer2Packet = packets;
        if ((mLayer2Packet != null) && (mLayer2Packet.size() > 0)) {
            mWifiNative.flushAllHlp(mInterfaceName);

            for (int j = 0; j < mLayer2Packet.size(); j++) {
                byte [] bytes = mLayer2Packet.get(j).payload;
                byte [] payloadBytes = Arrays.copyOfRange(bytes, 12, bytes.length);
                MacAddress dstAddress = mLayer2Packet.get(j).dstMacAddress;

                mWifiNative.addHlpReq(mInterfaceName, dstAddress, payloadBytes);
            }
        }
    }

    void handlePostDhcpSetup() {
        /* Restore power save and suspend optimizations */
        setSuspendOptimizationsNative(SUSPEND_DUE_TO_DHCP, true);
        setPowerSave(POWER_SAVE_CLIENT_DHCP, true);

        mWifiP2pConnection.sendMessage(
                WifiP2pServiceImpl.BLOCK_DISCOVERY, WifiP2pServiceImpl.DISABLED);

        // Set the coexistence mode back to its default value
        mWifiNative.setBluetoothCoexistenceMode(
                mInterfaceName, WifiNative.BLUETOOTH_COEXISTENCE_MODE_SENSE);
    }

    /**
     * Set power save mode
     *
     * @param ps true to enable power save (default behavior)
     *           false to disable power save.
     * @return true for success, false for failure
     */
    public boolean setPowerSave(@PowerSaveClientType int client, boolean ps) {
        if (mInterfaceName != null) {
            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "Request to set power save for: " + mInterfaceName + " to: " + ps
                        + " requested by: " + client + ", mPowerSaveDisableRequests = "
                        + mPowerSaveDisableRequests);
            }
            if (ps) {
                mPowerSaveDisableRequests &= ~client;
            } else {
                mPowerSaveDisableRequests |= client;
            }
            boolean actualPs = mPowerSaveDisableRequests == 0;
            if (mVerboseLoggingEnabled) {
                Log.d(getTag(), "Setting power save to: " + actualPs
                        + ", mPowerSaveDisableRequests = " + mPowerSaveDisableRequests);
            }

            mWifiNative.setPowerSave(mInterfaceName, actualPs);
        } else {
            Log.e(getTag(), "Failed to setPowerSave, interfaceName is null");
            return false;
        }
        return true;
    }

    /**
     * Enable power save.
     *
     * @return true for success, false for failure.
     */
    public boolean enablePowerSave() {
        return setPowerSave(~0, true);
    }

    /**
     * Set low latency mode
     *
     * @param enabled true to enable low latency
     *                false to disable low latency (default behavior).
     * @return true for success, false for failure
     */
    public boolean setLowLatencyMode(boolean enabled) {
        if (mVerboseLoggingEnabled) {
            Log.d(getTag(), "Setting low latency mode to " + enabled);
        }
        if (!mWifiNative.setLowLatencyMode(enabled)) {
            Log.e(getTag(), "Failed to setLowLatencyMode");
            return false;
        }
        return true;
    }

    @VisibleForTesting
    public static final long DIAGS_CONNECT_TIMEOUT_MILLIS = 60 * 1000;
    /**
     * Inform other components that a new connection attempt is starting.
     */
    private void reportConnectionAttemptStart(
            WifiConfiguration config, String targetBSSID, int roamType) {
        int overlapWithLastConnectionMs =
                mWifiMetrics.startConnectionEvent(mInterfaceName, config, targetBSSID, roamType);
        if (mDeviceConfigFacade.isOverlappingConnectionBugreportEnabled()
                && overlapWithLastConnectionMs
                > mDeviceConfigFacade.getOverlappingConnectionDurationThresholdMs()) {
            String bugTitle = "Wi-Fi BugReport";
            String bugDetail = "Detect abnormal overlapping connection";
            mWifiDiagnostics.takeBugReport(bugTitle, bugDetail);
        }
        mWifiDiagnostics.reportConnectionEvent(WifiDiagnostics.CONNECTION_EVENT_STARTED,
                mClientModeManager);
        if (isPrimary()) {
            mWrongPasswordNotifier.onNewConnectionAttempt();
        }
        removeMessages(CMD_DIAGS_CONNECT_TIMEOUT);
        sendMessageDelayed(CMD_DIAGS_CONNECT_TIMEOUT, DIAGS_CONNECT_TIMEOUT_MILLIS);
    }

    private void handleConnectionAttemptEndForDiagnostics(int level2FailureCode) {
        switch (level2FailureCode) {
            case WifiMetrics.ConnectionEvent.FAILURE_NONE:
                break;
            case WifiMetrics.ConnectionEvent.FAILURE_CONNECT_NETWORK_FAILED:
                // WifiDiagnostics doesn't care about pre-empted connections, or cases
                // where we failed to initiate a connection attempt with supplicant.
                break;
            default:
                removeMessages(CMD_DIAGS_CONNECT_TIMEOUT);
                mWifiDiagnostics.reportConnectionEvent(WifiDiagnostics.CONNECTION_EVENT_FAILED,
                        mClientModeManager);
        }
    }

    /**
     * Inform other components (WifiMetrics, WifiDiagnostics, WifiConnectivityManager, etc.) that
     * the current connection attempt has concluded.
     */
    private void reportConnectionAttemptEnd(int level2FailureCode, int connectivityFailureCode,
            int level2FailureReason) {
        // if connected, this should be non-null.
        WifiConfiguration configuration = getConnectedWifiConfigurationInternal();
        if (configuration == null) {
            // If not connected, this should be non-null.
            configuration = getConnectingWifiConfigurationInternal();
        }

        String bssid = mLastBssid == null ? mTargetBssid : mLastBssid;
        String ssid = mWifiInfo.getSSID();
        if (WifiManager.UNKNOWN_SSID.equals(ssid)) {
            ssid = getConnectingSsidInternal();
        }
        if (level2FailureCode != WifiMetrics.ConnectionEvent.FAILURE_NONE) {
            int blocklistReason = convertToWifiBlocklistMonitorFailureReason(
                    level2FailureCode, level2FailureReason);
            if (blocklistReason != -1) {
                mWifiScoreCard.noteConnectionFailure(mWifiInfo, mLastScanRssi, ssid,
                        blocklistReason);
                checkAbnormalConnectionFailureAndTakeBugReport(ssid);
                mWifiBlocklistMonitor.handleBssidConnectionFailure(bssid, configuration,
                        blocklistReason, mLastScanRssi);
                WifiScoreCard.NetworkConnectionStats recentStats = mWifiScoreCard.lookupNetwork(
                        ssid).getRecentStats();
                if (recentStats.getCount(WifiScoreCard.CNT_CONSECUTIVE_CONNECTION_FAILURE)
                        >= WifiBlocklistMonitor.NUM_CONSECUTIVE_FAILURES_PER_NETWORK_EXP_BACKOFF
                        && configuration.getNetworkSelectionStatus().isNetworkEnabled()) {
                    mWifiConfigManager.updateNetworkSelectionStatus(mTargetNetworkId,
                            WifiConfiguration.NetworkSelectionStatus.DISABLED_CONSECUTIVE_FAILURES);
                }
                if (recentStats.getCount(WifiScoreCard.CNT_CONSECUTIVE_WRONG_PASSWORD_FAILURE)
                        >= THRESHOLD_TO_PERM_WRONG_PASSWORD) {
                    mWifiConfigManager.updateNetworkSelectionStatus(mTargetNetworkId,
                            WifiConfiguration.NetworkSelectionStatus.DISABLED_BY_WRONG_PASSWORD);
                }
            }
        }

        if (configuration != null
                && configuration.carrierId != TelephonyManager.UNKNOWN_CARRIER_ID) {
            if (level2FailureCode == WifiMetrics.ConnectionEvent.FAILURE_NONE) {
                mWifiMetrics.incrementNumOfCarrierWifiConnectionSuccess();
            } else if (level2FailureCode
                            == WifiMetrics.ConnectionEvent.FAILURE_AUTHENTICATION_FAILURE
                    && level2FailureReason
                            != WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_NONE) {
                mWifiMetrics.incrementNumOfCarrierWifiConnectionAuthFailure();
            } else {
                mWifiMetrics.incrementNumOfCarrierWifiConnectionNonAuthFailure();
            }
        }

        boolean isAssociationRejection = level2FailureCode
                == WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_REJECTION;
        boolean isAuthenticationFailure = level2FailureCode
                == WifiMetrics.ConnectionEvent.FAILURE_AUTHENTICATION_FAILURE
                && level2FailureReason != WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_WRONG_PSWD;
        if ((isAssociationRejection || isAuthenticationFailure)
                && mWifiConfigManager.isInFlakyRandomizationSsidHotlist(mTargetNetworkId)
                && isPrimary()) {
            mConnectionFailureNotifier
                    .showFailedToConnectDueToNoRandomizedMacSupportNotification(mTargetNetworkId);
        }

        mWifiMetrics.endConnectionEvent(mInterfaceName, level2FailureCode,
                connectivityFailureCode, level2FailureReason, mWifiInfo.getFrequency());
        if (configuration != null) {
            mWifiConnectivityManager.handleConnectionAttemptEnded(
                    mClientModeManager, level2FailureCode, level2FailureReason, bssid,
                    configuration);
            mNetworkFactory.handleConnectionAttemptEnded(level2FailureCode, configuration, bssid);
            mWifiNetworkSuggestionsManager.handleConnectionAttemptEnded(
                    level2FailureCode, configuration, getConnectedBssidInternal());
            ScanResult candidate = configuration.getNetworkSelectionStatus().getCandidate();
            if (candidate != null
                    && !TextUtils.equals(candidate.BSSID, getConnectedBssidInternal())) {
                mWifiMetrics.incrementNumBssidDifferentSelectionBetweenFrameworkAndFirmware();
            }
        }
        handleConnectionAttemptEndForDiagnostics(level2FailureCode);
    }

    /* If this connection attempt fails after 802.1x stage, clear intermediate cached data. */
    void clearNetworkCachedDataIfNeeded(WifiConfiguration config, int reason) {
        if (config == null) return;

        switch(reason) {
            case StaIfaceReasonCode.UNSPECIFIED:
            case StaIfaceReasonCode.DEAUTH_LEAVING:
                logi("Keep PMK cache for network disconnection reason " + reason);
                break;
            default:
                mWifiNative.removeNetworkCachedData(config.networkId);
                break;
        }
    }

    /**
     * Returns the sufficient RSSI for the frequency that this network is last seen on.
     */
    private int getSufficientRssi(int networkId, String bssid) {
        ScanDetailCache scanDetailCache =
                mWifiConfigManager.getScanDetailCacheForNetwork(networkId);
        if (scanDetailCache == null) {
            return WifiInfo.INVALID_RSSI;
        }
        ScanResult scanResult = scanDetailCache.getScanResult(bssid);
        if (scanResult == null) {
            return WifiInfo.INVALID_RSSI;
        }
        return mScoringParams.getSufficientRssi(scanResult.frequency);
    }

    private int convertToWifiBlocklistMonitorFailureReason(
            int level2FailureCode, int failureReason) {
        switch (level2FailureCode) {
            case WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_TIMED_OUT:
                return WifiBlocklistMonitor.REASON_ASSOCIATION_TIMEOUT;
            case WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_REJECTION:
                if (failureReason == WifiMetricsProto.ConnectionEvent
                        .ASSOCIATION_REJECTION_AP_UNABLE_TO_HANDLE_NEW_STA) {
                    return WifiBlocklistMonitor.REASON_AP_UNABLE_TO_HANDLE_NEW_STA;
                }
                return WifiBlocklistMonitor.REASON_ASSOCIATION_REJECTION;
            case WifiMetrics.ConnectionEvent.FAILURE_AUTHENTICATION_FAILURE:
                if (failureReason == WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_WRONG_PSWD) {
                    return WifiBlocklistMonitor.REASON_WRONG_PASSWORD;
                } else if (failureReason == WifiMetricsProto.ConnectionEvent
                        .AUTH_FAILURE_EAP_FAILURE) {
                    return WifiBlocklistMonitor.REASON_EAP_FAILURE;
                }
                return WifiBlocklistMonitor.REASON_AUTHENTICATION_FAILURE;
            case WifiMetrics.ConnectionEvent.FAILURE_DHCP:
                return WifiBlocklistMonitor.REASON_DHCP_FAILURE;
            case WifiMetrics.ConnectionEvent.FAILURE_NETWORK_DISCONNECTION:
                if (failureReason == WifiMetricsProto.ConnectionEvent.DISCONNECTION_NON_LOCAL) {
                    return WifiBlocklistMonitor.REASON_NONLOCAL_DISCONNECT_CONNECTING;
                }
                return -1;
            default:
                return -1;
        }
    }

    private void handleIPv4Success(DhcpResultsParcelable dhcpResults) {
        if (mVerboseLoggingEnabled) {
            logd("handleIPv4Success <" + dhcpResults.toString() + ">");
            logd("link address " + dhcpResults.baseConfiguration.getIpAddress());
        }

        Inet4Address addr;
        synchronized (mDhcpResultsParcelableLock) {
            mDhcpResultsParcelable = dhcpResults;
            addr = (Inet4Address) dhcpResults.baseConfiguration.getIpAddress().getAddress();
        }

        if (mIsAutoRoaming) {
            int previousAddress = mWifiInfo.getIpAddress();
            int newAddress = Inet4AddressUtils.inet4AddressToIntHTL(addr);
            if (previousAddress != newAddress) {
                logd("handleIPv4Success, roaming and address changed"
                        + mWifiInfo + " got: " + addr);
            }
        }

        mWifiInfo.setInetAddress(addr);

        final WifiConfiguration config = getConnectedWifiConfigurationInternal();
        if (config != null) {
            updateWifiInfoWhenConnected(config);
            mWifiConfigManager.updateRandomizedMacExpireTime(config, dhcpResults.leaseDuration);
            mWifiBlocklistMonitor.handleDhcpProvisioningSuccess(mLastBssid, mWifiInfo.getSSID());
        }

        // Set meteredHint if DHCP result says network is metered
        if (dhcpResults.vendorInfo != null && dhcpResults.vendorInfo.contains("ANDROID_METERED")) {
            mWifiInfo.setMeteredHint(true);
            mWifiMetrics.addMeteredStat(config, true);
        } else {
            mWifiMetrics.addMeteredStat(config, false);
        }

        updateCapabilities();
    }

    private void handleSuccessfulIpConfiguration() {
        mLastSignalLevel = -1; // Force update of signal strength
        WifiConfiguration c = getConnectedWifiConfigurationInternal();
        if (c != null) {
            // Reset IP failure tracking
            c.getNetworkSelectionStatus().clearDisableReasonCounter(
                    WifiConfiguration.NetworkSelectionStatus.DISABLED_DHCP_FAILURE);
        }
    }

    private void handleIPv4Failure() {
        // TODO: Move this to provisioning failure, not DHCP failure.
        // DHCPv4 failure is expected on an IPv6-only network.
        mWifiDiagnostics.triggerBugReportDataCapture(WifiDiagnostics.REPORT_REASON_DHCP_FAILURE);
        if (mVerboseLoggingEnabled) {
            int count = -1;
            WifiConfiguration config = getConnectedWifiConfigurationInternal();
            if (config != null) {
                count = config.getNetworkSelectionStatus().getDisableReasonCounter(
                        WifiConfiguration.NetworkSelectionStatus.DISABLED_DHCP_FAILURE);
            }
            log("DHCP failure count=" + count);
        }
        synchronized (mDhcpResultsParcelableLock) {
            mDhcpResultsParcelable = new DhcpResultsParcelable();
        }
        if (mVerboseLoggingEnabled) {
            logd("handleIPv4Failure");
        }
    }

    private void handleIpConfigurationLost() {
        mWifiInfo.setInetAddress(null);
        mWifiInfo.setMeteredHint(false);

        mWifiConfigManager.updateNetworkSelectionStatus(mLastNetworkId,
                WifiConfiguration.NetworkSelectionStatus.DISABLED_DHCP_FAILURE);

        /* DHCP times out after about 30 seconds, we do a
         * disconnect thru supplicant, we will let autojoin retry connecting to the network
         */
        mWifiNative.disconnect(mInterfaceName);
    }

    private void handleIpReachabilityLost() {
        mWifiScoreCard.noteIpReachabilityLost(mWifiInfo);
        mWifiInfo.setInetAddress(null);
        mWifiInfo.setMeteredHint(false);

        // Disconnect via supplicant, and let autojoin retry connecting to the network.
        mWifiNative.disconnect(mInterfaceName);
    }

    private void handleIpReachabilityFailure(ReachabilityLossInfoParcelable lossInfo) {
        if (lossInfo == null || lossInfo.reason == ReachabilityLossReason.CONFIRM
                || lossInfo.reason == ReachabilityLossReason.ORGANIC) {
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CMD_IP_REACHABILITY_LOST);
            mWifiMetrics.logWifiIsUnusableEvent(mInterfaceName,
                    WifiIsUnusableEvent.TYPE_IP_REACHABILITY_LOST);
            mWifiMetrics.addToWifiUsabilityStatsList(mInterfaceName,
                    WifiUsabilityStats.LABEL_BAD,
                    WifiUsabilityStats.TYPE_IP_REACHABILITY_LOST, -1);
            if (mWifiGlobals.getIpReachabilityDisconnectEnabled()) {
                handleIpReachabilityLost();
            } else {
                logd("CMD_IP_REACHABILITY_LOST but disconnect disabled -- ignore");
            }
            return;
        }

        if (lossInfo.reason == ReachabilityLossReason.ROAM) {
            final WifiConfiguration config = getConnectedWifiConfigurationInternal();
            final NetworkAgentConfig naConfig = getNetworkAgentConfigInternal(config);
            final NetworkCapabilities nc = getCapabilities(
                    getConnectedWifiConfigurationInternal(), getConnectedBssidInternal());

            mWifiInfo.setInetAddress(null);
            if (mNetworkAgent != null) {
                if (SdkLevel.isAtLeastT()) {
                    mNetworkAgent.unregisterAfterReplacement(NETWORK_AGENT_TEARDOWN_DELAY_MS);
                } else {
                    mNetworkAgent.unregister();
                }
            }
            mNetworkAgent = mWifiInjector.makeWifiNetworkAgent(nc, mLinkProperties, naConfig,
                    mNetworkFactory.getProvider(), new WifiNetworkAgentCallback());
            mWifiScoreReport.setNetworkAgent(mNetworkAgent);
            if (SdkLevel.isAtLeastT()) {
                mQosPolicyRequestHandler.setNetworkAgent(mNetworkAgent);
            }

            transitionTo(mL3ProvisioningState);
        } else {
            logd("Invalid failure reason from onIpReachabilityFailure");
        }
    }

    private NetworkAgentConfig getNetworkAgentConfigInternal(WifiConfiguration config) {
        boolean explicitlySelected = false;
        // Non primary CMMs is never user selected. This prevents triggering the No Internet
        // dialog for those networks, which is difficult to handle.
        if (isPrimary() && isRecentlySelectedByTheUser(config)) {
            // If explicitlySelected is true, the network was selected by the user via Settings
            // or QuickSettings. If this network has Internet access, switch to it. Otherwise,
            // switch to it only if the user confirms that they really want to switch, or has
            // already confirmed and selected "Don't ask again".
            explicitlySelected =
                    mWifiPermissionsUtil.checkNetworkSettingsPermission(config.lastConnectUid);
            if (mVerboseLoggingEnabled) {
                log("Network selected by UID " + config.lastConnectUid
                        + " explicitlySelected=" + explicitlySelected);
            }
        }
        NetworkAgentConfig.Builder naConfigBuilder = new NetworkAgentConfig.Builder()
                .setLegacyType(ConnectivityManager.TYPE_WIFI)
                .setLegacyTypeName(NETWORKTYPE)
                .setExplicitlySelected(explicitlySelected)
                .setUnvalidatedConnectivityAcceptable(
                        explicitlySelected && config.noInternetAccessExpected)
                .setPartialConnectivityAcceptable(config.noInternetAccessExpected);
        if (config.carrierMerged) {
            String subscriberId = null;
            TelephonyManager subMgr = mTelephonyManager.createForSubscriptionId(
                    config.subscriptionId);
            if (subMgr != null) {
                subscriberId = subMgr.getSubscriberId();
            }
            if (subscriberId != null) {
                naConfigBuilder.setSubscriberId(subscriberId);
            }
        }
        if (mVcnManager == null && SdkLevel.isAtLeastS()) {
            mVcnManager = mContext.getSystemService(VcnManager.class);
        }
        if (mVcnManager != null && mVcnPolicyChangeListener == null) {
            mVcnPolicyChangeListener = new WifiVcnNetworkPolicyChangeListener();
            mVcnManager.addVcnNetworkPolicyChangeListener(new HandlerExecutor(getHandler()),
                    mVcnPolicyChangeListener);
        }
        return naConfigBuilder.build();
    }

    /*
     * Read a MAC address in /proc/net/arp, used by ClientModeImpl
     * so as to record MAC address of default gateway.
     **/
    private String macAddressFromRoute(String ipAddress) {
        String macAddress = null;
        BufferedReader reader = null;
        try {
            reader = mWifiInjector.createBufferedReader(ARP_TABLE_PATH);

            // Skip over the line bearing column titles
            String line = reader.readLine();

            while ((line = reader.readLine()) != null) {
                String[] tokens = line.split("[ ]+");
                if (tokens.length < 6) {
                    continue;
                }

                // ARP column format is
                // IPAddress HWType Flags HWAddress Mask Device
                String ip = tokens[0];
                String mac = tokens[3];

                if (TextUtils.equals(ipAddress, ip)) {
                    macAddress = mac;
                    break;
                }
            }

            if (macAddress == null) {
                loge("Did not find remoteAddress {" + ipAddress + "} in /proc/net/arp");
            }

        } catch (FileNotFoundException e) {
            loge("Could not open /proc/net/arp to lookup mac address");
        } catch (IOException e) {
            loge("Could not read /proc/net/arp to lookup mac address");
        } finally {
            try {
                if (reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                // Do nothing
            }
        }
        return macAddress;

    }

    /**
     * Determine if the specified auth failure is considered to be a permanent wrong password
     * failure. The criteria for such failure is when wrong password error is detected
     * and the network had never been connected before.
     *
     * For networks that have previously connected successfully, we consider wrong password
     * failures to be temporary, to be on the conservative side.  Since this might be the
     * case where we are trying to connect to a wrong network (e.g. A network with same SSID
     * but different password).
     */
    private boolean isPermanentWrongPasswordFailure(int networkId, int reasonCode) {
        if (reasonCode != WifiManager.ERROR_AUTH_FAILURE_WRONG_PSWD) {
            return false;
        }
        WifiConfiguration network = mWifiConfigManager.getConfiguredNetwork(networkId);
        if (network != null && network.getNetworkSelectionStatus().hasEverConnected()) {
            return false;
        }
        return true;
    }

     /**
     * Dynamically change the MAC address to use the locally randomized
     * MAC address generated for each network.
     * @param config WifiConfiguration with mRandomizedMacAddress to change into. If the address
     * is masked out or not set, it will generate a new random MAC address.
     */
    private void configureRandomizedMacAddress(WifiConfiguration config) {
        if (config == null) {
            Log.e(getTag(), "No config to change MAC address to");
            return;
        }
        String currentMacString = mWifiNative.getMacAddress(mInterfaceName);
        MacAddress currentMac = getMacAddressFromBssidString(currentMacString);
        MacAddress newMac = isSecondaryInternet() && mClientModeManager.isSecondaryInternetDbsAp()
                ? MacAddressUtils.createRandomUnicastAddress()
                : mWifiConfigManager.getRandomizedMacAndUpdateIfNeeded(config);
        if (!WifiConfiguration.isValidMacAddressForRandomization(newMac)) {
            Log.wtf(getTag(), "Config generated an invalid MAC address");
        } else if (Objects.equals(newMac, currentMac)) {
            Log.d(getTag(), "No changes in MAC address");
        } else {
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_MAC_CHANGE, config);
            boolean setMacSuccess =
                    mWifiNative.setStaMacAddress(mInterfaceName, newMac);
            if (setMacSuccess) {
                mWifiNative.removeNetworkCachedDataIfNeeded(config.networkId, newMac);
            }
            Log.d(getTag(), "ConnectedMacRandomization SSID(" + config.getPrintableSsid()
                    + "). setMacAddress(" + newMac.toString() + ") from "
                    + currentMacString + " = " + setMacSuccess);
        }
    }

    /**
     * Sets the current MAC to the factory MAC address.
     */
    private void setCurrentMacToFactoryMac(WifiConfiguration config) {
        MacAddress factoryMac = retrieveFactoryMacAddressAndStoreIfNecessary();
        if (factoryMac == null) {
            Log.e(getTag(), "Fail to set factory MAC address. Factory MAC is null.");
            return;
        }
        String currentMacStr = mWifiNative.getMacAddress(mInterfaceName);
        if (!TextUtils.equals(currentMacStr, factoryMac.toString())) {
            if (mWifiNative.setStaMacAddress(mInterfaceName, factoryMac)) {
                mWifiNative.removeNetworkCachedDataIfNeeded(config.networkId, factoryMac);
                mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_MAC_CHANGE, config);
            } else {
                Log.e(getTag(), "Failed to set MAC address to " + "'"
                        + factoryMac.toString() + "'");
            }
        }
    }

    /**
     * Helper method to start other services and get state ready for client mode
     */
    private void setupClientMode() {
        Log.d(getTag(), "setupClientMode() ifacename = " + mInterfaceName);

        setMulticastFilter(true);
        registerForWifiMonitorEvents();
        if (isPrimary()) {
            mWifiLastResortWatchdog.clearAllFailureCounts();
        }

        // Initialize data structures
        mTargetBssid = SUPPLICANT_BSSID_ANY;
        mTargetNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
        mLastBssid = null;
        mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
        mLastSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
        mLastSimBasedConnectionCarrierName = null;
        mLastSignalLevel = -1;
        if (mWifiGlobals.isConnectedMacRandomizationEnabled()) {
            mFailedToResetMacAddress = !mWifiNative.setStaMacAddress(
                    mInterfaceName, MacAddressUtils.createRandomUnicastAddress());
            if (mFailedToResetMacAddress) {
                Log.e(getTag(), "Failed to set random MAC address on ClientMode creation");
            }
        }
        mWifiInfo.setMacAddress(mWifiNative.getMacAddress(mInterfaceName));
        // TODO: b/79504296 This broadcast has been deprecated and should be removed
        sendSupplicantConnectionChangedBroadcast(true);

        mWifiNative.setExternalSim(mInterfaceName, true);

        mWifiDiagnostics.startPktFateMonitoring(mInterfaceName);
        mWifiDiagnostics.startLogging(mInterfaceName);

        mMboOceController.enable();

        // Enable bluetooth coexistence scan mode when bluetooth connection is active.
        // When this mode is on, some of the low-level scan parameters used by the
        // driver are changed to reduce interference with bluetooth
        mWifiNative.setBluetoothCoexistenceScanMode(
                mInterfaceName, mWifiGlobals.isBluetoothConnected());
        sendNetworkChangeBroadcast(DetailedState.DISCONNECTED);

        // Disable legacy multicast filtering, which on some chipsets defaults to enabled.
        // Legacy IPv6 multicast filtering blocks ICMPv6 router advertisements which breaks IPv6
        // provisioning. Legacy IPv4 multicast filtering may be re-enabled later via
        // IpClient.Callback.setFallbackMulticastFilter()
        mWifiNative.stopFilteringMulticastV4Packets(mInterfaceName);
        mWifiNative.stopFilteringMulticastV6Packets(mInterfaceName);

        // Set the right suspend mode settings
        mWifiNative.setSuspendOptimizations(mInterfaceName, mSuspendOptNeedsDisabled == 0
                && mContext.getResources().getBoolean(
                        R.bool.config_wifiSuspendOptimizationsEnabled));

        enablePowerSave();

        // Disable wpa_supplicant from auto reconnecting.
        mWifiNative.enableStaAutoReconnect(mInterfaceName, false);
        // STA has higher priority over P2P
        mWifiNative.setConcurrencyPriority(true);

        // Retrieve and store the factory MAC address (on first bootup).
        retrieveFactoryMacAddressAndStoreIfNecessary();
    }

    /**
     * Helper method to stop external services and clean up state from client mode.
     */
    private void stopClientMode() {
        handleNetworkDisconnect(false,
                WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__WIFI_DISABLED);
        // exiting supplicant started state is now only applicable to client mode
        mWifiDiagnostics.stopLogging(mInterfaceName);

        mMboOceController.disable();
        if (mIpClient != null && mIpClient.shutdown()) {
            // Block to make sure IpClient has really shut down, lest cleanup
            // race with, say, bringup code over in tethering.
            mIpClientCallbacks.awaitShutdown();
            mIpClientCallbacks = null;
            mIpClient = null;
        }
        deregisterForWifiMonitorEvents(); // uses mInterfaceName, must call before nulling out
        // TODO: b/79504296 This broadcast has been deprecated and should be removed
        sendSupplicantConnectionChangedBroadcast(false);
    }

    /**
     * Helper method called when a L3 connection is successfully established to a network.
     */
    void registerConnected() {
        if (mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID) {
            WifiConfiguration config = getConnectedWifiConfigurationInternal();
            boolean shouldSetUserConnectChoice = config != null
                    && isRecentlySelectedByTheUser(config)
                    && (config.getNetworkSelectionStatus().hasEverConnected()
                    || config.isEphemeral())
                    && mWifiPermissionsUtil.checkNetworkSettingsPermission(config.lastConnectUid);
            mWifiConfigManager.updateNetworkAfterConnect(mLastNetworkId,
                    shouldSetUserConnectChoice, mWifiInfo.getRssi());
            // Notify PasspointManager of Passpoint network connected event.
            WifiConfiguration currentNetwork = getConnectedWifiConfigurationInternal();
            if (currentNetwork != null && currentNetwork.isPasspoint()) {
                mPasspointManager.onPasspointNetworkConnected(
                        currentNetwork.getProfileKey());
            }
        }
    }

    void registerDisconnected() {
        if (mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID) {
            mWifiConfigManager.updateNetworkAfterDisconnect(mLastNetworkId);
        }
    }

    /**
     * Returns WifiConfiguration object corresponding to the currently connected network, null if
     * not connected.
     */
    @Nullable private WifiConfiguration getConnectedWifiConfigurationInternal() {
        if (mLastNetworkId == WifiConfiguration.INVALID_NETWORK_ID) {
            return null;
        }
        return mWifiConfigManager.getConfiguredNetwork(mLastNetworkId);
    }

    /**
     * Returns WifiConfiguration object corresponding to the currently connecting network, null if
     * not connecting.
     */
    @Nullable private WifiConfiguration getConnectingWifiConfigurationInternal() {
        if (mTargetNetworkId == WifiConfiguration.INVALID_NETWORK_ID) {
            return null;
        }
        return mWifiConfigManager.getConfiguredNetwork(mTargetNetworkId);
    }

    @Nullable private String getConnectedBssidInternal() {
        return mLastBssid;
    }

    @Nullable private String getConnectingBssidInternal() {
        return mTargetBssid;
    }

    /**
     * Returns WifiConfiguration object corresponding to the currently connected network, null if
     * not connected.
     */
    @Override
    @Nullable public WifiConfiguration getConnectedWifiConfiguration() {
        if (!isConnected()) return null;
        return getConnectedWifiConfigurationInternal();
    }

    /**
     * Returns WifiConfiguration object corresponding to the currently connecting network, null if
     * not connecting.
     */
    @Override
    @Nullable public WifiConfiguration getConnectingWifiConfiguration() {
        if (!isConnecting() && !isRoaming()) return null;
        return getConnectingWifiConfigurationInternal();
    }

    @Override
    @Nullable public String getConnectedBssid() {
        if (!isConnected()) return null;
        return getConnectedBssidInternal();
    }

    @Override
    @Nullable public String getConnectingBssid() {
        if (!isConnecting() && !isRoaming()) return null;
        return getConnectingBssidInternal();
    }

    ScanResult getCurrentScanResult() {
        WifiConfiguration config = getConnectedWifiConfigurationInternal();
        if (config == null) {
            return null;
        }
        String bssid = mWifiInfo.getBSSID();
        if (bssid == null) {
            bssid = mTargetBssid;
        }
        ScanDetailCache scanDetailCache =
                mWifiConfigManager.getScanDetailCacheForNetwork(config.networkId);

        if (scanDetailCache == null) {
            return null;
        }

        return scanDetailCache.getScanResult(bssid);
    }

    private MacAddress getMacAddressFromBssidString(@Nullable String bssidStr) {
        try {
            return (bssidStr != null) ? MacAddress.fromString(bssidStr) : null;
        } catch (IllegalArgumentException e) {
            Log.e(getTag(), "Invalid BSSID format: " + bssidStr);
            return null;
        }
    }

    private MacAddress getCurrentBssidInternalMacAddress() {
        return getMacAddressFromBssidString(mLastBssid);
    }

    private void connectToNetwork(WifiConfiguration config) {
        if ((config != null) && mWifiNative.connectToNetwork(mInterfaceName, config)) {
            // Update the internal config once the connection request is accepted.
            mWifiConfigManager.setNetworkLastUsedSecurityParams(config.networkId,
                    config.getNetworkSelectionStatus().getCandidateSecurityParams());
            mWifiLastResortWatchdog.noteStartConnectTime(config.networkId);
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CMD_START_CONNECT, config);
            mIsAutoRoaming = false;
            transitionTo(mL2ConnectingState);
        } else {
            loge("CMD_START_CONNECT Failed to start connection to network " + config);
            mTargetWifiConfiguration = null;
            stopIpClient();
            reportConnectionAttemptEnd(
                    WifiMetrics.ConnectionEvent.FAILURE_CONNECT_NETWORK_FAILED,
                    WifiMetricsProto.ConnectionEvent.HLF_NONE,
                    WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
        }
    }

    /********************************************************
     * HSM states
     *******************************************************/

    class ConnectableState extends State {
        private boolean mIsScreenStateChangeReceiverRegistered = false;
        BroadcastReceiver mScreenStateChangeReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                String action = intent.getAction();
                if (TextUtils.equals(action, Intent.ACTION_SCREEN_ON)) {
                    sendMessage(CMD_SCREEN_STATE_CHANGED, 1);
                } else if (TextUtils.equals(action, Intent.ACTION_SCREEN_OFF)) {
                    sendMessage(CMD_SCREEN_STATE_CHANGED, 0);
                }
            }
        };

        @Override
        public void enter() {
            Log.d(getTag(), "entering ConnectableState: ifaceName = " + mInterfaceName);

            setSuspendOptimizationsNative(SUSPEND_DUE_TO_HIGH_PERF, true);

            mWifiStateTracker.updateState(mInterfaceName, WifiStateTracker.INVALID);
            mIpClientCallbacks = new IpClientCallbacksImpl();
            Log.d(getTag(), "Start makeIpClient ifaceName = " + mInterfaceName);
            mFacade.makeIpClient(mContext, mInterfaceName, mIpClientCallbacks);
            mIpClientCallbacks.awaitCreation();
        }

        private void continueEnterSetup(IpClientManager ipClientManager) {
            mIpClient = ipClientManager;
            setupClientMode();

            IntentFilter filter = new IntentFilter();
            filter.addAction(Intent.ACTION_SCREEN_ON);
            filter.addAction(Intent.ACTION_SCREEN_OFF);
            if (!mIsScreenStateChangeReceiverRegistered) {
                mContext.registerReceiver(mScreenStateChangeReceiver, filter);
                mIsScreenStateChangeReceiverRegistered = true;
            }
            // Learn the initial state of whether the screen is on.
            // We update this field when we receive broadcasts from the system.
            handleScreenStateChanged(mContext.getSystemService(PowerManager.class).isInteractive());

            if (!mWifiNative.removeAllNetworks(mInterfaceName)) {
                loge("Failed to remove networks on entering connect mode");
            }
            mWifiInfo.reset();
            mWifiInfo.setSupplicantState(SupplicantState.DISCONNECTED);

            sendNetworkChangeBroadcast(DetailedState.DISCONNECTED);

            // Inform metrics that Wifi is Enabled (but not yet connected)
            mWifiMetrics.setWifiState(mInterfaceName, WifiMetricsProto.WifiLog.WIFI_DISCONNECTED);
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_WIFI_ENABLED);
            mWifiScoreCard.noteSupplicantStateChanged(mWifiInfo);
        }

        @Override
        public void exit() {
            // Inform metrics that Wifi is being disabled (Toggled, airplane enabled, etc)
            mWifiMetrics.setWifiState(mInterfaceName, WifiMetricsProto.WifiLog.WIFI_DISABLED);
            mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_WIFI_DISABLED);

            if (!mWifiNative.removeAllNetworks(mInterfaceName)) {
                loge("Failed to remove networks on exiting connect mode");
            }
            if (mIsScreenStateChangeReceiverRegistered) {
                mContext.unregisterReceiver(mScreenStateChangeReceiver);
                mIsScreenStateChangeReceiverRegistered = false;
            }

            stopClientMode();
            mWifiScoreCard.doWrites();
        }

        @Override
        public boolean processMessage(Message message) {
            switch (message.what) {
                case CMD_CONNECTABLE_STATE_SETUP:
                    if (mIpClient != null) {
                        loge("Setup connectable state again when IpClient is ready?");
                    } else {
                        IpClientManager ipClientManager = (IpClientManager) message.obj;
                        continueEnterSetup(ipClientManager);
                    }
                    break;
                case CMD_ENABLE_RSSI_POLL: {
                    mEnableRssiPolling = (message.arg1 == 1);
                    break;
                }
                case CMD_SCREEN_STATE_CHANGED: {
                    handleScreenStateChanged(message.arg1 != 0);
                    break;
                }
                case WifiP2pServiceImpl.DISCONNECT_WIFI_REQUEST: {
                    if (mIpClient == null) {
                        logd("IpClient is not ready, "
                                + "WifiP2pServiceImpl.DISCONNECT_WIFI_REQUEST dropped");
                        break;
                    }
                    if (mWifiP2pConnection.shouldTemporarilyDisconnectWifi()) {
                        mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                StaEvent.DISCONNECT_P2P_DISCONNECT_WIFI_REQUEST);
                        mWifiNative.disconnect(mInterfaceName);
                    } else {
                        mWifiNative.reconnect(mInterfaceName);
                    }
                    break;
                }
                case CMD_RECONNECT: {
                    WorkSource workSource = (WorkSource) message.obj;
                    mWifiConnectivityManager.forceConnectivityScan(workSource);
                    break;
                }
                case CMD_REASSOCIATE: {
                    if (mIpClient != null) {
                        logd("IpClient is not ready, REASSOCIATE dropped");

                        mWifiNative.reassociate(mInterfaceName);
                    }
                    break;
                }
                case CMD_START_CONNECT: {
                    if (mIpClient == null) {
                        logd("IpClient is not ready, START_CONNECT dropped");

                        break;
                    }
                    /* connect command coming from auto-join */
                    int netId = message.arg1;
                    int uid = message.arg2;
                    String bssid = (String) message.obj;
                    mSentHLPs = false;
                    // Stop lingering (if it was lingering before) if we start a new connection.
                    // This means that the ClientModeManager was reused for another purpose, so it
                    // should no longer be in lingering mode.
                    mClientModeManager.setShouldReduceNetworkScore(false);

                    if (!hasConnectionRequests()) {
                        if (mNetworkAgent == null) {
                            loge("CMD_START_CONNECT but no requests and not connected,"
                                    + " bailing");
                            break;
                        } else if (!mWifiPermissionsUtil.checkNetworkSettingsPermission(uid)) {
                            loge("CMD_START_CONNECT but no requests and connected, but app "
                                    + "does not have sufficient permissions, bailing");
                            break;
                        }
                    }
                    WifiConfiguration config =
                            mWifiConfigManager.getConfiguredNetworkWithoutMasking(netId);
                    logd("CMD_START_CONNECT "
                            + " my state " + getCurrentState().getName()
                            + " nid=" + netId
                            + " roam=" + mIsAutoRoaming);
                    if (config == null) {
                        loge("CMD_START_CONNECT and no config, bail out...");
                        break;
                    }
                    mCurrentConnectionDetectedCaptivePortal = false;
                    mTargetNetworkId = netId;
                    // Update scorecard while there is still state from existing connection
                    mLastScanRssi = mWifiConfigManager.findScanRssi(netId,
                            mWifiHealthMonitor.getScanRssiValidTimeMs());
                    mWifiScoreCard.noteConnectionAttempt(mWifiInfo, mLastScanRssi, config.SSID);
                    mWifiBlocklistMonitor.setAllowlistSsids(config.SSID, Collections.emptyList());
                    mWifiBlocklistMonitor.updateFirmwareRoamingConfiguration(Set.of(config.SSID));

                    updateWifiConfigOnStartConnection(config, bssid);
                    reportConnectionAttemptStart(config, mTargetBssid,
                            WifiMetricsProto.ConnectionEvent.ROAM_UNRELATED);

                    String currentMacAddress = mWifiNative.getMacAddress(mInterfaceName);
                    mWifiInfo.setMacAddress(currentMacAddress);
                    Log.i(getTag(), "Connecting with " + currentMacAddress + " as the mac address");

                    mTargetWifiConfiguration = config;
                    mNetworkNotFoundEventCount = 0;
                    /* Check for FILS configuration again after updating the config */
                    if (config.isFilsSha256Enabled() || config.isFilsSha384Enabled()) {
                        boolean isIpClientStarted = startIpClient(config, true);
                        if (isIpClientStarted) {
                            mIpClientWithPreConnection = true;
                            transitionTo(mL2ConnectingState);
                            break;
                        }
                    }
                    setSelectedRcoiForPasspoint(config);

                    // TOFU flow for devices that do not support this feature
                    mInsecureEapNetworkHandler.prepareConnection(mTargetWifiConfiguration);
                    mLeafCertSent = false;
                    if (!isTrustOnFirstUseSupported()) {
                        mInsecureEapNetworkHandler.startUserApprovalIfNecessary(mIsUserSelected);
                    }
                    connectToNetwork(config);
                    break;
                }
                case CMD_START_FILS_CONNECTION: {
                    if (mIpClient == null) {
                        logd("IpClient is not ready, START_FILS_CONNECTION dropped");
                        break;
                    }
                    mWifiMetrics.incrementConnectRequestWithFilsAkmCount();
                    List<Layer2PacketParcelable> packets;
                    packets = (List<Layer2PacketParcelable>) message.obj;
                    if (mVerboseLoggingEnabled) {
                        Log.d(getTag(), "Send HLP IEs to supplicant");
                    }
                    addLayer2PacketsToHlpReq(packets);
                    WifiConfiguration config = mTargetWifiConfiguration;
                    connectToNetwork(config);
                    break;
                }
                case CMD_CONNECT_NETWORK: {
                    ConnectNetworkMessage cnm = (ConnectNetworkMessage) message.obj;
                    if (mIpClient == null) {
                        logd("IpClient is not ready, CONNECT_NETWORK dropped");
                        cnm.listener.sendFailure(WifiManager.ActionListener.FAILURE_INTERNAL_ERROR);
                        break;
                    }
                    NetworkUpdateResult result = cnm.result;
                    int netId = result.getNetworkId();
                    connectToUserSelectNetwork(
                            netId, message.sendingUid, result.hasCredentialChanged(),
                            cnm.packageName);
                    mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_CONNECT_NETWORK,
                            mWifiConfigManager.getConfiguredNetwork(netId));
                    cnm.listener.sendSuccess();
                    break;
                }
                case CMD_SAVE_NETWORK: {
                    ConnectNetworkMessage cnm = (ConnectNetworkMessage) message.obj;
                    if (mIpClient == null) {
                        logd("IpClient is not ready, SAVE_NETWORK dropped");
                        cnm.listener.sendFailure(WifiManager.ActionListener.FAILURE_INTERNAL_ERROR);
                        break;
                    }
                    NetworkUpdateResult result = cnm.result;
                    int netId = result.getNetworkId();
                    if (mWifiInfo.getNetworkId() == netId) {
                        if (result.hasCredentialChanged()) {
                            // The network credentials changed and we're connected to this network,
                            // start a new connection with the updated credentials.
                            logi("CMD_SAVE_NETWORK credential changed for nid="
                                    + netId + ". Reconnecting.");
                            startConnectToNetwork(netId, message.sendingUid, SUPPLICANT_BSSID_ANY);
                        } else {
                            if (result.hasProxyChanged()) {
                                if (mIpClient != null) {
                                    log("Reconfiguring proxy on connection");
                                    WifiConfiguration currentConfig =
                                            getConnectedWifiConfigurationInternal();
                                    if (currentConfig != null) {
                                        mIpClient.setHttpProxy(currentConfig.getHttpProxy());
                                    } else {
                                        Log.w(getTag(),
                                                "CMD_SAVE_NETWORK proxy change - but no current "
                                                        + "Wi-Fi config");
                                    }
                                }
                            }
                            if (result.hasIpChanged()) {
                                // The current connection configuration was changed
                                // We switched from DHCP to static or from static to DHCP, or the
                                // static IP address has changed.
                                log("Reconfiguring IP on connection");
                                WifiConfiguration currentConfig =
                                        getConnectedWifiConfigurationInternal();
                                if (currentConfig != null) {
                                    transitionTo(mL3ProvisioningState);
                                } else {
                                    Log.w(getTag(), "CMD_SAVE_NETWORK Ip change - but no current "
                                            + "Wi-Fi config");
                                }
                            }
                        }
                    } else if (mWifiInfo.getNetworkId() == WifiConfiguration.INVALID_NETWORK_ID
                            && result.hasCredentialChanged()) {
                        logi("CMD_SAVE_NETWORK credential changed for nid="
                                + netId + " while disconnected. Connecting.");
                        WifiConfiguration config =
                                mWifiConfigManager.getConfiguredNetwork(netId);
                        if (!mWifiPermissionsUtil.isAdminRestrictedNetwork(config)) {
                            startConnectToNetwork(netId, message.sendingUid, SUPPLICANT_BSSID_ANY);
                        }
                    } else if (result.hasCredentialChanged()) {
                        WifiConfiguration currentConfig =
                                getConnectedWifiConfigurationInternal();
                        WifiConfiguration updatedConfig =
                                mWifiConfigManager.getConfiguredNetwork(netId);
                        if (currentConfig != null && currentConfig.isLinked(updatedConfig)) {
                            logi("current network linked config saved, update linked networks");
                            updateLinkedNetworks(currentConfig);
                        }
                    }
                    cnm.listener.sendSuccess();
                    break;
                }
                case CMD_BLUETOOTH_CONNECTION_STATE_CHANGE: {
                    mWifiNative.setBluetoothCoexistenceScanMode(
                            mInterfaceName, mWifiGlobals.isBluetoothConnected());
                    break;
                }
                case CMD_SET_SUSPEND_OPT_ENABLED: {
                    if (message.arg1 == 1) {
                        setSuspendOptimizationsNative(SUSPEND_DUE_TO_SCREEN, true);
                        if (message.arg2 == 1) {
                            mSuspendWakeLock.release();
                        }
                    } else {
                        setSuspendOptimizationsNative(SUSPEND_DUE_TO_SCREEN, false);
                    }
                    break;
                }
                case WifiMonitor.ANQP_DONE_EVENT: {
                    mPasspointManager.notifyANQPDone((AnqpEvent) message.obj);
                    break;
                }
                case CMD_STOP_IP_PACKET_OFFLOAD: {
                    int slot = message.arg1;
                    int ret = stopWifiIPPacketOffload(slot);
                    if (mNetworkAgent != null) {
                        mNetworkAgent.sendSocketKeepaliveEvent(slot, ret);
                    }
                    break;
                }
                case WifiMonitor.RX_HS20_ANQP_ICON_EVENT: {
                    mPasspointManager.notifyIconDone((IconEvent) message.obj);
                    break;
                }
                case WifiMonitor.HS20_DEAUTH_IMMINENT_EVENT:
                    mPasspointManager.handleDeauthImminentEvent((WnmData) message.obj,
                            getConnectedWifiConfigurationInternal());
                    break;
                case WifiMonitor.HS20_TERMS_AND_CONDITIONS_ACCEPTANCE_REQUIRED_EVENT:
                    mWifiMetrics
                            .incrementTotalNumberOfPasspointConnectionsWithTermsAndConditionsUrl();
                    mTermsAndConditionsUrl = mPasspointManager
                            .handleTermsAndConditionsEvent((WnmData) message.obj,
                            getConnectedWifiConfigurationInternal());
                    if (mTermsAndConditionsUrl == null) {
                        loge("Disconnecting from Passpoint network due to an issue with the "
                                + "Terms and Conditions URL");
                        sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_PASSPOINT_TAC);
                    }
                    break;
                case WifiMonitor.HS20_REMEDIATION_EVENT:
                    mPasspointManager.receivedWnmFrame((WnmData) message.obj);
                    break;
                case WifiMonitor.MBO_OCE_BSS_TM_HANDLING_DONE: {
                    handleBssTransitionRequest((BtmFrameData) message.obj);
                    break;
                }
                case CMD_CONFIG_ND_OFFLOAD: {
                    final boolean enabled = (message.arg1 > 0);
                    mWifiNative.configureNeighborDiscoveryOffload(mInterfaceName, enabled);
                    break;
                }
                // Link configuration (IP address, DNS, ...) changes notified via netlink
                case CMD_UPDATE_LINKPROPERTIES: {
                    updateLinkProperties((LinkProperties) message.obj);
                    break;
                }
                case CMD_START_IP_PACKET_OFFLOAD:
                case CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF:
                case CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF: {
                    if (mNetworkAgent != null) {
                        mNetworkAgent.sendSocketKeepaliveEvent(message.arg1,
                                SocketKeepalive.ERROR_INVALID_NETWORK);
                    }
                    break;
                }
                case CMD_INSTALL_PACKET_FILTER: {
                    mCachedPacketFilter = (byte[]) message.obj;
                    if (mContext.getResources().getBoolean(
                            R.bool.config_wifiEnableApfOnNonPrimarySta)
                            || isPrimary()) {
                        mWifiNative.installPacketFilter(mInterfaceName, mCachedPacketFilter);
                    } else {
                        Log.v(TAG, "Not applying packet filter on non primary CMM");
                    }
                    break;
                }
                case CMD_READ_PACKET_FILTER: {
                    final byte[] packetFilter;
                    if (mContext.getResources().getBoolean(
                            R.bool.config_wifiEnableApfOnNonPrimarySta)
                            || isPrimary()) {
                        packetFilter = mWifiNative.readPacketFilter(mInterfaceName);
                    } else {
                        Log.v(TAG, "Retrieving cached packet filter on non primary CMM");
                        packetFilter = mCachedPacketFilter;
                    }
                    if (mIpClient != null) {
                        mIpClient.readPacketFilterComplete(packetFilter);
                    }
                    break;
                }
                case CMD_SET_FALLBACK_PACKET_FILTERING: {
                    if ((boolean) message.obj) {
                        mWifiNative.startFilteringMulticastV4Packets(mInterfaceName);
                    } else {
                        mWifiNative.stopFilteringMulticastV4Packets(mInterfaceName);
                    }
                    break;
                }
                case CMD_DIAGS_CONNECT_TIMEOUT: {
                    mWifiDiagnostics.reportConnectionEvent(
                            WifiDiagnostics.CONNECTION_EVENT_TIMEOUT, mClientModeManager);
                    break;
                }
                case WifiP2pServiceImpl.P2P_CONNECTION_CHANGED:
                case CMD_RESET_SIM_NETWORKS:
                case WifiMonitor.NETWORK_CONNECTION_EVENT:
                case WifiMonitor.NETWORK_DISCONNECTION_EVENT:
                case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT:
                case WifiMonitor.AUTHENTICATION_FAILURE_EVENT:
                case WifiMonitor.ASSOCIATION_REJECTION_EVENT:
                case CMD_RSSI_POLL:
                case CMD_ONESHOT_RSSI_POLL:
                case CMD_PRE_DHCP_ACTION:
                case CMD_PRE_DHCP_ACTION_COMPLETE:
                case CMD_POST_DHCP_ACTION:
                case WifiMonitor.SUP_REQUEST_IDENTITY:
                case WifiMonitor.SUP_REQUEST_SIM_AUTH:
                case WifiMonitor.TARGET_BSSID_EVENT:
                case WifiMonitor.ASSOCIATED_BSSID_EVENT:
                case WifiMonitor.TRANSITION_DISABLE_INDICATION:
                case CMD_UNWANTED_NETWORK:
                case CMD_CONNECTING_WATCHDOG_TIMER:
                case WifiMonitor.NETWORK_NOT_FOUND_EVENT:
                case CMD_ROAM_WATCHDOG_TIMER: {
                    // no-op: all messages must be handled in the base state in case it was missed
                    // in one of the child states.
                    break;
                }
                case CMD_ACCEPT_EAP_SERVER_CERTIFICATE:
                    // If TOFU is not supported, then we are already connected
                    if (!isTrustOnFirstUseSupported()) break;
                    // Got an approval for a TOFU network. Disconnect (if connected) and trigger
                    // a connection to the new approved network.
                    logd("User accepted TOFU provided certificate");
                    startConnectToNetwork(message.arg1, Process.WIFI_UID, SUPPLICANT_BSSID_ANY);
                    break;
                case CMD_REJECT_EAP_INSECURE_CONNECTION:
                case CMD_START_ROAM:
                case CMD_START_RSSI_MONITORING_OFFLOAD:
                case CMD_STOP_RSSI_MONITORING_OFFLOAD:
                case CMD_IP_CONFIGURATION_SUCCESSFUL:
                case CMD_IP_CONFIGURATION_LOST:
                case CMD_IP_REACHABILITY_LOST:
                case CMD_IP_REACHABILITY_FAILURE: {
                    mMessageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
                    break;
                }
                case 0: {
                    // We want to notice any empty messages (with what == 0) that might crop up.
                    // For example, we may have recycled a message sent to multiple handlers.
                    Log.wtf(getTag(), "Error! empty message encountered");
                    break;
                }
                default: {
                    loge("Error! unhandled message" + message);
                    break;
                }
            }

            logStateAndMessage(message, this);
            return HANDLED;
        }
    }

    private boolean handleL3MessagesWhenNotConnected(Message message) {
        boolean handleStatus = HANDLED;

        if (!mIpClientWithPreConnection) {
            return NOT_HANDLED;
        }

        switch (message.what) {
            case CMD_PRE_DHCP_ACTION:
                handlePreDhcpSetup();
                break;
            case CMD_PRE_DHCP_ACTION_COMPLETE:
                if (mIpClient != null) {
                    mIpClient.completedPreDhcpAction();
                }
                break;
            case CMD_IPV4_PROVISIONING_FAILURE:
                stopDhcpSetup();
                deferMessage(message);
                break;
            case CMD_POST_DHCP_ACTION:
            case CMD_IPV4_PROVISIONING_SUCCESS:
            case CMD_IP_CONFIGURATION_SUCCESSFUL:
                deferMessage(message);
                break;
            default:
                return NOT_HANDLED;
        }

        return handleStatus;
    }

    private WifiNetworkAgentSpecifier createNetworkAgentSpecifier(
            @NonNull WifiConfiguration currentWifiConfiguration, @Nullable String currentBssid,
            boolean matchLocationSensitiveInformation) {
        // Defensive copy to avoid mutating the passed argument
        final WifiConfiguration conf = new WifiConfiguration(currentWifiConfiguration);
        conf.BSSID = currentBssid;
        WifiNetworkAgentSpecifier wns =
                new WifiNetworkAgentSpecifier(conf,
                        WifiNetworkSpecifier.getBand(mWifiInfo.getFrequency()),
                        matchLocationSensitiveInformation);
        return wns;
    }

    private NetworkCapabilities getCapabilities(
            WifiConfiguration currentWifiConfiguration, String currentBssid) {
        final NetworkCapabilities.Builder builder =
                new NetworkCapabilities.Builder(mNetworkCapabilitiesFilter);
        // MatchAllNetworkSpecifier set in the mNetworkCapabilitiesFilter should never be set in the
        // agent's specifier.
        builder.setNetworkSpecifier(null);
        if (currentWifiConfiguration == null) {
            return builder.build();
        }

        if (mWifiInfo.isTrusted()) {
            builder.addCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED);
        } else {
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_TRUSTED);
        }

        if (mWifiInfo.isRestricted()) {
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
        }

        if (SdkLevel.isAtLeastS()) {
            if (mWifiInfo.isOemPaid()) {
                builder.addCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID);
                builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
            } else {
                builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PAID);
            }
            if (mWifiInfo.isOemPrivate()) {
                builder.addCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE);
                builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
            } else {
                builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_OEM_PRIVATE);
            }
        }

        builder.setOwnerUid(currentWifiConfiguration.creatorUid);
        builder.setAdministratorUids(new int[]{currentWifiConfiguration.creatorUid});
        if (SdkLevel.isAtLeastT()) {
            builder.setAllowedUids(Set.of(currentWifiConfiguration.creatorUid));
        }

        if (!WifiConfiguration.isMetered(currentWifiConfiguration, mWifiInfo)) {
            builder.addCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
        } else {
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
        }

        if (mWifiInfo.getRssi() != WifiInfo.INVALID_RSSI) {
            builder.setSignalStrength(mWifiInfo.getRssi());
        } else {
            builder.setSignalStrength(NetworkCapabilities.SIGNAL_STRENGTH_UNSPECIFIED);
        }

        if (currentWifiConfiguration.osu) {
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
        }

        if (!WifiManager.UNKNOWN_SSID.equals(mWifiInfo.getSSID())) {
            builder.setSsid(mWifiInfo.getSSID());
        }

        // Only send out WifiInfo in >= Android S devices.
        if (SdkLevel.isAtLeastS()) {
            builder.setTransportInfo(new WifiInfo(mWifiInfo));

            if (mWifiInfo.getSubscriptionId() != SubscriptionManager.INVALID_SUBSCRIPTION_ID
                    && mWifiInfo.isCarrierMerged()) {
                builder.setSubscriptionIds(Collections.singleton(mWifiInfo.getSubscriptionId()));
            }
        }

        List<Integer> uids = new ArrayList<>(mNetworkFactory
                .getSpecificNetworkRequestUids(
                        currentWifiConfiguration, currentBssid));
        // There is an active specific request.
        // TODO: Check if the specific Request is for dual band Wifi or local only.
        if (!uids.isEmpty()
                && !mWifiConnectivityManager.hasMultiInternetConnection()) {
            // Remove internet capability.
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
            if (SdkLevel.isAtLeastS()) {
                builder.setUids(getUidRangeSet(uids));
            } else {
                // Use requestor Uid and PackageName on pre-S device.
                Pair<Integer, String> specificRequestUidAndPackageName = mNetworkFactory
                        .getSpecificNetworkRequestUidAndPackageName(currentWifiConfiguration,
                                currentBssid);
                // Fill up the uid/packageName for this connection.
                builder.setRequestorUid(specificRequestUidAndPackageName.first);
                builder.setRequestorPackageName(specificRequestUidAndPackageName.second);
            }
            // Fill up the network agent specifier for this connection, allowing NetworkCallbacks
            // to match local-only specifiers in requests. TODO(b/187921303): a third-party app can
            // observe this location-sensitive information by registering a NetworkCallback.
            builder.setNetworkSpecifier(createNetworkAgentSpecifier(currentWifiConfiguration,
                    getConnectedBssidInternal(), true /* matchLocalOnlySpecifiers */));
        } else {
            // Fill up the network agent specifier for this connection, without allowing
            // NetworkCallbacks to match local-only specifiers in requests.
            builder.setNetworkSpecifier(createNetworkAgentSpecifier(currentWifiConfiguration,
                    getConnectedBssidInternal(), false /* matchLocalOnlySpecifiers */));
        }

        updateLinkBandwidth(builder);
        final NetworkCapabilities networkCapabilities = builder.build();
        if (mVcnManager == null || !currentWifiConfiguration.carrierMerged) {
            return networkCapabilities;
        }
        final VcnNetworkPolicyResult vcnNetworkPolicy =
                mVcnManager.applyVcnNetworkPolicy(networkCapabilities, mLinkProperties);
        if (vcnNetworkPolicy.isTeardownRequested()) {
            sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_VCN_REQUEST);
        }
        final NetworkCapabilities vcnCapability = vcnNetworkPolicy.getNetworkCapabilities();
        if (!vcnCapability.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED)) {
            if (mVerboseLoggingEnabled) {
                logd("NET_CAPABILITY_NOT_VCN_MANAGED is removed");
            }
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VCN_MANAGED);
        }
        if (!vcnCapability.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED)) {
            if (mVerboseLoggingEnabled) {
                logd("NET_CAPABILITY_NOT_RESTRICTED is removed");
            }
            builder.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED);
        }
        return builder.build();
    }

    private Set<Range<Integer>> getUidRangeSet(List<Integer> uids) {
        Collections.sort(uids);
        Set<Range<Integer>> uidRanges = new ArraySet<>();
        int start = 0;
        int next = 0;
        for (int i : uids) {
            if (start == next) {
                start = i;
                next = start + 1;
            } else if (i == next) {
                next++;
            } else {
                uidRanges.add(new Range<>(start, next - 1));
                start = i;
                next = start + 1;
            }
        }
        uidRanges.add(new Range<>(start, next - 1));
        return uidRanges;
    }

    private void updateLinkBandwidth(NetworkCapabilities.Builder networkCapabilitiesBuilder) {
        int txTputKbps = 0;
        int rxTputKbps = 0;
        int currRssi = mWifiInfo.getRssi();
        if (currRssi != WifiInfo.INVALID_RSSI) {
            WifiScoreCard.PerNetwork network = mWifiScoreCard.lookupNetwork(mWifiInfo.getSSID());
            txTputKbps = network.getTxLinkBandwidthKbps();
            rxTputKbps = network.getRxLinkBandwidthKbps();
        } else {
            // Fall back to max link speed. This should rarely happen if ever
            int maxTxLinkSpeedMbps = mWifiInfo.getMaxSupportedTxLinkSpeedMbps();
            int maxRxLinkSpeedMbps = mWifiInfo.getMaxSupportedRxLinkSpeedMbps();
            txTputKbps = maxTxLinkSpeedMbps * 1000;
            rxTputKbps = maxRxLinkSpeedMbps * 1000;
        }
        if (mVerboseLoggingEnabled) {
            logd("reported txKbps " + txTputKbps + " rxKbps " + rxTputKbps);
        }
        if (txTputKbps > 0) {
            networkCapabilitiesBuilder.setLinkUpstreamBandwidthKbps(txTputKbps);
        }
        if (rxTputKbps > 0) {
            networkCapabilitiesBuilder.setLinkDownstreamBandwidthKbps(rxTputKbps);
        }
    }

    /**
     * Method to update network capabilities from the current WifiConfiguration.
     */
    @Override
    public void updateCapabilities() {
        updateCapabilities(getConnectedWifiConfigurationInternal());
    }

    private void updateCapabilities(WifiConfiguration currentWifiConfiguration) {
        updateCapabilities(getCapabilities(currentWifiConfiguration, getConnectedBssidInternal()));
    }

    private void updateCapabilities(NetworkCapabilities networkCapabilities) {
        if (mNetworkAgent == null) {
            return;
        }
        mNetworkAgent.sendNetworkCapabilitiesAndCache(networkCapabilities);
    }

    private void handleEapAuthFailure(int networkId, int errorCode) {
        WifiConfiguration targetedNetwork =
                mWifiConfigManager.getConfiguredNetwork(mTargetNetworkId);
        if (targetedNetwork != null) {
            switch (targetedNetwork.enterpriseConfig.getEapMethod()) {
                case WifiEnterpriseConfig.Eap.SIM:
                case WifiEnterpriseConfig.Eap.AKA:
                case WifiEnterpriseConfig.Eap.AKA_PRIME:
                    if (errorCode == WifiNative.EAP_SIM_VENDOR_SPECIFIC_CERT_EXPIRED) {
                        mWifiCarrierInfoManager.resetCarrierKeysForImsiEncryption(targetedNetwork);
                    }
                    break;

                default:
                    // Do Nothing
            }
        }
    }

    /**
     * All callbacks are triggered on the main Wifi thread.
     * See {@link WifiNetworkAgent#WifiNetworkAgent}'s looper argument in
     * {@link WifiInjector#makeWifiNetworkAgent}.
     */
    private class WifiNetworkAgentCallback implements WifiNetworkAgent.Callback {
        private int mLastNetworkStatus = -1; // To detect when the status really changes

        private boolean isThisCallbackActive() {
            return mNetworkAgent != null && mNetworkAgent.getCallback() == this;
        }

        @Override
        public void onNetworkUnwanted() {
            // Ignore if we're not the current networkAgent.
            if (!isThisCallbackActive()) return;
            if (mVerboseLoggingEnabled) {
                logd("WifiNetworkAgent -> Wifi unwanted score " + mWifiInfo.getScore());
            }
            unwantedNetwork(NETWORK_STATUS_UNWANTED_DISCONNECT);
        }

        @Override
        public void onValidationStatus(int status, @Nullable Uri redirectUri) {
            if (!isThisCallbackActive()) return;
            if (status == mLastNetworkStatus) return;
            mLastNetworkStatus = status;
            if (status == NetworkAgent.VALIDATION_STATUS_NOT_VALID) {
                if (mVerboseLoggingEnabled) {
                    logd("WifiNetworkAgent -> Wifi networkStatus invalid, score="
                            + mWifiInfo.getScore());
                }
                unwantedNetwork(NETWORK_STATUS_UNWANTED_VALIDATION_FAILED);
            } else if (status == NetworkAgent.VALIDATION_STATUS_VALID) {
                if (mVerboseLoggingEnabled) {
                    logd("WifiNetworkAgent -> Wifi networkStatus valid, score= "
                            + mWifiInfo.getScore());
                }
                mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_NETWORK_AGENT_VALID_NETWORK);
                doNetworkStatus(status);
            }
            boolean captivePortalDetected = redirectUri != null
                    && redirectUri.toString() != null
                    && redirectUri.toString().length() > 0;
            if (captivePortalDetected) {
                Log.i(getTag(), "Captive Portal detected, status=" + status
                        + ", redirectUri=" + redirectUri);
                mWifiConfigManager.noteCaptivePortalDetected(mWifiInfo.getNetworkId());
                mCmiMonitor.onCaptivePortalDetected(mClientModeManager);
                mCurrentConnectionDetectedCaptivePortal = true;
            }
        }

        @Override
        public void onSaveAcceptUnvalidated(boolean accept) {
            if (!isThisCallbackActive()) return;
            ClientModeImpl.this.sendMessage(CMD_ACCEPT_UNVALIDATED, accept ? 1 : 0);
        }

        @Override
        public void onStartSocketKeepalive(int slot, @NonNull Duration interval,
                @NonNull KeepalivePacketData packet) {
            if (!isThisCallbackActive()) return;
            ClientModeImpl.this.sendMessage(
                    CMD_START_IP_PACKET_OFFLOAD, slot, (int) interval.getSeconds(), packet);
        }

        @Override
        public void onStopSocketKeepalive(int slot) {
            if (!isThisCallbackActive()) return;
            ClientModeImpl.this.sendMessage(CMD_STOP_IP_PACKET_OFFLOAD, slot);
        }

        @Override
        public void onAddKeepalivePacketFilter(int slot, @NonNull KeepalivePacketData packet) {
            if (!isThisCallbackActive()) return;
            ClientModeImpl.this.sendMessage(
                    CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF, slot, 0, packet);
        }

        @Override
        public void onRemoveKeepalivePacketFilter(int slot) {
            if (!isThisCallbackActive()) return;
            ClientModeImpl.this.sendMessage(CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF, slot);
        }

        @Override
        public void onSignalStrengthThresholdsUpdated(@NonNull int[] thresholds) {
            if (!isThisCallbackActive()) return;
            // 0. If there are no thresholds, or if the thresholds are invalid,
            //    stop RSSI monitoring.
            // 1. Tell the hardware to start RSSI monitoring here, possibly adding MIN_VALUE and
            //    MAX_VALUE at the start/end of the thresholds array if necessary.
            // 2. Ensure that when the hardware event fires, we fetch the RSSI from the hardware
            //    event, call mWifiInfo.setRssi() with it, and call updateCapabilities(), and then
            //    re-arm the hardware event. This needs to be done on the state machine thread to
            //    avoid race conditions. The RSSI used to re-arm the event (and perhaps also the one
            //    sent in the NetworkCapabilities) must be the one received from the hardware event
            //    received, or we might skip callbacks.
            // 3. Ensure that when we disconnect, RSSI monitoring is stopped.
            logd("Received signal strength thresholds: " + Arrays.toString(thresholds));
            if (thresholds.length == 0) {
                ClientModeImpl.this.sendMessage(CMD_STOP_RSSI_MONITORING_OFFLOAD,
                        mWifiInfo.getRssi());
                return;
            }
            int [] rssiVals = Arrays.copyOf(thresholds, thresholds.length + 2);
            rssiVals[rssiVals.length - 2] = Byte.MIN_VALUE;
            rssiVals[rssiVals.length - 1] = Byte.MAX_VALUE;
            Arrays.sort(rssiVals);
            byte[] rssiRange = new byte[rssiVals.length];
            for (int i = 0; i < rssiVals.length; i++) {
                int val = rssiVals[i];
                if (val <= Byte.MAX_VALUE && val >= Byte.MIN_VALUE) {
                    rssiRange[i] = (byte) val;
                } else {
                    Log.e(getTag(), "Illegal value " + val + " for RSSI thresholds: "
                            + Arrays.toString(rssiVals));
                    ClientModeImpl.this.sendMessage(CMD_STOP_RSSI_MONITORING_OFFLOAD,
                            mWifiInfo.getRssi());
                    return;
                }
            }
            // TODO: Do we quash rssi values in this sorted array which are very close?
            mRssiRanges = rssiRange;
            ClientModeImpl.this.sendMessage(CMD_START_RSSI_MONITORING_OFFLOAD,
                    mWifiInfo.getRssi());
        }

        @Override
        public void onAutomaticReconnectDisabled() {
            if (!isThisCallbackActive()) return;
            unwantedNetwork(NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN);
        }

        @Override
        public void onDscpPolicyStatusUpdated(int policyId, int status) {
            mQosPolicyRequestHandler.setQosPolicyStatus(policyId, status);
        }
    }

    private boolean isNewConnectionInProgress(@NonNull String disconnectingSsid) {
        String targetSsid = getConnectingSsidInternal();
        // If network is removed while connecting, targetSsid can be null.
        if (targetSsid == null) {
            return false;
        }
        // When connecting to another network while already connected, the old network will first
        // disconnect before the new connection can begin. Thus, the presence of a mLastNetworkId
        // that's different from the mTargetNetworkId indicates that this network disconnection is
        // triggered for the previously connected network as opposed to the current ongoing
        // connection.
        boolean isConnectingWhileAlreadyConnected =
                mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID
                && mLastNetworkId != mTargetNetworkId;

        // This second condition is needed to catch cases where 2 simultaneous connections happen
        // back-to-back. When a new connection start before the previous one finishes, the
        // previous network will get removed from the supplicant and cause a disconnect message
        // to be received with the previous network's SSID. Thus, if the disconnecting SSID does not
        // match the target SSID, it means a new connection is in progress.
        boolean isConnectingToAnotherNetwork = !disconnectingSsid.equals(targetSsid);
        return isConnectingWhileAlreadyConnected || isConnectingToAnotherNetwork;
    }

    private void unwantedNetwork(int reason) {
        sendMessage(CMD_UNWANTED_NETWORK, reason);
    }

    private void doNetworkStatus(int status) {
        sendMessage(CMD_NETWORK_STATUS, status);
    }

    class ConnectingOrConnectedState extends State {
        @Override
        public void enter() {
            if (mVerboseLoggingEnabled) Log.v(getTag(), "Entering ConnectingOrConnectedState");
            mCmiMonitor.onConnectionStart(mClientModeManager);
        }

        @Override
        public void exit() {
            if (mVerboseLoggingEnabled) Log.v(getTag(), "Exiting ConnectingOrConnectedState");
            mCmiMonitor.onConnectionEnd(mClientModeManager);

            // Not connected/connecting to any network:
            // 1. Disable the network in supplicant to prevent it from auto-connecting. We don't
            // remove the network to avoid losing any cached info in supplicant (reauth, etc) in
            // case we reconnect back to the same network.
            // 2. Set a random MAC address to ensure that we're not leaking the MAC address.
            mWifiNative.disableNetwork(mInterfaceName);
            if (mWifiGlobals.isConnectedMacRandomizationEnabled()) {
                mFailedToResetMacAddress = !mWifiNative.setStaMacAddress(
                        mInterfaceName, MacAddressUtils.createRandomUnicastAddress());
                if (mFailedToResetMacAddress) {
                    Log.e(getTag(), "Failed to set random MAC address on disconnect");
                }
            }
            mWifiInfo.reset();
            mWifiInfo.setSupplicantState(SupplicantState.DISCONNECTED);
            mWifiScoreCard.noteSupplicantStateChanged(mWifiInfo);

            // For secondary client roles, they should stop themselves upon disconnection.
            // - Primary role shouldn't because it is persistent, and should try connecting to other
            //   networks upon disconnection.
            // - ROLE_CLIENT_LOCAL_ONLY shouldn't because it has auto-retry logic if the connection
            //   fails. WifiNetworkFactory will explicitly remove the CMM when the request is
            //   complete.
            // TODO(b/160346062): Maybe clean this up by having ClientModeManager register a
            //  onExitConnectingOrConnectedState() callback with ClientModeImpl and implementing
            //  this logic in ClientModeManager. ClientModeImpl should be role-agnostic.
            ClientRole role = mClientModeManager.getRole();
            if (role == ROLE_CLIENT_SECONDARY_LONG_LIVED
                    || role == ROLE_CLIENT_SECONDARY_TRANSIENT) {
                if (mVerboseLoggingEnabled) {
                    Log.d(getTag(), "Disconnected in ROLE_CLIENT_SECONDARY_*, "
                            + "stop ClientModeManager=" + mClientModeManager);
                }
                // stop owner ClientModeManager, which will in turn stop this ClientModeImpl
                mClientModeManager.stop();
            }
        }

        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;
            switch (message.what) {
                case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT: {
                    StateChangeResult stateChangeResult = (StateChangeResult) message.obj;
                    SupplicantState state = handleSupplicantStateChange(stateChangeResult);
                    // Supplicant can fail to report a NETWORK_DISCONNECTION_EVENT
                    // when authentication times out after a successful connection,
                    // we can figure this from the supplicant state. If supplicant
                    // state is DISCONNECTED, but the agent is not disconnected, we
                    // need to handle a disconnection
                    if (mVerboseLoggingEnabled) {
                        log("ConnectingOrConnectedState: Supplicant State change "
                                + stateChangeResult);
                    }
                    @SupplicantEventCode int supplicantEvent;
                    switch (stateChangeResult.state) {
                        case COMPLETED:
                            supplicantEvent = SupplicantStaIfaceHal.SUPPLICANT_EVENT_CONNECTED;
                            break;
                        case ASSOCIATING:
                            supplicantEvent = SupplicantStaIfaceHal.SUPPLICANT_EVENT_ASSOCIATING;
                            break;
                        case ASSOCIATED:
                            supplicantEvent = SupplicantStaIfaceHal.SUPPLICANT_EVENT_ASSOCIATED;
                            break;
                        default:
                            supplicantEvent = -1;
                    }
                    if (supplicantEvent != -1) {
                        WifiConfiguration config = mWifiConfigManager.getConfiguredNetwork(
                                    stateChangeResult.networkId);
                        try {
                            logEventIfManagedNetwork(config, supplicantEvent,
                                    MacAddress.fromString(stateChangeResult.bssid), "");
                        } catch (IllegalArgumentException e) {
                            Log.i(TAG, "Invalid bssid received for state change event");
                        }
                    }
                    if (state == SupplicantState.DISCONNECTED && mNetworkAgent != null) {
                        if (mVerboseLoggingEnabled) {
                            log("Missed CTRL-EVENT-DISCONNECTED, disconnect");
                        }
                        handleNetworkDisconnect(false,
                                WIFI_DISCONNECT_REPORTED__FAILURE_CODE__SUPPLICANT_DISCONNECTED);
                        transitionTo(mDisconnectedState);
                    }
                    if (state == SupplicantState.COMPLETED) {
                        mWifiScoreReport.noteIpCheck();
                    }
                    break;
                }
                case WifiMonitor.ASSOCIATED_BSSID_EVENT: {
                    // This is where we can confirm the connection BSSID. Use it to find the
                    // right ScanDetail to populate metrics.
                    String someBssid = (String) message.obj;
                    if (someBssid != null) {
                        // Get the ScanDetail associated with this BSSID.
                        ScanDetailCache scanDetailCache =
                                mWifiConfigManager.getScanDetailCacheForNetwork(mTargetNetworkId);
                        if (scanDetailCache != null) {
                            mWifiMetrics.setConnectionScanDetail(mInterfaceName,
                                    scanDetailCache.getScanDetail(someBssid));
                        }
                        // Update last associated BSSID
                        mLastBssid = someBssid;
                    }
                    handleStatus = NOT_HANDLED;
                    break;
                }
                case WifiMonitor.NETWORK_CONNECTION_EVENT: {
                    if (mVerboseLoggingEnabled) log("Network connection established");
                    NetworkConnectionEventInfo connectionInfo =
                            (NetworkConnectionEventInfo) message.obj;
                    mLastNetworkId = connectionInfo.networkId;
                    mSentHLPs = connectionInfo.isFilsConnection;
                    if (mSentHLPs) mWifiMetrics.incrementL2ConnectionThroughFilsAuthCount();
                    mWifiConfigManager.clearRecentFailureReason(mLastNetworkId);
                    mLastBssid = connectionInfo.bssid;
                    // TODO: This check should not be needed after ClientModeImpl refactor.
                    // Currently, the last connected network configuration is left in
                    // wpa_supplicant, this may result in wpa_supplicant initiating connection
                    // to it after a config store reload. Hence the old network Id lookups may not
                    // work, so disconnect the network and let network selector reselect a new
                    // network.
                    WifiConfiguration config = getConnectedWifiConfigurationInternal();
                    if (config == null) {
                        logw("Connected to unknown networkId " + mLastNetworkId
                                + ", disconnecting...");
                        sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_UNKNOWN_NETWORK);
                        break;
                    }
                    mWifiInfo.setBSSID(mLastBssid);
                    mWifiInfo.setNetworkId(mLastNetworkId);
                    mWifiInfo.setMacAddress(mWifiNative.getMacAddress(mInterfaceName));

                    ScanDetailCache scanDetailCache =
                            mWifiConfigManager.getScanDetailCacheForNetwork(config.networkId);
                    ScanResult scanResult = null;
                    if (scanDetailCache != null && mLastBssid != null) {
                        scanResult = scanDetailCache.getScanResult(mLastBssid);
                        if (scanResult != null) {
                            mWifiInfo.setFrequency(scanResult.frequency);
                        }
                    }

                    // We need to get the updated pseudonym from supplicant for EAP-SIM/AKA/AKA'
                    if (config.enterpriseConfig != null
                            && config.enterpriseConfig.isAuthenticationSimBased()) {
                        mLastSubId = mWifiCarrierInfoManager.getBestMatchSubscriptionId(config);
                        mLastSimBasedConnectionCarrierName =
                                mWifiCarrierInfoManager.getCarrierNameForSubId(mLastSubId);
                        String anonymousIdentity =
                                mWifiNative.getEapAnonymousIdentity(mInterfaceName);
                        if (!TextUtils.isEmpty(anonymousIdentity)
                                && !WifiCarrierInfoManager
                                .isAnonymousAtRealmIdentity(anonymousIdentity)) {
                            String decoratedPseudonym = mWifiCarrierInfoManager
                                    .decoratePseudonymWith3GppRealm(config,
                                            anonymousIdentity);
                            if (decoratedPseudonym != null
                                    && !decoratedPseudonym.equals(anonymousIdentity)) {
                                anonymousIdentity = decoratedPseudonym;
                                // propagate to the supplicant to avoid using
                                // the original anonymous identity for firmware
                                // roaming.
                                if (mVerboseLoggingEnabled) {
                                    log("Update decorated pseudonym: " + anonymousIdentity);
                                }
                                mWifiNative.setEapAnonymousIdentity(mInterfaceName,
                                        anonymousIdentity);
                            }
                            if (mVerboseLoggingEnabled) {
                                log("EAP Pseudonym: " + anonymousIdentity);
                            }
                            // Save the pseudonym only if it is a real one
                            config.enterpriseConfig.setAnonymousIdentity(anonymousIdentity);
                        } else {
                            // Clear any stored pseudonyms
                            config.enterpriseConfig.setAnonymousIdentity(null);
                        }
                        mWifiConfigManager.addOrUpdateNetwork(config, Process.WIFI_UID);
                        if (config.isPasspoint()) {
                            mPasspointManager.setAnonymousIdentity(config);
                        } else if (config.fromWifiNetworkSuggestion) {
                            mWifiNetworkSuggestionsManager.setAnonymousIdentity(config);
                        }
                    }
                    // When connecting to Passpoint, ask for the Venue URL
                    if (config.isPasspoint()) {
                        mTermsAndConditionsUrl = null;
                        if (scanResult == null && mLastBssid != null) {
                            // The cached scan result of connected network would be null at the
                            // first connection, try to check full scan result list again to look up
                            // matched scan result associated to the current SSID and BSSID.
                            scanResult = mScanRequestProxy.getScanResult(mLastBssid);
                        }
                        if (scanResult != null) {
                            mPasspointManager.requestVenueUrlAnqpElement(scanResult);
                        }
                    }
                    mWifiInfo.setNetworkKey(config.getNetworkKeyFromSecurityType(
                            mWifiInfo.getCurrentSecurityType()));
                    transitionTo(mL3ProvisioningState);
                    break;
                }
                case WifiMonitor.SUP_REQUEST_SIM_AUTH: {
                    logd("Received SUP_REQUEST_SIM_AUTH");
                    SimAuthRequestData requestData = (SimAuthRequestData) message.obj;
                    if (requestData != null) {
                        if (requestData.protocol == WifiEnterpriseConfig.Eap.SIM) {
                            handleGsmAuthRequest(requestData);
                        } else if (requestData.protocol == WifiEnterpriseConfig.Eap.AKA
                                || requestData.protocol == WifiEnterpriseConfig.Eap.AKA_PRIME) {
                            handle3GAuthRequest(requestData);
                        }
                    } else {
                        loge("Invalid SIM auth request");
                    }
                    break;
                }
                case WifiMonitor.NETWORK_DISCONNECTION_EVENT: {
                    DisconnectEventInfo eventInfo = (DisconnectEventInfo) message.obj;
                    if (mVerboseLoggingEnabled) {
                        log("ConnectingOrConnectedState: Network disconnection " + eventInfo);
                    }
                    if (eventInfo.reasonCode
                            == StaIfaceReasonCode.FOURWAY_HANDSHAKE_TIMEOUT) {
                        String bssid = !isValidBssid(eventInfo.bssid)
                                ? mTargetBssid : eventInfo.bssid;
                        mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                                getConnectingSsidInternal(), bssid,
                                WifiLastResortWatchdog.FAILURE_CODE_AUTHENTICATION,
                                isConnected());
                    }
                    WifiConfiguration config = getConnectingWifiConfigurationInternal();
                    clearNetworkCachedDataIfNeeded(config, eventInfo.reasonCode);
                    try {
                        logEventIfManagedNetwork(config,
                                SupplicantStaIfaceHal.SUPPLICANT_EVENT_DISCONNECTED,
                                MacAddress.fromString(eventInfo.bssid),
                                "reason=" + eventInfo.reasonCode);
                    } catch (IllegalArgumentException e) {
                        Log.e(TAG, "Invalid bssid received for disconnection event");
                    }
                    boolean newConnectionInProgress = isNewConnectionInProgress(eventInfo.ssid);
                    if (!newConnectionInProgress) {
                        int level2FailureReason = eventInfo.locallyGenerated
                                ? WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN :
                                WifiMetricsProto.ConnectionEvent.DISCONNECTION_NON_LOCAL;
                        if (!eventInfo.locallyGenerated) {
                            mWifiScoreCard.noteNonlocalDisconnect(
                                    mInterfaceName, eventInfo.reasonCode);
                        }
                        reportConnectionAttemptEnd(
                                WifiMetrics.ConnectionEvent.FAILURE_NETWORK_DISCONNECTION,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE, level2FailureReason);
                    }
                    handleNetworkDisconnect(newConnectionInProgress, eventInfo.reasonCode);
                    if (!newConnectionInProgress) {
                        transitionTo(mDisconnectedState);
                    }
                    mTermsAndConditionsUrl = null;
                    break;
                }
                case WifiMonitor.TARGET_BSSID_EVENT: {
                    // Trying to associate to this BSSID
                    if (message.obj != null) {
                        mTargetBssid = (String) message.obj;
                    }
                    break;
                }
                case WifiMonitor.AUXILIARY_SUPPLICANT_EVENT: {
                    SupplicantEventInfo eventInfo = (SupplicantEventInfo) message.obj;
                    logEventIfManagedNetwork(getConnectingWifiConfigurationInternal(),
                            eventInfo.eventCode, eventInfo.bssid,
                            eventInfo.reasonString);
                    break;
                }
                case CMD_DISCONNECT: {
                    mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                            message.arg1);
                    mWifiNative.disconnect(mInterfaceName);
                    break;
                }
                case CMD_PRE_DHCP_ACTION:
                case CMD_PRE_DHCP_ACTION_COMPLETE:
                case CMD_POST_DHCP_ACTION:
                case CMD_IPV4_PROVISIONING_SUCCESS:
                case CMD_IP_CONFIGURATION_SUCCESSFUL:
                case CMD_IPV4_PROVISIONING_FAILURE: {
                    handleStatus = handleL3MessagesWhenNotConnected(message);
                    break;
                }
                case WifiMonitor.TRANSITION_DISABLE_INDICATION: {
                    log("Received TRANSITION_DISABLE_INDICATION: networkId=" + message.arg1
                            + ", indication=" + message.arg2);
                    mWifiConfigManager.updateNetworkTransitionDisable(message.arg1, message.arg2);
                    break;
                }
                case WifiMonitor.QOS_POLICY_RESET_EVENT: {
                    if (SdkLevel.isAtLeastT() && mNetworkAgent != null) {
                        mNetworkAgent.sendRemoveAllDscpPolicies();
                    }
                    break;
                }
                case WifiMonitor.QOS_POLICY_REQUEST_EVENT: {
                    if (SdkLevel.isAtLeastT()) {
                        mQosPolicyRequestHandler.queueQosPolicyRequest(
                                message.arg1, (List<QosPolicyRequest>) message.obj);
                    }
                    break;
                }
                case CMD_REJECT_EAP_INSECURE_CONNECTION: {
                    log("Received CMD_REJECT_EAP_INSECURE_CONNECTION event");
                    boolean disconnectRequired = message.arg2 == 1;

                    // TOFU connections are not established until the user approves the certificate.
                    // If TOFU is not supported and the network is already connected, this will
                    // disconnect the network.
                    if (disconnectRequired) {
                        sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_UNTRUSTED);
                    }
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }
            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }
            return handleStatus;
        }
    }

    class L2ConnectingState extends State {
        @Override
        public void enter() {
            if (mVerboseLoggingEnabled) Log.v(getTag(), "Entering L2ConnectingState");
            // Make sure we connect: we enter this state prior to connecting to a new
            // network. In some cases supplicant ignores the connect requests (it might not
            // find the target SSID in its cache), Therefore we end up stuck that state, hence the
            // need for the watchdog.
            mConnectingWatchdogCount++;
            logd("Start Connecting Watchdog " + mConnectingWatchdogCount);
            sendMessageDelayed(obtainMessage(CMD_CONNECTING_WATCHDOG_TIMER,
                    mConnectingWatchdogCount, 0), CONNECTING_WATCHDOG_TIMEOUT_MS);
        }

        @Override
        public void exit() {
            if (mVerboseLoggingEnabled) Log.v(getTag(), "Exiting L2ConnectingState");
        }

        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;
            switch (message.what) {
                case WifiMonitor.NETWORK_NOT_FOUND_EVENT:
                    mNetworkNotFoundEventCount++;
                    String networkName = (String) message.obj;
                    if (networkName != null && !networkName.equals(getConnectingSsidInternal())) {
                        loge("Network not found event received, network: " + networkName
                                + " which is not the target network: "
                                + getConnectingSsidInternal());
                        break;
                    }
                    Log.d(getTag(), "Network not found event received: network: " + networkName);
                    if (mNetworkNotFoundEventCount >= NETWORK_NOT_FOUND_EVENT_THRESHOLD
                            && mTargetWifiConfiguration != null
                            && mTargetWifiConfiguration.SSID != null
                            && mTargetWifiConfiguration.SSID.equals(networkName)) {
                        stopIpClient();
                        mWifiConfigManager.updateNetworkSelectionStatus(
                                mTargetWifiConfiguration.networkId,
                                WifiConfiguration.NetworkSelectionStatus
                                        .DISABLED_NETWORK_NOT_FOUND);
                        if (SdkLevel.isAtLeastS()) {
                            mWifiConfigManager.setRecentFailureAssociationStatus(
                                    mTargetWifiConfiguration.networkId,
                                    WifiConfiguration.RECENT_FAILURE_NETWORK_NOT_FOUND);
                        }
                        reportConnectionAttemptEnd(
                                WifiMetrics.ConnectionEvent.FAILURE_NETWORK_NOT_FOUND,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE,
                                WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
                        handleNetworkDisconnect(false,
                                WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__UNSPECIFIED);
                        transitionTo(mDisconnectedState); // End of connection attempt.
                    }
                    break;
                case WifiMonitor.ASSOCIATION_REJECTION_EVENT: {
                    AssocRejectEventInfo assocRejectEventInfo = (AssocRejectEventInfo) message.obj;
                    log("L2ConnectingState: Association rejection " + assocRejectEventInfo);
                    if (!assocRejectEventInfo.ssid.equals(getConnectingSsidInternal())) {
                        loge("Association rejection event received on not target network");
                        break;
                    }
                    stopIpClient();
                    mWifiDiagnostics.triggerBugReportDataCapture(
                            WifiDiagnostics.REPORT_REASON_ASSOC_FAILURE);
                    String bssid = assocRejectEventInfo.bssid;
                    boolean timedOut = assocRejectEventInfo.timedOut;
                    int statusCode = assocRejectEventInfo.statusCode;
                    if (!isValidBssid(bssid)) {
                        // If BSSID is null, use the target roam BSSID
                        bssid = mTargetBssid;
                    } else if (SUPPLICANT_BSSID_ANY.equals(mTargetBssid)) {
                        // This is needed by WifiBlocklistMonitor to block continuously
                        // failing BSSIDs. Need to set here because mTargetBssid is currently
                        // not being set until association success.
                        mTargetBssid = bssid;
                    }
                    mWifiConfigManager.updateNetworkSelectionStatus(mTargetNetworkId,
                            WifiConfiguration.NetworkSelectionStatus
                                    .DISABLED_ASSOCIATION_REJECTION);
                    setAssociationRejectionStatusInConfig(mTargetNetworkId, assocRejectEventInfo);
                    int level2FailureReason =
                            WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN;
                    if (statusCode == StaIfaceStatusCode.AP_UNABLE_TO_HANDLE_NEW_STA
                            || statusCode == StaIfaceStatusCode.ASSOC_REJECTED_TEMPORARILY
                            || statusCode == StaIfaceStatusCode.DENIED_INSUFFICIENT_BANDWIDTH) {
                        level2FailureReason = WifiMetricsProto.ConnectionEvent
                                .ASSOCIATION_REJECTION_AP_UNABLE_TO_HANDLE_NEW_STA;
                    }
                    // If rejection occurred while Metrics is tracking a ConnectionEvent, end it.
                    reportConnectionAttemptEnd(
                            timedOut
                                    ? WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_TIMED_OUT
                                    : WifiMetrics.ConnectionEvent.FAILURE_ASSOCIATION_REJECTION,
                            WifiMetricsProto.ConnectionEvent.HLF_NONE,
                            level2FailureReason);
                    if (level2FailureReason != WifiMetricsProto.ConnectionEvent
                            .ASSOCIATION_REJECTION_AP_UNABLE_TO_HANDLE_NEW_STA) {
                        mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                                getConnectingSsidInternal(), bssid,
                                WifiLastResortWatchdog.FAILURE_CODE_ASSOCIATION,
                                isConnected());
                    }
                    handleNetworkDisconnect(false,
                            WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__UNSPECIFIED);
                    transitionTo(mDisconnectedState); // End of connection attempt.
                    break;
                }
                case WifiMonitor.AUTHENTICATION_FAILURE_EVENT: {
                    AuthenticationFailureEventInfo authenticationFailureEventInfo =
                            (AuthenticationFailureEventInfo) message.obj;
                    if (!TextUtils.equals(authenticationFailureEventInfo.ssid,
                            getConnectingSsidInternal())) {
                        logw("Authentication failure event received on not target network");
                        break;
                    }
                    stopIpClient();
                    mWifiDiagnostics.triggerBugReportDataCapture(
                            WifiDiagnostics.REPORT_REASON_AUTH_FAILURE);
                    int disableReason = WifiConfiguration.NetworkSelectionStatus
                            .DISABLED_AUTHENTICATION_FAILURE;
                    int reasonCode = authenticationFailureEventInfo.reasonCode;
                    int errorCode = authenticationFailureEventInfo.errorCode;
                    log("L2ConnectingState: Authentication failure "
                            + " reason=" + reasonCode + " error=" + errorCode);
                    WifiConfiguration targetedNetwork =
                            mWifiConfigManager.getConfiguredNetwork(mTargetNetworkId);
                    // Check if this is a permanent wrong password failure.
                    if (isPermanentWrongPasswordFailure(mTargetNetworkId, reasonCode)) {
                        disableReason = WifiConfiguration.NetworkSelectionStatus
                                .DISABLED_BY_WRONG_PASSWORD;
                        // For primary role, send error notification except for local only network,
                        // for secondary role, send only for secondary internet.
                        final boolean isForLocalOnly = isRequestedForLocalOnly(
                                targetedNetwork, mTargetBssid) || isLocalOnly();
                        final boolean needNotifyError = isPrimary() ? !isForLocalOnly
                                : isSecondaryInternet();
                        if (targetedNetwork != null && needNotifyError) {
                            mWrongPasswordNotifier.onWrongPasswordError(targetedNetwork);
                        }
                    } else if (reasonCode == WifiManager.ERROR_AUTH_FAILURE_EAP_FAILURE) {
                        logEventIfManagedNetwork(targetedNetwork,
                                SupplicantStaIfaceHal.SUPPLICANT_EVENT_EAP_FAILURE,
                                authenticationFailureEventInfo.bssid, "error=" + errorCode);
                        if (targetedNetwork != null && targetedNetwork.enterpriseConfig != null
                                && targetedNetwork.enterpriseConfig.isAuthenticationSimBased()) {
                            // only show EAP failure notification if primary
                            if (mEapFailureNotifier
                                    .onEapFailure(errorCode, targetedNetwork, isPrimary())) {
                                disableReason = WifiConfiguration.NetworkSelectionStatus
                                    .DISABLED_AUTHENTICATION_PRIVATE_EAP_ERROR;
                                mWifiBlocklistMonitor.loadCarrierConfigsForDisableReasonInfos();
                            }
                        }
                        handleEapAuthFailure(mTargetNetworkId, errorCode);
                        if (errorCode == WifiNative.EAP_SIM_NOT_SUBSCRIBED) {
                            disableReason = WifiConfiguration.NetworkSelectionStatus
                                    .DISABLED_AUTHENTICATION_NO_SUBSCRIPTION;
                        }
                    }
                    mWifiConfigManager.updateNetworkSelectionStatus(
                            mTargetNetworkId, disableReason);
                    mWifiConfigManager.clearRecentFailureReason(mTargetNetworkId);

                    //If failure occurred while Metrics is tracking a ConnnectionEvent, end it.
                    int level2FailureReason;
                    switch (reasonCode) {
                        case WifiManager.ERROR_AUTH_FAILURE_NONE:
                            level2FailureReason =
                                    WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_NONE;
                            break;
                        case WifiManager.ERROR_AUTH_FAILURE_TIMEOUT:
                            level2FailureReason =
                                    WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_TIMEOUT;
                            break;
                        case WifiManager.ERROR_AUTH_FAILURE_WRONG_PSWD:
                            level2FailureReason =
                                    WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_WRONG_PSWD;
                            break;
                        case WifiManager.ERROR_AUTH_FAILURE_EAP_FAILURE:
                            level2FailureReason =
                                    WifiMetricsProto.ConnectionEvent.AUTH_FAILURE_EAP_FAILURE;
                            break;
                        default:
                            level2FailureReason =
                                    WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN;
                            break;
                    }
                    reportConnectionAttemptEnd(
                            WifiMetrics.ConnectionEvent.FAILURE_AUTHENTICATION_FAILURE,
                            WifiMetricsProto.ConnectionEvent.HLF_NONE,
                            level2FailureReason);
                    if (reasonCode != WifiManager.ERROR_AUTH_FAILURE_WRONG_PSWD && reasonCode
                            != WifiManager.ERROR_AUTH_FAILURE_EAP_FAILURE) {
                        mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                                getConnectingSsidInternal(),
                                (mLastBssid == null) ? mTargetBssid : mLastBssid,
                                WifiLastResortWatchdog.FAILURE_CODE_AUTHENTICATION,
                                isConnected());
                    }
                    handleNetworkDisconnect(false,
                            WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__UNSPECIFIED);
                    transitionTo(mDisconnectedState); // End of connection attempt.
                    break;
                }
                case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT: {
                    StateChangeResult stateChangeResult = (StateChangeResult) message.obj;
                    if (SupplicantState.isConnecting(stateChangeResult.state)) {
                        WifiConfiguration config = mWifiConfigManager.getConfiguredNetwork(
                                stateChangeResult.networkId);
                        // Update Passpoint information before setNetworkDetailedState as
                        // WifiTracker monitors NETWORK_STATE_CHANGED_ACTION to update UI.
                        mWifiInfo.setFQDN(null);
                        mWifiInfo.setPasspointUniqueId(null);
                        mWifiInfo.setOsuAp(false);
                        mWifiInfo.setProviderFriendlyName(null);
                        if (config != null && (config.isPasspoint() || config.osu)) {
                            if (config.isPasspoint()) {
                                mWifiInfo.setFQDN(config.FQDN);
                                mWifiInfo.setPasspointUniqueId(config.getPasspointUniqueId());
                            } else {
                                mWifiInfo.setOsuAp(true);
                            }
                            mWifiInfo.setProviderFriendlyName(config.providerFriendlyName);
                            mWifiInfo.setNetworkKey(
                                    config.getNetworkKeyFromSecurityType(
                                            mWifiInfo.getCurrentSecurityType()));
                        }
                    }
                    sendNetworkChangeBroadcast(
                            WifiInfo.getDetailedStateOf(stateChangeResult.state));
                    // Let the parent state handle the rest of the state changed.
                    handleStatus = NOT_HANDLED;
                    break;
                }
                case WifiMonitor.SUP_REQUEST_IDENTITY: {
                    int netId = message.arg2;
                    boolean identitySent = false;
                    // For SIM & AKA/AKA' EAP method Only, get identity from ICC
                    if (mTargetWifiConfiguration != null
                            && mTargetWifiConfiguration.networkId == netId
                            && mTargetWifiConfiguration.enterpriseConfig != null
                            && mTargetWifiConfiguration.enterpriseConfig
                            .isAuthenticationSimBased()) {
                        // Pair<identity, encrypted identity>
                        Pair<String, String> identityPair = mWifiCarrierInfoManager
                                .getSimIdentity(mTargetWifiConfiguration);
                        if (identityPair != null && identityPair.first != null) {
                            Log.i(getTag(), "SUP_REQUEST_IDENTITY: identityPair=["
                                    + ((identityPair.first.length() >= 7)
                                    ? identityPair.first.substring(0, 7 /* Prefix+PLMN ID */)
                                    + "****"
                                    : identityPair.first) + ", "
                                    + (!TextUtils.isEmpty(identityPair.second) ? identityPair.second
                                    : "<NONE>") + "]");
                            mWifiNative.simIdentityResponse(mInterfaceName, identityPair.first,
                                    identityPair.second);
                            identitySent = true;
                        } else {
                            Log.e(getTag(), "Unable to retrieve identity from Telephony");
                        }
                    }

                    if (!identitySent) {
                        // Supplicant lacks credentials to connect to that network, hence block list
                        String ssid = (String) message.obj;
                        if (mTargetWifiConfiguration != null && ssid != null
                                && mTargetWifiConfiguration.SSID != null
                                && mTargetWifiConfiguration.SSID.equals("\"" + ssid + "\"")) {
                            mWifiConfigManager.updateNetworkSelectionStatus(
                                    mTargetWifiConfiguration.networkId,
                                    WifiConfiguration.NetworkSelectionStatus
                                            .DISABLED_AUTHENTICATION_NO_CREDENTIALS);
                        }
                        mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                StaEvent.DISCONNECT_GENERIC);
                        mWifiNative.disconnect(mInterfaceName);
                    }
                    break;
                }
                case CMD_CONNECTING_WATCHDOG_TIMER: {
                    if (mConnectingWatchdogCount == message.arg1) {
                        if (mVerboseLoggingEnabled) log("Connecting watchdog! -> disconnect");
                        handleNetworkDisconnect(false,
                                WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__CONNECTING_WATCHDOG_TIMER);
                        transitionTo(mDisconnectedState);
                    }
                    break;
                }
                case WifiMonitor.NETWORK_CONNECTION_EVENT: {
                    NetworkConnectionEventInfo connectionInfo =
                            (NetworkConnectionEventInfo) message.obj;
                    String quotedOrHexConnectingSsid = getConnectingSsidInternal();
                    String quotedOrHexConnectedSsid = NativeUtil.encodeSsid(
                            NativeUtil.byteArrayToArrayList(connectionInfo.wifiSsid.getBytes()));
                    if (quotedOrHexConnectingSsid != null
                            && !quotedOrHexConnectingSsid.equals(quotedOrHexConnectedSsid)) {
                        // possibly a NETWORK_CONNECTION_EVENT for a successful roam on the previous
                        // network while connecting to a new network, ignore it.
                        Log.d(TAG, "Connecting to ssid=" + quotedOrHexConnectingSsid + ", but got "
                                + "NETWORK_CONNECTION_EVENT for ssid=" + quotedOrHexConnectedSsid
                                + ", ignoring");
                        break;
                    }
                    handleStatus = NOT_HANDLED;
                    break;
                }
                case WifiMonitor.TOFU_CERTIFICATE_EVENT: {
                    if (null == mTargetWifiConfiguration) break;
                    final int certificateDepth = message.arg2;
                    final CertificateEventInfo eventInfo = (CertificateEventInfo) message.obj;
                    if (!mInsecureEapNetworkHandler.addPendingCertificate(
                            mTargetWifiConfiguration.SSID, certificateDepth, eventInfo)) {
                        Log.d(TAG, "Cannot set pending cert.");
                    }
                    // Launch user approval upon receiving the server certificate and disconnect
                    if (certificateDepth == 0 && !mLeafCertSent && mInsecureEapNetworkHandler
                            .startUserApprovalIfNecessary(mIsUserSelected)) {
                        // In the TOFU flow, the user approval dialog is now displayed and the
                        // network remains disconnected and disabled until it is approved.
                        sendMessage(CMD_DISCONNECT, StaEvent.DISCONNECT_NETWORK_UNTRUSTED);
                        mLeafCertSent = true;
                    }
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }
            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }
            return handleStatus;
        }
    }

    class L2ConnectedState extends State {
        class RssiEventHandler implements WifiNative.WifiRssiEventHandler {
            @Override
            public void onRssiThresholdBreached(byte curRssi) {
                if (mVerboseLoggingEnabled) {
                    Log.e(getTag(), "onRssiThresholdBreach event. Cur Rssi = " + curRssi);
                }
                sendMessage(CMD_RSSI_THRESHOLD_BREACHED, curRssi);
            }
        }

        RssiEventHandler mRssiEventHandler = new RssiEventHandler();

        @Override
        public void enter() {
            mRssiPollToken++;
            if (mEnableRssiPolling) {
                if (isPrimary()) {
                    mLinkProbeManager.resetOnNewConnection();
                }
                sendMessage(CMD_RSSI_POLL, mRssiPollToken, 0);
            }
            sendNetworkChangeBroadcast(DetailedState.CONNECTING);

            // If this network was explicitly selected by the user, evaluate whether to inform
            // ConnectivityService of that fact so the system can treat it appropriately.
            final WifiConfiguration config = getConnectedWifiConfigurationInternal();

            final NetworkAgentConfig naConfig = getNetworkAgentConfigInternal(config);
            final NetworkCapabilities nc = getCapabilities(
                    getConnectedWifiConfigurationInternal(), getConnectedBssidInternal());
            // This should never happen.
            if (mNetworkAgent != null) {
                Log.wtf(getTag(), "mNetworkAgent is not null: " + mNetworkAgent);
                mNetworkAgent.unregister();
            }
            mNetworkAgent = mWifiInjector.makeWifiNetworkAgent(nc, mLinkProperties, naConfig,
                    mNetworkFactory.getProvider(), new WifiNetworkAgentCallback());
            mWifiScoreReport.setNetworkAgent(mNetworkAgent);
            if (SdkLevel.isAtLeastT()) {
                mQosPolicyRequestHandler.setNetworkAgent(mNetworkAgent);
            }

            // We must clear the config BSSID, as the wifi chipset may decide to roam
            // from this point on and having the BSSID specified in the network block would
            // cause the roam to faile and the device to disconnect
            clearTargetBssid("L2ConnectedState");
            mWifiMetrics.setWifiState(mInterfaceName, WifiMetricsProto.WifiLog.WIFI_ASSOCIATED);
            mWifiScoreCard.noteNetworkAgentCreated(mWifiInfo,
                    mNetworkAgent.getNetwork().getNetId());
            mWifiBlocklistMonitor.handleBssidConnectionSuccess(mLastBssid, mWifiInfo.getSSID());
            // too many places to record connection failure with too many failure reasons.
            // So only record success here.
            mWifiMetrics.noteFirstL2ConnectionAfterBoot(true);
            mCmiMonitor.onL2Connected(mClientModeManager);
            mIsLinkedNetworkRoaming = false;
        }

        @Override
        public void exit() {
            // This is handled by receiving a NETWORK_DISCONNECTION_EVENT in ConnectableState
            // Bug: 15347363
            // For paranoia's sake, call handleNetworkDisconnect
            // only if BSSID is null or last networkId
            // is not invalid.
            if (mVerboseLoggingEnabled) {
                StringBuilder sb = new StringBuilder();
                sb.append("leaving L2ConnectedState state nid=" + Integer.toString(mLastNetworkId));
                if (mLastBssid != null) {
                    sb.append(" ").append(mLastBssid);
                }
            }
            mWifiMetrics.setWifiState(mInterfaceName, WifiMetricsProto.WifiLog.WIFI_DISCONNECTED);
            mWifiStateTracker.updateState(mInterfaceName, WifiStateTracker.DISCONNECTED);
            // Inform WifiLockManager
            mWifiLockManager.updateWifiClientConnected(mClientModeManager, false);
            mLastConnectionCapabilities = null;
        }

        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;

            switch (message.what) {
                case CMD_PRE_DHCP_ACTION: {
                    handlePreDhcpSetup();
                    break;
                }
                case CMD_PRE_DHCP_ACTION_COMPLETE: {
                    if (mIpClient != null) {
                        mIpClient.completedPreDhcpAction();
                    }
                    break;
                }
                case CMD_POST_DHCP_ACTION: {
                    handlePostDhcpSetup();
                    // We advance to mL3ConnectedState because IpClient will also send a
                    // CMD_IPV4_PROVISIONING_SUCCESS message, which calls handleIPv4Success(),
                    // which calls updateLinkProperties, which then sends
                    // CMD_IP_CONFIGURATION_SUCCESSFUL.
                    break;
                }
                case CMD_IPV4_PROVISIONING_SUCCESS: {
                    handleIPv4Success((DhcpResultsParcelable) message.obj);
                    sendNetworkChangeBroadcastWithCurrentState();
                    break;
                }
                case CMD_IPV4_PROVISIONING_FAILURE: {
                    handleIPv4Failure();
                    mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                            getConnectingSsidInternal(),
                            (mLastBssid == null) ? mTargetBssid : mLastBssid,
                            WifiLastResortWatchdog.FAILURE_CODE_DHCP,
                            isConnected());
                    break;
                }
                case CMD_IP_CONFIGURATION_SUCCESSFUL: {
                    if (getConnectedWifiConfigurationInternal() == null || mNetworkAgent == null) {
                        // The current config may have been removed while we were connecting,
                        // trigger a disconnect to clear up state.
                        reportConnectionAttemptEnd(
                                WifiMetrics.ConnectionEvent.FAILURE_NETWORK_DISCONNECTION,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE,
                                WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
                        mWifiNative.disconnect(mInterfaceName);
                    } else {
                        handleSuccessfulIpConfiguration();
                        sendConnectedState();
                        transitionTo(mL3ConnectedState);
                    }
                    break;
                }
                case CMD_IP_CONFIGURATION_LOST: {
                    // Get Link layer stats so that we get fresh tx packet counters.
                    getWifiLinkLayerStats();
                    handleIpConfigurationLost();
                    reportConnectionAttemptEnd(
                            WifiMetrics.ConnectionEvent.FAILURE_DHCP,
                            WifiMetricsProto.ConnectionEvent.HLF_NONE,
                            WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
                    mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                            getConnectingSsidInternal(),
                            (mLastBssid == null) ? mTargetBssid : mLastBssid,
                            WifiLastResortWatchdog.FAILURE_CODE_DHCP,
                            isConnected());
                    handleNetworkDisconnect(false,
                            WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__UNSPECIFIED);
                    transitionTo(mDisconnectedState); // End of connection attempt.
                    break;
                }
                case CMD_IP_REACHABILITY_LOST: {
                    if (mVerboseLoggingEnabled && message.obj != null) log((String) message.obj);
                    mWifiDiagnostics.triggerBugReportDataCapture(
                            WifiDiagnostics.REPORT_REASON_REACHABILITY_LOST);
                    mWifiMetrics.logWifiIsUnusableEvent(mInterfaceName,
                            WifiIsUnusableEvent.TYPE_IP_REACHABILITY_LOST);
                    mWifiMetrics.addToWifiUsabilityStatsList(mInterfaceName,
                            WifiUsabilityStats.LABEL_BAD,
                            WifiUsabilityStats.TYPE_IP_REACHABILITY_LOST, -1);
                    if (mWifiGlobals.getIpReachabilityDisconnectEnabled()) {
                        handleIpReachabilityLost();
                    } else {
                        logd("CMD_IP_REACHABILITY_LOST but disconnect disabled -- ignore");
                    }
                    break;
                }
                case CMD_IP_REACHABILITY_FAILURE: {
                    mWifiDiagnostics.triggerBugReportDataCapture(
                            WifiDiagnostics.REPORT_REASON_REACHABILITY_FAILURE);
                    handleIpReachabilityFailure((ReachabilityLossInfoParcelable) message.obj);
                    break;
                }
                case WifiP2pServiceImpl.DISCONNECT_WIFI_REQUEST: {
                    if (mWifiP2pConnection.shouldTemporarilyDisconnectWifi()) {
                        mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                StaEvent.DISCONNECT_P2P_DISCONNECT_WIFI_REQUEST);
                        mWifiNative.disconnect(mInterfaceName);
                    }
                    break;
                }
                case WifiMonitor.NETWORK_CONNECTION_EVENT: {
                    NetworkConnectionEventInfo connectionInfo =
                            (NetworkConnectionEventInfo) message.obj;
                    mWifiInfo.setBSSID(connectionInfo.bssid);
                    mLastNetworkId = connectionInfo.networkId;
                    mWifiInfo.setNetworkId(mLastNetworkId);
                    mWifiInfo.setMacAddress(mWifiNative.getMacAddress(mInterfaceName));
                    if (!Objects.equals(mLastBssid, connectionInfo.bssid)) {
                        mLastBssid = connectionInfo.bssid;
                        sendNetworkChangeBroadcastWithCurrentState();
                    }
                    if (mIsLinkedNetworkRoaming) {
                        mIsLinkedNetworkRoaming = false;
                        mTargetNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
                        mTargetWifiConfiguration = null;
                        clearTargetBssid("AllowlistRoamingCompleted");
                        sendNetworkChangeBroadcast(DetailedState.CONNECTED);
                    }
                    break;
                }
                case CMD_ONESHOT_RSSI_POLL: {
                    if (!mEnableRssiPolling) {
                        updateLinkLayerStatsRssiDataStallScoreReport();
                    }
                    break;
                }
                case CMD_RSSI_POLL: {
                    // TODO(b/179792830): getBSSID() shouldn't be null in L2ConnectedState,
                    //  add debug logs in the meantime. Remove once root cause identified.
                    if (mWifiInfo.getBSSID() == null) {
                        Log.wtf(getTag(), "WifiInfo.getBSSID() is null in L2ConnectedState!");
                        break;
                    }
                    if (message.arg1 == mRssiPollToken) {
                        updateLinkLayerStatsRssiDataStallScoreReport();
                        mWifiScoreCard.noteSignalPoll(mWifiInfo);
                        if (isPrimary()) {
                            mLinkProbeManager.updateConnectionStats(mWifiInfo, mInterfaceName);
                        }
                        sendMessageDelayed(obtainMessage(CMD_RSSI_POLL, mRssiPollToken, 0),
                                mWifiGlobals.getPollRssiIntervalMillis());
                        if (mVerboseLoggingEnabled) sendRssiChangeBroadcast(mWifiInfo.getRssi());
                        if (isPrimary()) {
                            mWifiTrafficPoller.notifyOnDataActivity(
                                    mWifiInfo.txSuccess, mWifiInfo.rxSuccess);
                        }
                    } else {
                        // Polling has completed
                    }
                    break;
                }
                case CMD_ENABLE_RSSI_POLL: {
                    cleanWifiScore();
                    mEnableRssiPolling = (message.arg1 == 1);
                    mRssiPollToken++;
                    if (mEnableRssiPolling) {
                        // First poll
                        mLastSignalLevel = -1;
                        if (isPrimary()) {
                            mLinkProbeManager.resetOnScreenTurnedOn();
                        }
                        long txBytes = mFacade.getTotalTxBytes() - mFacade.getMobileTxBytes();
                        long rxBytes = mFacade.getTotalRxBytes() - mFacade.getMobileRxBytes();
                        updateLinkLayerStatsRssiSpeedFrequencyCapabilities(txBytes, rxBytes);
                        sendMessageDelayed(obtainMessage(CMD_RSSI_POLL, mRssiPollToken, 0),
                                mWifiGlobals.getPollRssiIntervalMillis());
                    }
                    break;
                }
                case WifiMonitor.ASSOCIATED_BSSID_EVENT: {
                    if ((String) message.obj == null) {
                        logw("Associated command w/o BSSID");
                        break;
                    }
                    mLastBssid = (String) message.obj;
                    if (checkAndHandleLinkedNetworkRoaming(mLastBssid)) {
                        Log.i(TAG, "Driver initiated allowlist SSID roaming");
                        break;
                    }
                    if (mLastBssid != null && (mWifiInfo.getBSSID() == null
                            || !mLastBssid.equals(mWifiInfo.getBSSID()))) {
                        mWifiInfo.setBSSID(mLastBssid);
                        WifiConfiguration config = getConnectedWifiConfigurationInternal();
                        if (config != null) {
                            ScanDetailCache scanDetailCache = mWifiConfigManager
                                    .getScanDetailCacheForNetwork(config.networkId);
                            if (scanDetailCache != null) {
                                ScanResult scanResult = scanDetailCache.getScanResult(mLastBssid);
                                if (scanResult != null) {
                                    mWifiInfo.setFrequency(scanResult.frequency);
                                    boolean isHidden = true;
                                    for (byte b : scanResult.getWifiSsid().getBytes()) {
                                        if (b != 0) {
                                            isHidden = false;
                                            break;
                                        }
                                    }
                                    mWifiInfo.setHiddenSSID(isHidden);
                                }
                            }
                        }
                        sendNetworkChangeBroadcastWithCurrentState();
                        mMultiInternetManager.notifyBssidAssociatedEvent(mClientModeManager);
                    }
                    break;
                }
                case CMD_START_RSSI_MONITORING_OFFLOAD:
                case CMD_RSSI_THRESHOLD_BREACHED: {
                    byte currRssi = (byte) message.arg1;
                    processRssiThreshold(currRssi, message.what, mRssiEventHandler);
                    break;
                }
                case CMD_STOP_RSSI_MONITORING_OFFLOAD: {
                    stopRssiMonitoringOffload();
                    break;
                }
                case CMD_RECONNECT: {
                    log(" Ignore CMD_RECONNECT request because wifi is already connected");
                    break;
                }
                case CMD_RESET_SIM_NETWORKS: {
                    if (message.arg1 != RESET_SIM_REASON_SIM_INSERTED
                            && mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID) {
                        WifiConfiguration config =
                                mWifiConfigManager.getConfiguredNetwork(mLastNetworkId);
                        if (config != null
                            && ((message.arg1 == RESET_SIM_REASON_DEFAULT_DATA_SIM_CHANGED
                                && config.carrierId != TelephonyManager.UNKNOWN_CARRIER_ID)
                                || (config.enterpriseConfig != null
                                && config.enterpriseConfig.isAuthenticationSimBased()
                                && !mWifiCarrierInfoManager.isSimReady(mLastSubId)))) {
                            mWifiMetrics.logStaEvent(mInterfaceName,
                                    StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                    StaEvent.DISCONNECT_RESET_SIM_NETWORKS);
                            // remove local PMKSA cache in framework
                            mWifiNative.removeNetworkCachedData(mLastNetworkId);
                            // remove network so that supplicant's PMKSA cache is cleared
                            mWifiNative.removeAllNetworks(mInterfaceName);
                            if (isPrimary() && !mWifiCarrierInfoManager.isSimReady(mLastSubId)) {
                                mSimRequiredNotifier.showSimRequiredNotification(
                                        config, mLastSimBasedConnectionCarrierName);
                            }
                        }
                    }
                    break;
                }
                case CMD_START_IP_PACKET_OFFLOAD: {
                    int slot = message.arg1;
                    int intervalSeconds = message.arg2;
                    KeepalivePacketData pkt = (KeepalivePacketData) message.obj;
                    int result = startWifiIPPacketOffload(slot, pkt, intervalSeconds);
                    if (mNetworkAgent != null) {
                        mNetworkAgent.sendSocketKeepaliveEvent(slot, result);
                    }
                    break;
                }
                case CMD_ADD_KEEPALIVE_PACKET_FILTER_TO_APF: {
                    if (mIpClient != null) {
                        final int slot = message.arg1;
                        if (message.obj instanceof NattKeepalivePacketData) {
                            final NattKeepalivePacketData pkt =
                                    (NattKeepalivePacketData) message.obj;
                            mIpClient.addKeepalivePacketFilter(slot, pkt);
                        } else if (SdkLevel.isAtLeastS()) {
                            if (message.obj instanceof TcpKeepalivePacketData) {
                                final TcpKeepalivePacketData pkt =
                                        (TcpKeepalivePacketData) message.obj;
                                mIpClient.addKeepalivePacketFilter(slot, pkt);
                            }
                            // Otherwise unsupported keepalive data class: skip
                        } else {
                            // Before S, non-NattKeepalivePacketData KeepalivePacketData would be
                            // the not-yet-SystemApi android.net.TcpKeepalivePacketData.
                            // Attempt to parse TcpKeepalivePacketDataParcelable from the
                            // KeepalivePacketData superclass.
                            final TcpKeepalivePacketDataParcelable p =
                                    parseTcpKeepalivePacketData((KeepalivePacketData) message.obj);
                            if (p != null) {
                                mIpClient.addKeepalivePacketFilter(slot, p);
                            }
                        }
                    }
                    break;
                }
                case CMD_REMOVE_KEEPALIVE_PACKET_FILTER_FROM_APF: {
                    if (mIpClient != null) {
                        mIpClient.removeKeepalivePacketFilter(message.arg1);
                    }
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }

            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }

            return handleStatus;
        }

        /**
         * Fetches link stats, updates Wifi Data Stall, Score Card and Score Report.
         */
        private WifiLinkLayerStats updateLinkLayerStatsRssiDataStallScoreReport() {
            // Get Info and continue polling
            long txBytes = mFacade.getTotalTxBytes() - mFacade.getMobileTxBytes();
            long rxBytes = mFacade.getTotalRxBytes() - mFacade.getMobileRxBytes();
            WifiLinkLayerStats stats = updateLinkLayerStatsRssiSpeedFrequencyCapabilities(txBytes,
                    rxBytes);
            mWifiMetrics.updateWifiUsabilityStatsEntries(mInterfaceName, mWifiInfo, stats);
            // checkDataStallAndThroughputSufficiency() should be called before
            // mWifiScoreReport.calculateAndReportScore() which needs the latest throughput
            int statusDataStall = mWifiDataStall.checkDataStallAndThroughputSufficiency(
                    mInterfaceName, mLastConnectionCapabilities, mLastLinkLayerStats, stats,
                    mWifiInfo, txBytes, rxBytes);
            if (mDataStallTriggerTimeMs == -1
                    && statusDataStall != WifiIsUnusableEvent.TYPE_UNKNOWN) {
                mDataStallTriggerTimeMs = mClock.getElapsedSinceBootMillis();
                mLastStatusDataStall = statusDataStall;
            }
            if (mDataStallTriggerTimeMs != -1) {
                long elapsedTime =  mClock.getElapsedSinceBootMillis()
                        - mDataStallTriggerTimeMs;
                if (elapsedTime >= DURATION_TO_WAIT_ADD_STATS_AFTER_DATA_STALL_MS) {
                    mDataStallTriggerTimeMs = -1;
                    mWifiMetrics.addToWifiUsabilityStatsList(mInterfaceName,
                            WifiUsabilityStats.LABEL_BAD,
                            convertToUsabilityStatsTriggerType(mLastStatusDataStall),
                            -1);
                    mLastStatusDataStall = WifiIsUnusableEvent.TYPE_UNKNOWN;
                }
            }
            // Send the update score to network agent.
            mWifiScoreReport.calculateAndReportScore();

            if (mWifiScoreReport.shouldCheckIpLayer()) {
                if (mIpClient != null) {
                    mIpClient.confirmConfiguration();
                }
                mWifiScoreReport.noteIpCheck();
            }

            mLastLinkLayerStats = stats;
            return stats;
        }
    }

    /**
     * Fetches link stats and updates Wifi Score Report.
     */
    private void updateLinkLayerStatsRssiAndScoreReport() {
        sendMessage(CMD_ONESHOT_RSSI_POLL);
    }

    private int convertToUsabilityStatsTriggerType(int unusableEventTriggerType) {
        int triggerType;
        switch (unusableEventTriggerType) {
            case WifiIsUnusableEvent.TYPE_DATA_STALL_BAD_TX:
                triggerType = WifiUsabilityStats.TYPE_DATA_STALL_BAD_TX;
                break;
            case WifiIsUnusableEvent.TYPE_DATA_STALL_TX_WITHOUT_RX:
                triggerType = WifiUsabilityStats.TYPE_DATA_STALL_TX_WITHOUT_RX;
                break;
            case WifiIsUnusableEvent.TYPE_DATA_STALL_BOTH:
                triggerType = WifiUsabilityStats.TYPE_DATA_STALL_BOTH;
                break;
            case WifiIsUnusableEvent.TYPE_FIRMWARE_ALERT:
                triggerType = WifiUsabilityStats.TYPE_FIRMWARE_ALERT;
                break;
            case WifiIsUnusableEvent.TYPE_IP_REACHABILITY_LOST:
                triggerType = WifiUsabilityStats.TYPE_IP_REACHABILITY_LOST;
                break;
            default:
                triggerType = WifiUsabilityStats.TYPE_UNKNOWN;
                Log.e(getTag(), "Unknown WifiIsUnusableEvent: " + unusableEventTriggerType);
        }
        return triggerType;
    }

    class L3ProvisioningState extends State {
        @Override
        public void enter() {
            startL3Provisioning();
        }

        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;

            switch(message.what) {
                case WifiMonitor.NETWORK_DISCONNECTION_EVENT: {
                    DisconnectEventInfo eventInfo = (DisconnectEventInfo) message.obj;
                    mWifiLastResortWatchdog.noteConnectionFailureAndTriggerIfNeeded(
                            getConnectingSsidInternal(),
                            !isValidBssid(eventInfo.bssid)
                            ? mTargetBssid : eventInfo.bssid,
                            WifiLastResortWatchdog.FAILURE_CODE_DHCP,
                            isConnected());
                    handleStatus = NOT_HANDLED;
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }

            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }
            return handleStatus;
        }

        private void startL3Provisioning() {
            WifiConfiguration currentConfig = getConnectedWifiConfigurationInternal();
            if (mIpClientWithPreConnection && mIpClient != null) {
                mIpClient.notifyPreconnectionComplete(mSentHLPs);
                mIpClientWithPreConnection = false;
                mSentHLPs = false;
            } else {
                startIpClient(currentConfig, false);
            }
            // Get Link layer stats so as we get fresh tx packet counters
            getWifiLinkLayerStats();
        }

    }

    /**
     * Helper function to check if a network has been recently selected by the user.
     * (i.e less than {@link #LAST_SELECTED_NETWORK_EXPIRATION_AGE_MILLIS) before).
     */
    @VisibleForTesting
    public boolean isRecentlySelectedByTheUser(@NonNull WifiConfiguration currentConfig) {
        long currentTimeMillis = mClock.getElapsedSinceBootMillis();
        return mWifiConfigManager.getLastSelectedNetwork() == currentConfig.networkId
                && currentTimeMillis - mWifiConfigManager.getLastSelectedTimeStamp()
                < LAST_SELECTED_NETWORK_EXPIRATION_AGE_MILLIS;
    }

    private void sendConnectedState() {
        mNetworkAgent.markConnected();
        sendNetworkChangeBroadcast(DetailedState.CONNECTED);
    }

    class RoamingState extends State {
        boolean mAssociated;
        @Override
        public void enter() {
            if (mVerboseLoggingEnabled) {
                log("RoamingState Enter mScreenOn=" + mScreenOn);
            }

            // Make sure we disconnect if roaming fails
            mRoamWatchdogCount++;
            logd("Start Roam Watchdog " + mRoamWatchdogCount);
            sendMessageDelayed(obtainMessage(CMD_ROAM_WATCHDOG_TIMER,
                    mRoamWatchdogCount, 0), ROAM_GUARD_TIMER_MSEC);
            mAssociated = false;
        }
        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;

            switch (message.what) {
                case CMD_IP_CONFIGURATION_LOST: {
                    WifiConfiguration config = getConnectedWifiConfigurationInternal();
                    if (config != null) {
                        mWifiDiagnostics.triggerBugReportDataCapture(
                                WifiDiagnostics.REPORT_REASON_AUTOROAM_FAILURE);
                    }
                    handleStatus = NOT_HANDLED;
                    break;
                }
                case CMD_UNWANTED_NETWORK: {
                    if (mVerboseLoggingEnabled) {
                        log("Roaming and CS doesn't want the network -> ignore");
                    }
                    break;
                }
                case WifiMonitor.SUPPLICANT_STATE_CHANGE_EVENT: {
                    /**
                     * If we get a SUPPLICANT_STATE_CHANGE_EVENT indicating a DISCONNECT
                     * before NETWORK_DISCONNECTION_EVENT
                     * And there is an associated BSSID corresponding to our target BSSID, then
                     * we have missed the network disconnection, transition to mDisconnectedState
                     * and handle the rest of the events there.
                     */
                    StateChangeResult stateChangeResult = (StateChangeResult) message.obj;
                    SupplicantState state = handleSupplicantStateChange(stateChangeResult);
                    if (state == SupplicantState.DISCONNECTED
                            || state == SupplicantState.INACTIVE
                            || state == SupplicantState.INTERFACE_DISABLED) {
                        if (mVerboseLoggingEnabled) {
                            log("RoamingState: Supplicant State change " + stateChangeResult);
                        }
                        handleNetworkDisconnect(false,
                                WIFI_DISCONNECT_REPORTED__FAILURE_CODE__SUPPLICANT_DISCONNECTED);
                        transitionTo(mDisconnectedState);
                    }
                    if (stateChangeResult.state == SupplicantState.ASSOCIATED) {
                        // We completed the layer2 roaming part
                        mAssociated = true;
                        mTargetBssid = stateChangeResult.bssid;
                    }
                    break;
                }
                case CMD_ROAM_WATCHDOG_TIMER: {
                    if (mRoamWatchdogCount == message.arg1) {
                        if (mVerboseLoggingEnabled) log("roaming watchdog! -> disconnect");
                        mWifiMetrics.endConnectionEvent(
                                mInterfaceName,
                                WifiMetrics.ConnectionEvent.FAILURE_ROAM_TIMEOUT,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE,
                                WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN,
                                mWifiInfo.getFrequency());
                        mRoamFailCount++;
                        handleNetworkDisconnect(false,
                                WifiStatsLog.WIFI_DISCONNECT_REPORTED__FAILURE_CODE__ROAM_WATCHDOG_TIMER);
                        mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                StaEvent.DISCONNECT_ROAM_WATCHDOG_TIMER);
                        mWifiNative.disconnect(mInterfaceName);
                        transitionTo(mDisconnectedState);
                    }
                    break;
                }
                case WifiMonitor.NETWORK_CONNECTION_EVENT: {
                    if (mAssociated) {
                        if (mVerboseLoggingEnabled) {
                            log("roaming and Network connection established");
                        }
                        NetworkConnectionEventInfo connectionInfo =
                                (NetworkConnectionEventInfo) message.obj;
                        mLastNetworkId = connectionInfo.networkId;
                        mLastBssid = connectionInfo.bssid;
                        mWifiInfo.setBSSID(mLastBssid);
                        mWifiInfo.setNetworkId(mLastNetworkId);
                        sendNetworkChangeBroadcastWithCurrentState();

                        // Successful framework roam! (probably)
                        mWifiBlocklistMonitor.handleBssidConnectionSuccess(mLastBssid,
                                mWifiInfo.getSSID());
                        reportConnectionAttemptEnd(
                                WifiMetrics.ConnectionEvent.FAILURE_NONE,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE,
                                WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);

                        // We must clear the config BSSID, as the wifi chipset may decide to roam
                        // from this point on and having the BSSID specified by QNS would cause
                        // the roam to fail and the device to disconnect.
                        // When transition from RoamingState to DisconnectedState, the config BSSID
                        // is cleared by handleNetworkDisconnect().
                        clearTargetBssid("RoamingCompleted");

                        // We used to transition to L3ProvisioningState in an
                        // attempt to do DHCPv4 RENEWs on framework roams.
                        // DHCP can take too long to time out, and we now rely
                        // upon IpClient's use of IpReachabilityMonitor to
                        // confirm our current network configuration.
                        //
                        // mIpClient.confirmConfiguration() is called within
                        // the handling of SupplicantState.COMPLETED.
                        transitionTo(mL3ConnectedState);
                    } else {
                        mMessageHandlingStatus = MESSAGE_HANDLING_STATUS_DISCARD;
                    }
                    break;
                }
                case WifiMonitor.NETWORK_DISCONNECTION_EVENT: {
                    // Throw away but only if it corresponds to the network we're roaming to
                    DisconnectEventInfo eventInfo = (DisconnectEventInfo) message.obj;
                    if (true) {
                        String target = "";
                        if (mTargetBssid != null) target = mTargetBssid;
                        log("NETWORK_DISCONNECTION_EVENT in roaming state"
                                + " BSSID=" + eventInfo.bssid
                                + " target=" + target);
                    }
                    clearNetworkCachedDataIfNeeded(
                            getConnectingWifiConfigurationInternal(), eventInfo.reasonCode);
                    if (eventInfo.bssid.equals(mTargetBssid)) {
                        handleNetworkDisconnect(false, eventInfo.reasonCode);
                        transitionTo(mDisconnectedState);
                    }
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }

            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }
            return handleStatus;
        }

        @Override
        public void exit() {
            logd("ClientModeImpl: Leaving Roaming state");
        }
    }

    class L3ConnectedState extends State {
        @Override
        public void enter() {
            if (mVerboseLoggingEnabled) {
                log("Enter ConnectedState  mScreenOn=" + mScreenOn);
            }

            reportConnectionAttemptEnd(
                    WifiMetrics.ConnectionEvent.FAILURE_NONE,
                    WifiMetricsProto.ConnectionEvent.HLF_NONE,
                    WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
            mWifiConnectivityManager.handleConnectionStateChanged(
                    mClientModeManager,
                    WifiConnectivityManager.WIFI_STATE_CONNECTED);
            registerConnected();
            mTargetWifiConfiguration = null;
            mWifiScoreReport.reset();
            mLastSignalLevel = -1;

            // Not roaming anymore
            mIsAutoRoaming = false;

            mTargetNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
            mWifiLastResortWatchdog.connectedStateTransition(true);
            mWifiStateTracker.updateState(mInterfaceName, WifiStateTracker.CONNECTED);
            // Inform WifiLockManager
            mWifiLockManager.updateWifiClientConnected(mClientModeManager, true);
            WifiConfiguration config = getConnectedWifiConfigurationInternal();
            mWifiScoreReport.startConnectedNetworkScorer(
                    mNetworkAgent.getNetwork().getNetId(), isRecentlySelectedByTheUser(config));
            updateLinkLayerStatsRssiAndScoreReport();
            mWifiScoreCard.noteIpConfiguration(mWifiInfo);
            // too many places to record L3 failure with too many failure reasons.
            // So only record success here.
            mWifiMetrics.noteFirstL3ConnectionAfterBoot(true);
        }
        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;

            switch (message.what) {
                case CMD_UNWANTED_NETWORK: {
                    if (message.arg1 == NETWORK_STATUS_UNWANTED_DISCONNECT) {
                        mWifiMetrics.logStaEvent(mInterfaceName, StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                StaEvent.DISCONNECT_UNWANTED);
                        if (mClientModeManager.getRole() == ROLE_CLIENT_SECONDARY_TRANSIENT
                                && mClientModeManager.getPreviousRole() == ROLE_CLIENT_PRIMARY) {
                            mWifiMetrics.incrementMakeBeforeBreakLingerCompletedCount(
                                    mClock.getElapsedSinceBootMillis()
                                            - mClientModeManager.getLastRoleChangeSinceBootMs());
                        }
                        mWifiNative.disconnect(mInterfaceName);
                    } else if (message.arg1 == NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN
                            || message.arg1 == NETWORK_STATUS_UNWANTED_VALIDATION_FAILED) {
                        Log.d(getTag(), (message.arg1 == NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN
                                ? "NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN"
                                : "NETWORK_STATUS_UNWANTED_VALIDATION_FAILED"));
                        WifiConfiguration config = getConnectedWifiConfigurationInternal();
                        if (config != null) {
                            // Disable autojoin
                            if (message.arg1 == NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN) {
                                mWifiConfigManager.setNetworkValidatedInternetAccess(
                                        config.networkId, false);
                                WifiScoreCard.PerBssid perBssid = mWifiScoreCard.lookupBssid(
                                        mWifiInfo.getSSID(), mWifiInfo.getBSSID());
                                int probInternet = perBssid.estimatePercentInternetAvailability();
                                if (mVerboseLoggingEnabled) {
                                    Log.d(TAG, "Potentially disabling network due to no "
                                            + "internet. Probability of having internet = "
                                            + probInternet);
                                }
                                // Only permanently disable a network if probability of having
                                // internet from the currently connected BSSID is less than 60%.
                                // If there is no historically information of the current BSSID,
                                // the probability of internet will default to 50%, and the network
                                // will be permanently disabled.
                                mWifiConfigManager.updateNetworkSelectionStatus(config.networkId,
                                        probInternet < PROBABILITY_WITH_INTERNET_TO_PERMANENTLY_DISABLE_NETWORK
                                                ? DISABLED_NO_INTERNET_PERMANENT
                                                : DISABLED_NO_INTERNET_TEMPORARY);
                            } else {
                                // stop collect last-mile stats since validation fail
                                removeMessages(CMD_DIAGS_CONNECT_TIMEOUT);
                                mWifiDiagnostics.reportConnectionEvent(
                                        WifiDiagnostics.CONNECTION_EVENT_FAILED,
                                        mClientModeManager);
                                mWifiConfigManager.incrementNetworkNoInternetAccessReports(
                                        config.networkId);
                                // If this was not recently selected by the user, update network
                                // selection status to temporarily disable the network.
                                if (!isRecentlySelectedByTheUser(config)
                                        && !config.noInternetAccessExpected) {
                                    if (config.getNetworkSelectionStatus()
                                            .getNetworkSelectionDisableReason()
                                            != DISABLED_NO_INTERNET_PERMANENT) {
                                        Log.i(getTag(), "Temporarily disabling network "
                                                + "because of no-internet access");
                                        mWifiConfigManager.updateNetworkSelectionStatus(
                                                config.networkId,
                                                DISABLED_NO_INTERNET_TEMPORARY);
                                    }
                                    mWifiBlocklistMonitor.handleBssidConnectionFailure(
                                            mLastBssid, config,
                                            WifiBlocklistMonitor.REASON_NETWORK_VALIDATION_FAILURE,
                                            mWifiInfo.getRssi());
                                }
                                mWifiScoreCard.noteValidationFailure(mWifiInfo);
                            }
                        }
                        if (mClientModeManager.getRole() == ROLE_CLIENT_SECONDARY_TRANSIENT
                                && !mCurrentConnectionDetectedCaptivePortal) {
                            Log.d(getTag(), "Internet validation failed during MBB,"
                                    + " disconnecting ClientModeManager=" + mClientModeManager);
                            mWifiMetrics.logStaEvent(
                                    mInterfaceName,
                                    StaEvent.TYPE_FRAMEWORK_DISCONNECT,
                                    StaEvent.DISCONNECT_MBB_NO_INTERNET);
                            mWifiMetrics.incrementMakeBeforeBreakNoInternetCount();
                            mWifiNative.disconnect(mInterfaceName);
                        }
                    }
                    break;
                }
                case CMD_NETWORK_STATUS: {
                    if (message.arg1 == NetworkAgent.VALIDATION_STATUS_VALID) {
                        // stop collect last-mile stats since validation pass
                        removeMessages(CMD_DIAGS_CONNECT_TIMEOUT);
                        mWifiDiagnostics.reportConnectionEvent(
                                WifiDiagnostics.CONNECTION_EVENT_SUCCEEDED, mClientModeManager);
                        mWifiScoreCard.noteValidationSuccess(mWifiInfo);
                        mWifiBlocklistMonitor.handleNetworkValidationSuccess(mLastBssid,
                                mWifiInfo.getSSID());
                        WifiConfiguration config = getConnectedWifiConfigurationInternal();
                        if (config != null) {
                            // re-enable autojoin
                            mWifiConfigManager.updateNetworkSelectionStatus(
                                    config.networkId,
                                    WifiConfiguration.NetworkSelectionStatus
                                            .DISABLED_NONE);
                            mWifiConfigManager.setNetworkValidatedInternetAccess(
                                    config.networkId, true);
                            if (config.isPasspoint()
                                    && mTermsAndConditionsUrl != null) {
                                // Clear the T&C after the user accepted them and the we are
                                // notified that the network validation is successful
                                mTermsAndConditionsUrl = null;
                                LinkProperties newLp = new LinkProperties(mLinkProperties);
                                addPasspointInfoToLinkProperties(newLp);
                                sendMessage(CMD_UPDATE_LINKPROPERTIES, newLp);
                                mWifiMetrics
                                        .incrementTotalNumberOfPasspointAcceptanceOfTermsAndConditions();
                            }
                            if (retrieveConnectedNetworkDefaultGateway()) {
                                updateLinkedNetworks(config);
                            }
                        }
                        mCmiMonitor.onInternetValidated(mClientModeManager);
                    }
                    break;
                }
                case CMD_ACCEPT_UNVALIDATED: {
                    boolean accept = (message.arg1 != 0);
                    mWifiConfigManager.setNetworkNoInternetAccessExpected(mLastNetworkId, accept);
                    break;
                }
                case WifiMonitor.NETWORK_DISCONNECTION_EVENT: {
                    DisconnectEventInfo eventInfo = (DisconnectEventInfo) message.obj;
                    reportConnectionAttemptEnd(
                            WifiMetrics.ConnectionEvent.FAILURE_NETWORK_DISCONNECTION,
                            WifiMetricsProto.ConnectionEvent.HLF_NONE,
                            WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
                    if (unexpectedDisconnectedReason(eventInfo.reasonCode)) {
                        mWifiDiagnostics.triggerBugReportDataCapture(
                                WifiDiagnostics.REPORT_REASON_UNEXPECTED_DISCONNECT);
                    }

                    if (!eventInfo.locallyGenerated) {
                        // ignore disconnects initiated by wpa_supplicant.
                        mWifiScoreCard.noteNonlocalDisconnect(mInterfaceName, eventInfo.reasonCode);
                        int rssi = mWifiInfo.getRssi();
                        mWifiBlocklistMonitor.handleBssidConnectionFailure(mWifiInfo.getBSSID(),
                                getConnectedWifiConfiguration(),
                                WifiBlocklistMonitor.REASON_ABNORMAL_DISCONNECT, rssi);
                    }
                    WifiConfiguration config = getConnectedWifiConfigurationInternal();

                    if (mVerboseLoggingEnabled) {
                        log("NETWORK_DISCONNECTION_EVENT in connected state"
                                + " BSSID=" + mWifiInfo.getBSSID()
                                + " RSSI=" + mWifiInfo.getRssi()
                                + " freq=" + mWifiInfo.getFrequency()
                                + " reason=" + eventInfo.reasonCode
                                + " Network Selection Status=" + (config == null ? "Unavailable"
                                : config.getNetworkSelectionStatus().getNetworkStatusString()));
                    }
                    handleNetworkDisconnect(false, eventInfo.reasonCode);
                    transitionTo(mDisconnectedState);
                    break;
                }
                case CMD_START_ROAM: {
                    /* Connect command coming from auto-join */
                    int netId = message.arg1;
                    String bssid = (String) message.obj;
                    if (bssid == null) {
                        bssid = SUPPLICANT_BSSID_ANY;
                    }
                    WifiConfiguration config =
                            mWifiConfigManager.getConfiguredNetworkWithoutMasking(netId);
                    if (config == null) {
                        loge("CMD_START_ROAM and no config, bail out...");
                        break;
                    }
                    mLastScanRssi = mWifiConfigManager.findScanRssi(netId,
                            mWifiHealthMonitor.getScanRssiValidTimeMs());
                    mWifiScoreCard.noteConnectionAttempt(mWifiInfo, mLastScanRssi, config.SSID);
                    setTargetBssid(config, bssid);
                    mTargetNetworkId = netId;

                    logd("CMD_START_ROAM sup state "
                            + " my state " + getCurrentState().getName()
                            + " nid=" + Integer.toString(netId)
                            + " config " + config.getProfileKey()
                            + " targetRoamBSSID " + mTargetBssid);

                    reportConnectionAttemptStart(config, mTargetBssid,
                            WifiMetricsProto.ConnectionEvent.ROAM_ENTERPRISE);
                    if (mWifiNative.roamToNetwork(mInterfaceName, config)) {
                        mTargetWifiConfiguration = config;
                        mIsAutoRoaming = true;
                        mWifiMetrics.logStaEvent(
                                mInterfaceName, StaEvent.TYPE_CMD_START_ROAM, config);
                        transitionTo(mRoamingState);
                    } else {
                        loge("CMD_START_ROAM Failed to start roaming to network " + config);
                        reportConnectionAttemptEnd(
                                WifiMetrics.ConnectionEvent.FAILURE_CONNECT_NETWORK_FAILED,
                                WifiMetricsProto.ConnectionEvent.HLF_NONE,
                                WifiMetricsProto.ConnectionEvent.FAILURE_REASON_UNKNOWN);
                        mMessageHandlingStatus = MESSAGE_HANDLING_STATUS_FAIL;
                        break;
                    }
                    break;
                }
                case CMD_IP_CONFIGURATION_LOST: {
                    mWifiMetrics.incrementIpRenewalFailure();
                    handleStatus = NOT_HANDLED;
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }

            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }

            return handleStatus;
        }

        @Override
        public void exit() {
            logd("ClientModeImpl: Leaving Connected state");
            mWifiConnectivityManager.handleConnectionStateChanged(
                    mClientModeManager,
                     WifiConnectivityManager.WIFI_STATE_TRANSITIONING);

            mWifiLastResortWatchdog.connectedStateTransition(false);
        }
    }

    class DisconnectedState extends State {
        @Override
        public void enter() {
            Log.i(getTag(), "disconnectedstate enter");
            // We don't scan frequently if this is a temporary disconnect
            // due to p2p
            if (mWifiP2pConnection.shouldTemporarilyDisconnectWifi()) {
                // TODO(b/161569371): P2P should wait for all ClientModeImpls to enter
                //  DisconnectedState, not just one instance.
                // (Does P2P Service support STA+P2P concurrency?)
                mWifiP2pConnection.sendMessage(WifiP2pServiceImpl.DISCONNECT_WIFI_RESPONSE);
                return;
            }

            if (mVerboseLoggingEnabled) {
                logd(" Enter DisconnectedState screenOn=" + mScreenOn);
            }

            /** clear the roaming state, if we were roaming, we failed */
            mIsAutoRoaming = false;
            mTargetNetworkId = WifiConfiguration.INVALID_NETWORK_ID;

            mWifiConnectivityManager.handleConnectionStateChanged(
                    mClientModeManager,
                    WifiConnectivityManager.WIFI_STATE_DISCONNECTED);
        }

        @Override
        public boolean processMessage(Message message) {
            boolean handleStatus = HANDLED;

            switch (message.what) {
                case CMD_RECONNECT:
                case CMD_REASSOCIATE: {
                    if (mWifiP2pConnection.shouldTemporarilyDisconnectWifi()) {
                        // Drop a third party reconnect/reassociate if STA is
                        // temporarily disconnected for p2p
                        break;
                    } else {
                        // ConnectableState handles it
                        handleStatus = NOT_HANDLED;
                    }
                    break;
                }
                default: {
                    handleStatus = NOT_HANDLED;
                    break;
                }
            }

            if (handleStatus == HANDLED) {
                logStateAndMessage(message, this);
            }
            return handleStatus;
        }

        @Override
        public void exit() {
            mWifiConnectivityManager.handleConnectionStateChanged(
                    mClientModeManager,
                     WifiConnectivityManager.WIFI_STATE_TRANSITIONING);
        }
    }

    void handleGsmAuthRequest(SimAuthRequestData requestData) {
        WifiConfiguration requestingWifiConfiguration = null;
        if (mTargetWifiConfiguration != null
                && mTargetWifiConfiguration.networkId
                == requestData.networkId) {
            requestingWifiConfiguration = mTargetWifiConfiguration;
            logd("id matches targetWifiConfiguration");
        } else if (mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID
                && mLastNetworkId == requestData.networkId) {
            requestingWifiConfiguration = getConnectedWifiConfigurationInternal();
            logd("id matches currentWifiConfiguration");
        }

        if (requestingWifiConfiguration == null) {
            logd("GsmAuthRequest received with null target/current WifiConfiguration.");
            return;
        }

        /*
         * Try authentication in the following order.
         *
         *    Standard       Cellular_auth     Type Command
         *
         * 1. 3GPP TS 31.102 3G_authentication [Length][RAND][Length][AUTN]
         *                            [Length][RES][Length][CK][Length][IK] and more
         * 2. 3GPP TS 31.102 2G_authentication [Length][RAND]
         *                            [Length][SRES][Length][Cipher Key Kc]
         * 3. 3GPP TS 11.11  2G_authentication [RAND]
         *                            [SRES][Cipher Key Kc]
         */
        String response = mWifiCarrierInfoManager
                .getGsmSimAuthResponse(requestData.data, requestingWifiConfiguration);
        if (response == null) {
            // In case of failure, issue may be due to sim type, retry as No.2 case
            response = mWifiCarrierInfoManager
                    .getGsmSimpleSimAuthResponse(requestData.data, requestingWifiConfiguration);
            if (response == null) {
                // In case of failure, issue may be due to sim type, retry as No.3 case
                response = mWifiCarrierInfoManager.getGsmSimpleSimNoLengthAuthResponse(
                                requestData.data, requestingWifiConfiguration);
            }
        }
        if (response == null || response.length() == 0) {
            mWifiNative.simAuthFailedResponse(mInterfaceName);
        } else {
            logv("Supplicant Response -" + response);
            mWifiNative.simAuthResponse(
                    mInterfaceName, WifiNative.SIM_AUTH_RESP_TYPE_GSM_AUTH, response);
        }
    }

    void handle3GAuthRequest(SimAuthRequestData requestData) {
        WifiConfiguration requestingWifiConfiguration = null;
        if (mTargetWifiConfiguration != null
                && mTargetWifiConfiguration.networkId
                == requestData.networkId) {
            requestingWifiConfiguration = mTargetWifiConfiguration;
            logd("id matches targetWifiConfiguration");
        } else if (mLastNetworkId != WifiConfiguration.INVALID_NETWORK_ID
                && mLastNetworkId == requestData.networkId) {
            requestingWifiConfiguration = getConnectedWifiConfigurationInternal();
            logd("id matches currentWifiConfiguration");
        }

        if (requestingWifiConfiguration == null) {
            logd("3GAuthRequest received with null target/current WifiConfiguration.");
            return;
        }

        SimAuthResponseData response = mWifiCarrierInfoManager
                .get3GAuthResponse(requestData, requestingWifiConfiguration);
        if (response != null) {
            mWifiNative.simAuthResponse(
                    mInterfaceName, response.type, response.response);
        } else {
            mWifiNative.umtsAuthFailedResponse(mInterfaceName);
        }
    }

    /**
     * Automatically connect to the network specified
     *
     * @param networkId ID of the network to connect to
     * @param uid UID of the app triggering the connection.
     * @param bssid BSSID of the network
     */
    public void startConnectToNetwork(int networkId, int uid, String bssid) {
        sendMessage(CMD_START_CONNECT, networkId, uid, bssid);
    }

    /**
     * Automatically roam to the network specified
     *
     * @param networkId ID of the network to roam to
     * @param bssid BSSID of the access point to roam to.
     */
    public void startRoamToNetwork(int networkId, String bssid) {
        sendMessage(CMD_START_ROAM, networkId, 0, bssid);
    }

    /**
     * @param reason reason code from supplicant on network disconnected event
     * @return true if this is a suspicious disconnect
     */
    static boolean unexpectedDisconnectedReason(int reason) {
        return reason == StaIfaceReasonCode.PREV_AUTH_NOT_VALID
                || reason == StaIfaceReasonCode.CLASS2_FRAME_FROM_NONAUTH_STA
                || reason == StaIfaceReasonCode.CLASS3_FRAME_FROM_NONASSOC_STA
                || reason == StaIfaceReasonCode.DISASSOC_STA_HAS_LEFT
                || reason == StaIfaceReasonCode.STA_REQ_ASSOC_WITHOUT_AUTH
                || reason == StaIfaceReasonCode.MICHAEL_MIC_FAILURE
                || reason == StaIfaceReasonCode.FOURWAY_HANDSHAKE_TIMEOUT
                || reason == StaIfaceReasonCode.GROUP_KEY_UPDATE_TIMEOUT
                || reason == StaIfaceReasonCode.GROUP_CIPHER_NOT_VALID
                || reason == StaIfaceReasonCode.PAIRWISE_CIPHER_NOT_VALID
                || reason == StaIfaceReasonCode.IEEE_802_1X_AUTH_FAILED
                || reason == StaIfaceReasonCode.DISASSOC_LOW_ACK;
    }

    private static String getLinkPropertiesSummary(LinkProperties lp) {
        List<String> attributes = new ArrayList<>(6);
        if (lp.hasIpv4Address()) {
            attributes.add("v4");
        }
        if (lp.hasIpv4DefaultRoute()) {
            attributes.add("v4r");
        }
        if (lp.hasIpv4DnsServer()) {
            attributes.add("v4dns");
        }
        if (lp.hasGlobalIpv6Address()) {
            attributes.add("v6");
        }
        if (lp.hasIpv6DefaultRoute()) {
            attributes.add("v6r");
        }
        if (lp.hasIpv6DnsServer()) {
            attributes.add("v6dns");
        }

        return TextUtils.join(" ", attributes);
    }

    /**
     * Gets the SSID from the WifiConfiguration pointed at by 'mTargetNetworkId'
     * This should match the network config framework is attempting to connect to.
     */
    private String getConnectingSsidInternal() {
        WifiConfiguration config = getConnectingWifiConfigurationInternal();
        return config != null ? config.SSID : null;
    }

    /**
     * Check if there is any connection request for WiFi network.
     */
    private boolean hasConnectionRequests() {
        return mNetworkFactory.hasConnectionRequests()
                || mUntrustedNetworkFactory.hasConnectionRequests()
                || mOemWifiNetworkFactory.hasConnectionRequests()
                || mRestrictedWifiNetworkFactory.hasConnectionRequests()
                || mMultiInternetManager.hasPendingConnectionRequests();
    }

    /**
     * Retrieve the factory MAC address from config store (stored on first bootup). If we don't have
     * a factory MAC address stored in config store, retrieve it now and store it.
     *
     * Note:
     * <li> This is needed to ensure that we use the same MAC address for connecting to
     * networks with MAC randomization disabled regardless of whether the connection is
     * occurring on "wlan0" or "wlan1" due to STA + STA. </li>
     * <li> Retries added to deal with any transient failures when invoking
     * {@link WifiNative#getStaFactoryMacAddress(String)}.
     */
    @Nullable
    private MacAddress retrieveFactoryMacAddressAndStoreIfNecessary() {
        boolean saveFactoryMacInConfigStore =
                mWifiGlobals.isSaveFactoryMacToConfigStoreEnabled();
        if (saveFactoryMacInConfigStore) {
            // Already present, just return.
            String factoryMacAddressStr = mSettingsConfigStore.get(WIFI_STA_FACTORY_MAC_ADDRESS);
            if (factoryMacAddressStr != null) return MacAddress.fromString(factoryMacAddressStr);
        }
        MacAddress factoryMacAddress = mWifiNative.getStaFactoryMacAddress(mInterfaceName);
        if (factoryMacAddress == null) {
            // the device may be running an older HAL (version < 1.3).
            Log.w(TAG, "Failed to retrieve factory MAC address");
            return null;
        }
        if (saveFactoryMacInConfigStore) {
            mSettingsConfigStore.put(WIFI_STA_FACTORY_MAC_ADDRESS, factoryMacAddress.toString());
            Log.i(TAG, "Factory MAC address stored in config store: " + factoryMacAddress);
        }
        Log.i(TAG, "Factory MAC address retrieved: " + factoryMacAddress);
        return factoryMacAddress;
    }

    /**
     * Gets the factory MAC address of wlan0 (station interface).
     * @return String representation of the factory MAC address.
     */
    @Nullable
    public String getFactoryMacAddress() {
        MacAddress factoryMacAddress = retrieveFactoryMacAddressAndStoreIfNecessary();
        if (factoryMacAddress != null) return factoryMacAddress.toString();

        // For devices with older HAL's (version < 1.3), no API exists to retrieve factory MAC
        // address (and also does not support MAC randomization - needs verson 1.2). So, just
        // return the regular MAC address from the interface.
        if (!mWifiGlobals.isConnectedMacRandomizationEnabled()) {
            Log.w(TAG, "Can't get factory MAC address, return the MAC address");
            return mWifiNative.getMacAddress(mInterfaceName);
        }
        return null;
    }

    /** Sends a link probe. */
    public void probeLink(LinkProbeCallback callback, int mcs) {
        String bssid = mWifiInfo.getBSSID();
        if (bssid == null) {
            Log.w(getTag(), "Attempted to send link probe when not connected!");
            callback.onFailure(LinkProbeCallback.LINK_PROBE_ERROR_NOT_CONNECTED);
            return;
        }
        mWifiNative.probeLink(mInterfaceName, MacAddress.fromString(bssid), callback, mcs);
    }

    private static class ConnectNetworkMessage {
        public final NetworkUpdateResult result;
        public final ActionListenerWrapper listener;
        public final String packageName;

        ConnectNetworkMessage(NetworkUpdateResult result, ActionListenerWrapper listener,
                String packageName) {
            this.result = result;
            this.listener = listener;
            this.packageName = packageName;
        }
    }

    /** Trigger network connection and provide status via the provided callback. */
    public void connectNetwork(NetworkUpdateResult result, ActionListenerWrapper wrapper,
            int callingUid, @NonNull String packageName) {
        Message message =
                obtainMessage(CMD_CONNECT_NETWORK,
                new ConnectNetworkMessage(result, wrapper, packageName));
        message.sendingUid = callingUid;
        sendMessage(message);
    }

    /** Trigger network save and provide status via the provided callback. */
    public void saveNetwork(NetworkUpdateResult result, ActionListenerWrapper wrapper,
            int callingUid, @NonNull String packageName) {
        Message message =
                obtainMessage(CMD_SAVE_NETWORK,
                new ConnectNetworkMessage(result, wrapper, packageName));
        message.sendingUid = callingUid;
        sendMessage(message);
    }

    /**
     * Handle BSS transition request from Connected BSS.
     *
     * @param frameData Data retrieved from received BTM request frame.
     */
    private void handleBssTransitionRequest(BtmFrameData frameData) {
        if (frameData == null) {
            return;
        }

        String bssid = mWifiInfo.getBSSID();
        String ssid = mWifiInfo.getSSID();
        if ((bssid == null) || (ssid == null) || WifiManager.UNKNOWN_SSID.equals(ssid)) {
            Log.e(getTag(), "Failed to handle BSS transition: bssid: " + bssid + " ssid: " + ssid);
            return;
        }

        mWifiMetrics.incrementSteeringRequestCount();

        if ((frameData.mBssTmDataFlagsMask
                & MboOceConstants.BTM_DATA_FLAG_MBO_CELL_DATA_CONNECTION_PREFERENCE_INCLUDED)
                != 0) {
            mWifiMetrics.incrementMboCellularSwitchRequestCount();
        }


        if ((frameData.mBssTmDataFlagsMask
                & MboOceConstants.BTM_DATA_FLAG_DISASSOCIATION_IMMINENT) != 0) {
            long duration = 0;
            if ((frameData.mBssTmDataFlagsMask
                    & MboOceConstants.BTM_DATA_FLAG_MBO_ASSOC_RETRY_DELAY_INCLUDED) != 0) {
                mWifiMetrics.incrementSteeringRequestCountIncludingMboAssocRetryDelay();
                duration = frameData.mBlockListDurationMs;
            }
            if (duration == 0) {
                /*
                 * When disassoc imminent bit alone is set or MBO assoc retry delay is
                 * set to zero(reserved as per spec), blocklist the BSS for sometime to
                 * avoid AP rejecting the re-connect request.
                 */
                duration = MboOceConstants.DEFAULT_BLOCKLIST_DURATION_MS;
            }
            // Blocklist the current BSS
            WifiConfiguration config = getConnectedWifiConfiguration();
            if (config == null) {
                config = getConnectingWifiConfiguration();
            }
            mWifiBlocklistMonitor.blockBssidForDurationMs(bssid, config, duration,
                    WifiBlocklistMonitor.REASON_FRAMEWORK_DISCONNECT_MBO_OCE, 0);
        }

        if (frameData.mStatus != MboOceConstants.BTM_RESPONSE_STATUS_ACCEPT) {
            // Trigger the network selection and re-connect to new network if available.
            mWifiMetrics.incrementForceScanCountDueToSteeringRequest();
            mWifiConnectivityManager.forceConnectivityScan(ClientModeImpl.WIFI_WORK_SOURCE);
        }
    }

    /**
     * @return true if this device supports FILS-SHA256
     */
    private boolean isFilsSha256Supported() {
        return (getSupportedFeatures() & WIFI_FEATURE_FILS_SHA256) != 0;
    }

    /**
     * @return true if this device supports FILS-SHA384
     */
    private boolean isFilsSha384Supported() {
        return (getSupportedFeatures() & WIFI_FEATURE_FILS_SHA384) != 0;
    }

    /**
     * @return true if this device supports Trust On First Use
     */
    private boolean isTrustOnFirstUseSupported() {
        return (getSupportedFeatures() & WIFI_FEATURE_TRUST_ON_FIRST_USE) != 0;
    }

    /**
     * Helper method to set the allowed key management schemes from
     * scan result.
     * When the AKM is updated, changes should be propagated to the
     * actual saved network, and the correct AKM could be retrieved
     * on selecting the security params.
     */
    private void updateAllowedKeyManagementSchemesFromScanResult(
            WifiConfiguration config, ScanResult scanResult) {
        config.enableFils(
                isFilsSha256Supported()
                && ScanResultUtil.isScanResultForFilsSha256Network(scanResult),
                isFilsSha384Supported()
                && ScanResultUtil.isScanResultForFilsSha384Network(scanResult));
        mWifiConfigManager.updateFilsAkms(config.networkId,
                config.isFilsSha256Enabled(), config.isFilsSha384Enabled());
    }
    /**
     * Update wifi configuration based on the matching scan result.
     *
     * @param config Wifi configuration object.
     * @param scanResult Scan result matching the network.
     */
    private void updateWifiConfigFromMatchingScanResult(WifiConfiguration config,
            ScanResult scanResult) {
        updateAllowedKeyManagementSchemesFromScanResult(config, scanResult);
        if (config.isFilsSha256Enabled() || config.isFilsSha384Enabled()) {
            config.enterpriseConfig.setFieldValue(WifiEnterpriseConfig.EAP_ERP, "1");
        }
    }

    private void selectCandidateSecurityParamsIfNecessary(
            WifiConfiguration config,
            List<ScanResult> scanResults) {
        if (null != config.getNetworkSelectionStatus().getCandidateSecurityParams()) return;
        if (mVerboseLoggingEnabled) {
            Log.d(getTag(), "Select candidate security params for " + config.getProfileKey());
        }

        // This comes from wifi picker directly so there is no candidate security params.
        // Run network selection against this SSID.
        List<ScanDetail> scanDetailsList = scanResults.stream()
                .filter(scanResult -> config.SSID.equals(
                        ScanResultUtil.createQuotedSsid(scanResult.SSID)))
                .map(ScanDetail::new)
                .collect(Collectors.toList());
        List<WifiCandidates.Candidate> candidates = mWifiNetworkSelector
                .getCandidatesForUserSelection(config, scanDetailsList);
        mWifiNetworkSelector.selectNetwork(candidates);
        // Get the fresh copy again to retrieve the candidate security params.
        WifiConfiguration freshConfig = mWifiConfigManager.getConfiguredNetwork(config.networkId);
        if (null != freshConfig
                && null != freshConfig.getNetworkSelectionStatus().getCandidateSecurityParams()) {
            config.getNetworkSelectionStatus().setCandidateSecurityParams(
                    freshConfig.getNetworkSelectionStatus().getCandidateSecurityParams());
            return;
        }

        // When a connecting request comes from network request or adding a network via
        // API directly, there might be no scan result to know the proper security params.
        // In this case, we use the first available security params to have a try first.
        Log.i(getTag(), "Cannot select a candidate security params from scan results,"
                + "try to select the first available security params.");
        SecurityParams defaultParams = config.getSecurityParamsList().stream()
                .filter(WifiConfigurationUtil::isSecurityParamsValid)
                .findFirst().orElse(null);
        config.getNetworkSelectionStatus().setCandidateSecurityParams(defaultParams);
        // populate the target security params to the internal configuration manually,
        // and then wifi info could retrieve this information.
        mWifiConfigManager.setNetworkCandidateScanResult(
                config.networkId, null, 0, defaultParams);
    }

    /**
     * Update the wifi configuration before sending connect to
     * supplicant/driver.
     *
     * @param config wifi configuration object.
     * @param bssid BSSID to assocaite with.
     */
    void updateWifiConfigOnStartConnection(WifiConfiguration config, String bssid) {
        setTargetBssid(config, bssid);

        // Go through the matching scan results and update wifi config.
        ScanResultMatchInfo key1 = ScanResultMatchInfo.fromWifiConfiguration(config);
        List<ScanResult> scanResults = mScanRequestProxy.getScanResults();
        for (ScanResult scanResult : scanResults) {
            if (!config.SSID.equals(ScanResultUtil.createQuotedSsid(scanResult.SSID))) {
                continue;
            }
            ScanResultMatchInfo key2 = ScanResultMatchInfo.fromScanResult(scanResult);
            if (!key1.equals(key2)) {
                continue;
            }
            updateWifiConfigFromMatchingScanResult(config, scanResult);
        }

        selectCandidateSecurityParamsIfNecessary(config, scanResults);

        if (mWifiGlobals.isConnectedMacRandomizationEnabled()) {
            boolean isMacRandomizationForceDisabled = isMacRandomizationForceDisabledOnSsid(config);
            if (config.macRandomizationSetting == WifiConfiguration.RANDOMIZATION_NONE
                    || isMacRandomizationForceDisabled) {
                setCurrentMacToFactoryMac(config);
            } else {
                configureRandomizedMacAddress(config);
            }
            if (isMacRandomizationForceDisabled
                    && config.macRandomizationSetting != WifiConfiguration.RANDOMIZATION_NONE) {
                // update WifiConfigManager to disable MAC randomization so Settings show the right
                // MAC randomization information.
                config.macRandomizationSetting = WifiConfiguration.RANDOMIZATION_NONE;
                mWifiConfigManager.addOrUpdateNetwork(config, Process.SYSTEM_UID);
            }
        }

        if (config.enterpriseConfig != null
                && config.enterpriseConfig.isAuthenticationSimBased()
                && mWifiCarrierInfoManager.isImsiEncryptionInfoAvailable(
                mWifiCarrierInfoManager.getBestMatchSubscriptionId(config))
                && TextUtils.isEmpty(config.enterpriseConfig.getAnonymousIdentity())) {
            String anonAtRealm = mWifiCarrierInfoManager
                    .getAnonymousIdentityWith3GppRealm(config);
            // Use anonymous@<realm> when pseudonym is not available
            config.enterpriseConfig.setAnonymousIdentity(anonAtRealm);
        }
    }

    private boolean isMacRandomizationForceDisabledOnSsid(WifiConfiguration config) {
        Set<String> unsupportedSsids = new ArraySet<>(mContext.getResources().getStringArray(
                R.array.config_wifiForceDisableMacRandomizationSsidList));
        return unsupportedSsids.contains(config.SSID);
    }

    private void setConfigurationsPriorToIpClientProvisioning(WifiConfiguration config) {
        mIpClient.setHttpProxy(config.getHttpProxy());
        if (!TextUtils.isEmpty(mContext.getResources().getString(
                R.string.config_wifi_tcp_buffers))) {
            mIpClient.setTcpBufferSizes(mContext.getResources().getString(
                    R.string.config_wifi_tcp_buffers));
        }
    }

    private boolean startIpClient(WifiConfiguration config, boolean isFilsConnection) {
        if (mIpClient == null || config == null) {
            return false;
        }

        final boolean isUsingStaticIp =
                (config.getIpAssignment() == IpConfiguration.IpAssignment.STATIC);
        final boolean isUsingMacRandomization =
                config.macRandomizationSetting
                        != WifiConfiguration.RANDOMIZATION_NONE
                        && mWifiGlobals.isConnectedMacRandomizationEnabled();
        final List<byte[]> ouis = getOuiInternal(config);
        final List<android.net.DhcpOption> options =
                mWifiConfigManager.getCustomDhcpOptions(WifiSsid.fromString(config.SSID), ouis);
        if (mVerboseLoggingEnabled) {
            final String key = config.getProfileKey();
            log("startIpClient netId=" + Integer.toString(mLastNetworkId)
                    + " " + key + " "
                    + " roam=" + mIsAutoRoaming
                    + " static=" + isUsingStaticIp
                    + " randomMac=" + isUsingMacRandomization
                    + " isFilsConnection=" + isFilsConnection);
        }

        final MacAddress currentBssid = getCurrentBssidInternalMacAddress();
        final String l2Key = mLastL2KeyAndGroupHint != null
                ? mLastL2KeyAndGroupHint.first : null;
        final String groupHint = mLastL2KeyAndGroupHint != null
                ? mLastL2KeyAndGroupHint.second : null;
        final Layer2Information layer2Info = new Layer2Information(l2Key, groupHint,
                currentBssid);

        if (isFilsConnection) {
            stopIpClient();
            if (isUsingStaticIp) {
                mWifiNative.flushAllHlp(mInterfaceName);
                return false;
            }
            setConfigurationsPriorToIpClientProvisioning(config);
            final ProvisioningConfiguration.Builder prov =
                    new ProvisioningConfiguration.Builder()
                    .withPreDhcpAction()
                    .withPreconnection()
                    .withDisplayName(config.SSID)
                    .withLayer2Information(layer2Info);
            if (mContext.getResources().getBoolean(R.bool.config_wifiEnableApfOnNonPrimarySta)
                    || isPrimary()) {
                // unclear if the native layer will return the correct non-capabilities if APF is
                // not supported on secondary interfaces.
                prov.withApfCapabilities(mWifiNative.getApfCapabilities(mInterfaceName));
            }
            if (isUsingMacRandomization) {
                // Use EUI64 address generation for link-local IPv6 addresses.
                prov.withRandomMacAddress();
            }
            prov.withDhcpOptions(convertToInternalDhcpOptions(options));
            mIpClient.startProvisioning(prov.build());
        } else {
            sendNetworkChangeBroadcast(DetailedState.OBTAINING_IPADDR);
            // We must clear the config BSSID, as the wifi chipset may decide to roam
            // from this point on and having the BSSID specified in the network block would
            // cause the roam to fail and the device to disconnect.
            clearTargetBssid("ObtainingIpAddress");

            // Stop IpClient in case we're switching from DHCP to static
            // configuration or vice versa.
            //
            // When we transition from static configuration to DHCP in
            // particular, we must tell ConnectivityService that we're
            // disconnected, because DHCP might take a long time during which
            // connectivity APIs such as getActiveNetworkInfo should not return
            // CONNECTED.
            stopDhcpSetup();
            setConfigurationsPriorToIpClientProvisioning(config);
            ScanResult scanResult = getScanResultInternal(config);

            final ProvisioningConfiguration.Builder prov;
            ProvisioningConfiguration.ScanResultInfo scanResultInfo = null;
            if (scanResult != null) {
                final List<ScanResultInfo.InformationElement> ies =
                        new ArrayList<ScanResultInfo.InformationElement>();
                for (ScanResult.InformationElement ie : scanResult.getInformationElements()) {
                    ScanResultInfo.InformationElement scanResultInfoIe =
                            new ScanResultInfo.InformationElement(ie.getId(), ie.getBytes());
                    ies.add(scanResultInfoIe);
                }
                scanResultInfo = new ProvisioningConfiguration.ScanResultInfo(scanResult.SSID,
                        scanResult.BSSID, ies);
            }

            if (!isUsingStaticIp) {
                prov = new ProvisioningConfiguration.Builder()
                    .withPreDhcpAction()
                    .withNetwork(getCurrentNetwork())
                    .withDisplayName(config.SSID)
                    .withScanResultInfo(scanResultInfo)
                    .withLayer2Information(layer2Info);
            } else {
                StaticIpConfiguration staticIpConfig = config.getStaticIpConfiguration();
                prov = new ProvisioningConfiguration.Builder()
                        .withStaticConfiguration(staticIpConfig)
                        .withNetwork(getCurrentNetwork())
                        .withDisplayName(config.SSID)
                        .withLayer2Information(layer2Info);
            }
            if (mContext.getResources().getBoolean(R.bool.config_wifiEnableApfOnNonPrimarySta)
                    || isPrimary()) {
                // unclear if the native layer will return the correct non-capabilities if APF is
                // not supported on secondary interfaces.
                prov.withApfCapabilities(mWifiNative.getApfCapabilities(mInterfaceName));
            }
            if (isUsingMacRandomization) {
                // Use EUI64 address generation for link-local IPv6 addresses.
                prov.withRandomMacAddress();
            }
            prov.withDhcpOptions(convertToInternalDhcpOptions(options));
            mIpClient.startProvisioning(prov.build());
        }

        return true;
    }

    private List<byte[]> getOuiInternal(WifiConfiguration config) {
        List<byte[]> ouis = new ArrayList<>();
        ScanResult scanResult = getScanResultInternal(config);
        if (scanResult == null) {
            return ouis;
        }
        List<InformationElementUtil.Vsa> vsas = InformationElementUtil.getVendorSpecificIE(
                scanResult.informationElements);
        for (InformationElementUtil.Vsa vsa : vsas) {
            byte[] oui = vsa.oui;
            if (oui != null) {
                ouis.add(oui);
            }
        }
        return ouis;
    }

    private ScanResult getScanResultInternal(WifiConfiguration config) {
        ScanDetailCache scanDetailCache =
                mWifiConfigManager.getScanDetailCacheForNetwork(config.networkId);
        ScanResult scanResult = null;
        if (mLastBssid != null) {
            if (scanDetailCache != null) {
                scanResult = scanDetailCache.getScanResult(mLastBssid);
            }
            // The cached scan result of connected network would be null at the first
            // connection, try to check full scan result list again to look up matched
            // scan result associated to the current BSSID.
            if (scanResult == null) {
                scanResult = mScanRequestProxy.getScanResult(mLastBssid);
            }
        }
        return scanResult;
    }

    @Override
    public boolean setWifiConnectedNetworkScorer(IBinder binder,
            IWifiConnectedNetworkScorer scorer) {
        return mWifiScoreReport.setWifiConnectedNetworkScorer(binder, scorer);
    }

    @Override
    public void clearWifiConnectedNetworkScorer() {
        mWifiScoreReport.clearWifiConnectedNetworkScorer();
    }

    @Override
    public void sendMessageToClientModeImpl(Message msg) {
        sendMessage(msg);
    }

    @Override
    public long getId() {
        return mId;
    }

    @Override
    public void dumpWifiScoreReport(FileDescriptor fd, PrintWriter pw, String[] args) {
        mWifiScoreReport.dump(fd, pw, args);
    }

    /**
     * Notifies changes in data connectivity of the default data SIM.
     */
    @Override
    public void onCellularConnectivityChanged(@WifiDataStall.CellularDataStatusCode int status) {
        mWifiConfigManager.onCellularConnectivityChanged(status);
        // do a scan if no cell data and currently not connect to wifi
        if (status == WifiDataStall.CELLULAR_DATA_NOT_AVAILABLE
                && getConnectedWifiConfigurationInternal() == null) {
            if (mContext.getResources().getBoolean(
                    R.bool.config_wifiScanOnCellularDataLossEnabled)) {
                mWifiConnectivityManager.forceConnectivityScan(WIFI_WORK_SOURCE);
            }
        }
    }

    @Override
    public void setMboCellularDataStatus(boolean available) {
        mWifiNative.setMboCellularDataStatus(mInterfaceName, available);
    }

    @Override
    public WifiNative.RoamingCapabilities getRoamingCapabilities() {
        return mWifiNative.getRoamingCapabilities(mInterfaceName);
    }

    @Override
    public boolean configureRoaming(WifiNative.RoamingConfig config) {
        return mWifiNative.configureRoaming(mInterfaceName, config);
    }

    @Override
    public boolean enableRoaming(boolean enabled) {
        int status = mWifiNative.enableFirmwareRoaming(
                mInterfaceName, enabled
                        ? WifiNative.ENABLE_FIRMWARE_ROAMING
                        : WifiNative.DISABLE_FIRMWARE_ROAMING);
        return status == WifiNative.SET_FIRMWARE_ROAMING_SUCCESS;
    }

    @Override
    public boolean setCountryCode(String countryCode) {
        return mWifiNative.setStaCountryCode(mInterfaceName, countryCode);
    }

    @Override
    public List<TxFateReport> getTxPktFates() {
        return mWifiNative.getTxPktFates(mInterfaceName);
    }

    @Override
    public List<RxFateReport> getRxPktFates() {
        return mWifiNative.getRxPktFates(mInterfaceName);
    }

    @Override
    public void setShouldReduceNetworkScore(boolean shouldReduceNetworkScore) {
        mWifiScoreReport.setShouldReduceNetworkScore(shouldReduceNetworkScore);
    }

    private void applyCachedPacketFilter() {
        // If packet filter is supported on both connections, ignore since we would have already
        // applied the filter.
        if (mContext.getResources().getBoolean(R.bool.config_wifiEnableApfOnNonPrimarySta)) return;
        if (mCachedPacketFilter == null) {
            Log.w(TAG, "No cached packet filter to apply");
            return;
        }
        Log.i(TAG, "Applying cached packet filter");
        mWifiNative.installPacketFilter(mInterfaceName, mCachedPacketFilter);
    }

    /**
     * Invoked by parent ConcreteClientModeManager whenever a role change occurs.
     */
    public void onRoleChanged() {
        ClientRole role = mClientModeManager.getRole();
        if (role == ROLE_CLIENT_PRIMARY) {
            applyCachedPacketFilter();
            if (mScreenOn) {
                // Start RSSI polling for the new primary network to enable scoring.
                enableRssiPolling(true);
            }
        } else {
            if (mScreenOn && !isSecondaryInternet()) {
                // Stop RSSI polling (if enabled) for the secondary network.
                enableRssiPolling(false);
            }
        }
        WifiConfiguration connectedNetwork = getConnectedWifiConfiguration();
        if (connectedNetwork != null) {
            updateWifiInfoWhenConnected(connectedNetwork);
            // Update capabilities after a role change.
            updateCapabilities(connectedNetwork);
        }
        mWifiScoreReport.onRoleChanged(role);
    }

    private void addPasspointInfoToLinkProperties(LinkProperties linkProperties) {
        // CaptivePortalData.Builder.setVenueFriendlyName API not available on R
        if (!SdkLevel.isAtLeastS()) {
            return;
        }
        WifiConfiguration currentNetwork = getConnectedWifiConfigurationInternal();
        if (currentNetwork == null || !currentNetwork.isPasspoint()) {
            return;
        }
        ScanResult scanResult = mScanRequestProxy.getScanResult(mLastBssid);

        if (scanResult == null) {
            return;
        }
        URL venueUrl = mPasspointManager.getVenueUrl(scanResult);

        // Update the friendly name to populate the notification
        CaptivePortalData.Builder captivePortalDataBuilder = new CaptivePortalData.Builder()
                .setVenueFriendlyName(currentNetwork.providerFriendlyName);

        // Update the Venue URL if available
        if (venueUrl != null) {
            captivePortalDataBuilder.setVenueInfoUrl(Uri.parse(venueUrl.toString()),
                    CaptivePortalData.CAPTIVE_PORTAL_DATA_SOURCE_PASSPOINT);
        }

        // Update the T&C URL if available. The network is captive if T&C URL is available
        if (mTermsAndConditionsUrl != null) {
            captivePortalDataBuilder.setUserPortalUrl(
                    Uri.parse(mTermsAndConditionsUrl.toString()),
                    CaptivePortalData.CAPTIVE_PORTAL_DATA_SOURCE_PASSPOINT).setCaptive(true);
        }

        linkProperties.setCaptivePortalData(captivePortalDataBuilder.build());
    }

    private boolean mHasQuit = false;

    @Override
    protected void onQuitting() {
        mHasQuit = true;
        mClientModeManager.onClientModeImplQuit();
    }

    /** Returns true if the ClientModeImpl has fully stopped, false otherwise. */
    public boolean hasQuit() {
        return mHasQuit;
    }

    /**
     * WifiVcnNetworkPolicyChangeListener tracks VCN-defined Network policies for a
     * WifiNetworkAgent. These policies are used to restart Networks or update their
     * NetworkCapabilities.
     */
    private class WifiVcnNetworkPolicyChangeListener
            implements VcnManager.VcnNetworkPolicyChangeListener {
        @Override
        public void onPolicyChanged() {
            if (mNetworkAgent == null) {
                return;
            }
            // Update the NetworkAgent's NetworkCapabilities which will merge the current
            // capabilities with VcnManagementService's underlying Network policy.
            Log.i(getTag(), "VCN policy changed, updating NetworkCapabilities.");
            updateCapabilities();
        }
    }

    /**
     * Updates the default gateway mac address of the connected network config and updates the
     * linked networks resulting from the new default gateway.
     */
    private boolean retrieveConnectedNetworkDefaultGateway() {
        WifiConfiguration currentConfig = getConnectedWifiConfiguration();
        if (currentConfig == null) {
            logi("can't fetch config of current network id " + mLastNetworkId);
            return false;
        }

        // Find IPv4 default gateway.
        if (mLinkProperties == null) {
            logi("cannot retrieve default gateway from null link properties");
            return false;
        }
        String gatewayIPv4 = null;
        for (RouteInfo routeInfo : mLinkProperties.getRoutes()) {
            if (routeInfo.isDefaultRoute()
                    && routeInfo.getDestination().getAddress() instanceof Inet4Address
                    && routeInfo.hasGateway()) {
                gatewayIPv4 = routeInfo.getGateway().getHostAddress();
                break;
            }
        }

        if (TextUtils.isEmpty(gatewayIPv4)) {
            logi("default gateway ipv4 is null");
            return false;
        }

        String gatewayMac = macAddressFromRoute(gatewayIPv4);
        if (TextUtils.isEmpty(gatewayMac)) {
            logi("default gateway mac fetch failed for ipv4 addr = " + gatewayIPv4);
            return false;
        }

        logi("Default Gateway MAC address of " + mLastBssid + " from routes is : " + gatewayMac);
        if (!mWifiConfigManager.setNetworkDefaultGwMacAddress(mLastNetworkId, gatewayMac)) {
            logi("default gateway mac set failed for " + currentConfig.getKey() + " network");
            return false;
        }

        return mWifiConfigManager.saveToStore(true);
    }

    /**
     * Links the supplied config to all matching saved configs and updates the WifiBlocklistMonitor
     * SSID allowlist with the linked networks.
     */
    private void updateLinkedNetworks(@NonNull WifiConfiguration config) {
        if (!mContext.getResources().getBoolean(R.bool.config_wifiEnableLinkedNetworkRoaming)) {
            return;
        }

        SecurityParams params = mWifiNative.getCurrentNetworkSecurityParams(mInterfaceName);
        if (params == null || !params.isSecurityType(WifiConfiguration.SECURITY_TYPE_PSK)) {
            return;
        }

        // check for FT/PSK
        ScanResult scanResult = mScanRequestProxy.getScanResult(mLastBssid);
        if (scanResult == null || scanResult.capabilities.contains("FT/PSK")) {
            return;
        }

        mWifiConfigManager.updateLinkedNetworks(config.networkId);
        Map<String, WifiConfiguration> linkedNetworks = mWifiConfigManager
                .getLinkedNetworksWithoutMasking(config.networkId);

        if (!mWifiNative.updateLinkedNetworks(mInterfaceName, config.networkId, linkedNetworks)) {
            return;
        }
        // Update internal configs once the connection requests are accepted.
        linkedNetworks.values().forEach(linkedConfig ->
                mWifiConfigManager.setNetworkLastUsedSecurityParams(
                        linkedConfig.networkId, params));

        List<String> allowlistSsids = new ArrayList<>(linkedNetworks.values().stream()
                .map(linkedConfig -> linkedConfig.SSID)
                .collect(Collectors.toList()));
        if (linkedNetworks.size() > 0) {
            allowlistSsids.add(config.SSID);
        }
        mWifiBlocklistMonitor.setAllowlistSsids(config.SSID, allowlistSsids);
        mWifiBlocklistMonitor.updateFirmwareRoamingConfiguration(new ArraySet<>(allowlistSsids));
    }

    private boolean checkAndHandleLinkedNetworkRoaming(String associatedBssid) {
        if (!mContext.getResources().getBoolean(R.bool.config_wifiEnableLinkedNetworkRoaming)) {
            return false;
        }

        ScanResult scanResult = mScanRequestProxy.getScanResult(associatedBssid);
        if (scanResult == null) {
            return false;
        }

        WifiConfiguration config = mWifiConfigManager
                .getSavedNetworkForScanResult(scanResult);
        if (config == null || !config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)
                || mLastNetworkId == config.networkId) {
            return false;
        }

        mIsLinkedNetworkRoaming = true;
        setTargetBssid(config, associatedBssid);
        mTargetNetworkId = config.networkId;
        mTargetWifiConfiguration = config;
        mLastNetworkId = WifiConfiguration.INVALID_NETWORK_ID;
        sendNetworkChangeBroadcast(DetailedState.CONNECTING);
        mWifiInfo.setFrequency(scanResult.frequency);
        mWifiInfo.setBSSID(associatedBssid);
        return true;
    }

    @RequiresApi(Build.VERSION_CODES.S)
    private @WifiConfiguration.RecentFailureReason int
            mboAssocDisallowedReasonCodeToWifiConfigurationRecentFailureReason(
            @MboOceConstants.MboAssocDisallowedReasonCode int reasonCode) {
        switch (reasonCode) {
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_MAX_NUM_STA_ASSOCIATED:
                return WifiConfiguration.RECENT_FAILURE_MBO_ASSOC_DISALLOWED_MAX_NUM_STA_ASSOCIATED;
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_AIR_INTERFACE_OVERLOADED:
                return WifiConfiguration
                        .RECENT_FAILURE_MBO_ASSOC_DISALLOWED_AIR_INTERFACE_OVERLOADED;
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_AUTH_SERVER_OVERLOADED:
                return WifiConfiguration.RECENT_FAILURE_MBO_ASSOC_DISALLOWED_AUTH_SERVER_OVERLOADED;
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_INSUFFICIENT_RSSI:
                return WifiConfiguration.RECENT_FAILURE_MBO_ASSOC_DISALLOWED_INSUFFICIENT_RSSI;
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_UNSPECIFIED:
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_RESERVED_0:
            case MboOceConstants.MBO_ASSOC_DISALLOWED_REASON_RESERVED:
            default:
                return WifiConfiguration.RECENT_FAILURE_MBO_ASSOC_DISALLOWED_UNSPECIFIED;
        }
    }

    /**
     * To set association rejection status in wifi config.
     * @param netId The network ID.
     * @param assocRejectEventInfo Association rejection information.
     */
    private void setAssociationRejectionStatusInConfig(int netId,
            AssocRejectEventInfo assocRejectEventInfo) {
        int statusCode = assocRejectEventInfo.statusCode;
        @WifiConfiguration.RecentFailureReason int reason;

        switch (statusCode) {
            case StaIfaceStatusCode.AP_UNABLE_TO_HANDLE_NEW_STA:
                reason = WifiConfiguration.RECENT_FAILURE_AP_UNABLE_TO_HANDLE_NEW_STA;
                break;
            case StaIfaceStatusCode.ASSOC_REJECTED_TEMPORARILY:
                reason = WifiConfiguration.RECENT_FAILURE_REFUSED_TEMPORARILY;
                break;
            case StaIfaceStatusCode.DENIED_POOR_CHANNEL_CONDITIONS:
                reason = WifiConfiguration.RECENT_FAILURE_POOR_CHANNEL_CONDITIONS;
                break;
            default:
                // do nothing
                return;
        }

        if (SdkLevel.isAtLeastS()) {
            if (assocRejectEventInfo.mboAssocDisallowedInfo != null) {
                reason = mboAssocDisallowedReasonCodeToWifiConfigurationRecentFailureReason(
                        assocRejectEventInfo.mboAssocDisallowedInfo.mReasonCode);
            } else if (assocRejectEventInfo.oceRssiBasedAssocRejectInfo != null) {
                reason = WifiConfiguration.RECENT_FAILURE_OCE_RSSI_BASED_ASSOCIATION_REJECTION;
            }
        }

        mWifiConfigManager.setRecentFailureAssociationStatus(netId, reason);

    }

    private void setSelectedRcoiForPasspoint(WifiConfiguration config) {
        // Only relevant for Passpoint providers with roaming consortium subscriptions
        if (config.isPasspoint() && config.roamingConsortiumIds != null
                && config.roamingConsortiumIds.length > 0) {
            long selectedRcoi = mPasspointManager.getSelectedRcoiForNetwork(
                    config.getPasspointUniqueId(), config.SSID);
            if (selectedRcoi != 0) {
                config.enterpriseConfig.setSelectedRcoi(selectedRcoi);
            }
        }
    }
}