WiFi Stack

Overview

The Android WiFi stack is a complex, multi-layered architecture responsible for discovering, connecting to, and managing 802.11 networks. It spans from high-level Java APIs used by applications down through system services, native daemons, hardware abstraction layers, and kernel drivers. Understanding this stack is critical for debugging connectivity drops, optimizing power consumption, and developing network-aware applications.

The WiFi Framework

The framework layer provides the APIs for application interaction and houses the core connection management logic.

WifiManager and ConnectivityManager

WifiManager provides the primary API for applications to query WiFi state, initiate scans, and manage saved configurations. However, modern Android heavily restricts direct connection manipulation by standard apps to ensure a seamless and secure user experience.

Instead, applications request network capabilities using ConnectivityManager and NetworkRequest.

// Modern way to request a specific type of WiFi connection
ConnectivityManager connManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);

NetworkRequest request = new NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
    .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
    .build();

connManager.requestNetwork(request, new ConnectivityManager.NetworkCallback() {
    @Override
    public void onAvailable(Network network) {
        // Connected to a WiFi network with internet access
    }
});

WifiNetworkSpecifier

For IoT devices or peer-to-peer setups where an app must connect to a specific, non-internet-providing SSID (e.g., configuring a smart home device), Android provides WifiNetworkSpecifier. This prompts the user with a system dialogue to approve the connection, enhancing privacy and control.

WifiNetworkSpecifier specifier = new WifiNetworkSpecifier.Builder()
    .setSsid("MyIoTDevice")
    .setWpa2Passphrase("secretpassword")
    .build();

NetworkRequest request = new NetworkRequest.Builder()
    .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
    .setNetworkSpecifier(specifier)
    .build();

WifiService (System Server)

Residing within the system_server, WifiService implements the heavy lifting. It manages the state machine for WiFi (enabled, disabled, scanning, connecting, connected), handles automatic network selection (scoring saved networks based on signal strength and history), and manages IP configuration via DHCP.

Native Daemons: wpa_supplicant and hostapd

Android relies on robust, open-source Linux networking daemons to handle the complex 802.11 protocols and security handshakes.

• wpa_supplicant: The core daemon responsible for operating the WiFi interface in Station (STA) mode. It handles scanning, parsing beacons, and crucially, managing the cryptographic handshakes for WPA/WPA2/WPA3 and 802.1X (EAP) authentication. WifiService communicates with wpa_supplicant via AIDL (historically HIDL/Sockets).
• hostapd: When the device acts as a Hotspot (SoftAP), Android uses hostapd. It manages the access point lifecycle, authenticates connecting clients, and sets up encryption keys.

The WiFi HAL (IWifi AIDL)

The WiFi Hardware Abstraction Layer acts as the bridge between the vendor-specific kernel drivers and the framework. The interface is defined via AIDL (android.hardware.wifi).

The HAL is divided into several logical components:

• IWifi: The root interface managing the lifecycle of chips and interfaces.
• IWifiStaIface: Interface for Station mode operations (connecting to networks, MAC randomization).
• IWifiApIface: Interface for SoftAP operations.
• IWifiRttController: Interface for Round Trip Time (RTT) measurements for indoor positioning (802.11mc).

Driver Interaction

The HAL translates AIDL calls into Netlink messages (specifically nl80211) which are standard Linux kernel interfaces for configuring WiFi drivers (like cfg80211 and mac80211).

Advanced Connectivity Features

Android supports specialized WiFi modes beyond standard access point connections.

WiFi Direct (P2P)

WiFi Direct allows devices to connect directly to each other without an intermediate access point, negotiating which device acts as the Group Owner (a software AP). It is heavily used for file sharing (Nearby Share/Quick Share) and screen mirroring (Miracast).

The framework handles P2P via WifiP2pManager, which coordinates with a dedicated P2P interface in wpa_supplicant.

WiFi Aware (NAN - Neighbor Awareness Networking)

WiFi Aware (802.11aq) is a protocol for continuous, low-power discovery of nearby devices and services without requiring a connection. Devices form clusters and synchronize small windows to wake up and exchange service information.

// Publishing a service via WiFi Aware
WifiAwareManager awareManager = (WifiAwareManager) getSystemService(Context.WIFI_AWARE_SERVICE);

PublishConfig config = new PublishConfig.Builder()
    .setServiceName("com.example.my_service")
    .build();

awareSession.publish(config, new DiscoverySessionCallback() {
    @Override
    public void onPublishStarted(PublishDiscoverySession session) {
        // Service is actively broadcasting
    }
}, handler);

Once a service is discovered, devices can optionally establish an out-of-band data path (like a WiFi Direct connection) to exchange larger payloads.

Debugging the WiFi Stack

When investigating connection failures or authentication issues, developers utilize several command-line tools.

# View detailed WiFi framework state, active networks, and recent connection logs
adb shell dumpsys wifi

# View connectivity manager state (routing, link properties)
adb shell dumpsys connectivity

# Logcat filtering for supplicant activity (vital for debugging WPA handshakes)
adb logcat | grep -i supplicant

Capturing a bugreport is essential for deep debugging, as it includes historical logs of WiFi state transitions and driver-level events.