WiFi 连接过程_wifi连接流程csdn

1. 在 WifiNative 类中 connectNetwork 被调用用于连接，其主要工作为停止当前扫描过程，删除 wpa_supplicant 中的网络配置信息，并将新的配置传送给 wpa_supplicant 保存，这会触发对已有配置网络的 disconnect 操作，最后触发 reconnect 操作到 wpa_supplicant：

    /**
     * Add the provided network configuration to wpa_supplicant and initiate connection to it.
     * This method does the following:
     * 1. Abort any ongoing scan to unblock the connection request.
     * 2. Remove any existing network in wpa_supplicant(This implicitly triggers disconnect).
     * 3. Add a new network to wpa_supplicant.
     * 4. Save the provided configuration to wpa_supplicant.
     * 5. Select the new network in wpa_supplicant.
     * 6. Triggers reconnect command to wpa_supplicant.
     *
     * @param ifaceName Name of the interface.
     * @param configuration WifiConfiguration parameters for the provided network.
     * @return {@code true} if it succeeds, {@code false} otherwise
     */
    public boolean connectToNetwork(@NonNull String ifaceName, WifiConfiguration configuration) {
        // Abort ongoing scan before connect() to unblock connection request.
        mWifiCondManager.abortScan(ifaceName);
        return mSupplicantStaIfaceHal.connectToNetwork(ifaceName, configuration);
    }

2. SupplicantStaIfaceHal 类中的 connectToNetwork 方法被调用：

    /**
     * Add the provided network configuration to wpa_supplicant and initiate connection to it.
     * This method does the following:
     * 1. If |config| is different to the current supplicant network, removes all supplicant
     * networks and saves |config|.
     * 2. Select the new network in wpa_supplicant.
     *
     * @param ifaceName Name of the interface.
     * @param config WifiConfiguration parameters for the provided network.
     * @return {@code true} if it succeeds, {@code false} otherwise
     */
    public boolean connectToNetwork(@NonNull String ifaceName, @NonNull WifiConfiguration config) {
        synchronized (mLock) {
            logd("connectToNetwork " + config.getKey());
            WifiConfiguration currentConfig = getCurrentNetworkLocalConfig(ifaceName);
            /* 如果新旧配置对应的网络是同一个 */
            if (WifiConfigurationUtil.isSameNetwork(config, currentConfig)) {
                String networkSelectionBSSID = config.getNetworkSelectionStatus()
                        .getNetworkSelectionBSSID();
                String networkSelectionBSSIDCurrent =
                        currentConfig.getNetworkSelectionStatus().getNetworkSelectionBSSID();
                if (Objects.equals(networkSelectionBSSID, networkSelectionBSSIDCurrent)) {
                    logd("Network is already saved, will not trigger remove and add operation.");
                } else {
                    logd("Network is already saved, but need to update BSSID.");
                    if (!setCurrentNetworkBssid(
                            ifaceName,
                            config.getNetworkSelectionStatus().getNetworkSelectionBSSID())) {
                        loge("Failed to set current network BSSID.");
                        return false;
                    }
                    mCurrentNetworkLocalConfigs.put(ifaceName, new WifiConfiguration(config));
                }
            } else { /* 新旧配置对应的网络部是同一个，也有可能存在一个配置是 null */
                /* 删除 HashMap 中 ifaceName 对应的配置 */
                mCurrentNetworkRemoteHandles.remove(ifaceName);
                /* 删除 HashMap 中 ifaceName 对应的配置 */
                mCurrentNetworkLocalConfigs.remove(ifaceName);
                if (!removeAllNetworks(ifaceName)) {
                    loge("Failed to remove existing networks");
                    return false;
                }
                Pair<SupplicantStaNetworkHal, WifiConfiguration> pair =
                        addNetworkAndSaveConfig(ifaceName, config);
                if (pair == null) {
                    loge("Failed to add/save network configuration: " + config.getKey());
                    return false;
                }
                mCurrentNetworkRemoteHandles.put(ifaceName, pair.first);
                mCurrentNetworkLocalConfigs.put(ifaceName, pair.second);
            }
            SupplicantStaNetworkHal networkHandle =
                    checkSupplicantStaNetworkAndLogFailure(ifaceName, "connectToNetwork");
            if (networkHandle == null) {
                loge("No valid remote network handle for network configuration: "
                        + config.getKey());
                return false;
            }
 
            PmkCacheStoreData pmkData = mPmkCacheEntries.get(config.networkId);
            if (pmkData != null
                    && !WifiConfigurationUtil.isConfigForPskNetwork(config)
                    && pmkData.expirationTimeInSec > mClock.getElapsedSinceBootMillis() / 1000) {
                logi("Set PMK cache for config id " + config.networkId);
                if (networkHandle.setPmkCache(pmkData.data)) {
                    mWifiMetrics.setConnectionPmkCache(true);
                }
            }
 
            if (!networkHandle.select()) {
                loge("Failed to select network configuration: " + config.getKey());
                return false;
            }
            return true;
        }
    }

