一.Wifi SA简介

   SA: System Ability 系统能力的简称。每个SA都有一个id来标识

   wifi相关的sa有4个：分别是 1120 1121 1123和1124

        #define WIFI_DEVICE_ABILITY_ID OHOS::WIFI_DEVICE_SYS_ABILITY_ID /* 1120 */    libwifi_device_ability.z.so

        #define WIFI_HOTSPOT_ABILITY_ID OHOS::WIFI_HOTSPOT_SYS_ABILITY_ID /* 1121 */   libwifi_hotspot_ability.z.so

        #define WIFI_P2P_ABILITY_ID OHOS::WIFI_P2P_SYS_ABILITY_ID /* 1123 */     libwifi_p2p_ability.z.so

        #define WIFI_SCAN_ABILITY_ID OHOS::WIFI_SCAN_SYS_ABILITY_ID /* 1124 */  libwifi_scan_ability.z.so

 

二.wifi sa的类图

三.wifi sa的关键代码:

  

WIFI_DEVICE_ABILITY_ID:
const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
    WifiDeviceMgrServiceImpl::GetInstance().GetRefPtr());

WifiDeviceMgrServiceImpl::WifiDeviceMgrServiceImpl()
    : SystemAbility(WIFI_DEVICE_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
{}

void WifiDeviceMgrServiceImpl::OnStart()
{
    if (mState == ServiceRunningState::STATE_RUNNING) {
        return;
    }
    WifiManager::GetInstance().Init();
    Init();
    mState = ServiceRunningState::STATE_RUNNING;
}

bool WifiDeviceMgrServiceImpl::Init()
{
    std::lock_guard<std::mutex> lock(g_initMutex);
    if (!mPublishFlag) {
        for (int i = 0; i < STA_INSTANCE_MAX_NUM; i++) {
            sptr<WifiDeviceServiceImpl> wifi = new WifiDeviceServiceImpl(i);
            mWifiService[i] = wifi->AsObject();
        }

        bool ret = Publish(WifiDeviceMgrServiceImpl::GetInstance());
        mPublishFlag = true;
    }
    return true;
}

WIFI_P2P_ABILITY_ID:
const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
    WifiP2pServiceImpl::GetInstance().GetRefPtr());

WifiP2pServiceImpl::WifiP2pServiceImpl()
    : SystemAbility(WIFI_P2P_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
{}

void WifiP2pServiceImpl::OnStart()
{
    if (mState == ServiceRunningState::STATE_RUNNING) {
        return;
    }
    WifiManager::GetInstance().Init();
    Init();
    mState = ServiceRunningState::STATE_RUNNING;
}

bool WifiP2pServiceImpl::Init()
{
    if (!mPublishFlag) {
        bool ret = Publish(WifiP2pServiceImpl::GetInstance());
        mPublishFlag = true;
    }
    return true;
}

WIFI_SCAN_ABILITY_ID:
const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
    WifiScanMgrServiceImpl::GetInstance().GetRefPtr());

