鸿蒙 WiFi 扫描流程（1）

最新推荐文章于 2024-04-26 18:02:32 发布

奶一口仙气

最新推荐文章于 2024-04-26 18:02:32 发布

阅读量760

点赞数 7

分类专栏： OpenHarmony（鸿蒙）文章标签： harmonyos 华为

本文链接：https://blog.csdn.net/weixin_43278325/article/details/136021752

版权

OpenHarmony（鸿蒙）专栏收录该内容

7 篇文章 2 订阅

订阅专栏

上一篇记录了WiFi 的打开流程，这里我们继续看，WiFi使能后，如何发起扫描？代码还是用的鸿蒙OpenHarmony4.0基线代码。

foundation/communication/wifi/wifi/services/wifi_standard/wifi_hal/wifi_hal_sta_interface.c

WifiErrorNo Start(void)
{
    LOGI("Ready to start wifi");
    if (StartSupplicant() != WIFI_HAL_SUCCESS) {
        LOGE("wpa_supplicant start failed!");
        return WIFI_HAL_OPEN_SUPPLICANT_FAILED;
    }
    LOGI("wpa_supplicant start successfully!");

    if (AddWpaIface(0) != WIFI_HAL_SUCCESS) {
        LOGE("Failed to add wpa interface!");
        StopWpaAndWpaHal(0);
        return WIFI_HAL_CONN_SUPPLICANT_FAILED;
    }

    if (ConnectSupplicant() != WIFI_HAL_SUCCESS) {
        LOGE("SupplicantHal connect wpa_supplicant failed!");
        StopWpaAndWpaHal(0);
        return WIFI_HAL_CONN_SUPPLICANT_FAILED;
    }
#ifdef HDI_INTERFACE_SUPPORT
    if (HdiStart() != WIFI_HAL_SUCCESS) {
        LOGE("[STA] Start hdi failed!");
        return WIFI_HAL_FAILED;
    }
    if (RegisterHdiStaCallbackEvent() != WIFI_HAL_SUCCESS) {
        LOGE("[STA] Start RegisterHdiStaCallbackEvent failed!");
        return WIFI_HAL_FAILED;
    }
#endif
    LOGI("Start wifi successfully");
    return WIFI_HAL_SUCCESS;
}

上段代码我们知道，如果使能成功后就会返回 WIFI_HAL_SUCCESS，那看下那个地方去判断这个返回值，这里的 WIFI_HAL_SUCCESS 值是 0，表示 Success；
foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_state_machine.cpp

void StaStateMachine::StartWifiProcess()
{
    WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::ENABLING));
    staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_OPENING);
    int res;
    if (WifiOprMidState::RUNNING == WifiConfigCenter::GetInstance().GetWifiScanOnlyMidState()) {
        res = static_cast<int>(WIFI_IDL_OPT_OK);
    } else {
        res = WifiStaHalInterface::GetInstance().StartWifi();     ---> 此时成功后，返回值是 0；
    }

    if (res == static_cast<int>(WIFI_IDL_OPT_OK)) {    ---> 就走到这里来了
        WIFI_LOGI("Start wifi successfully!");
        if (WifiStaHalInterface::GetInstance().WpaAutoConnect(false) != WIFI_IDL_OPT_OK) {
            WIFI_LOGI("The automatic Wpa connection is disabled failed.");
        }

        /* callback the InterfaceService that wifi is enabled successfully. */        ---> 通知给相应的接口服务
        WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::ENABLED));
        staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_SUCCEED);
        /* Sets the MAC address of WifiSettings. */
        std::string mac;
        if ((WifiStaHalInterface::GetInstance().GetStaDeviceMacAddress(mac)) == WIFI_IDL_OPT_OK) {
            WifiSettings::GetInstance().SetMacAddress(mac);
            std::string realMacAddress;
            WifiSettings::GetInstance().GetRealMacAddress(realMacAddress);
            if (realMacAddress.empty()) {
                WifiSettings::GetInstance().SetRealMacAddress(mac);
            }
        } else {
            WIFI_LOGI("GetStaDeviceMacAddress failed!");
        }
#ifndef OHOS_ARCH_LITE
        WIFI_LOGI("Register netsupplier");
        WifiNetAgent::GetInstance().OnStaMachineWifiStart();