3. 假设一开始配置为空，新增加了一条配置，则会进入 else 操作，重点进行分析，首先来看 removeAllNetworks 接口的操作：

    /**
     * Remove all networks from supplicant
     *
     * @param ifaceName Name of the interface.
     */
    public boolean removeAllNetworks(@NonNull String ifaceName) {
        synchronized (mLock) {
            ArrayList<Integer> networks = listNetworks(ifaceName);
            if (networks == null) {
                Log.e(TAG, "removeAllNetworks failed, got null networks");
                return false;
            }
            for (int id : networks) {
                if (!removeNetwork(ifaceName, id)) {
                    Log.e(TAG, "removeAllNetworks failed to remove network: " + id);
                    return false;
                }
            }
            // Reset current network info.  Probably not needed once we add support to remove/reset
            // current network on receiving disconnection event from supplicant (b/32898136).
            mCurrentNetworkRemoteHandles.remove(ifaceName);
            mCurrentNetworkLocalConfigs.remove(ifaceName);
            return true;
        }
    }

4. 进而来看 listNetworks，因为这里面我们会进入到底层 Hal 以及 wpa_supplicant 的操作过程：

    /**
     * @return a list of SupplicantNetworkID ints for all networks controlled by supplicant, returns
     * null if the call fails
     */
    private java.util.ArrayList<Integer> listNetworks(@NonNull String ifaceName) {
        synchronized (mLock) {
            final String methodStr = "listNetworks";
            ISupplicantStaIface iface = checkSupplicantStaIfaceAndLogFailure(ifaceName, methodStr);
            if (iface == null) return null;
            Mutable<ArrayList<Integer>> networkIdList = new Mutable<>();
            try {
                iface.listNetworks((SupplicantStatus status, ArrayList<Integer> networkIds) -> {
                    if (checkStatusAndLogFailure(status, methodStr)) {
                        networkIdList.value = networkIds;
                    }
                });
            } catch (RemoteException e) {
                handleRemoteException(e, methodStr);
            }
            return networkIdList.value;
        }
    }

① ISupplicantStaIface 定义在 hardware/interfaces/wifi/supplicant/1.0/ISupplicantStaIface.hal 文件中，继承自 ISupplicantIface，定义在 hardware/interfaces/wifi/supplicant/1.0/ISupplicantIface.hal 文件中，在经过 HIDL 转化之后 Native 代码实现在 external/wpa_supplicant_8/wpa_supplicant/hidl/ 目录下，而 ISupplicantStaIface 对应的 cpp 实现是 StaIface 类，定义在 sta_iface.h，实现在 sta_iface.cpp

② 上面在 framework 层的实际处理过程会进入到 HIDL 转化后的服务层 Native 代码中，进而调用到 wpa_supplicant 中的接口展开响应的操作；

③ 通过 checkSupplicantStaIfaceAndLogFailure 获取到 iface 对象，调用其 listNetworks 进而进入到 Native 层的对应接口 StaIface::listNetworks，进一步调用 listNetworksInternal；

④ listNetworksInternal 等内部操作通过 struct wpa_supplicant 对象来获取相应的信息，这些信息即为底层 wpa_supplicant 内部维护的内容，每个 struct wpa_supplicant 对应一个 iface；

