GetScanResult的接口调用流程：

                                         

GetScanResult流程关键代码：

所在文件：foundation\communication\wifi\wifi\frameworks\js\napi\src\wifi_napi_device.cpp
NO_SANITIZE("cfi") napi_value GetScanResults(napi_env env, napi_callback_info info) {
    std::vector<WifiScanInfo> scanInfos;
    ErrCode ret = wifiScanPtr->GetScanInfoList(scanInfos, true);
}

所在文件：foundation\communication\wifi\wifi\frameworks\native\src\wifi_scan_impl.cpp
ErrCode WifiScanImpl::GetScanInfoList(std::vector<WifiScanInfo> &result, bool compatible) {
    return client_->GetScanInfoList(result, compatible);
}

所在文件：foundation\communication\wifi\wifi\frameworks\native\src\wifi_scan_proxy.cpp
ErrCode WifiScanProxy::GetScanInfoList(std::vector<WifiScanInfo> &result, bool compatible)
{
    MessageOption option;
    MessageParcel data;
    MessageParcel reply;
    data.WriteInterfaceToken(GetDescriptor());
    data.WriteInt32(0);
    data.WriteBool(compatible);
    int error = Remote()->SendRequest(static_cast<uint32_t>(ScanInterfaceCode::WIFI_SVR_CMD_GET_SCAN_INFO_LIST), data,
        reply, option);

    int exception = reply.ReadInt32();
    int ret = reply.ReadInt32();

    constexpr int maxSize = 200;
    std::vector<uint32_t> allSize;
    reply.ReadUInt32Vector(&allSize);
    uint32_t retSize = allSize.size();
    return ParseScanInfos(reply, result, allSize);
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_scan_sa\wifi_scan_stub.cpp
    handleFuncMap[static_cast<uint32_t>(ScanInterfaceCode::WIFI_SVR_CMD_GET_SCAN_INFO_LIST)] = [this](uint32_t code, 
        MessageParcel &data, MessageParcel &reply,
        
int WifiScanStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    HandleFuncMap::iterator iter = handleFuncMap.find(code);
    (iter->second)(code, data, reply, option);
}
    
int WifiScanStub::OnGetScanInfoList(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    bool compatible = data.ReadBool();
    std::vector<WifiScanInfo> result;
    ErrCode ret = GetScanInfoList(result, compatible);
    reply.WriteInt32(0);

    int32_t size = static_cast<int>(result.size());
    constexpr int maxSize = 200;
    if (size > maxSize) {
        size = maxSize;
    }
    SendScanInfo(size, result, reply);
    return ret;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_scan_sa\wifi_scan_service_impl.cpp
ErrCode WifiScanServiceImpl::GetScanInfoList(std::vector<WifiScanInfo> &result, bool compatible)
{
    WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(result);
    return WIFI_OPT_SUCCESS;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_toolkit\config\wifi_scan_config.cpp
int WifiScanConfig::GetScanInfoList(std::vector<WifiScanInfo> &results)
{
    std::unique_lock<std::mutex> lock(mScanMutex);
    int64_t currentTime = GetElapsedMicrosecondsSinceBoot();
    for (auto iter = mWifiScanInfoList.begin(); iter != mWifiScanInfoList.end();) {
        if (iter->disappearCount >= WIFI_DISAPPEAR_TIMES) {
#ifdef SUPPORT_RANDOM_MAC_ADDR
            WifiConfigCenter::GetInstance().RemoveMacAddrPairInfo(
                WifiMacAddrInfoType::WIFI_SCANINFO_MACADDR_INFO, iter->bssid, iter->bssidType);
#endif
            hilinkAbilityRecord.erase(iter->bssid);
            iter = mWifiScanInfoList.erase(iter);
            mWifiCategoryRecord.erase(iter->bssid);
            continue;
        }

        /* Obtain the scanning result that is valid within 30s. */
        // constexpr int WIFI_GET_SCAN_INFO_VALID_TIMESTAMP = 30 * 1000 * 1000;
        if (iter->timestamp > currentTime - WIFI_GET_SCAN_INFO_VALID_TIMESTAMP) {
            results.push_back(*iter);
        }
        ++iter;
    }
    if (results.empty()) {
        results.assign(mWifiScanInfoList.begin(), mWifiScanInfoList.end());
    }
    return 0;
}

 

上面的流程可以看出，获取的扫描结果实际是保存在了WifiScanConfig的mWifiScanInfoList中。下面要研究一下是扫描结果是如何保存在WifiScanConfig的mWifiScanInfoList的！

保存扫描结果流程：

    

保存扫描结果流程关键代码：

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_scan\scan_monitor.cpp

void ScanMonitor::ReceiveScanEventFromIdl(int result) {
    ProcessReceiveScanEvent(result);
}

void ScanMonitor::ProcessReceiveScanEvent(int result) {
    switch (result) {
        case HAL_SINGLE_SCAN_OVER_OK: {
            SendScanInfoEvent();
            break;
        }
        default: {
            WIFI_LOGE("result is error.\n");
            break;
        }
    }
}
void ScanMonitor::SendScanInfoEvent() {
    pScanStateMachine->SendMessage(static_cast<int>(SCAN_RESULT_EVENT));
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_scan\scan_state_machine.cpp

bool ScanStateMachine::CommonScanning::ExecuteStateMsg(InternalMessagePtr msg)
{
    switch (msg->GetMessageName()) {
        case SCAN_RESULT_EVENT:
            pScanStateMachine->CommonScanInfoProcess();
            pScanStateMachine->SwitchState(pScanStateMachine->commonScanUnworkedState);
            return true;
        default:
            return false;
    }
}

void ScanStateMachine::CommonScanInfoProcess() {
    ScanStatusReport scanStatusReport;

    // 从wpa_supplicant获取扫描结果
    GetScanInfos(scanStatusReport.scanInfoList)；
    FilterScanResult(scanStatusReport.scanInfoList);
    GetRunningIndexList(scanStatusReport.requestIndexList);

    scanStatusReport.status = COMMON_SCAN_SUCCESS;
    if (scanStatusReportHandler) {
        scanStatusReportHandler(scanStatusReport);
    }
    std::unique_lock<std::shared_mutex> guard(lock);
    runningScans.clear();
}

        bool ScanStateMachine::GetScanInfos(std::vector<InterScanInfo> &scanInfos)
        {
            WifiStaHalInterface::GetInstance().QueryScanInfos(
                WifiConfigCenter::GetInstance().GetStaIfaceName(), scanInfos);
            GetSecurityTypeAndBand(scanInfos);
            return true;
        }

       所在文件：

        foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\wifi_hal_interface\wifi_sta_hal_interface.cpp

        WifiErrorNo WifiStaHalInterface::QueryScanInfos(const std::string &ifaceName, std::vector<InterScanInfo> &scanInfos)
        {
            std::vector<ScanResultsInfo> scanResultsInfo;
            HalDeviceManager::GetInstance().GetScanInfos(ifaceName, scanResultsInfo)
            ParseScanInfo(scanResultsInfo, scanInfos);
            return WIFI_HAL_OPT_OK;
        }

        所在文件：

        foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\hal_device_manage\hal_device_manage.cpp
        bool HalDeviceManager::GetScanInfos(const std::string &ifaceName, std::vector<ScanResultsInfo> &scanResultsInfo)
        {
            int32_t ret = iface->GetScanInfos(scanResultsInfo);
            return true;   
        }

        所在文件：drivers\peripheral\wlan\chip\hdi_service\wifi_sta_iface.cpp

        int32_t WifiStaIface::GetScanInfos(std::vector<ScanResultsInfo>& scanResultsInfo)
        {
            WifiError status = vendorHal_.lock()->GetScanInfos(ifname_, scanResultsInfo);
        }

        所在文件：chip\hdi_service\wifi_vendor_hal.cpp

        WifiError WifiVendorHal::GetScanInfos(const std::string& ifaceName,
            std::vector<ScanResultsInfo>& scanResultsInfo)
        {
            WifiError status = globalFuncTable_.getScanResults(GetIfaceHandle(ifaceName), scanResultsInfo);
            return status;
        }

        所在文件：drivers\peripheral\wlan\chip\wifi_hal\wifi_scan.cpp

        WifiError WifiGetScanInfo(wifiInterfaceHandle handle,
            std::vector<OHOS::HDI::Wlan::Chip::V1_0::ScanResultsInfo>& mscanResults)
        {

            GetScanResultsCommand command(handle);
            auto lock = ReadLockData();
            WifiError status = (WifiError)command.RequestResponse();
            mscanResults = command.GetScanResultsInfo();
            return status;
        }

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_scan\scan_service.cpp

void ScanService::HandleScanStatusReport(ScanStatusReport &scanStatusReport)
{
    switch (scanStatusReport.status) {
        case COMMON_SCAN_SUCCESS: { 
            HandleCommonScanInfo(scanStatusReport.requestIndexList, scanStatusReport.scanInfoList);
            break;
        }
    }
}

void ScanService::HandleCommonScanInfo( 
    std::vector<int> &requestIndexList, std::vector<InterScanInfo> &scanInfoList) {

    bool fullScanStored = false;
    {
        std::unique_lock<std::mutex> lock(scanConfigMapMutex);
        HandleScanResults(requestIndexList, scanInfoList, fullScanStored);
    }
}

void ScanService::HandleScanResults(std::vector<int> &requestIndexList, std::vector<InterScanInfo> &scanInfoList,
    bool &fullScanStored) {
    
    StoreFullScanInfo(configIter->second, scanInfoList);
}

bool ScanService::StoreFullScanInfo(
    const StoreScanConfig &scanConfig, std::vector<InterScanInfo> &scanInfoList)
{
    if (scanInfoList.size() == 0) {
        /* Don't overwrite ScanInfoList */
        std::vector<WifiScanInfo> results;
        int ret = WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(results);

        for (auto iter = results.begin(); iter != results.end(); ++iter) {
            iter->disappearCount++; // 目的是更新消失的次数
        }
        WifiConfigCenter::GetInstance().GetWifiScanConfig()->SaveScanInfoList(results)；
        return true;
    }

    std::vector<WifiScanInfo> storeInfoList;
    for (auto iter = scanInfoList.begin(); iter != scanInfoList.end(); ++iter) {
        WifiScanInfo scanInfo;
        ConvertScanInfo(scanInfo, *iter);
        storeInfoList.push_back(scanInfo);
    }

    std::vector<WifiScanInfo> results;
    int ret = WifiConfigCenter::GetInstance().GetWifiScanConfig()->GetScanInfoList(results);
    for (auto iter = results.begin(); iter != results.end(); ++iter) {
        iter->disappearCount++;
    }
    // 合并扫描结果
    MergeScanResult(results, storeInfoList);
    return true;
}

void ScanService::MergeScanResult(std::vector<WifiScanInfo> &results, std::vector<WifiScanInfo> &storeInfoList)
{
    for (auto storedIter = storeInfoList.begin(); storedIter != storeInfoList.end(); ++storedIter) {
        bool find = false;
        for (auto iter = results.begin(); iter != results.end(); ++iter) {
            if (iter->bssid == storedIter->bssid) {
                iter = results.erase(iter);
                find = true;
                break;
            }
        }

        results.push_back(*storedIter);
    }

    WifiConfigCenter::GetInstance().GetWifiScanConfig()->SaveScanInfoList(results);
    WifiConfigCenter::GetInstance().UpdateLinkedInfo(m_instId);
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_toolkit\config\wifi_scan_config.cpp

int WifiScanConfig::SaveScanInfoList(const std::vector<WifiScanInfo> &results)
{
    std::unique_lock<std::mutex> lock(mScanMutex);
    mWifiScanInfoList.clear();
    mWifiScanInfoList = results;
    return 0;
}

 

ScanMonitor::ReceiveScanEventFromIdl的注册和回调关键代码：

bool ScanMonitor::InitScanMonitor()
{
    SupplicantEventCallback eventCallback;
    eventCallback.onScanNotify = [this](int result) { this->ReceiveScanEventFromIdl(result); };
    WifiSupplicantHalInterface::GetInstance().RegisterSupplicantEventCallback(eventCallback)
    return true;
}

WifiErrorNo WifiSupplicantHalInterface::RegisterSupplicantEventCallback(SupplicantEventCallback &callback)
{
    mCallback = callback;
    return WIFI_HAL_OPT_OK;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\client\hdi_client\wifi_hdi_wpa_callback.cpp
int32_t OnEventScanResult(struct IWpaCallback *self,
    const struct HdiWpaRecvScanResultParam *recvScanResultParam, const char* ifName)
{
    const OHOS::Wifi::SupplicantEventCallback &cbk =
        OHOS::Wifi::WifiSupplicantHalInterface::GetInstance().GetCallbackInst();
    if (cbk.onScanNotify) {
        cbk.onScanNotify(HAL_SINGLE_SCAN_OVER_OK);
    }
    return 0;
}