#endif
        /* Initialize Connection Information. */
        InitWifiLinkedInfo();
        InitLastWifiLinkedInfo();
        WifiSettings::GetInstance().SaveLinkedInfo(linkedInfo);
        SyncDeviceConfigToWpa();
#ifndef OHOS_ARCH_LITE
        ChipCapability::GetInstance().InitializeChipCapability();
#endif
        /* The current state of StaStateMachine transfers to SeparatedState after
         * enable supplicant.
         */
        SwitchState(pSeparatedState);      ---> 切换状态机
    } else {
        /* Notify the InterfaceService that wifi is failed to enable wifi. */
        LOGE("StartWifi failed, and errcode is %d.", res);
        WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::DISABLED));
        WifiSettings::GetInstance().SetUserLastSelectedNetworkId(INVALID_NETWORK_ID);
        staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_FAILED);
    }
}

这里我们看如何callback 的

// 更新状态
WifiSettings::GetInstance().SetWifiState(static_cast<int>(WifiState::ENABLED));
// 主要找到 staCallback 里面的 OnStaOpenRes 方法
staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_SUCCEED);
// 我们看下这个staCallback 是何时被赋值的，在 sta_state_machine.cpp 类里面找到如下：
void StaStateMachine::RegisterStaServiceCallback(const StaServiceCallback &callbacks)
{
    WIFI_LOGI("RegisterStaServiceCallback.");
    staCallback = callbacks;
}
// 那何时注册的呢？在往回找：
//foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_sta/sta_service.cpp
ErrCode StaService::InitStaService(const StaServiceCallback &callbacks)
{
	 RegisterStaServiceCallback(callbacks);
}
void StaService::RegisterStaServiceCallback(const StaServiceCallback &callbacks) const
{
    LOGI("Enter StaService::RegisterStaServiceCallback.");
    if (pStaStateMachine == nullptr) {
        LOGE("pStaStateMachine is null.\n");
        return;
    }
    pStaStateMachine->RegisterStaServiceCallback(callbacks);    ---> 注册到上面的  sta_state_machine.cpp 类里面
}
// 再往回找，看谁调用StaService::InitStaService 方法，这里我就省去流程了，最终可以发现在 wifi_manager.cpp 类里面
// 传的参数都是  WifiManager::GetInstance().GetStaCallback()，所以直接看WifiManager里面的GetStaCallback方法
StaServiceCallback WifiManager::GetStaCallback()
{
    return mStaCallback;       ---> 就是这个
}

// staCallback.OnStaOpenRes(OperateResState::OPEN_WIFI_SUCCEED); 也就是回掉WifiManager::mStaCallback::OnStaOpenRes方法
// foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_manager.cpp
void WifiManager::InitStaCallback(void)
{
    mStaCallback.OnStaOpenRes = DealStaOpenRes;      ---》 初始化成这个，那我们就看这个
    mStaCallback.OnStaCloseRes = DealStaCloseRes;
    mStaCallback.OnStaConnChanged = DealStaConnChanged;
    mStaCallback.OnWpsChanged = DealWpsChanged;
    mStaCallback.OnStaStreamChanged = DealStreamChanged;
    mStaCallback.OnStaRssiLevelChanged = DealRssiChanged;
    return;
}
// OPEN_WIFI_SUCCEED 值是 1
void WifiManager::DealStaOpenRes(OperateResState state)
{   //  OPEN_WIFI_OPENING = 0, OPEN_WIFI_SUCCEED = 1, OPEN_WIFI_FAILED = 2；
    WIFI_LOGI("Enter DealStaOpenRes: %{public}d", static_cast<int>(state));
    WifiEventCallbackMsg cbMsg;
    cbMsg.msgCode = WIFI_CBK_MSG_STATE_CHANGE;
    if (state == OperateResState::OPEN_WIFI_OPENING) {
        cbMsg.msgData = static_cast<int>(WifiState::ENABLING);
        WifiInternalEventDispatcher::GetInstance().AddBroadCastMsg(cbMsg);
        return;
    }
    if ((state == OperateResState::OPEN_WIFI_FAILED) || (state == OperateResState::OPEN_WIFI_DISABLED)) {
        WIFI_LOGE("DealStaOpenRes:wifi open failed!");
        WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::OPENING, WifiOprMidState::CLOSED);
        DealStaCloseRes(state);
        return;
    }

    WIFI_LOGI("DealStaOpenRes:wifi open successfully!");
    WifiConfigCenter::GetInstance().SetWifiMidState(WifiOprMidState::OPENING, WifiOprMidState::RUNNING);
    WifiConfigCenter::GetInstance().SetStaLastRunState(true);
    if (WifiConfigCenter::GetInstance().GetAirplaneModeState() == MODE_STATE_OPEN) {
        WifiConfigCenter::GetInstance().SetWifiStateWhenAirplaneMode(true);
    }