5. struct wpa_supplicant 的信息管理由 struct wpa_global 统一进行，而 struct wpa_global 是在 wpa_supplicant 初始化的时候由 wpa_supplicant_init() 进行初始化的，而 wpa_supplicant_init 则是直接在 main 函数中被调用，它完成了如下操作：

① wpa_supplicant_init 初始化之后进行 wpas_notify_supplicant_initialized 以告知所有可能的控制途径 wpa_global 已经初始化完成；

② 如果定义了 CONFIG_HIDL 则 wpas_notify_supplicant_initialized 会调用 wpas_hidl_init 初始化其类型为 struct wpas_hidl_priv 的 hidl 对象；

③ wpas_hidl_init 分配对应的对象并采用 wpa_global 进行其初始化，而这里面非常重要的一步是通过 HidlManager 的 registerHidlService 方法来注册 wpa_supplicant 对应的 HIDL 服务，在这里创建了 Supplicant 类对象，以初始化后的 wpa_global 类型的 global 为参数；

④ 可以看到在 wpa_supplicant 的管理过程中如前面需要获取网络配置对应的 struct wpa_supplicat 对象，调用了 wpa_supplicant_get_iface，都是需要以 struct wpa_global 为参数进行的

6. StaIface 类对象的创建和管理由 Supplicant 进行，创建过程中会将 struct wpa_global 对象作为参数传递，从而如上面我们通过 StaIface 的 listNetworks 方法可以直接调用 wpa_supplicant 内部的公共控制接口并将 struct wpa_global 对象作为参数直接传入；

7. 同样这里查询和操作的对应接口都是在 Supplicant 类中进行创建和管理的，位于 hidl 中的 supplicant.{h,cpp} 进行了定义和实现，如 addInterface 方法，然后调用了 addInterfaceInternal 内部方法，进而调用了 wpa_supplicant 的公共管理接口 wpa_supplicant_add_iface；

8. 返回前面主流程来，在 SupplicantStaIfaceHal 的方法 connectToNetwork 中继续执行 removeAllNetworks，将获取到的 list 进行遍历，依次对其进行 removeNetwork 操作，实际上还是调用了 StaIface 的 removeNetwork 方法进入 wpa_supplicant 进行操作；

9. 删除接口之后开始进入 addNetworkAndSaveConfig 操作：

    /**
     * Add a network configuration to wpa_supplicant.
     *
     * @param config Config corresponding to the network.
     * @return a Pair object including SupplicantStaNetworkHal and WifiConfiguration objects
     * for the current network.
     */
    private Pair<SupplicantStaNetworkHal, WifiConfiguration>
            addNetworkAndSaveConfig(@NonNull String ifaceName, WifiConfiguration config) {
        synchronized (mLock) {
            logi("addSupplicantStaNetwork via HIDL");
            if (config == null) {
                loge("Cannot add NULL network!");
                return null;
            }
            SupplicantStaNetworkHal network = addNetwork(ifaceName);
            if (network == null) {
                loge("Failed to add a network!");
                return null;
            }
            boolean saveSuccess = false;
            try {
                saveSuccess = network.saveWifiConfiguration(config);
            } catch (IllegalArgumentException e) {
                Log.e(TAG, "Exception while saving config params: " + config, e);
            }
            if (!saveSuccess) {
                loge("Failed to save variables for: " + config.getKey());
                if (!removeAllNetworks(ifaceName)) {
                    loge("Failed to remove all networks on failure.");
                }
                return null;
            }
            return new Pair(network, new WifiConfiguration(config));
        }
    }

这里重点是 addNetwork 方法，从此开始由 Iface 类型转换到 Network 类型的操作上，需要返回的是 SupplicantStaNetworkHal 对象，该对象是新创建，包含了 ISupplicantStaNetwork 的 HIDL 客户端对象，Context 信息以及 WifiMonitor 信息，而 ISupplicantStaNetwork 对象是在进行 iface 的 addNetwork 中创建的：

