OpenHarmony-wifi开发学习路径：https://laval.csdn.net/69159bca0e4c466a32e78763.html

wifi框架CreateGroup流程：

关键数据结构：

class WifiP2pConfig {
public:
    WifiP2pConfig()
        : mDeviceAddress(""),
          deviceAddressType(REAL_DEVICE_ADDRESS),
          goBand(GroupOwnerBand::GO_BAND_AUTO),
          netId(-1),
          passphrase(""),
          groupOwnerIntent(AUTO_GROUP_OWNER_VALUE),
          groupName("")
    {}
private:
    std::string mDeviceAddress; /* the device MAC address, the length is 17 characters. */
    int deviceAddressType; /* the device MAC address type */
    GroupOwnerBand goBand;
    int netId; /* network id, when -2 means persistent and -1 means temporary, else need >= 0 */
    std::string passphrase; /* the value ranges from 8 to 63. */
    int groupOwnerIntent; /* the value is -1.(A value of -1 indicates the system can choose an appropriate value.) */
    std::string groupName; /* the value ranges from 1 to 32. */
};

所在文件：foundation\communication\wifi\wifi\frameworks\js\napi\src\wifi_napi_p2p.cpp
NO_SANITIZE("cfi") napi_value CreateGroup(napi_env env, napi_callback_info info)
{
    WifiP2pConfig config;
    JsObjToP2pConfig(env, argv[0], config);
    ErrCode ret = wifiP2pPtr->CreateGroup(config);
}

所在文件：foundation\communication\wifi\wifi\frameworks\native\src\wifi_p2p_impl.cpp
ErrCode WifiP2pImpl::CreateGroup(const WifiP2pConfig &config)
{
    return client_->CreateGroup(config);
}

所在文件：foundation\communication\wifi\wifi\frameworks\native\src\wifi_p2p_proxy.cpp
ErrCode WifiP2pProxy::CreateGroup(const WifiP2pConfig &config)
{
    MessageOption option;
    MessageParcel data;
    MessageParcel reply;
    
    data.WriteInterfaceToken(GetDescriptor());
    data.WriteInt32(0);
    WriteWifiP2pConfigData(data, config);
    int error = Remote()->SendRequest(static_cast<uint32_t>(P2PInterfaceCode::WIFI_SVR_CMD_P2P_CREATE_GROUP), data,
        reply, option);

    int exception = reply.ReadInt32();
    if (exception) {
        return WIFI_OPT_FAILED;
    }
    return ErrCode(reply.ReadInt32());
}

所在文件:foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p_sa\wifi_p2p_stub.cpp

    handleFuncMap[static_cast<uint32_t>(P2PInterfaceCode::WIFI_SVR_CMD_P2P_CREATE_GROUP)] = [this](uint32_t code,
        MessageParcel &data, MessageParcel &reply, MessageOption &option) { OnCreateGroup(code, data, reply, option); };
        
int WifiP2pStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    HandleFuncMap::iterator iter = handleFuncMap.find(code);
    int exception = data.ReadInt32();
    if (exception) {
        return WIFI_OPT_FAILED;
    }
    (iter->second)(code, data, reply, option);
    return 0;
}