#ifdef FEATURE_P2P_SUPPORT
    WifiOprMidState p2pState = WifiConfigCenter::GetInstance().GetP2pMidState();
    WIFI_LOGI("DealStaOpenRes, current p2p state:%{public}d", p2pState);
    if (p2pState == WifiOprMidState::CLOSED) {
        WifiManager::GetInstance().AutoStartP2pService(AutoStartOrStopServiceReason::TYRTO_ENABLE_P2P_WHEN_WIFI_OPENED);
    }
#endif
    cbMsg.msgData = static_cast<int>(WifiState::ENABLED);
    WifiInternalEventDispatcher::GetInstance().AddBroadCastMsg(cbMsg);
    AutoStartEnhanceService();
    CheckAndStartScanService();    ---> 和扫描相关的

    if (WifiSettings::GetInstance().CheckScanOnlyAvailable() &&
        WifiManager::GetInstance().GetLocationModeByDatashare(WIFI_SCAN_ABILITY_ID)) {
        WifiConfigCenter::GetInstance().SetWifiScanOnlyMidState(WifiOprMidState::RUNNING);
    }
}

// 看扫描相关的 CheckAndStartScanService 方法：
void WifiManager::CheckAndStartScanService(void)
{
    WifiOprMidState scanState = WifiConfigCenter::GetInstance().GetScanMidState();
    WIFI_LOGI("CheckAndStartScanService scanState: %{public}d", static_cast<int>(scanState));
    if (scanState != WifiOprMidState::CLOSED) {
        /* If the scanning function is enabled when the STA is not enabled, you need to start the scheduled
             scanning function immediately when the STA is enabled. */
        IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst();
        if (pService != nullptr) {
            pService->OnClientModeStatusChanged(static_cast<int>(OperateResState::DISCONNECT_DISCONNECTED));
        }
        return;
    }
    if (!WifiConfigCenter::GetInstance().SetScanMidState(scanState, WifiOprMidState::OPENING)) {
        WIFI_LOGW("Failed to set scan mid state opening! may be other activity has been operated");
        return;
    }
    ErrCode errCode = WIFI_OPT_FAILED;
    do {
        if (WifiServiceManager::GetInstance().CheckAndEnforceService(WIFI_SERVICE_SCAN) < 0) {
            WIFI_LOGE("Load %{public}s service failed!", WIFI_SERVICE_SCAN);
            break;
        }
        IScanService *pService = WifiServiceManager::GetInstance().GetScanServiceInst();    ---> 这个就是scan_interface.cpp
        if (pService == nullptr) {
            WIFI_LOGE("Create %{public}s service failed!", WIFI_SERVICE_SCAN);
            break;
        }
        errCode = pService->RegisterScanCallbacks(WifiManager::GetInstance().GetScanCallback());
        if (errCode != WIFI_OPT_SUCCESS) {
            WIFI_LOGE("Register scan service callback failed!");
            break;
        }
        errCode = pService->Init();     ----> 主要看下这个
        if (errCode != WIFI_OPT_SUCCESS) {
            WIFI_LOGE("init scan service failed, ret %{public}d!", static_cast<int>(errCode));
            break;
        }
        IEnhanceService *pEnhanceService = WifiServiceManager::GetInstance().GetEnhanceServiceInst();
        if (pEnhanceService == nullptr) {
            WIFI_LOGE("Create %{public}s service failed!", WIFI_SERVICE_ENHANCE);
            break;
        }
        errCode = pService->SetEnhanceService(pEnhanceService);
        if (errCode != WIFI_OPT_SUCCESS) {
            WIFI_LOGE("SetEnhanceService failed, ret %{public}d!", static_cast<int>(errCode));
            break;
        }
    } while (0);
    if (errCode != WIFI_OPT_SUCCESS) {
        WifiConfigCenter::GetInstance().SetScanMidState(WifiOprMidState::OPENING, WifiOprMidState::CLOSED);
        WifiServiceManager::GetInstance().UnloadService(WIFI_SERVICE_SCAN);
    }
    return;
}