/* sta_iface.cpp，StaIface 类实现 */
std::pair<SupplicantStatus, sp<ISupplicantNetwork>>
StaIface::addNetworkInternal()
{
	android::sp<ISupplicantStaNetwork> network;
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	struct wpa_ssid *ssid = wpa_supplicant_add_network(wpa_s);
	if (!ssid) {
		return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network};
	}
	HidlManager *hidl_manager = HidlManager::getInstance();
	if (!hidl_manager ||
	    hidl_manager->getStaNetworkHidlObjectByIfnameAndNetworkId(
		wpa_s->ifname, ssid->id, &network)) {
		return {{SupplicantStatusCode::FAILURE_UNKNOWN, ""}, network};
	}
	return {{SupplicantStatusCode::SUCCESS, ""}, network};
}

这里调用 wpa_supplicant_add_network 添加 network，并且通过 HidlManager 的 getStaNetworkHidlObjectByIfnameAndNetworkId 获取到对应的 network 信息返回；

10. network 对应 HIDL 服务端创建过程发生在 HidlManager::registerNetwork 方法中：

/**
 * Register a network to hidl manager.
 *
 * @param wpa_s |wpa_supplicant| struct corresponding to the interface on which
 * the network is added.
 * @param ssid |wpa_ssid| struct corresponding to the network being added.
 *
 * @return 0 on success, 1 on failure.
 */
int HidlManager::registerNetwork(
    struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid)
{
	if (!wpa_s || !ssid)
		return 1;
 
	// Generate the key to be used to lookup the network.
	const std::string network_key =
	    getNetworkObjectMapKey(wpa_s->ifname, ssid->id);
 
	if (isP2pIface(wpa_s)) {
		if (addHidlObjectToMap<P2pNetwork>(
			network_key,
			new P2pNetwork(wpa_s->global, wpa_s->ifname, ssid->id),
			p2p_network_object_map_)) {
			wpa_printf(
			    MSG_ERROR,
			    "Failed to register P2P network with HIDL "
			    "control: %d",
			    ssid->id);
			return 1;
		}
		p2p_network_callbacks_map_[network_key] =
		    std::vector<android::sp<ISupplicantP2pNetworkCallback>>();
		// Invoke the |onNetworkAdded| method on all registered
		// callbacks.
		callWithEachP2pIfaceCallback(
		    wpa_s->ifname,
		    std::bind(
			&ISupplicantP2pIfaceCallback::onNetworkAdded,
			std::placeholders::_1, ssid->id));
	} else {
		if (addHidlObjectToMap<StaNetwork>(
			network_key,
			new StaNetwork(wpa_s->global, wpa_s->ifname, ssid->id),
			sta_network_object_map_)) {
			wpa_printf(
			    MSG_ERROR,
			    "Failed to register STA network with HIDL "
			    "control: %d",
			    ssid->id);
			return 1;
		}
		sta_network_callbacks_map_[network_key] =
		    std::vector<android::sp<ISupplicantStaNetworkCallback>>();
		// Invoke the |onNetworkAdded| method on all registered
		// callbacks.
		callWithEachStaIfaceCallback(
		    wpa_s->ifname,
		    std::bind(
			&ISupplicantStaIfaceCallback::onNetworkAdded,
			std::placeholders::_1, ssid->id));
	}
	return 0;
}

对应的 StaNetwork 对象呗创建，并且添加到 sta_network_object_map_ 中，而 StaNetwork 类定义和实现在 sta_network.{h,cpp} 中，registerNetwork 是在 wpas_hidl_register_network 中被调用，继而被 wpas_notify_network_added 调用，调用时机是在 wpa_supplicant_add_network 内部添加了对应的 network 之后通知给监听和管理者；从而又回归到前面在分析的 StaIface::addNetworkInternal 中；

11. 继续返回到 Framework 层，addNetwork 创建 SupplicantStaNetworkHal 后将其返回，紧接着通过其 saveWiFiConfiguration 方法进行配置的保存，这里其实是调用了 SupplicantStaNetworkHal 中的接口通过 HIDL 将对应的信息配置到 wpa_supplicant 中维护的对应的 network 中，比如 ssid 信息；