void WifiP2pStub::OnCreateGroup(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
{
    WifiP2pConfig config;
    ReadWifiP2pConfigData(data, config);
    ErrCode ret = CreateGroup(config);
    reply.WriteInt32(0);
    reply.WriteInt32(ret);
    return;
}
所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p_sa\wifi_p2p_service_impl.cpp
ErrCode WifiP2pServiceImpl::CreateGroup(const WifiP2pConfig &config)
{
    if (!IsP2pServiceRunning()) {
        WIFI_LOGE("P2pService is not running!");
        return WIFI_OPT_P2P_NOT_OPENED;
    }
    IP2pService *pService = WifiServiceManager::GetInstance().GetP2pServiceInst();
    return pService->CreateGroup(config);
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p\p2p_interface.cpp
ErrCode P2pInterface::CreateGroup(const WifiP2pConfig &config)
{
    return p2pService.CreateGroup(config);
}

所在文件:foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p\wifi_p2p_service.cpp
ErrCode WifiP2pService::CreateGroup(const WifiP2pConfig &config)
{
    int callingUid = IPCSkeleton::GetCallingUid();
    WifiConfigCenter::GetInstance().SaveP2pCreatorUid(callingUid);

    WifiP2pConfigInternal configInternal(config);
    WpsInfo wps;
    wps.SetWpsMethod(WpsMethod::WPS_METHOD_PBC);
    configInternal.SetWpsInfo(wps);
    const std::any info = configInternal;
    p2pStateMachine.SendMessage(static_cast<int>(P2P_STATE_MACHINE_CMD::CMD_FORM_GROUP), callingUid, 0, info);
    return ErrCode::WIFI_OPT_SUCCESS;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p\p2p_idle_state.cpp
bool P2pIdleState::ProcessCmdCreateGroup(InternalMessagePtr msg) const
{
    p2pStateMachine.DelayMessage(msg);
    p2pStateMachine.SwitchState(&p2pStateMachine.p2pGroupOperatingState);
    return EXECUTED;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_p2p\p2p_group_operating_state.cpp
        constexpr int MIN_PSK_LEN = 8;
        constexpr int MAX_PSK_LEN = 63;
bool P2pGroupOperatingState::ProcessCmdCreateGroup(const InternalMessagePtr msg) const
{
    WifiErrorNo ret = WIFI_HAL_OPT_FAILED;
    const int minValidNetworkid = 0;
    WifiP2pConfigInternal config;
    SharedLinkManager::SetGroupUid(msg->GetParam1());
    msg->GetMessageObj(config);
    int freq = p2pStateMachine.GetAvailableFreqByBand(config.GetGoBand());
    int netId = config.GetNetId();
    if (netId >= minValidNetworkid) {
        // Restart the group using an existing network ID.
        WIFI_LOGE("Restart the group using an existing network ID.");
        if ((!config.GetPassphrase().empty() && config.GetPassphrase().length() >= MIN_PSK_LEN &&
            config.GetPassphrase().length() <= MAX_PSK_LEN) ||
            config.GetPassphrase().empty()) {
            if (!p2pStateMachine.SetGroupConfig(config, false)) {
                WIFI_LOGW("Some configuration settings failed!");
            }
            ret = WifiP2PHalInterface::GetInstance().GroupAdd(true, netId, freq);
            p2pStateMachine.UpdateGroupManager();
            p2pStateMachine.UpdatePersistentGroups();
        }
    } else if (netId == PERSISTENT_NET_ID || netId == TEMPORARY_NET_ID) {
        // Create a new persistence group.
        WIFI_LOGE("Create a new %{public}s group.", (netId == PERSISTENT_NET_ID) ? "persistence" : "temporary");
        if (config.GetPassphrase().empty() && config.GetGroupName().empty()) {
            WifiConfigCenter::GetInstance().SetExplicitGroup(true);
            ret = WifiP2PHalInterface::GetInstance().GroupAdd((netId == PERSISTENT_NET_ID) ? true : false, netId, freq);
            p2pStateMachine.UpdateGroupManager();
            p2pStateMachine.UpdatePersistentGroups();
        } else if (!config.GetPassphrase().empty() && !config.GetGroupName().empty() &&
                   config.GetPassphrase().length() >= MIN_PSK_LEN && config.GetPassphrase().length() <= MAX_PSK_LEN) {
            WifiConfigCenter::GetInstance().SetExplicitGroup(true);
            if (p2pStateMachine.DealCreateNewGroupWithConfig(config, freq)) {
                ret = WIFI_HAL_OPT_OK;
            }
        }
    } 
    if (WifiErrorNo::WIFI_HAL_OPT_FAILED == ret) {
        WIFI_LOGE("p2p configure to CreateGroup failed.");
        p2pStateMachine.BroadcastActionResult(P2pActionCallback::CreateGroup, WIFI_OPT_FAILED);
        p2pStateMachine.SwitchState(&p2pStateMachine.p2pIdleState);
    } else {
        WIFI_LOGI("p2p configure to CreateGroup successful.");
        p2pStateMachine.MessageExecutedLater(
            static_cast<int>(P2P_STATE_MACHINE_CMD::CREATE_GROUP_TIMED_OUT), CREATE_GROUP_TIMEOUT);
        p2pStateMachine.BroadcastActionResult(P2pActionCallback::CreateGroup, WIFI_OPT_SUCCESS);
    }
    return EXECUTED;
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\wifi_hal_interface\wifi_p2p_hal_interface.cpp
WifiErrorNo WifiP2PHalInterface::GroupAdd(bool isPersistent, int networkId, int freq) const
{
    return mHdiWpaClient->ReqP2pAddGroup(isPersistent, networkId, freq);
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\client\hdi_client\wifi_hdi_wpa_client.cpp
WifiErrorNo WifiHdiWpaClient::ReqP2pAddGroup(bool isPersistent, int networkId, int freq) const
{
    int flag = isPersistent;
    return HdiP2pAddGroup(flag, networkId, freq);
}

所在文件：foundation\communication\wifi\wifi\services\wifi_standard\wifi_framework\wifi_manage\wifi_native\client\hdi_client\hdi_interface\wifi_hdi_wpa_p2p_impl.c
WifiErrorNo HdiP2pAddGroup(int isPersistent, int networkId, int freq)
{
    struct IWpaInterface *wpaObj = GetWpaInterface();
    int32_t result = wpaObj->P2pAddGroup(wpaObj, GetHdiP2pIfaceName(), isPersistent, networkId, freq);
    LOGI("HdiP2pAddGroup success.");
    return WIFI_HAL_OPT_OK;
}

所在文件：drivers\peripheral\wlan\wpa\interfaces\hdi_service\service_common\wpa_p2p_cmd.c
int32_t WpaInterfaceP2pAddGroup(struct IWpaInterface *self, const char *ifName, int32_t isPersistent,
    int32_t networkId, int32_t freq)
{
    WifiWpaP2pInterface *pMainIfc = GetWifiWapP2pInterface(ifName);
    P2pSupplicantErrCode ret = pMainIfc->wpaP2pCliCmdGroupAdd(pMainIfc, isPersistent, networkId, freq);
    return HDF_SUCCESS;
}

所在文件：drivers\peripheral\wlan\wpa\interfaces\hdi_service\service_common\wpa_p2p_hal.c
static P2pSupplicantErrCode WpaP2pCliCmdGroupAdd(WifiWpaP2pInterface *this, int isPersistent, int networkId, int freq)
{
    char buf[P2P_REPLY_BUF_SMALL_LENGTH] = {0};
    char cmd[P2P_CMD_BUF_LENGTH] = {0};
    int res;
    if (isPersistent) {
        if (networkId < 0) {
            res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD persistent freq=%d",
                this->ifName, freq);
        } else {
            res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD persistent=%d freq=%d",
                this->ifName, networkId, freq);
        }
    } else {
        res = snprintf_s(cmd, sizeof(cmd), sizeof(cmd) - 1, "IFNAME=%s P2P_GROUP_ADD freq=%d", this->ifName, freq);
    }

    if (WpaCliCmd(cmd, buf, sizeof(buf)) != 0) {
        HDF_LOGE("P2P_GROUP_ADD command failed!");
        return P2P_SUP_ERRCODE_FAILED;
    }
    return P2P_SUP_ERRCODE_SUCCESS;
}