pService->Init() 看下初始化扫描服务foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan/scan_interface.cpp

ErrCode ScanInterface::Init()
{
    WIFI_LOGI("Enter ScanInterface::Init.\n");
    pScanService = new (std::nothrow)ScanService();     ---> 创建可一个 ScanService，初始化参数
    if (pScanService == nullptr) {
        WIFI_LOGE("New ScanService failed.\n");
        return WIFI_OPT_INVALID_PARAM;
    }

    if (!(pScanService->InitScanService(mScanSerivceCallbacks))) {   ---> 对应上面传下来的注册参数
        WIFI_LOGE("InitScanService failed.\n");
        delete pScanService;
        pScanService = nullptr;
        return WIFI_OPT_INVALID_PARAM;
    }
    return WIFI_OPT_SUCCESS;
}

//foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan/scan_service.cpp
bool ScanService::InitScanService(const IScanSerivceCallbacks &scanSerivceCallbacks)
{
    WIFI_LOGI("Enter ScanService::InitScanService.\n");

    mScanSerivceCallbacks = scanSerivceCallbacks;
    pScanStateMachine = new (std::nothrow) ScanStateMachine();    ---> 状态机
    if (pScanStateMachine == nullptr) {
        WIFI_LOGE("Alloc pScanStateMachine failed.\n");
        return false;
    }

    if (!pScanStateMachine->InitScanStateMachine()) {
        WIFI_LOGE("InitScanStateMachine failed.\n");
        return false;
    }

    if (!pScanStateMachine->EnrollScanStatusListener(
        std::bind(&ScanService::HandleScanStatusReport, this, std::placeholders::_1))) {
        WIFI_LOGE("ScanStateMachine_->EnrollScanStatusListener failed.\n");
        return false;
    }
    pScanMonitor = new (std::nothrow) ScanMonitor();     ---> 消息监视
    if (pScanMonitor == nullptr) {
        WIFI_LOGE("Alloc pScanMonitor failed.\n");
        return false;
    }

    if (!pScanMonitor->InitScanMonitor()) {
        WIFI_LOGE("InitScanMonitor failed.\n");
        return false;
    }
#ifndef OHOS_ARCH_LITE
    if (standByListerner.Init()) {
        WIFI_LOGE("standByListerner Init failed.");
    }
#endif

    if ((WifiStaHalInterface::GetInstance().GetSupportFrequencies(SCAN_BAND_24_GHZ, freqs2G) != WIFI_IDL_OPT_OK) ||
        (WifiStaHalInterface::GetInstance().GetSupportFrequencies(SCAN_BAND_5_GHZ, freqs5G) != WIFI_IDL_OPT_OK) ||
        (WifiStaHalInterface::GetInstance().GetSupportFrequencies(SCAN_BAND_5_GHZ_DFS_ONLY, freqsDfs) !=
        WIFI_IDL_OPT_OK)) {
        WIFI_LOGE("GetSupportFrequencies failed.\n");
    }

    ChannelsTable chanTbs;
    (void)WifiSettings::GetInstance().GetValidChannels(chanTbs);
    if (chanTbs[BandType::BAND_2GHZ].size() == 0) {
        WIFI_LOGI("Update valid channels!");
        std::vector<int32_t> supp2Gfreqs(freqs2G.begin(), freqs2G.end());
        std::vector<int32_t> supp5Gfreqs(freqs5G.begin(), freqs5G.end());
        for (auto iter = supp2Gfreqs.begin(); iter != supp2Gfreqs.end(); iter++) {
            int32_t channel = FrequencyToChannel(*iter);
            if (channel == INVALID_FREQ_OR_CHANNEL) {
                continue;
            }
            chanTbs[BandType::BAND_2GHZ].push_back(channel);
        }
        for (auto iter = supp5Gfreqs.begin(); iter != supp5Gfreqs.end(); iter++) {
            int32_t channel = FrequencyToChannel(*iter);
            if (channel == INVALID_FREQ_OR_CHANNEL) {
                continue;
            }
            chanTbs[BandType::BAND_5GHZ].push_back(channel);
        }
        if (WifiSettings::GetInstance().SetValidChannels(chanTbs)) {
            WIFI_LOGE("%{public}s, fail to SetValidChannels", __func__);
        }
    }
    pScanMonitor->SetScanStateMachine(pScanStateMachine);
    pScanStateMachine->SendMessage(static_cast<int>(CMD_SCAN_PREPARE));    ---> 状态机里面处理 CMD_SCAN_PREPARE
    GetScanControlInfo();

    return true;
}