12. 最终创建信息 WifiConfiguration 信息并与 network 配对之后返回 Pair<SupplicantStaNetworkHal, WifiConfiguration> 对象，WiFiConfiguration 对象为根据传递进来的 config 进行初始化的；

13. 再回到 connectToNetwork 中，将返回的 Pair 中两个配置信息分别加入到对应的 HashMap 中（mCurrentNetworkRemoteHandles 和 mCurrentNetworkLocalConfigs），更新缓存信息；

14. 紧接着调用了 SupplicantStaNetworkHal 类的 select 方法进行网络连接，实际上又回到其内部的 SupplicantStaNetwork 类，调用其 select 方法，进而调用到 Native 层 StaNetwork 类的 select 方法，继续回到 sta_network.cpp 中的 selectInternel 方法：

SupplicantStatus StaNetwork::selectInternal()
{
	struct wpa_ssid *wpa_ssid = retrieveNetworkPtr();
	if (wpa_ssid->disabled == 2) {
		return {SupplicantStatusCode::FAILURE_UNKNOWN, ""};
	}
	struct wpa_supplicant *wpa_s = retrieveIfacePtr();
	wpa_s->scan_min_time.sec = 0;
	wpa_s->scan_min_time.usec = 0;
	wpa_supplicant_select_network(wpa_s, wpa_ssid);
	return {SupplicantStatusCode::SUCCESS, ""};
}

可以看到其内部实际上调用的是 wpa_supplicant_select_network 通用控制接口，实际功能为 “Attempt association with a network”，尝试与对应的网络进行协商；

15. wpa_supplicant 连接过程会发生相应的状态变化，对应的变化过程需要通知给上层，而通知的回调则是在 SupplicantStaIfaceHal 类的 setupStaIface 接口中创建 SupplicantStaIface 的过程中注册的：

    /**
     * Helper function to set up StaIface with different HAL version.
     *
     * This helper function would try newer version recursively.
     * Once the latest version is found, it would register the callback
     * of the latest version and skip unnecessary older HAL init flow.
     *
     * New version callback will be extended from the older one, as a result,
     * older callback is always created regardless of the latest version.
     *
     * Uprev steps:
     * 1. add new helper function trySetupStaIfaceV1_Y.
     * 2. call newly added function in trySetupStaIfaceV1_X (X should be Y-1).
     */
    private ISupplicantStaIface setupStaIface(@NonNull String ifaceName,
            @NonNull ISupplicantIface ifaceHwBinder) throws RemoteException {
        /* Prepare base type for later cast. */
        ISupplicantStaIface iface = getStaIfaceMockable(ifaceHwBinder);
 
        /* try newer version first. */
        if (trySetupStaIfaceV1_1(ifaceName, iface)) {
            logd("Newer HAL is found, skip V1_0 remaining init flow.");
            return iface;
        }
 
        SupplicantStaIfaceHalCallback callback = new SupplicantStaIfaceHalCallback(ifaceName);
        if (!registerCallback(iface, callback)) {
            throw new RemoteException("Init StaIface V1_0 failed.");
        }
        /* keep this in a store to avoid recycling by garbage collector. */
        mISupplicantStaIfaceCallbacks.put(ifaceName, callback);
        return iface;
    }

对应的网络相关的事件都会通过该回调进行反馈，hardware/interfaces/wifi/supplicant/1.0/ISupplicantStaNetwork.hal 中关于注册接口的说明如下：

  /**  
   * Register for callbacks from this network.
   *
   * These callbacks are invoked for events that are specific to this network.
   * Registration of multiple callback objects is supported. These objects must 
   * be automatically deleted when the corresponding client process is dead or
   * if this network is removed.
   *
   * @param callback An instance of the |ISupplicantStaNetworkCallback| HIDL 
   *        interface object.
   * @return status Status of the operation.
   *         Possible status codes:
   *         |SupplicantStatusCode.SUCCESS|,
   *         |SupplicantStatusCode.FAILURE_UNKNOWN|,
   *         |SupplicantStatusCode.FAILURE_NETWORK_INVALID|
   */   
  registerCallback(ISupplicantStaNetworkCallback callback)
      generates (SupplicantStatus status);