WifiScanMgrServiceImpl::WifiScanMgrServiceImpl()
    : SystemAbility(WIFI_SCAN_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
{}

void WifiScanMgrServiceImpl::OnStart()
{
    if (mState == ServiceRunningState::STATE_RUNNING) {
        return;
    }
    WifiManager::GetInstance().Init();
    Init();
    mState = ServiceRunningState::STATE_RUNNING;
    return;
}

bool WifiScanMgrServiceImpl::Init()
{
    std::lock_guard<std::mutex> lock(g_scanMutex);
    if (!mPublishFlag) {
        for (int i = 0; i < STA_INSTANCE_MAX_NUM; i++) {
            sptr<WifiScanServiceImpl> wifi = new WifiScanServiceImpl(i);
            mWifiService[i] = wifi->AsObject();
        }

        bool ret = Publish(WifiScanMgrServiceImpl::GetInstance());
        mPublishFlag = true;
    }
    return true;
}

WIFI_HOTSPOT_ABILITY_ID:
const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(
    WifiHotspotMgrServiceImpl::GetInstance().GetRefPtr());

WifiHotspotMgrServiceImpl::WifiHotspotMgrServiceImpl()
    : SystemAbility(WIFI_HOTSPOT_ABILITY_ID, true), mPublishFlag(false), mState(ServiceRunningState::STATE_NOT_START)
{}

void WifiHotspotMgrServiceImpl::OnStart()
{
    if (mState == ServiceRunningState::STATE_RUNNING) {
        return;
    }
    WifiManager::GetInstance().Init()
    Init();
    mState = ServiceRunningState::STATE_RUNNING;
}

bool WifiHotspotMgrServiceImpl::Init()
{
    std::lock_guard<std::mutex> lock(g_hotspotMutex);
    if (!mPublishFlag) {
        for (int i = 0; i < AP_INSTANCE_MAX_NUM; i++) {
            sptr<WifiHotspotServiceImpl> wifi = new WifiHotspotServiceImpl(i);
            mWifiService[i] = wifi->AsObject();
        }

        bool ret = Publish(WifiHotspotMgrServiceImpl::GetInstance());
        mPublishFlag = true;
    }
    return true;
}
 

总结：可以看到这个是个SA的流程基本一致。在OnStart中初始化WifiManager和自身的初始化。调用Publish来发布自己！

四.Wifi sa的加载流程-以WIFI_DEVICE_ABILITY_ID为例

 

所在文件：foundation\communication\wifi\wifi\utils\src\wifi_sa_manager.cpp

ErrCode WifiSaLoadManager::LoadWifiSa(int32_t systemAbilityId)
{
    sptr<ISystemAbilityManager> samgr =
        SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();

   // 如果检查到，说明已经加载过了！
    auto object = samgr->CheckSystemAbility(systemAbilityId);
    if (object != nullptr) {
        return WIFI_OPT_SUCCESS;
    }
    InitLoadState();
    sptr<WifiSaLoadCallback> loadCallback = new (std::nothrow) WifiSaLoadCallback();
    int32_t ret = samgr->LoadSystemAbility(systemAbilityId, loadCallback);
    return WaitLoadStateChange(systemAbilityId);
}

所在文件：foundation\systemabilitymgr\samgr\frameworks\native\source\system_ability_manager_proxy.cpp

int32_t SystemAbilityManagerProxy::LoadSystemAbility(int32_t systemAbilityId,
    const sptr<ISystemAbilityLoadCallback>& callback) {
    sptr<IRemoteObject> remote = Remote();
    MessageParcel data;
    data.WriteInterfaceToken(SAMANAGER_INTERFACE_TOKEN);
    bool ret = data.WriteInt32(systemAbilityId);
    ret = data.WriteRemoteObject(callback->AsObject());

    MessageParcel reply;
    MessageOption option;
    int32_t err = remote->SendRequest(
        static_cast<uint32_t>(SamgrInterfaceCode::LOAD_SYSTEM_ABILITY_TRANSACTION), data, reply, option);

    int32_t result = 0;
    ret = reply.ReadInt32(result);
    return result;
}

所在文件：foundation\systemabilitymgr\samgr\services\samgr\native\source\system_ability_manager_stub.cpp
int32_t SystemAbilityManagerStub::LoadSystemAbilityInner(MessageParcel& data, MessageParcel& reply)
{
    int32_t systemAbilityId = -1;
    bool ret = false;
    sptr<ISystemAbilityLoadCallback> callback = nullptr;
    {
        ret = data.ReadInt32(systemAbilityId);
        sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
        callback = iface_cast<ISystemAbilityLoadCallback>(remoteObject);
    }

    int32_t result = LoadSystemAbility(systemAbilityId, callback);
    return result;
}

所在文件：foundation\systemabilitymgr\samgr\services\samgr\native\source\system_ability_manager.cpp
int32_t SystemAbilityManager::LoadSystemAbility(int32_t systemAbilityId,
    const sptr<ISystemAbilityLoadCallback>& callback)
{
    CommonSaProfile saProfile;
    bool ret = GetSaProfile(systemAbilityId, saProfile);
    auto callingPid = IPCSkeleton::GetCallingPid();
    OnDemandEvent onDemandEvent = {INTERFACE_CALL, "load"};
    LoadRequestInfo loadRequestInfo = {LOCAL_DEVICE, callback, systemAbilityId, callingPid, onDemandEvent};
    return abilityStateScheduler_->HandleLoadAbilityEvent(loadRequestInfo);
}

所在文件：foundation\systemabilitymgr\samgr\services\samgr\native\source\schedule\system_ability_state_scheduler.cpp
int32_t SystemAbilityStateScheduler::HandleLoadAbilityEvent(const LoadRequestInfo& loadRequestInfo)
{
    std::shared_ptr<SystemAbilityContext> abilityContext;
    GetSystemAbilityContext(loadRequestInfo.systemAbilityId, abilityContext);
    std::lock_guard<std::mutex> autoLock(abilityContext->ownProcessContext->processLock);
    int32_t result = HandleLoadAbilityEventLocked(abilityContext, loadRequestInfo);
    return result;
}

五.WifiManager的初始化流程

wifi的4个sa加载。都会在其OnStart函数中执行WifiManager::GetInstance().Init()

所在文件：

int WifiManager::Init()
{
    std::unique_lock<std::mutex> lock(initStatusMutex);
    if (mInitStatus == INIT_OK) {
        WIFI_LOGI("WifiManager already init!");
        return 0;
    }

    WifiServiceManager::GetInstance().Init();

    WifiStaHalInterface::GetInstance().RegisterNativeProcessCallback(
        [this](int status) { this->OnNativeProcessStatusChange(status); });

    wifiStaManager = std::make_unique<WifiStaManager>();
    wifiScanManager = std::make_unique<WifiScanManager>();
    wifiTogglerManager = std::make_unique<WifiTogglerManager>();
    wifiHotspotManager = std::make_unique<WifiHotspotManager>();
    wifiP2pManager = std::make_unique<WifiP2pManager>();
    WifiServiceManager::GetInstance().CheckPreLoadService();
    mInitStatus = INIT_OK;

    return 0;
}

int WifiServiceManager::Init()
{
    mP2pServiceHandle.Clear();
    mApServiceHandle.Clear();
    mStaServiceHandle.Clear();
    mScanServiceHandle.Clear();

    mServiceDllMap.insert(std::make_pair(WIFI_SERVICE_STA, "libwifi_sta_service.z.so"));
    mServiceDllMap.insert(std::make_pair(WIFI_SERVICE_SCAN, "libwifi_scan_service.z.so"));
    mServiceDllMap.insert(std::make_pair(WIFI_SERVICE_AP, "libwifi_ap_service.z.so"));
    mServiceDllMap.insert(std::make_pair(WIFI_SERVICE_P2P, "libwifi_p2p_service.z.so"));
    return 0;
}

int WifiServiceManager::CheckPreLoadService(void) {

    for (auto iter = mServiceDllMap.begin(); iter != mServiceDllMap.end(); ++iter) {

        bool bLoad = WifiSettings::GetInstance().IsModulePreLoad(iter->first);

        if (bLoad) {

            int ret = CheckAndEnforceService(iter->first, 0, false);

            if (ret < 0) {

                return -1;

            }

        }

    }

    return 0;

}