我们到状态机里面看下如何处理这个消息 CMD_SCAN_PREPARE
foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan/scan_state_machine.cpp

bool ScanStateMachine::InitState::ExecuteStateMsg(InternalMessage *msg)
{
    WIFI_LOGI("Enter ScanStateMachine::InitState::ExecuteStateMsg.\n");
    if (msg == nullptr) {
        WIFI_LOGE("msg is null.\n");
        return true;
    }

    switch (msg->GetMessageName()) {
        case CMD_SCAN_PREPARE:
            LoadDriver();   ---> 执行这个方法
            return true;
            
// 看下LoadDriver() 方法：
void ScanStateMachine::InitState::LoadDriver()
{
    WIFI_LOGI("Enter ScanStateMachine::LoadDriver.\n");
    pScanStateMachine->SwitchState(pScanStateMachine->hardwareReadyState);   ---> 状态切换为 HardwareReadyState
    pScanStateMachine->ReportStatusChange(SCAN_STARTED_STATUS);     ---> 上报 SCAN_STARTED_STATUS = 0,  /* Started successfully */
    WIFI_LOGI("Start Scan Service Success.\n");
}

void ScanStateMachine::ReportStatusChange(ScanStatus status)
{
    WIFI_LOGI("Enter ScanStateMachine::ReportStatusChange.\n");
    ScanStatusReport scanStatusReport;
    scanStatusReport.status = status;
    if (scanStatusReportHandler) {
        scanStatusReportHandler(scanStatusReport);     ---> 看这个
    }
}
// foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan/scan_service.cpp
void ScanService::HandleScanStatusReport(ScanStatusReport &scanStatusReport)
{
    WIFI_LOGI("Enter ScanService::HandleScanStatusReport.\n");

    switch (scanStatusReport.status) {
        case SCAN_STARTED_STATUS: {
            if (pScanStateMachine == nullptr) {
                WIFI_LOGE("HandleScanStatusReport-SCAN_STARTED_STATUS pScanStateMachine is null\n");
                return;
            }
            scanStartedFlag = true;
            /* Pno scan maybe has started, stop it first. */
            pScanStateMachine->SendMessage(CMD_STOP_PNO_SCAN);    ---》 先停止PNO扫描
            mScanSerivceCallbacks.OnScanStartEvent();    ---> 更新下状态
            SystemScanProcess(true);    ---> 看这个方法
            break;
        }
// 跟着流程继续往下看： 
void ScanService::SystemScanProcess(bool scanAtOnce)
{
    WIFI_LOGI("Enter ScanService::SystemScanProcess, scanAtOnce:%{public}d.", scanAtOnce);
    StopSystemScan();

    int state = WifiSettings::GetInstance().GetScreenState();
    WIFI_LOGI("Screen state(1:OPEN, 2:CLOSE): %{public}d.", state);   ---> 屏幕状态决定哪种扫描模式
    if (state == MODE_STATE_OPEN) {
        {
            std::unique_lock<std::mutex> lock(scanControlInfoMutex);
            int i = 0;
            for (auto iter = scanControlInfo.scanIntervalList.begin(); iter != scanControlInfo.scanIntervalList.end(); ++iter) {
                if (iter->scanScene ==SCAN_SCENE_ALL && iter->scanMode ==ScanMode::SYSTEM_TIMER_SCAN && iter->isSingle ==false) {
                    WIFI_LOGI("iter[%{public}d]: intervalMode:%{public}d, interval:%{public}d, count:%{public}d",
                        i++, iter->intervalMode, iter->interval, iter->count);
                    systemScanIntervalMode.scanIntervalMode.intervalMode = iter->intervalMode;
                    systemScanIntervalMode.scanIntervalMode.interval = iter->interval;
                    systemScanIntervalMode.scanIntervalMode.count = iter->count;
                    systemScanIntervalMode.expScanCount = 0;
                }
            }
        }
        // 上面的参数配置好后，执行系统调度扫描
        StartSystemTimerScan(scanAtOnce);
    } else {
        if (!BeginPnoScan()) {
            WIFI_LOGE("BeginPnoScan failed.");
            return;
        }
    }
    return;
}

看下扫描模式有哪些，这里的是 SYSTEM_TIMER_SCAN

enum class ScanMode {
    APP_FOREGROUND_SCAN = 0, /* Scan initiated by the foreground application */
    APP_BACKGROUND_SCAN = 1, /* Scan initiated by background applications */
    SYS_FOREGROUND_SCAN = 2, /* System foreground scan */
    SYS_BACKGROUND_SCAN = 3, /* System background scan */
    ALL_EXTERN_SCAN = 4,     /* All external scans, including the first four */
    PNO_SCAN = 5,            /* PNO scan */
    SYSTEM_TIMER_SCAN = 6,   /* Scheduled system scan */
    ANYTIME_SCAN = 7,        /* Scan at any time */
    BAND_24GHZ_SCAN = 8,     /* 2.4 GHz scan */
    BAND_5GHZ_SCAN = 9,      /* 5G scan */
    SCAN_MODE_MAX            /* Invalid value */

接着看上面提到的这个方法： StartSystemTimerScan(scanAtOnce);

void ScanService::StartSystemTimerScan(bool scanAtOnce)
{
    WIFI_LOGI("Enter ScanService::StartSystemTimerScan, scanAtOnce: %{public}d.", scanAtOnce);
    ErrCode rlt = ApplyScanPolices(ScanType::SCAN_TYPE_SYSTEMTIMER);    ---> 决定是否允许以及如何对Wi-Fi进行扫描操作的一些判断
    if (rlt != WIFI_OPT_SUCCESS) {
        return;
    }

    struct timespec times = { 0, 0 };
    clock_gettime(CLOCK_MONOTONIC, &times);
    int64_t nowTime =
        static_cast<int64_t>(times.tv_sec) * SECOND_TO_MILLI_SECOND + times.tv_nsec / SECOND_TO_MICRO_SECOND;
    int sinceLastScan = 0;
    if (lastSystemScanTime != 0) {
        sinceLastScan = nowTime - lastSystemScanTime;
    }

    /*
     * The scan is performed immediately, the first scan is required,
     * or the time since the last scan is longer than the scan interval.
     */
    int scanTime = SYSTEM_SCAN_INIT_TIME;
    if (systemScanIntervalMode.scanIntervalMode.interval > 0) {
        scanTime = systemScanIntervalMode.scanIntervalMode.interval;
    }
    if (scanAtOnce || (lastSystemScanTime == 0) || (sinceLastScan >= systemScanIntervalMode.scanIntervalMode.interval)) {
        if (Scan(false) != WIFI_OPT_SUCCESS) {      ---> 发起扫描
            WIFI_LOGE("Scan failed.");
        }
        lastSystemScanTime = nowTime;
    } else {
        scanTime = systemScanIntervalMode.scanIntervalMode.interval - sinceLastScan;
    }
    // 上面都是对扫描时间的一些逻辑
    WIFI_LOGI("StartSystemTimerScan, scanTime: %{public}d,  interval:%{public}d,  count:%{public}d",
        scanTime,
        systemScanIntervalMode.scanIntervalMode.interval,
        systemScanIntervalMode.scanIntervalMode.count);
    pScanStateMachine->StartTimer(static_cast<int>(SYSTEM_SCAN_TIMER), scanTime * SECOND_TO_MILLI_SECOND);   ---》 启动一个定时器
    return;
}

两个参数，前者是实际的扫描时间，后者是最大的扫描时间，这里是10s
pScanStateMachine->StartTimer(static_cast(SYSTEM_SCAN_TIMER), scanTime * SECOND_TO_MILLI_SECOND);
继续看下发起的扫描 Scan(false)
foundation/communication/wifi/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_scan/scan_service.cpp

ErrCode ScanService::Scan(bool externFlag)
{
    WIFI_LOGI("Enter ScanService::Scan, externFlag:%{public}d.\n", externFlag);      ---> 传下来的是false
    if (!scanStartedFlag) {
        WIFI_LOGE("Scan service has not started.\n");
        return WIFI_OPT_FAILED;
    }

    if (externFlag) {      ---> 这里没有额外的
        ErrCode rlt = ApplyScanPolices(ScanType::SCAN_TYPE_EXTERN);
        if (rlt != WIFI_OPT_SUCCESS) {
            return rlt;
        }
    }

    ScanConfig scanConfig;
    /*
     * Invoke the interface provided by the configuration center to obtain the
     * hidden network list.
     */
    if (!GetHiddenNetworkSsidList(scanConfig.hiddenNetworkSsid)) {       ---> 发现是否有隐藏网络
        WIFI_LOGE("GetHiddenNetworkSsidList failed.\n");
    }

    scanConfig.scanBand = SCAN_BAND_BOTH_WITH_DFS;
    scanConfig.fullScanFlag = true;
    scanConfig.externFlag = externFlag;
    scanConfig.scanStyle = SCAN_TYPE_HIGH_ACCURACY;
    if (!SingleScan(scanConfig)) {                  ---> 发起单词扫描，这个和Android 扫描差不多     
        WIFI_LOGE("SingleScan failed.\n");
        return WIFI_OPT_FAILED;
    }

    return WIFI_OPT_SUCCESS;
}
// 继续看 发起单次扫描：
bool ScanService::SingleScan(ScanConfig &scanConfig)
{
    WIFI_LOGI("Enter ScanService::SingleScan.\n");

#ifndef OHOS_ARCH_LITE
    if (!standByListerner.AllowScan()) {
        WIFI_LOGE("Scan not allowed when device in standby state.\n");
        return WIFI_OPT_FAILED;
    }
#endif

    GetAllowBandFreqsControlInfo(scanConfig.scanBand, scanConfig.scanFreqs);
    if ((scanConfig.scanBand == SCAN_BAND_UNSPECIFIED) && (scanConfig.scanFreqs.empty())) {
        WIFI_LOGE("Have no allowed band or freq.\n");
        return false;
    }

    InterScanConfig interConfig;
    interConfig.fullScanFlag = scanConfig.fullScanFlag;
    interConfig.hiddenNetworkSsid.assign(scanConfig.hiddenNetworkSsid.begin(), scanConfig.hiddenNetworkSsid.end());
    interConfig.scanStyle = scanConfig.scanStyle;

    /* Specified frequency */
    if (scanConfig.scanBand == SCAN_BAND_UNSPECIFIED) {
        interConfig.scanFreqs.assign(scanConfig.scanFreqs.begin(), scanConfig.scanFreqs.end());
        /*
         * When band is SCAN_BAND_BOTH_WITH_DFS, need to scan all frequency,
         * scanFreqs can be empty.
         */
    } else if (scanConfig.scanBand != SCAN_BAND_BOTH_WITH_DFS) {
        /* Converting frequency bands to frequencies. */
        if (!GetBandFreqs(scanConfig.scanBand, interConfig.scanFreqs)) {
            WIFI_LOGE("GetBandFreqs failed.\n");
            return false;
        }
    }

    /* Save the configuration. */
    int requestIndex = StoreRequestScanConfig(scanConfig, interConfig);
    if (requestIndex == MAX_SCAN_CONFIG_STORE_INDEX) {
        WIFI_LOGE("StoreRequestScanConfig failed.\n");
        return false;
    }

    std::unique_lock<std::mutex> lock(scanConfigMapMutex);
    if (pScanStateMachine == nullptr) {
        WIFI_LOGE("pScanStateMachine is null.\n");
        return false;
    }
    /* Construct a message. */
    InternalMessage *interMessage =
        pScanStateMachine->CreateMessage(static_cast<int>(CMD_START_COMMON_SCAN), requestIndex);
    if (interMessage == nullptr) {
        scanConfigMap.erase(requestIndex);
        WIFI_LOGE("CreateMessage failed.\n");
        return false;
    }

    if (!AddScanMessageBody(interMessage, interConfig)) {
        scanConfigMap.erase(requestIndex);
        MessageManage::GetInstance().ReclaimMsg(interMessage);
        WIFI_LOGE("AddScanMessageBody failed.\n");
        return false;
    }
    pScanStateMachine->SendMessage(interMessage);

    return true;
}