fix codecheck

Signed-off-by: zhaoshenghua <zhaoshenghua1@huawei.com>

0002-callback.patch

@@ -0,0 +1,742 @@
+From cfc04fdab06a83cae0737b5a1b8ca8f6dfc21fbf Mon Sep 17 00:00:00 2001
+From: zhaoshenghua <zhaoshenghua1@huawei.com>
+Date: Thu, 15 Aug 2024 19:27:45 +0800
+Subject: [PATCH 2/4] callback
+
+Change-Id: Ib59d9795eb4d154e06dc2615285cbd86f7683bb7
+Signed-off-by: zhaoshenghua <zhaoshenghua1@huawei.com>
+---
+ wifi/frameworks/cj/BUILD.gn                |   1 +
+ wifi/frameworks/cj/include/ffi_structs.h   |   6 +-
+ wifi/frameworks/cj/include/wifi_callback.h |  80 +++
+ wifi/frameworks/cj/include/wifi_ffi.h      |   2 +-
+ wifi/frameworks/cj/src/wifi_callback.cpp   | 534 +++++++++++++++++++++
+ wifi/frameworks/cj/src/wifi_ffi.cpp        |  15 +-
+ 6 files changed, 631 insertions(+), 7 deletions(-)
+ create mode 100644 wifi/frameworks/cj/include/wifi_callback.h
+ create mode 100644 wifi/frameworks/cj/src/wifi_callback.cpp
+
+diff --git a/wifi/frameworks/cj/BUILD.gn b/wifi/frameworks/cj/BUILD.gn
+index 71fed17cc..a83ae447e 100644
+--- a/wifi/frameworks/cj/BUILD.gn
++++ b/wifi/frameworks/cj/BUILD.gn
+@@ -39,6 +39,7 @@ ohos_shared_library("cj_wifi_ffi") {
+ 
+   sources = [
+     "src/wifi_ffi.cpp",
++    "src/wifi_callback.cpp",
+   ]
+ 
+   deps = [ "$WIFI_ROOT_DIR/frameworks/native:wifi_sdk" ]
+diff --git a/wifi/frameworks/cj/include/ffi_structs.h b/wifi/frameworks/cj/include/ffi_structs.h
+index ca174fecf..e1f0d9b23 100644
+--- a/wifi/frameworks/cj/include/ffi_structs.h
++++ b/wifi/frameworks/cj/include/ffi_structs.h
+@@ -45,14 +45,14 @@ extern "C" {
+         int32_t supportedWifiCategory;
+         bool isHiLinkNetwork;
+     };
+-    
++
+     struct WifiScanInfoArr
+     {
+         CWifiScanInfo *head;
+         int64_t size;
+     };
+ 
+-    // TODO figure out clientCert
++    // TODO figure out clientCertAlias
+     struct CWifiEapConfig
+     {
+         int32_t eapMethod;                        /* EAP authentication mode:PEAP/TLS/TTLS/PWD/SIM/AKA/AKA' */
+@@ -112,7 +112,7 @@ extern "C" {
+         char *groupName;
+         int32_t netId;
+         int32_t goBand;
+-        int32_t deviceAddressType;        
++        int32_t deviceAddressType;
+     };
+ 
+     struct CWifiP2PLinkedInfo
+diff --git a/wifi/frameworks/cj/include/wifi_callback.h b/wifi/frameworks/cj/include/wifi_callback.h
+new file mode 100644
+index 000000000..7039f9605
+--- /dev/null
++++ b/wifi/frameworks/cj/include/wifi_callback.h
+@@ -0,0 +1,80 @@
++/*
++ * Copyright (c) 2024 Huawei Device Co., Ltd.
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <shared_mutex>
++
++#include "ffi_structs.h"
++#include "wifi_errcode.h"
++#include "wifi_p2p.h"
++#include "wifi_hotspot.h"
++#include "wifi_logger.h"
++#include "wifi_sa_event.h"
++
++namespace OHOS::Wifi {
++
++class CjWifiAbilityStatusChange : public WifiAbilityStatusChange {
++public:
++    void OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
++};
++
++class CjEventRegister {
++public:
++    CjEventRegister()
++    {
++        int32_t ret;
++        auto samgrProxy = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
++        if (samgrProxy == nullptr) {
++            return;
++        }
++        mSaStatusListener = new OHOS::Wifi::CjWifiAbilityStatusChange();
++        if (mSaStatusListener == nullptr) {
++            return;
++        }
++        ret = samgrProxy->SubscribeSystemAbility((int32_t)WIFI_DEVICE_ABILITY_ID, mSaStatusListener);
++        samgrProxy->SubscribeSystemAbility((int32_t)WIFI_SCAN_ABILITY_ID, mSaStatusListener);
++        samgrProxy->SubscribeSystemAbility((int32_t)WIFI_HOTSPOT_ABILITY_ID, mSaStatusListener);
++        samgrProxy->SubscribeSystemAbility((int32_t)WIFI_P2P_ABILITY_ID, mSaStatusListener);
++    }
++    ~CjEventRegister()
++    {}
++
++    static CjEventRegister& GetInstance();
++
++    int32_t Register(const std::string& type, void (* callback)());
++    int32_t UnRegister(const std::string& type);
++    ErrCode RegisterDeviceEvents(const std::vector<std::string> &event);
++    ErrCode RegisterScanEvents(const std::vector<std::string> &event);
++    ErrCode RegisterHotspotEvents(const std::vector<std::string> &event);
++    ErrCode RegisterP2PEvents(const std::vector<std::string> &event);
++
++private:
++    // std::function<void(int32_t)> wifiStateChange{nullptr};
++    // std::function<void(int32_t)> wifiConnectionChange{nullptr};
++    // std::function<void(int32_t)> wifiRssiChange{nullptr};
++    // std::function<void(int32_t)> wifiScanStateChange{nullptr};
++    // std::function<void(int32_t)> hotspotStateChange{nullptr};
++    // std::function<void(int32_t)> p2pStateChange{nullptr};
++    // std::function<void(CWifiP2PLinkedInfo)> p2pConnectionChange{nullptr};
++    // std::function<void(CWifiP2pDevice)> p2pDeviceChange{nullptr};
++    // std::function<void(WifiP2pDeviceArr)> p2pPeerDeviceChange{nullptr};
++    // std::function<void()> p2pPersistentGroupChange{nullptr};
++    // std::function<void(int32_t)> p2pDiscoveryChange{nullptr};
++    OHOS::sptr<OHOS::ISystemAbilityStatusChange> mSaStatusListener = nullptr;
++};
++
++
++
++
++}
+\ No newline at end of file
+diff --git a/wifi/frameworks/cj/include/wifi_ffi.h b/wifi/frameworks/cj/include/wifi_ffi.h
+index 5525813ed..f7f59dcb9 100644
+--- a/wifi/frameworks/cj/include/wifi_ffi.h
++++ b/wifi/frameworks/cj/include/wifi_ffi.h
+@@ -72,7 +72,7 @@ FFI_EXPORT int32_t CJ_CreateGroup(CWifiP2PConfig &cfg);
+ FFI_EXPORT int32_t CJ_GetLinkedInfo(CWifiLinkedInfo &info);
+ FFI_EXPORT int32_t CJ_AddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret);
+ FFI_EXPORT WifiDeviceConfigArr CJ_GetCandidateConfigs(int32_t &code);
+-FFI_EXPORT int32_t CJ_WifiOn(char *type, int64_t id);
++FFI_EXPORT int32_t CJ_WifiOn(char *type, void (*callback)());
+ FFI_EXPORT int32_t CJ_WifiOff(char* type);
+ }
+ 
+diff --git a/wifi/frameworks/cj/src/wifi_callback.cpp b/wifi/frameworks/cj/src/wifi_callback.cpp
+new file mode 100644
+index 000000000..cbd564eb0
+--- /dev/null
++++ b/wifi/frameworks/cj/src/wifi_callback.cpp
+@@ -0,0 +1,534 @@
++/*
++ * Copyright (c) 2024 Huawei Device Co., Ltd.
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *     http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include "wifi_callback.h"
++
++#include "ffi_structs.h"
++#include "accesstoken_kit.h"
++#include "ipc_skeleton.h"
++#include "wifi_device.h"
++#include "wifi_logger.h"
++#include "wifi_scan.h"
++#include "cj_lambda.h"
++
++DEFINE_WIFILOG_LABEL("CJ_Wifi_Callback");
++
++namespace OHOS::Wifi {
++
++std::shared_ptr<WifiDevice> g_cjWifiStaPtr = WifiDevice::GetInstance(WIFI_DEVICE_ABILITY_ID);
++std::shared_ptr<WifiScan> g_cjWifiScanPtr = WifiScan::GetInstance(WIFI_SCAN_ABILITY_ID);
++std::shared_ptr<WifiHotspot> g_cjWifiHotspotPtr = WifiHotspot::GetInstance(WIFI_HOTSPOT_ABILITY_ID);
++std::shared_ptr<WifiP2p> g_cjWifiP2pPtr = WifiP2p::GetInstance(WIFI_P2P_ABILITY_ID);
++
++CjEventRegister& CjEventRegister::GetInstance()
++{
++    static CjEventRegister inst;
++    return inst;
++}
++
++class CjWifiDeviceEventCallback : public IWifiDeviceCallBack {
++public:
++    CjWifiDeviceEventCallback() {
++    }
++
++    virtual ~CjWifiDeviceEventCallback() {
++    }
++
++public:
++    void OnWifiStateChanged(int state) override
++    {
++        WIFI_LOGI("OnWifiStateChanged event: %{public}d [0:DISABLING, 1:DISABLED, 2:ENABLING, 3:ENABLED]",
++            state);
++        if (wifiStateChange == nullptr) {
++            WIFI_LOGI("OnWifiStateChanged not registered");
++            return;
++        }
++        if (m_wifiStateConvertMap.find(state) == m_wifiStateConvertMap.end()) {
++            WIFI_LOGW("not find state.");
++            return;
++        }
++        wifiStateChange(m_wifiStateConvertMap[state]);
++    }
++
++    void OnWifiConnectionChanged(int state, const WifiLinkedInfo &info) override
++    {
++        WIFI_LOGI("OnWifiConnectionChanged event: %{public}d [4:CONNECTED, 6:DISCONNECTED, 7:SPECIAL_CONNECT]", state);
++        if (wifiConnectionChange == nullptr) {
++            WIFI_LOGI("OnWifiConnectionChanged not registered");
++            return;
++        }
++        if (m_connectStateConvertMap.find(state) == m_connectStateConvertMap.end()) {
++            WIFI_LOGW("not find connect state.");
++            return;
++        }
++        wifiConnectionChange(m_connectStateConvertMap[state]);
++    }
++
++    void OnWifiRssiChanged(int rssi) override
++    {
++        WIFI_LOGI("OnWifiRssiChanged event: %{public}d", rssi);
++        if (wifiRssiChange == nullptr) {
++            WIFI_LOGI("OnWifiConnectionChanged not registered");
++            return;
++        }
++        wifiRssiChange(rssi);
++    }
++
++    void OnWifiWpsStateChanged(int state, const std::string &pinCode) override
++    {
++    }
++
++    void OnStreamChanged(int direction) override
++    {
++    }
++
++    void OnDeviceConfigChanged(ConfigChange value) override
++    {
++    }
++
++    OHOS::sptr<OHOS::IRemoteObject> AsObject() override
++    {
++        return nullptr;
++    }
++
++    void SetCallback(const std::string &type, void (* callback)(int32_t))
++    {
++        if (type == EVENT_STA_POWER_STATE_CHANGE) {
++            wifiStateChange = CJLambda::Create(callback);
++        }
++        if (type == EVENT_STA_CONN_STATE_CHANGE) {
++            wifiConnectionChange = CJLambda::Create(callback);
++        }
++        if (type == EVENT_STA_RSSI_STATE_CHANGE) {
++            wifiRssiChange = CJLambda::Create(callback);
++        }
++    }
++private:
++
++    std::function<void(int32_t)> wifiStateChange{nullptr};
++    std::function<void(int32_t)> wifiConnectionChange{nullptr};
++    std::function<void(int32_t)> wifiRssiChange{nullptr};
++
++    enum class JsLayerWifiState {
++        DISABLED = 0,
++        ENABLED = 1,
++        ENABLING = 2,
++        DISABLING = 3
++    };
++
++    enum class JsLayerConnectStatus {
++        DISCONNECTED = 0,
++        CONNECTED = 1,
++        SPECIAL_CONNECT = 2,
++    };
++
++    enum class JsLayerStreamDirection {
++        STREAM_DIRECTION_NONE = 0,
++        STREAM_DIRECTION_DOWN = 1,
++        STREAM_DIRECTION_UP = 2,
++        STREAM_DIRECTION_UPDOWN = 3
++    };
++
++    std::map<int, int> m_wifiStateConvertMap = {
++        { static_cast<int>(WifiState::DISABLING), static_cast<int>(JsLayerWifiState::DISABLING) },
++        { static_cast<int>(WifiState::DISABLED), static_cast<int>(JsLayerWifiState::DISABLED) },
++        { static_cast<int>(WifiState::ENABLING), static_cast<int>(JsLayerWifiState::ENABLING) },
++        { static_cast<int>(WifiState::ENABLED), static_cast<int>(JsLayerWifiState::ENABLED) },
++    };
++
++    std::map<int, int> m_connectStateConvertMap = {
++        { static_cast<int>(ConnState::CONNECTED), static_cast<int>(JsLayerConnectStatus::CONNECTED) },
++        { static_cast<int>(ConnState::DISCONNECTED), static_cast<int>(JsLayerConnectStatus::DISCONNECTED) },
++        { static_cast<int>(ConnState::SPECIAL_CONNECT), static_cast<int>(JsLayerConnectStatus::SPECIAL_CONNECT) },
++    };
++
++    std::map<int, int> m_streamDirectionConvertMap = {
++        { static_cast<int>(StreamDirection::STREAM_DIRECTION_NONE),
++            static_cast<int>(JsLayerStreamDirection::STREAM_DIRECTION_NONE) },
++        { static_cast<int>(StreamDirection::STREAM_DIRECTION_DOWN),
++            static_cast<int>(JsLayerStreamDirection::STREAM_DIRECTION_DOWN) },
++        { static_cast<int>(StreamDirection::STREAM_DIRECTION_UP),
++            static_cast<int>(JsLayerStreamDirection::STREAM_DIRECTION_UP) },
++        { static_cast<int>(StreamDirection::STREAM_DIRECTION_UPDOWN),
++            static_cast<int>(JsLayerStreamDirection::STREAM_DIRECTION_UPDOWN) },
++    };
++};
++
++class CjWifiScanEventCallback : public IWifiScanCallback {
++public:
++    CjWifiScanEventCallback() {
++    }
++
++    virtual ~CjWifiScanEventCallback() {
++    }
++
++public:
++    void OnWifiScanStateChanged(int state) override
++    {
++        WIFI_LOGI("scan received state changed event: %{public}d", state);
++        if (wifiScanStateChange == nullptr) {
++            WIFI_LOGI("OnWifiScanStateChanged not registered");
++            return;
++        }
++        wifiScanStateChange(state);
++    }
++
++    OHOS::sptr<OHOS::IRemoteObject> AsObject() override
++    {
++        return nullptr;
++    }
++
++    void SetScanStateChange(void (* callback)(int32_t))
++    {
++        wifiScanStateChange = CJLambda::Create(callback);
++    }
++private:
++    std::function<void(int32_t)> wifiScanStateChange{nullptr};
++};
++
++class CjWifiHotspotEventCallback : public IWifiHotspotCallback {
++public:
++    CjWifiHotspotEventCallback() {
++    }
++
++    virtual ~CjWifiHotspotEventCallback() {
++    }
++
++public:
++    void OnHotspotStateChanged(int state) override
++    {
++        WIFI_LOGI("Hotspot received state changed event: %{public}d", state);
++        if (hotspotStateChange == nullptr) {
++            WIFI_LOGI("OnHotspotStateChanged not registered");
++            return;
++        }
++        if (m_apStateConvertMap.find(state) == m_apStateConvertMap.end()) {
++            return;
++        }
++        hotspotStateChange(m_apStateConvertMap[state]);
++    }
++
++    void OnHotspotStaJoin(const StationInfo &info) override
++    {
++    }
++
++    void OnHotspotStaLeave(const StationInfo &info) override
++    {
++    }
++
++    void SetHotspotStateChanged(void (* callback)(int32_t))
++    {
++        hotspotStateChange = CJLambda::Create(callback);
++    }
++
++    OHOS::sptr<OHOS::IRemoteObject> AsObject() override
++    {
++        return nullptr;
++    }
++private:
++    std::function<void(int32_t)> hotspotStateChange{nullptr};
++
++    enum class JsLayerApState {
++        DISABLED = 0,
++        ENABLED = 1,
++        ENABLING = 2,
++        DISABLING = 3
++    };
++
++    std::map<int, int> m_apStateConvertMap = {
++        { static_cast<int>(ApState::AP_STATE_STARTING), static_cast<int>(JsLayerApState::ENABLING) },
++        { static_cast<int>(ApState::AP_STATE_STARTED), static_cast<int>(JsLayerApState::ENABLED) },
++        { static_cast<int>(ApState::AP_STATE_CLOSING), static_cast<int>(JsLayerApState::DISABLING) },
++        { static_cast<int>(ApState::AP_STATE_CLOSED), static_cast<int>(JsLayerApState::DISABLED) },
++    };
++};
++
++class CjWifiP2pEventCallback : public IWifiP2pCallback {
++public:
++    CjWifiP2pEventCallback() {
++    }
++
++    virtual ~CjWifiP2pEventCallback() {
++    }
++
++public:
++    void OnP2pStateChanged(int state) override
++    {
++        WIFI_LOGI("received p2p state changed event: %{public}d", state);
++        if (p2pStateChange == nullptr) {
++            WIFI_LOGI("OnP2pStateChanged not registered");
++            return;
++        }
++        p2pStateChange(state);
++    }
++
++    void OnP2pPersistentGroupsChanged(void) override
++    {
++        WIFI_LOGI("received persistent group changed event");
++        if (p2pPersistentGroupChange == nullptr) {
++            WIFI_LOGI("OnP2pPersistentGroupsChanged not registered");
++            return;
++        }
++        p2pPersistentGroupChange();
++    }
++
++    void OnP2pThisDeviceChanged(const WifiP2pDevice& device) override
++    {
++        WIFI_LOGI("received this device changed event");
++        if (p2pDeviceChange == nullptr) {
++            WIFI_LOGI("OnP2pThisDeviceChanged not registered");
++            return;
++        }
++        CWifiP2pDevice cdevice;
++        cdevice.deviceName = const_cast<char*>(device.GetDeviceName().c_str());
++        cdevice.deviceAddress = const_cast<char*>(device.GetDeviceAddress().c_str());
++        cdevice.primaryDeviceType = const_cast<char*>(device.GetPrimaryDeviceType().c_str());
++        cdevice.deviceStatus = static_cast<int32_t>(device.GetP2pDeviceStatus());
++        cdevice.groupCapabilities = device.GetGroupCapabilitys();
++        cdevice.deviceAddressType = device.GetDeviceAddressType();
++        p2pDeviceChange(cdevice);
++    }
++
++    void OnP2pPeersChanged(const std::vector<WifiP2pDevice>& devices) override
++    {
++        WIFI_LOGI("received p2p peers changed event, devices count: %{public}d", static_cast<int>(devices.size()));
++        if (p2pPeerDeviceChange == nullptr) {
++            WIFI_LOGI("OnP2pPeersChanged not registered");
++            return;
++        }
++        int64_t size = static_cast<int64_t>(devices.size());
++        if (size <= 0) {
++            return;
++        }
++        CWifiP2pDevice cdevices[size];
++        WifiP2pDeviceArr arr{.head = cdevices, .size = size};
++        uint32_t idx = 0;
++        for (auto& each : devices) {
++            cdevices[idx].deviceName = const_cast<char*>(each.GetDeviceName().c_str());
++            cdevices[idx].deviceAddress = const_cast<char*>(each.GetDeviceAddress().c_str());
++            cdevices[idx].primaryDeviceType = const_cast<char*>(each.GetPrimaryDeviceType().c_str());
++            cdevices[idx].deviceStatus = static_cast<int32_t>(each.GetP2pDeviceStatus());
++            cdevices[idx].groupCapabilities = each.GetGroupCapabilitys();
++            cdevices[idx].deviceAddressType = each.GetDeviceAddressType();
++            idx++;
++        }
++        p2pPeerDeviceChange(arr);
++    }
++
++    void OnP2pServicesChanged(const std::vector<WifiP2pServiceInfo>& srvInfo) override
++    {
++    }
++
++    void OnP2pConnectionChanged(const WifiP2pLinkedInfo& info) override
++    {
++        WIFI_LOGI("received p2p connection changed event, state: %{public}d",
++            static_cast<int>(info.GetConnectState()));
++        if (p2pConnectionChange == nullptr) {
++            WIFI_LOGI("OnP2pConnectionChanged not registered");
++            return;
++        }
++        CWifiP2PLinkedInfo cinfo;
++        cinfo.connectState = static_cast<int32_t>(info.GetConnectState());
++        cinfo.isGroupOwner = info.IsGroupOwner();
++        cinfo.groupOwnerAddr = const_cast<char*>(info.GetGroupOwnerAddress().c_str());
++        p2pConnectionChange(cinfo);
++    }
++
++    void OnP2pDiscoveryChanged(bool isChange) override
++    {
++        WIFI_LOGI("received discovery state changed event");
++        if (p2pDiscoveryChange == nullptr) {
++            WIFI_LOGI("OnP2pDiscoveryChanged not registered");
++            return;
++        }
++        p2pDiscoveryChange(static_cast<int32_t>(isChange));
++    }
++
++    void OnP2pActionResult(P2pActionCallback action, ErrCode code) override
++    {
++    }
++
++    void OnConfigChanged(CfgType type, char* data, int dataLen) override
++    {
++    }
++
++    void OnP2pGcJoinGroup(const OHOS::Wifi::GcInfo &info) override
++    {
++    }
++
++    void OnP2pGcLeaveGroup(const OHOS::Wifi::GcInfo &info) override
++    {
++    }
++
++    void OnP2pPrivatePeersChanged(const std::string &priWfdInfo) override
++    {
++    }
++
++    OHOS::sptr<OHOS::IRemoteObject> AsObject() override
++    {
++        return nullptr;
++    }
++
++    void SetCallback(const std::string &type, void (* callback)())
++    {
++        if (type == EVENT_P2P_STATE_CHANGE) {
++            p2pStateChange = CJLambda::Create(reinterpret_cast<void (*)(int32_t)>(callback));
++        }
++        if (type == EVENT_P2P_PERSISTENT_GROUP_CHANGE) {
++            p2pPersistentGroupChange = CJLambda::Create(callback);
++        }
++        if (type == EVENT_P2P_DEVICE_STATE_CHANGE) {
++            p2pDeviceChange = CJLambda::Create(reinterpret_cast<void (*)(CWifiP2pDevice)>(callback));
++        }
++        if (type == EVENT_P2P_PEER_DEVICE_CHANGE) {
++            p2pPeerDeviceChange = CJLambda::Create(reinterpret_cast<void (*)(WifiP2pDeviceArr)>(callback));
++        }
++        if (type == EVENT_P2P_CONN_STATE_CHANGE) {
++            p2pConnectionChange = CJLambda::Create(reinterpret_cast<void (*)(CWifiP2PLinkedInfo)>(callback));
++        }
++        if (type == EVENT_P2P_DISCOVERY_CHANGE) {
++            p2pDiscoveryChange = CJLambda::Create(reinterpret_cast<void (*)(int32_t)>(callback));
++        }
++    }
++private:
++    std::function<void(int32_t)> p2pStateChange{nullptr};
++    std::function<void(CWifiP2PLinkedInfo)> p2pConnectionChange{nullptr};
++    std::function<void(CWifiP2pDevice)> p2pDeviceChange{nullptr};
++    std::function<void(WifiP2pDeviceArr)> p2pPeerDeviceChange{nullptr};
++    std::function<void()> p2pPersistentGroupChange{nullptr};
++    std::function<void(int32_t)> p2pDiscoveryChange{nullptr};
++};
++
++sptr<CjWifiDeviceEventCallback> cjWifiDeviceCallback =
++    sptr<CjWifiDeviceEventCallback>(new (std::nothrow) CjWifiDeviceEventCallback());
++
++sptr<CjWifiScanEventCallback> cjWifiScanCallback =
++    sptr<CjWifiScanEventCallback>(new (std::nothrow) CjWifiScanEventCallback());
++
++sptr<CjWifiHotspotEventCallback> cjWifiHotspotCallback =
++    sptr<CjWifiHotspotEventCallback>(new (std::nothrow) CjWifiHotspotEventCallback());
++
++sptr<CjWifiP2pEventCallback> cjWifiP2pCallback =
++    sptr<CjWifiP2pEventCallback>(new (std::nothrow) CjWifiP2pEventCallback());
++
++int32_t CjEventRegister::Register(const std::string& type, void (* callback)())
++{
++    WIFI_LOGI("Register event: %{public}s", type.c_str());
++    std::vector<std::string> event = {type};
++
++    if (type == EVENT_STA_POWER_STATE_CHANGE || type == EVENT_STA_CONN_STATE_CHANGE
++        || type == EVENT_STA_RSSI_STATE_CHANGE) {
++            cjWifiDeviceCallback->SetCallback(type, reinterpret_cast<void (*)(int32_t)>(callback));
++            CjEventRegister::GetInstance().RegisterDeviceEvents(event);
++    }
++
++    if (type == EVENT_STA_SCAN_STATE_CHANGE) {
++        cjWifiScanCallback->SetScanStateChange(reinterpret_cast<void (*)(int32_t)>(callback));
++        CjEventRegister::GetInstance().RegisterScanEvents(event);
++    }
++
++    if (type == EVENT_HOTSPOT_STATE_CHANGE) {
++        cjWifiHotspotCallback->SetHotspotStateChanged(reinterpret_cast<void (*)(int32_t)>(callback));
++        CjEventRegister::GetInstance().RegisterHotspotEvents(event);
++    }
++
++    if (type == EVENT_P2P_STATE_CHANGE || type == EVENT_P2P_PERSISTENT_GROUP_CHANGE ||
++        type == EVENT_P2P_DEVICE_STATE_CHANGE || type == EVENT_P2P_PEER_DEVICE_CHANGE ||
++        type == EVENT_P2P_CONN_STATE_CHANGE || type == EVENT_P2P_DISCOVERY_CHANGE) {
++        cjWifiP2pCallback->SetCallback(type, callback);
++        CjEventRegister::GetInstance().RegisterP2PEvents(event);
++    }
++    return WIFI_OPT_SUCCESS;
++}
++
++int32_t CjEventRegister::UnRegister(const std::string& type)
++{
++    return WIFI_OPT_SUCCESS;
++}
++
++ErrCode CjEventRegister::RegisterDeviceEvents(const std::vector<std::string> &event)
++{
++    if (g_cjWifiStaPtr == nullptr) {
++        WIFI_LOGE("Register sta event get instance failed!");
++        return WIFI_OPT_FAILED;
++    }
++    return g_cjWifiStaPtr->RegisterCallBack(cjWifiDeviceCallback, event);
++}
++
++ErrCode CjEventRegister::RegisterScanEvents(const std::vector<std::string> &event)
++{
++    if (g_cjWifiScanPtr == nullptr) {
++        WIFI_LOGE("Register scan event get instance failed!");
++        return WIFI_OPT_FAILED;
++    }
++    return g_cjWifiScanPtr->RegisterCallBack(cjWifiScanCallback, event);
++}
++
++ErrCode CjEventRegister::RegisterHotspotEvents(const std::vector<std::string> &event)
++{
++    if (g_cjWifiHotspotPtr == nullptr) {
++        WIFI_LOGE("Register hotspot event get instance failed!");
++        return WIFI_OPT_FAILED;
++    }
++    return g_cjWifiHotspotPtr->RegisterCallBack(cjWifiHotspotCallback, event);
++}
++
++ErrCode CjEventRegister::RegisterP2PEvents(const std::vector<std::string> &event)
++{
++    if (g_cjWifiP2pPtr == nullptr) {
++        WIFI_LOGE("Register p2p event get instance failed!");
++        return WIFI_OPT_FAILED;
++    }
++    return g_cjWifiP2pPtr->RegisterCallBack(cjWifiP2pCallback, event);
++}
++
++void CjWifiAbilityStatusChange::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
++{
++    WIFI_LOGI("OnAddSystemAbility systemAbilityId:%{public}d", systemAbilityId);
++    std::vector<std::string> event;
++    switch (systemAbilityId) {
++        case WIFI_DEVICE_ABILITY_ID: {
++            event.push_back(EVENT_STA_POWER_STATE_CHANGE);
++            event.push_back(EVENT_STA_CONN_STATE_CHANGE);
++            event.push_back(EVENT_STA_RSSI_STATE_CHANGE);
++            CjEventRegister::GetInstance().RegisterDeviceEvents(event);
++            break;
++        }
++        case WIFI_SCAN_ABILITY_ID: {
++            event.push_back(EVENT_STA_SCAN_STATE_CHANGE);
++            CjEventRegister::GetInstance().RegisterScanEvents(event);
++            break;
++        }
++        case WIFI_HOTSPOT_ABILITY_ID: {
++            event.push_back(EVENT_HOTSPOT_STATE_CHANGE);
++            CjEventRegister::GetInstance().RegisterHotspotEvents(event);
++            break;
++        }
++        case WIFI_P2P_ABILITY_ID: {
++            event.push_back(EVENT_P2P_STATE_CHANGE);
++            event.push_back(EVENT_P2P_PERSISTENT_GROUP_CHANGE);
++            event.push_back(EVENT_P2P_DEVICE_STATE_CHANGE);
++            event.push_back(EVENT_P2P_PEER_DEVICE_CHANGE);
++            event.push_back(EVENT_P2P_CONN_STATE_CHANGE);
++            event.push_back(EVENT_P2P_DISCOVERY_CHANGE);
++            CjEventRegister::GetInstance().RegisterP2PEvents(event);
++            break;
++        }
++        default:
++            WIFI_LOGI("OnAddSystemAbility unhandled sysabilityId:%{public}d", systemAbilityId);
++            return;
++    }
++}
++}
+\ No newline at end of file
+diff --git a/wifi/frameworks/cj/src/wifi_ffi.cpp b/wifi/frameworks/cj/src/wifi_ffi.cpp
+index 2673fee55..3b1346526 100644
+--- a/wifi/frameworks/cj/src/wifi_ffi.cpp
++++ b/wifi/frameworks/cj/src/wifi_ffi.cpp
+@@ -22,6 +22,7 @@
+ #include "wifi_p2p.h"
+ #include "wifi_common_util.h"
+ #include "wifi_logger.h"
++#include "wifi_callback.h"
+ 
+ DEFINE_WIFILOG_LABEL("CJ_WIFI_FFI");
+ 
+@@ -721,14 +722,22 @@ WifiDeviceConfigArr CJ_GetCandidateConfigs(int32_t &code)
+     return arr;
+ }
+ 
+-int32_t CJ_WifiOn(char *type, int64_t id)
++int32_t CJ_WifiOn(char *type, void (*callback)())
+ {
+-    return 0;
++    std::string eventType(type);
++    if (eventType.empty()) {
++        return WIFI_OPT_FAILED;
++    }
++    return CjEventRegister::GetInstance().Register(eventType, callback);
+ }
+ 
+ int32_t CJ_WifiOff(char* type)
+ {
+-    return 0;
++    std::string eventType(type);
++    if (eventType.empty()) {
++        return WIFI_OPT_FAILED;
++    }
++    return CjEventRegister::GetInstance().UnRegister(eventType);
+ }
+ 
+ }
+-- 
+2.34.1
+

0003-rename-ffi.patch

@@ -0,0 +1,357 @@
+From 3c02a0a469b36213c86cf6584591035a5a9f36cd Mon Sep 17 00:00:00 2001
+From: zhaoshenghua <zhaoshenghua1@huawei.com>
+Date: Thu, 22 Aug 2024 11:35:29 +0800
+Subject: [PATCH 3/4] rename ffi
+
+Change-Id: I86acda2cf1be9e51284145bb5e9296916f714747
+Signed-off-by: zhaoshenghua <zhaoshenghua1@huawei.com>
+---
+ wifi/frameworks/cj/include/wifi_callback.h | 17 +------
+ wifi/frameworks/cj/include/wifi_ffi.h      | 54 +++++++++++-----------
+ wifi/frameworks/cj/src/wifi_ffi.cpp        | 54 +++++++++++-----------
+ 3 files changed, 55 insertions(+), 70 deletions(-)
+
+diff --git a/wifi/frameworks/cj/include/wifi_callback.h b/wifi/frameworks/cj/include/wifi_callback.h
+index 7039f9605..dd49d04a9 100644
+--- a/wifi/frameworks/cj/include/wifi_callback.h
++++ b/wifi/frameworks/cj/include/wifi_callback.h
+@@ -60,21 +60,6 @@ public:
+     ErrCode RegisterP2PEvents(const std::vector<std::string> &event);
+ 
+ private:
+-    // std::function<void(int32_t)> wifiStateChange{nullptr};
+-    // std::function<void(int32_t)> wifiConnectionChange{nullptr};
+-    // std::function<void(int32_t)> wifiRssiChange{nullptr};
+-    // std::function<void(int32_t)> wifiScanStateChange{nullptr};
+-    // std::function<void(int32_t)> hotspotStateChange{nullptr};
+-    // std::function<void(int32_t)> p2pStateChange{nullptr};
+-    // std::function<void(CWifiP2PLinkedInfo)> p2pConnectionChange{nullptr};
+-    // std::function<void(CWifiP2pDevice)> p2pDeviceChange{nullptr};
+-    // std::function<void(WifiP2pDeviceArr)> p2pPeerDeviceChange{nullptr};
+-    // std::function<void()> p2pPersistentGroupChange{nullptr};
+-    // std::function<void(int32_t)> p2pDiscoveryChange{nullptr};
+     OHOS::sptr<OHOS::ISystemAbilityStatusChange> mSaStatusListener = nullptr;
+ };
+-
+-
+-
+-
+-}
+\ No newline at end of file
++}
+diff --git a/wifi/frameworks/cj/include/wifi_ffi.h b/wifi/frameworks/cj/include/wifi_ffi.h
+index f7f59dcb9..e89d095ad 100644
+--- a/wifi/frameworks/cj/include/wifi_ffi.h
++++ b/wifi/frameworks/cj/include/wifi_ffi.h
+@@ -47,33 +47,33 @@ enum class SecTypeCj {
+ };
+ 
+ extern "C" {
+-FFI_EXPORT int32_t CJ_IsWifiActive(bool &ret);
+-FFI_EXPORT WifiScanInfoArr CJ_GetScanInfoList(int32_t &ret);
+-FFI_EXPORT int32_t CJ_RemoveCandidateConfig(int32_t id);
+-FFI_EXPORT int32_t CJ_ConnectToCandidateConfig(int32_t id);
+-FFI_EXPORT int32_t CJ_GetSignalLevel(int32_t rssi, int32_t band, uint32_t &ret);
+-FFI_EXPORT int32_t CJ_IsConnected(bool &ret);
+-FFI_EXPORT int32_t CJ_IsFeatureSupported(int64_t featureId, bool &ret);
+-FFI_EXPORT int32_t CJ_GetIpInfo(CIpInfo &ret);
+-FFI_EXPORT int32_t CJ_GetIpv6Info(CIpv6Info &ret);
+-FFI_EXPORT char *CJ_GetCountryCode(int32_t &code);
+-FFI_EXPORT int32_t CJ_IsBandTypeSupported(int32_t bandType, bool &ret);
+-FFI_EXPORT int32_t CJ_IsMeteredHotspot(bool &ret);
+-FFI_EXPORT int32_t CJ_RemoveGroup();
+-FFI_EXPORT int32_t CJ_P2pConnect(CWifiP2PConfig &cfg);
+-FFI_EXPORT int32_t CJ_P2pCancelConnect();
+-FFI_EXPORT int32_t CJ_StartDiscoverDevices();
+-FFI_EXPORT int32_t CJ_StopDiscoverDevices();
+-FFI_EXPORT int32_t CJ_GetP2pLinkedInfo(CWifiP2PLinkedInfo &info);
+-FFI_EXPORT int32_t CJ_GetCurrentGroup(CWifiP2PGroupInfo &info);
+-FFI_EXPORT WifiP2pDeviceArr CJ_GetP2pPeerDevices(int32_t &ret);
+-FFI_EXPORT int32_t CJ_GetP2pLocalDevice(CWifiP2pDevice &info);
+-FFI_EXPORT int32_t CJ_CreateGroup(CWifiP2PConfig &cfg);
+-FFI_EXPORT int32_t CJ_GetLinkedInfo(CWifiLinkedInfo &info);
+-FFI_EXPORT int32_t CJ_AddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret);
+-FFI_EXPORT WifiDeviceConfigArr CJ_GetCandidateConfigs(int32_t &code);
+-FFI_EXPORT int32_t CJ_WifiOn(char *type, void (*callback)());
+-FFI_EXPORT int32_t CJ_WifiOff(char* type);
++FFI_EXPORT int32_t FfiWifiIsWifiActive(bool &ret);
++FFI_EXPORT WifiScanInfoArr FfiWifiGetScanInfoList(int32_t &ret);
++FFI_EXPORT int32_t FfiWifiRemoveCandidateConfig(int32_t id);
++FFI_EXPORT int32_t FfiWifiConnectToCandidateConfig(int32_t id);
++FFI_EXPORT int32_t FfiWifiGetSignalLevel(int32_t rssi, int32_t band, uint32_t &ret);
++FFI_EXPORT int32_t FfiWifiIsConnected(bool &ret);
++FFI_EXPORT int32_t FfiWifiIsFeatureSupported(int64_t featureId, bool &ret);
++FFI_EXPORT int32_t FfiWifiGetIpInfo(CIpInfo &ret);
++FFI_EXPORT int32_t FfiWifiGetIpv6Info(CIpv6Info &ret);
++FFI_EXPORT char *FfiWifiGetCountryCode(int32_t &code);
++FFI_EXPORT int32_t FfiWifiIsBandTypeSupported(int32_t bandType, bool &ret);
++FFI_EXPORT int32_t FfiWifiIsMeteredHotspot(bool &ret);
++FFI_EXPORT int32_t FfiWifiRemoveGroup();
++FFI_EXPORT int32_t FfiWifiP2pConnect(CWifiP2PConfig &cfg);
++FFI_EXPORT int32_t FfiWifiP2pCancelConnect();
++FFI_EXPORT int32_t FfiWifiStartDiscoverDevices();
++FFI_EXPORT int32_t FfiWifiStopDiscoverDevices();
++FFI_EXPORT int32_t FfiWifiGetP2pLinkedInfo(CWifiP2PLinkedInfo &info);
++FFI_EXPORT int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info);
++FFI_EXPORT WifiP2pDeviceArr FfiWifiGetP2pPeerDevices(int32_t &ret);
++FFI_EXPORT int32_t FfiWifiGetP2pLocalDevice(CWifiP2pDevice &info);
++FFI_EXPORT int32_t FfiWifiCreateGroup(CWifiP2PConfig &cfg);
++FFI_EXPORT int32_t FfiWifiGetLinkedInfo(CWifiLinkedInfo &info);
++FFI_EXPORT int32_t FfiWifiAddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret);
++FFI_EXPORT WifiDeviceConfigArr FfiWifiGetCandidateConfigs(int32_t &code);
++FFI_EXPORT int32_t FfiWifiWifiOn(char *type, void (*callback)());
++FFI_EXPORT int32_t FfiWifiWifiOff(char* type);
+ }
+ 
+ #endif // CJ_WIFI_FFI_H
+\ No newline at end of file
+diff --git a/wifi/frameworks/cj/src/wifi_ffi.cpp b/wifi/frameworks/cj/src/wifi_ffi.cpp
+index 3b1346526..35f3b10a9 100644
+--- a/wifi/frameworks/cj/src/wifi_ffi.cpp
++++ b/wifi/frameworks/cj/src/wifi_ffi.cpp
+@@ -325,7 +325,7 @@ static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
+ 
+ extern "C" {
+ 
+-int32_t CJ_IsWifiActive(bool &ret)
++int32_t FfiWifiIsWifiActive(bool &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -333,7 +333,7 @@ int32_t CJ_IsWifiActive(bool &ret)
+     return cjWifiDevicePtr->IsWifiActive(ret);
+ }
+ 
+-WifiScanInfoArr CJ_GetScanInfoList(int32_t &ret)
++WifiScanInfoArr FfiWifiGetScanInfoList(int32_t &ret)
+ {
+     WifiScanInfoArr infos{ .head = nullptr, .size = 0 };
+     if (cjWifiScanPtr == nullptr) {
+@@ -348,7 +348,7 @@ WifiScanInfoArr CJ_GetScanInfoList(int32_t &ret)
+     return infos;
+ }
+ 
+-int32_t CJ_RemoveCandidateConfig(int32_t id)
++int32_t FfiWifiRemoveCandidateConfig(int32_t id)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -356,7 +356,7 @@ int32_t CJ_RemoveCandidateConfig(int32_t id)
+     return static_cast<int32_t>(cjWifiDevicePtr->RemoveCandidateConfig(id));
+ }
+ 
+-int32_t CJ_ConnectToCandidateConfig(int32_t id)
++int32_t FfiWifiConnectToCandidateConfig(int32_t id)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -364,7 +364,7 @@ int32_t CJ_ConnectToCandidateConfig(int32_t id)
+     return static_cast<int32_t>(cjWifiDevicePtr->ConnectToNetwork(id, true));
+ }
+ 
+-int32_t CJ_GetSignalLevel(int32_t rssi, int32_t band, uint32_t &ret)
++int32_t FfiWifiGetSignalLevel(int32_t rssi, int32_t band, uint32_t &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -375,7 +375,7 @@ int32_t CJ_GetSignalLevel(int32_t rssi, int32_t band, uint32_t &ret)
+     return static_cast<int32_t>(code);
+ }
+ 
+-int32_t CJ_IsConnected(bool &ret)
++int32_t FfiWifiIsConnected(bool &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -383,7 +383,7 @@ int32_t CJ_IsConnected(bool &ret)
+     return static_cast<int32_t>(cjWifiDevicePtr->IsConnected(ret));
+ }
+ 
+-int32_t CJ_IsFeatureSupported(int64_t featureId, bool &ret)
++int32_t FfiWifiIsFeatureSupported(int64_t featureId, bool &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -391,7 +391,7 @@ int32_t CJ_IsFeatureSupported(int64_t featureId, bool &ret)
+     return static_cast<int32_t>(cjWifiDevicePtr->IsFeatureSupported(featureId, ret));
+ }
+ 
+-int32_t CJ_GetIpInfo(CIpInfo &ret)
++int32_t FfiWifiGetIpInfo(CIpInfo &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -410,7 +410,7 @@ int32_t CJ_GetIpInfo(CIpInfo &ret)
+     return code;
+ }
+ 
+-int32_t CJ_GetIpv6Info(CIpv6Info &ret)
++int32_t FfiWifiGetIpv6Info(CIpv6Info &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -431,7 +431,7 @@ int32_t CJ_GetIpv6Info(CIpv6Info &ret)
+     return code;
+ }
+ 
+-char *CJ_GetCountryCode(int32_t &code)
++char *FfiWifiGetCountryCode(int32_t &code)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         code = WIFI_OPT_FAILED;
+@@ -445,7 +445,7 @@ char *CJ_GetCountryCode(int32_t &code)
+     return nullptr;
+ }
+ 
+-int32_t CJ_IsBandTypeSupported(int32_t bandType, bool &ret)
++int32_t FfiWifiIsBandTypeSupported(int32_t bandType, bool &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -453,7 +453,7 @@ int32_t CJ_IsBandTypeSupported(int32_t bandType, bool &ret)
+     return cjWifiDevicePtr->IsBandTypeSupported(bandType, ret);
+ }
+ 
+-int32_t CJ_IsMeteredHotspot(bool &ret)
++int32_t FfiWifiIsMeteredHotspot(bool &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -461,7 +461,7 @@ int32_t CJ_IsMeteredHotspot(bool &ret)
+     return cjWifiDevicePtr->IsMeteredHotspot(ret);
+ }
+ 
+-int32_t CJ_RemoveGroup()
++int32_t FfiWifiRemoveGroup()
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -469,7 +469,7 @@ int32_t CJ_RemoveGroup()
+     return cjWifiP2pPtr->RemoveGroup();
+ }
+ 
+-int32_t CJ_P2pConnect(CWifiP2PConfig &cfg)
++int32_t FfiWifiP2pConnect(CWifiP2PConfig &cfg)
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -479,7 +479,7 @@ int32_t CJ_P2pConnect(CWifiP2PConfig &cfg)
+     return cjWifiP2pPtr->P2pConnect(config);
+ }
+ 
+-int32_t CJ_P2pCancelConnect()
++int32_t FfiWifiP2pCancelConnect()
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -487,7 +487,7 @@ int32_t CJ_P2pCancelConnect()
+     return cjWifiP2pPtr->P2pCancelConnect();
+ }
+ 
+-int32_t CJ_StartDiscoverDevices()
++int32_t FfiWifiStartDiscoverDevices()
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -495,7 +495,7 @@ int32_t CJ_StartDiscoverDevices()
+     return cjWifiP2pPtr->DiscoverDevices();
+ }
+ 
+-int32_t CJ_StopDiscoverDevices()
++int32_t FfiWifiStopDiscoverDevices()
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -503,7 +503,7 @@ int32_t CJ_StopDiscoverDevices()
+     return cjWifiP2pPtr->StopDiscoverDevices();
+ }
+ 
+-int32_t CJ_GetP2pLinkedInfo(CWifiP2PLinkedInfo &info)
++int32_t FfiWifiGetP2pLinkedInfo(CWifiP2PLinkedInfo &info)
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -518,7 +518,7 @@ int32_t CJ_GetP2pLinkedInfo(CWifiP2PLinkedInfo &info)
+     return code;
+ }
+ 
+-int32_t CJ_GetCurrentGroup(CWifiP2PGroupInfo &info)
++int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info)
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -554,7 +554,7 @@ int32_t CJ_GetCurrentGroup(CWifiP2PGroupInfo &info)
+     return code;
+ }
+ 
+-WifiP2pDeviceArr CJ_GetP2pPeerDevices(int32_t &ret)
++WifiP2pDeviceArr FfiWifiGetP2pPeerDevices(int32_t &ret)
+ {
+     WifiP2pDeviceArr arr{.head = nullptr, .size = 0};
+     if (cjWifiP2pPtr == nullptr) {
+@@ -585,7 +585,7 @@ WifiP2pDeviceArr CJ_GetP2pPeerDevices(int32_t &ret)
+     return arr;
+ }
+ 
+-int32_t CJ_GetP2pLocalDevice(CWifiP2pDevice &info)
++int32_t FfiWifiGetP2pLocalDevice(CWifiP2pDevice &info)
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -598,7 +598,7 @@ int32_t CJ_GetP2pLocalDevice(CWifiP2pDevice &info)
+     return code;
+ }
+ 
+-int32_t CJ_CreateGroup(CWifiP2PConfig &cfg)
++int32_t FfiWifiCreateGroup(CWifiP2PConfig &cfg)
+ {
+     if (cjWifiP2pPtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -608,7 +608,7 @@ int32_t CJ_CreateGroup(CWifiP2PConfig &cfg)
+     return cjWifiP2pPtr->CreateGroup(config);
+ }
+ 
+-int32_t CJ_GetLinkedInfo(CWifiLinkedInfo &info)
++int32_t FfiWifiGetLinkedInfo(CWifiLinkedInfo &info)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -639,7 +639,7 @@ int32_t CJ_GetLinkedInfo(CWifiLinkedInfo &info)
+     return code;
+ }
+ 
+-int32_t CJ_AddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret)
++int32_t FfiWifiAddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret)
+ {
+     if (cjWifiDevicePtr == nullptr) {
+         return WIFI_OPT_FAILED;
+@@ -694,7 +694,7 @@ int32_t CJ_AddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret)
+     return code;
+ }
+ 
+-WifiDeviceConfigArr CJ_GetCandidateConfigs(int32_t &code)
++WifiDeviceConfigArr FfiWifiGetCandidateConfigs(int32_t &code)
+ {
+     WifiDeviceConfigArr arr{.head = nullptr, .size = 0};
+     if (cjWifiDevicePtr == nullptr) {
+@@ -722,7 +722,7 @@ WifiDeviceConfigArr CJ_GetCandidateConfigs(int32_t &code)
+     return arr;
+ }
+ 
+-int32_t CJ_WifiOn(char *type, void (*callback)())
++int32_t FfiWifiWifiOn(char *type, void (*callback)())
+ {
+     std::string eventType(type);
+     if (eventType.empty()) {
+@@ -731,7 +731,7 @@ int32_t CJ_WifiOn(char *type, void (*callback)())
+     return CjEventRegister::GetInstance().Register(eventType, callback);
+ }
+ 
+-int32_t CJ_WifiOff(char* type)
++int32_t FfiWifiWifiOff(char* type)
+ {
+     std::string eventType(type);
+     if (eventType.empty()) {
+-- 
+2.34.1
+

0004-fix-codecheck.patch

@@ -0,0 +1,546 @@
+From 79428c1a372c39ecabf310802bd6025fbfed6971 Mon Sep 17 00:00:00 2001
+From: zhaoshenghua <zhaoshenghua1@huawei.com>
+Date: Tue, 27 Aug 2024 10:33:20 +0800
+Subject: [PATCH 4/4] fix codecheck
+
+Signed-off-by: zhaoshenghua <zhaoshenghua1@huawei.com>
+---
+ wifi/frameworks/cj/BUILD.gn                |   6 +-
+ wifi/frameworks/cj/include/ffi_structs.h   |  48 ++---
+ wifi/frameworks/cj/include/wifi_callback.h |   5 +
+ wifi/frameworks/cj/include/wifi_ffi.h      |  27 ---
+ wifi/frameworks/cj/src/wifi_ffi.cpp        | 218 ++++++++++++---------
+ 5 files changed, 150 insertions(+), 154 deletions(-)
+
+diff --git a/wifi/frameworks/cj/BUILD.gn b/wifi/frameworks/cj/BUILD.gn
+index a83ae447e..c56e3973c 100644
+--- a/wifi/frameworks/cj/BUILD.gn
++++ b/wifi/frameworks/cj/BUILD.gn
+@@ -34,12 +34,12 @@ ohos_shared_library("cj_wifi_ffi") {
+     "$WIFI_ROOT_DIR/frameworks/native/src",
+     "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper",
+     "$WIFI_ROOT_DIR/utils/inc",
+-    "./include"
++    "./include",
+   ]
+ 
+   sources = [
+-    "src/wifi_ffi.cpp",
+     "src/wifi_callback.cpp",
++    "src/wifi_ffi.cpp",
+   ]
+ 
+   deps = [ "$WIFI_ROOT_DIR/frameworks/native:wifi_sdk" ]
+@@ -67,4 +67,4 @@ ohos_shared_library("cj_wifi_ffi") {
+   innerapi_tags = [ "platformsdk" ]
+   part_name = "wifi"
+   subsystem_name = "communication"
+-}
+\ No newline at end of file
++}
+diff --git a/wifi/frameworks/cj/include/ffi_structs.h b/wifi/frameworks/cj/include/ffi_structs.h
+index e1f0d9b23..a729dbdcc 100644
+--- a/wifi/frameworks/cj/include/ffi_structs.h
++++ b/wifi/frameworks/cj/include/ffi_structs.h
+@@ -20,14 +20,12 @@
+ #include "cj_ffi/cj_common_ffi.h"
+ 
+ extern "C" {
+-    struct CWifiInfoElem
+-    {
++    struct CWifiInfoElem {
+         uint32_t eid;
+         CArrUI8 content;
+     };
+ 
+-    struct CWifiScanInfo
+-    {
++    struct CWifiScanInfo {
+         char *ssid;
+         char *bssid;
+         int32_t bssidType;
+@@ -46,15 +44,12 @@ extern "C" {
+         bool isHiLinkNetwork;
+     };
+ 
+-    struct WifiScanInfoArr
+-    {
++    struct WifiScanInfoArr {
+         CWifiScanInfo *head;
+         int64_t size;
+     };
+ 
+-    // TODO figure out clientCertAlias
+-    struct CWifiEapConfig
+-    {
++    struct CWifiEapConfig {
+         int32_t eapMethod;                        /* EAP authentication mode:PEAP/TLS/TTLS/PWD/SIM/AKA/AKA' */
+         int32_t phase2Method;              /* Second stage authentication method */
+         char *identity;                   /* Identity information */
+@@ -73,16 +68,14 @@ extern "C" {
+         bool isNone;
+     };
+ 
+-    struct CWifiWapiConfig
+-    {
++    struct CWifiWapiConfig {
+         int32_t wapiPskType;
+         char *wapiAsCert;
+         char *wapiUserCert;
+         bool isNone;
+     };
+ 
+-    struct CIpInfo
+-    {
++    struct CIpInfo {
+         uint32_t ipAddress;
+         uint32_t gateway;
+         uint32_t netmask;
+@@ -92,8 +85,7 @@ extern "C" {
+         uint32_t leaseDuration;
+     };
+ 
+-    struct CIpv6Info
+-    {
++    struct CIpv6Info {
+         char *linkIpV6Address;
+         char *globalIpV6Address;
+         char *randomGlobalIpV6Address;
+@@ -105,8 +97,7 @@ extern "C" {
+         char *secondDNS;
+     };
+ 
+-    struct CWifiP2PConfig
+-    {
++    struct CWifiP2PConfig {
+         char *deviceAddress;
+         char *passphrase;
+         char *groupName;
+@@ -115,15 +106,13 @@ extern "C" {
+         int32_t deviceAddressType;
+     };
+ 
+-    struct CWifiP2PLinkedInfo
+-    {
++    struct CWifiP2PLinkedInfo {
+         int32_t connectState;
+         bool isGroupOwner;
+         char *groupOwnerAddr;
+     };
+ 
+-    struct CWifiP2pDevice
+-    {
++    struct CWifiP2pDevice {
+         char *deviceName;
+         char *deviceAddress;
+         char *primaryDeviceType;
+@@ -132,14 +121,12 @@ extern "C" {
+         int32_t deviceAddressType;
+     };
+ 
+-    struct WifiP2pDeviceArr
+-    {
++    struct WifiP2pDeviceArr {
+         CWifiP2pDevice *head;
+         int64_t size;
+     };
+ 
+-    struct CWifiP2PGroupInfo
+-    {
++    struct CWifiP2PGroupInfo {
+         bool isP2pGo;
+         CWifiP2pDevice ownerInfo;
+         char *passphrase;
+@@ -152,8 +139,7 @@ extern "C" {
+         char *goIpAddress;
+     };
+ 
+-    struct CWifiLinkedInfo
+-    {
++    struct CWifiLinkedInfo {
+         char *ssid;
+         char *bssid;
+         int32_t rssi;
+@@ -175,8 +161,7 @@ extern "C" {
+         bool isHiLinkNetwork;
+     };
+ 
+-    struct CWifiDeviceConfig
+-    {
++    struct CWifiDeviceConfig {
+         int32_t securityType;
+         int32_t bssidType;
+         bool isHiddenSsid;
+@@ -187,13 +172,10 @@ extern "C" {
+         CWifiWapiConfig wapiConfig;
+     };
+ 
+-    struct WifiDeviceConfigArr
+-    {
++    struct WifiDeviceConfigArr {
+         CWifiDeviceConfig *head;
+         int64_t size;
+     };
+ }
+ 
+-
+-
+ #endif // CJ_WIFI_FFI_STRUCTS_H
+\ No newline at end of file
+diff --git a/wifi/frameworks/cj/include/wifi_callback.h b/wifi/frameworks/cj/include/wifi_callback.h
+index dd49d04a9..e0af2d08c 100644
+--- a/wifi/frameworks/cj/include/wifi_callback.h
++++ b/wifi/frameworks/cj/include/wifi_callback.h
+@@ -13,6 +13,9 @@
+  * limitations under the License.
+  */
+ 
++#ifndef CJ_WIFI_CALLBACK_H
++#define CJ_WIFI_CALLBACK_H
++
+ #include <shared_mutex>
+ 
+ #include "ffi_structs.h"
+@@ -63,3 +66,5 @@ private:
+     OHOS::sptr<OHOS::ISystemAbilityStatusChange> mSaStatusListener = nullptr;
+ };
+ }
++
++#endif
+\ No newline at end of file
+diff --git a/wifi/frameworks/cj/include/wifi_ffi.h b/wifi/frameworks/cj/include/wifi_ffi.h
+index e89d095ad..41eb646e5 100644
+--- a/wifi/frameworks/cj/include/wifi_ffi.h
++++ b/wifi/frameworks/cj/include/wifi_ffi.h
+@@ -19,33 +19,6 @@
+ #include "cj_ffi/cj_common_ffi.h"
+ #include "ffi_structs.h"
+ 
+-char *MallocCString(const std::string &origin);
+-
+-enum class SecTypeCj {
+-    /** Invalid security type */
+-    SEC_TYPE_INVALID = 0,
+-    /** Open */
+-    SEC_TYPE_OPEN = 1,
+-    /** Wired Equivalent Privacy (WEP) */
+-    SEC_TYPE_WEP = 2,
+-    /** Pre-shared key (PSK) */
+-    SEC_TYPE_PSK = 3,
+-    /** Simultaneous Authentication of Equals (SAE) */
+-    SEC_TYPE_SAE = 4,
+-    /** EAP authentication. */
+-    SEC_TYPE_EAP = 5,
+-    /** SUITE_B_192 192 bit level. */
+-    SEC_TYPE_EAP_SUITE_B = 6,
+-#ifdef ENABLE_NAPI_WIFI_MANAGER
+-    /** Opportunistic Wireless Encryption. */
+-    SEC_TYPE_OWE = 7,
+-#endif
+-    /** WAPI certificate to be specified. */
+-    SEC_TYPE_WAPI_CERT = 8,
+-    /** WAPI pre-shared key to be specified. */
+-    SEC_TYPE_WAPI_PSK = 9,
+-};
+-
+ extern "C" {
+ FFI_EXPORT int32_t FfiWifiIsWifiActive(bool &ret);
+ FFI_EXPORT WifiScanInfoArr FfiWifiGetScanInfoList(int32_t &ret);
+diff --git a/wifi/frameworks/cj/src/wifi_ffi.cpp b/wifi/frameworks/cj/src/wifi_ffi.cpp
+index 35f3b10a9..cc88c220b 100644
+--- a/wifi/frameworks/cj/src/wifi_ffi.cpp
++++ b/wifi/frameworks/cj/src/wifi_ffi.cpp
+@@ -33,6 +33,31 @@ std::shared_ptr<WifiScan> cjWifiScanPtr = WifiScan::GetInstance(WIFI_SCAN_ABILIT
+ std::shared_ptr<WifiP2p> cjWifiP2pPtr = WifiP2p::GetInstance(WIFI_P2P_ABILITY_ID);
+ static const std::string EAP_METHOD[] = { "NONE", "PEAP", "TLS", "TTLS", "PWD", "SIM", "AKA", "AKA'" };
+ 
++enum class SecTypeCj {
++    /** Invalid security type */
++    SEC_TYPE_INVALID = 0,
++    /** Open */
++    SEC_TYPE_OPEN = 1,
++    /** Wired Equivalent Privacy (WEP) */
++    SEC_TYPE_WEP = 2,
++    /** Pre-shared key (PSK) */
++    SEC_TYPE_PSK = 3,
++    /** Simultaneous Authentication of Equals (SAE) */
++    SEC_TYPE_SAE = 4,
++    /** EAP authentication. */
++    SEC_TYPE_EAP = 5,
++    /** SUITE_B_192 192 bit level. */
++    SEC_TYPE_EAP_SUITE_B = 6,
++#ifdef ENABLE_NAPI_WIFI_MANAGER
++    /** Opportunistic Wireless Encryption. */
++    SEC_TYPE_OWE = 7,
++#endif
++    /** WAPI certificate to be specified. */
++    SEC_TYPE_WAPI_CERT = 8,
++    /** WAPI pre-shared key to be specified. */
++    SEC_TYPE_WAPI_PSK = 9,
++};
++
+ static std::string EapMethod2Str(const int& method)
+ {
+     if (method < 0 || method >= static_cast<int>(sizeof(EAP_METHOD) / sizeof(EAP_METHOD[0]))) {
+@@ -133,44 +158,45 @@ static void ProcessPassphrase(const SecTypeCj& securityType, WifiDeviceConfig& c
+     }
+ }
+ 
+-static void NativeInfoElems2Cj(const std::vector<WifiInfoElem>& infoElems, CWifiScanInfo &info)
++static void SetInfoElemContent(WifiInfoElem &infoElem, CWifiInfoElem &cinfo)
+ {
+     int valueStep = 2;
+-    int64_t size = static_cast<int64_t>(infoElems.size());
+-    if (size > 0) {
+-        info.infoElems = static_cast<CWifiInfoElem *>(malloc(sizeof(CWifiInfoElem) * size));
+-        if (info.infoElems == nullptr) {
+-            info.elemsSize = 0;
++    const char *uStr = &infoElem.content[0];
++    size_t len = infoElem.content.size();
++    size_t inLen = static_cast<size_t>(infoElem.content.size() * valueStep + 1);
++    char *buf = static_cast<char *>(calloc(inLen + 1, sizeof(char)));
++    if (buf == nullptr) {
++        return;
++    }
++    int pos = 0;
++    for (size_t k = 0; k < len; ++k) {
++        pos = (k << 1);
++        if (snprintf_s(buf + pos, inLen - pos, inLen - pos - 1, "%02x", uStr[k]) < 0) {
++            free(buf);
++            buf = NULL;
+             return;
+         }
+-        info.elemsSize = size;
+-        for (int64_t i = 0; i < size; i++) {
+-            CWifiInfoElem elem;
+-            elem.eid = infoElems[i].id;
+-
+-            const char *uStr = &infoElems[i].content[0];
+-            size_t len = infoElems[i].content.size();
+-            size_t inLen = static_cast<size_t>(infoElems[i].content.size() * valueStep + 1);
+-            char *buf = (char *)calloc(inLen + 1, sizeof(char));
+-            if (buf == nullptr) {
+-                elem.content = CArrUI8{.head = nullptr, .size = 0};
+-                info.infoElems[i] = elem;
+-                continue;
+-            }
+-            int pos = 0;
+-            for (size_t k = 0; k < len; ++k) {
+-                pos = (k << 1);
+-                if (snprintf_s(buf + pos, inLen - pos, inLen - pos - 1, "%02x", uStr[k]) < 0) {
+-                    free(buf);
+-                    buf = NULL;
+-                    elem.content = CArrUI8{.head = nullptr, .size = 0};
+-                    info.infoElems[i] = elem;
+-                    continue;
+-                }
+-            }
+-            elem.content = CArrUI8{.head = reinterpret_cast<uint8_t *>(buf), .size = inLen - 1}; // TODO check size
+-            info.infoElems[i] = elem;
+-        }
++    }
++    cinfo.content.head = reinterpret_cast<uint8_t *>(buf);
++    cinfo.content.size = inLen - 1;
++}
++
++static void NativeInfoElems2Cj(const std::vector<WifiInfoElem>& infoElems, CWifiScanInfo &info)
++{
++    info.infoElems == nullptr;
++    info.elemsSize = 0;
++    int64_t size = static_cast<int64_t>(infoElems.size());
++    if (size <= 0) {
++        return;
++    }
++    info.infoElems = static_cast<CWifiInfoElem *>(malloc(sizeof(CWifiInfoElem) * size));
++    if (info.infoElems == nullptr) {
++        return;
++    }
++    info.elemsSize = size;
++    for (int64_t i = 0; i < size; i++) {
++        info.infoElems[i] = CWifiInfoElem{ .eid = infoElems[i].id, .content = CArrUI8{.head = nullptr, .size = 0}};
++        SetInfoElemContent(infoElems[i], info.infoElems[i]);
+     }
+ }
+ 
+@@ -187,7 +213,7 @@ static int32_t ScanInfo2Cj(const std::vector<WifiScanInfo>& scanInfos, WifiScanI
+         infos.size = size;
+ 
+         uint32_t idx = 0;
+-        for(auto& each : scanInfos) {
++        for (auto& each : scanInfos) {
+             CWifiScanInfo info;
+             info.ssid = MallocCString(each.ssid);
+             info.bssid = MallocCString(each.bssid);
+@@ -275,6 +301,38 @@ static int Str2EapMethod(const std::string &str)
+     return 0;
+ }
+ 
++static void EapConfig2C(WifiEapConfig &wifiEapConfig, CWifiEapConfig &eapConfig)
++{
++    eapConfig.eapMethod = Str2EapMethod(wifiEapConfig.eap);
++    eapConfig.phase2Method = static_cast<int>(wifiEapConfig.phase2Method);
++    eapConfig.identity = MallocCString(wifiEapConfig.identity);
++    eapConfig.anonymousIdentity = MallocCString(wifiEapConfig.anonymousIdentity);
++    eapConfig.password = MallocCString(wifiEapConfig.password);
++    eapConfig.caCertAlias = MallocCString(wifiEapConfig.caCertAlias);
++    eapConfig.caPath = MallocCString(wifiEapConfig.caCertPath);
++    eapConfig.clientCertAlias = MallocCString(wifiEapConfig.caCertAlias);
++    CArrUI8 arr{.head = nullptr, .size = 0};
++    int64_t size = wifiEapConfig.certEntry.size();
++    if (size > 0) {
++        arr.head = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * size));
++        if (arr.head != nullptr) {
++            uint32_t idx = 0;
++            for (auto& each : wifiEapConfig.certEntry) {
++                arr.head[idx] = each;
++                idx++;
++            }
++        }
++    }
++    eapConfig.certEntry = arr;
++    eapConfig.certPassword = MallocCString(wifiEapConfig.certPassword);
++    eapConfig.altSubjectMatch = MallocCString(wifiEapConfig.altSubjectMatch);
++    eapConfig.domainSuffixMatch = MallocCString(wifiEapConfig.domainSuffixMatch);
++    eapConfig.realm = MallocCString(wifiEapConfig.realm);
++    eapConfig.plmn = MallocCString(wifiEapConfig.plmn);
++    eapConfig.eapSubId = wifiEapConfig.eapSubId;
++    eapConfig.isNone = false;
++}
++
+ static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
+ {
+     UpdateSecurityTypeAndPreSharedKey(config);
+@@ -288,32 +346,7 @@ static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
+     SecTypeCj type = ConvertKeyMgmtToSecType(config.keyMgmt);
+     cfg.securityType = static_cast<int32_t>(type);
+     if (type == SecTypeCj::SEC_TYPE_EAP || type == SecTypeCj::SEC_TYPE_EAP_SUITE_B) {
+-        cfg.eapConfig.eapMethod = Str2EapMethod(config.wifiEapConfig.eap);
+-        cfg.eapConfig.phase2Method = static_cast<int>(config.wifiEapConfig.phase2Method);
+-        cfg.eapConfig.identity = MallocCString(config.wifiEapConfig.identity);
+-        cfg.eapConfig.anonymousIdentity = MallocCString(config.wifiEapConfig.anonymousIdentity);
+-        cfg.eapConfig.password = MallocCString(config.wifiEapConfig.password);
+-        cfg.eapConfig.caCertAlias = MallocCString(config.wifiEapConfig.caCertAlias);
+-        cfg.eapConfig.caPath = MallocCString(config.wifiEapConfig.caCertPath);
+-        cfg.eapConfig.clientCertAlias = MallocCString(config.wifiEapConfig.caCertAlias); // ?
+-        CArrUI8 arr{.head = nullptr, .size = 0};
+-        int64_t size = config.wifiEapConfig.certEntry.size();
+-        arr.head = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * size));
+-        if (arr.head != nullptr) {
+-            uint32_t idx = 0;
+-            for (auto& each : config.wifiEapConfig.certEntry) {
+-                arr.head[idx] = each;
+-                idx++;
+-            }
+-        }
+-        cfg.eapConfig.certEntry = arr;
+-        cfg.eapConfig.certPassword = MallocCString(config.wifiEapConfig.certPassword);
+-        cfg.eapConfig.altSubjectMatch = MallocCString(config.wifiEapConfig.altSubjectMatch);
+-        cfg.eapConfig.domainSuffixMatch = MallocCString(config.wifiEapConfig.domainSuffixMatch);
+-        cfg.eapConfig.realm = MallocCString(config.wifiEapConfig.realm);
+-        cfg.eapConfig.plmn = MallocCString(config.wifiEapConfig.plmn);
+-        cfg.eapConfig.eapSubId = config.wifiEapConfig.eapSubId;
+-        cfg.eapConfig.isNone = false;
++        EapConfig2C(config.wifiEapConfig, cfg.eapConfig);
+     }
+     if (type == SecTypeCj::SEC_TYPE_WAPI_CERT || type == SecTypeCj::SEC_TYPE_WAPI_PSK) {
+         cfg.wapiConfig.wapiPskType = config.wifiWapiConfig.wapiPskType;
+@@ -525,31 +558,35 @@ int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info)
+     }
+     WifiP2pGroupInfo groupInfo;
+     ErrCode code = cjWifiP2pPtr->GetCurrentGroup(groupInfo);
+-    if (code == WIFI_OPT_SUCCESS) {
+-        info.isP2pGo = groupInfo.IsGroupOwner();
+-        DeviceInfo2Cj(groupInfo.GetOwner(), info.ownerInfo);
+-        info.passphrase = MallocCString(groupInfo.GetPassphrase());
+-        info.interfaceName = MallocCString(groupInfo.GetInterface());
+-        info.groupName = MallocCString(groupInfo.GetGroupName());
+-        info.goIpAddress = MallocCString(groupInfo.GetGoIpAddress());
+-        info.networkId = groupInfo.GetNetworkId();
+-        info.frequency = groupInfo.GetFrequency();
+-        info.clientSize = 0;
+-        if (!groupInfo.IsClientDevicesEmpty()) {
+-            const std::vector<OHOS::Wifi::WifiP2pDevice>& vecDevices = groupInfo.GetClientDevices();
+-            int64_t size = static_cast<int64_t>(vecDevices.size());
+-            info.clientDevices = static_cast<CWifiP2pDevice *>(malloc(sizeof(CWifiP2pDevice) * size));
+-            if (info.clientDevices != nullptr) {
+-                info.clientSize = size;
+-                uint32_t idx = 0;
+-                for (auto& each : vecDevices) {
+-                    CWifiP2pDevice device;
+-                    DeviceInfo2Cj(each, device);
+-                    info.clientDevices[idx] = device;
+-                    idx++;
+-                }
+-            }
+-        }
++    if (code != WIFI_OPT_SUCCESS) {
++        return code;
++    }
++    info.isP2pGo = groupInfo.IsGroupOwner();
++    DeviceInfo2Cj(groupInfo.GetOwner(), info.ownerInfo);
++    info.passphrase = MallocCString(groupInfo.GetPassphrase());
++    info.interfaceName = MallocCString(groupInfo.GetInterface());
++    info.groupName = MallocCString(groupInfo.GetGroupName());
++    info.goIpAddress = MallocCString(groupInfo.GetGoIpAddress());
++    info.networkId = groupInfo.GetNetworkId();
++    info.frequency = groupInfo.GetFrequency();
++    info.clientSize = 0;
++    info.clientDevices = nullptr;
++    if (groupInfo.IsClientDevicesEmpty()) {
++        return code;
++    }
++    const std::vector<OHOS::Wifi::WifiP2pDevice>& vecDevices = groupInfo.GetClientDevices();
++    int64_t size = static_cast<int64_t>(vecDevices.size());
++    info.clientDevices = static_cast<CWifiP2pDevice *>(malloc(sizeof(CWifiP2pDevice) * size));
++    if (info.clientDevices == nullptr) {
++        return code;
++    }
++    info.clientSize = size;
++    uint32_t idx = 0;
++    for (auto& each : vecDevices) {
++        CWifiP2pDevice device;
++        DeviceInfo2Cj(each, device);
++        info.clientDevices[idx] = device;
++        idx++;
+     }
+     return code;
+ }
+@@ -669,7 +706,8 @@ int32_t FfiWifiAddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret)
+         config.wifiEapConfig.caCertPath = std::string(cfg.eapConfig.caPath);
+         config.wifiEapConfig.clientCert = std::string(cfg.eapConfig.clientCertAlias);
+         config.wifiEapConfig.privateKey = std::string(cfg.eapConfig.clientCertAlias);
+-        config.wifiEapConfig.certEntry = std::vector<uint8_t>(cfg.eapConfig.certEntry.head, cfg.eapConfig.certEntry.head + cfg.eapConfig.certEntry.size);
++        config.wifiEapConfig.certEntry = std::vector<uint8_t>(cfg.eapConfig.certEntry.head,
++            cfg.eapConfig.certEntry.head + cfg.eapConfig.certEntry.size);
+         if (strncpy_s(config.wifiEapConfig.certPassword, sizeof(config.wifiEapConfig.certPassword),
+             cfg.eapConfig.certPassword, strlen(cfg.eapConfig.certPassword)) != EOK) {
+             WIFI_LOGE("%{public}s: failed to copy", __func__);
+@@ -706,14 +744,13 @@ WifiDeviceConfigArr FfiWifiGetCandidateConfigs(int32_t &code)
+     int64_t size = static_cast<int64_t>(vecDeviceConfigs.size());
+     if (code == WIFI_OPT_SUCCESS && size > 0) {
+         WIFI_LOGI("Get candidate device configs size: %{public}zu", vecDeviceConfigs.size());
+-        // transform
+         arr.head = static_cast<CWifiDeviceConfig *>(malloc(sizeof(CWifiDeviceConfig) * size));
+         if (arr.head == nullptr) {
+             code = WIFI_OPT_FAILED;
+             return arr;
+         }
+         arr.size = size;
+-        for(int64_t i = 0; i < size; i++) {
++        for (int64_t i = 0; i < size; i++) {
+             CWifiDeviceConfig cfg;
+             DeviceConfig2C(vecDeviceConfigs[i], cfg);
+             arr.head[i] = cfg;
+@@ -739,6 +776,5 @@ int32_t FfiWifiWifiOff(char* type)
+     }
+     return CjEventRegister::GetInstance().UnRegister(eventType);
+ }
+-
+ }
+-}
+\ No newline at end of file
++} //OHOS::Wifi
+\ No newline at end of file
+-- 
+2.34.1
+

wifi/frameworks/BUILD.gn

@@ -23,11 +23,11 @@ group("wifi_kits") {
   deps = [ "$WIFI_ROOT_DIR/frameworks/native:wifi_sdk" ]
   if (!defined(ohos_lite)) {
     deps += [
+      "$WIFI_ROOT_DIR/frameworks/cj:cj_wifi_ffi",
       "$WIFI_ROOT_DIR/frameworks/js/napi:wifi",
       "$WIFI_ROOT_DIR/frameworks/js/napi:wifiext",
       "$WIFI_ROOT_DIR/frameworks/js/napi:wifimanager",
       "$WIFI_ROOT_DIR/frameworks/js/napi:wifimanagerext",
-      "$WIFI_ROOT_DIR/frameworks/cj:cj_wifi_ffi",
     ]
   }
 }

wifi/frameworks/cj/BUILD.gn

@@ -34,12 +34,12 @@ ohos_shared_library("cj_wifi_ffi") {
     "$WIFI_ROOT_DIR/frameworks/native/src",
     "$WIFI_ROOT_DIR/services/wifi_standard/wifi_framework/wifi_toolkit/net_helper",
     "$WIFI_ROOT_DIR/utils/inc",
-    "./include"
+    "./include",
   ]
 
   sources = [
-    "src/wifi_ffi.cpp",
     "src/wifi_callback.cpp",
+    "src/wifi_ffi.cpp",
   ]
 
   deps = [ "$WIFI_ROOT_DIR/frameworks/native:wifi_sdk" ]

wifi/frameworks/cj/include/ffi_structs.h

@@ -20,14 +20,12 @@
 #include "cj_ffi/cj_common_ffi.h"
 
 extern "C" {
-    struct CWifiInfoElem
-    {
+    struct CWifiInfoElem {
         uint32_t eid;
         CArrUI8 content;
     };
 
-    struct CWifiScanInfo
-    {
+    struct CWifiScanInfo {
         char *ssid;
         char *bssid;
         int32_t bssidType;
@@ -46,15 +44,12 @@ extern "C" {
         bool isHiLinkNetwork;
     };
 
-    struct WifiScanInfoArr
-    {
+    struct WifiScanInfoArr {
         CWifiScanInfo *head;
         int64_t size;
     };
 
-    // TODO figure out clientCertAlias
-    struct CWifiEapConfig
-    {
+    struct CWifiEapConfig {
         int32_t eapMethod;                        /* EAP authentication mode:PEAP/TLS/TTLS/PWD/SIM/AKA/AKA' */
         int32_t phase2Method;              /* Second stage authentication method */
         char *identity;                   /* Identity information */
@@ -73,16 +68,14 @@ extern "C" {
         bool isNone;
     };
 
-    struct CWifiWapiConfig
-    {
+    struct CWifiWapiConfig {
         int32_t wapiPskType;
         char *wapiAsCert;
         char *wapiUserCert;
         bool isNone;
     };
 
-    struct CIpInfo
-    {
+    struct CIpInfo {
         uint32_t ipAddress;
         uint32_t gateway;
         uint32_t netmask;
@@ -92,8 +85,7 @@ extern "C" {
         uint32_t leaseDuration;
     };
 
-    struct CIpv6Info
-    {
+    struct CIpv6Info {
         char *linkIpV6Address;
         char *globalIpV6Address;
         char *randomGlobalIpV6Address;
@@ -105,8 +97,7 @@ extern "C" {
         char *secondDNS;
     };
 
-    struct CWifiP2PConfig
-    {
+    struct CWifiP2PConfig {
         char *deviceAddress;
         char *passphrase;
         char *groupName;
@@ -115,15 +106,13 @@ extern "C" {
         int32_t deviceAddressType;
     };
 
-    struct CWifiP2PLinkedInfo
-    {
+    struct CWifiP2PLinkedInfo {
         int32_t connectState;
         bool isGroupOwner;
         char *groupOwnerAddr;
     };
 
-    struct CWifiP2pDevice
-    {
+    struct CWifiP2pDevice {
         char *deviceName;
         char *deviceAddress;
         char *primaryDeviceType;
@@ -132,14 +121,12 @@ extern "C" {
         int32_t deviceAddressType;
     };
 
-    struct WifiP2pDeviceArr
-    {
+    struct WifiP2pDeviceArr {
         CWifiP2pDevice *head;
         int64_t size;
     };
 
-    struct CWifiP2PGroupInfo
-    {
+    struct CWifiP2PGroupInfo {
         bool isP2pGo;
         CWifiP2pDevice ownerInfo;
         char *passphrase;
@@ -152,8 +139,7 @@ extern "C" {
         char *goIpAddress;
     };
 
-    struct CWifiLinkedInfo
-    {
+    struct CWifiLinkedInfo {
         char *ssid;
         char *bssid;
         int32_t rssi;
@@ -175,8 +161,7 @@ extern "C" {
         bool isHiLinkNetwork;
     };
 
-    struct CWifiDeviceConfig
-    {
+    struct CWifiDeviceConfig {
         int32_t securityType;
         int32_t bssidType;
         bool isHiddenSsid;
@@ -187,13 +172,10 @@ extern "C" {
         CWifiWapiConfig wapiConfig;
     };
 
-    struct WifiDeviceConfigArr
-    {
+    struct WifiDeviceConfigArr {
         CWifiDeviceConfig *head;
         int64_t size;
     };
 }
 
-
-
 #endif // CJ_WIFI_FFI_STRUCTS_H

wifi/frameworks/cj/include/wifi_callback.h

@@ -13,6 +13,9 @@
  * limitations under the License.
  */
 
+#ifndef CJ_WIFI_CALLBACK_H
+#define CJ_WIFI_CALLBACK_H
+
 #include <shared_mutex>
 
 #include "ffi_structs.h"
@@ -63,3 +66,5 @@ private:
     OHOS::sptr<OHOS::ISystemAbilityStatusChange> mSaStatusListener = nullptr;
 };
 }
+
+#endif

wifi/frameworks/cj/include/wifi_ffi.h

@@ -19,33 +19,6 @@
 #include "cj_ffi/cj_common_ffi.h"
 #include "ffi_structs.h"
 
-char *MallocCString(const std::string &origin);
-
-enum class SecTypeCj {
-    /** Invalid security type */
-    SEC_TYPE_INVALID = 0,
-    /** Open */
-    SEC_TYPE_OPEN = 1,
-    /** Wired Equivalent Privacy (WEP) */
-    SEC_TYPE_WEP = 2,
-    /** Pre-shared key (PSK) */
-    SEC_TYPE_PSK = 3,
-    /** Simultaneous Authentication of Equals (SAE) */
-    SEC_TYPE_SAE = 4,
-    /** EAP authentication. */
-    SEC_TYPE_EAP = 5,
-    /** SUITE_B_192 192 bit level. */
-    SEC_TYPE_EAP_SUITE_B = 6,
-#ifdef ENABLE_NAPI_WIFI_MANAGER
-    /** Opportunistic Wireless Encryption. */
-    SEC_TYPE_OWE = 7,
-#endif
-    /** WAPI certificate to be specified. */
-    SEC_TYPE_WAPI_CERT = 8,
-    /** WAPI pre-shared key to be specified. */
-    SEC_TYPE_WAPI_PSK = 9,
-};
-
 extern "C" {
 FFI_EXPORT int32_t FfiWifiIsWifiActive(bool &ret);
 FFI_EXPORT WifiScanInfoArr FfiWifiGetScanInfoList(int32_t &ret);

wifi/frameworks/cj/src/wifi_ffi.cpp

@@ -33,6 +33,31 @@ std::shared_ptr<WifiScan> cjWifiScanPtr = WifiScan::GetInstance(WIFI_SCAN_ABILIT
 std::shared_ptr<WifiP2p> cjWifiP2pPtr = WifiP2p::GetInstance(WIFI_P2P_ABILITY_ID);
 static const std::string EAP_METHOD[] = { "NONE", "PEAP", "TLS", "TTLS", "PWD", "SIM", "AKA", "AKA'" };
 
+enum class SecTypeCj {
+    /** Invalid security type */
+    SEC_TYPE_INVALID = 0,
+    /** Open */
+    SEC_TYPE_OPEN = 1,
+    /** Wired Equivalent Privacy (WEP) */
+    SEC_TYPE_WEP = 2,
+    /** Pre-shared key (PSK) */
+    SEC_TYPE_PSK = 3,
+    /** Simultaneous Authentication of Equals (SAE) */
+    SEC_TYPE_SAE = 4,
+    /** EAP authentication. */
+    SEC_TYPE_EAP = 5,
+    /** SUITE_B_192 192 bit level. */
+    SEC_TYPE_EAP_SUITE_B = 6,
+#ifdef ENABLE_NAPI_WIFI_MANAGER
+    /** Opportunistic Wireless Encryption. */
+    SEC_TYPE_OWE = 7,
+#endif
+    /** WAPI certificate to be specified. */
+    SEC_TYPE_WAPI_CERT = 8,
+    /** WAPI pre-shared key to be specified. */
+    SEC_TYPE_WAPI_PSK = 9,
+};
+
 static std::string EapMethod2Str(const int& method)
 {
     if (method < 0 || method >= static_cast<int>(sizeof(EAP_METHOD) / sizeof(EAP_METHOD[0]))) {
@@ -133,44 +158,47 @@ static void ProcessPassphrase(const SecTypeCj& securityType, WifiDeviceConfig& c
     }
 }
 
-static void NativeInfoElems2Cj(const std::vector<WifiInfoElem>& infoElems, CWifiScanInfo &info)
+static void SetInfoElemContent(const WifiInfoElem &infoElem, CWifiInfoElem &cinfo)
 {
     int valueStep = 2;
-    int64_t size = static_cast<int64_t>(infoElems.size());
-    if (size > 0) {
-        info.infoElems = static_cast<CWifiInfoElem *>(malloc(sizeof(CWifiInfoElem) * size));
-        if (info.infoElems == nullptr) {
-            info.elemsSize = 0;
-            return;
-        }
-        info.elemsSize = size;
-        for (int64_t i = 0; i < size; i++) {
-            CWifiInfoElem elem;
-            elem.eid = infoElems[i].id;
-
-            const char *uStr = &infoElems[i].content[0];
-            size_t len = infoElems[i].content.size();
-            size_t inLen = static_cast<size_t>(infoElems[i].content.size() * valueStep + 1);
-            char *buf = (char *)calloc(inLen + 1, sizeof(char));
+    const char *uStr = &infoElem.content[0];
+    size_t len = infoElem.content.size();
+    size_t inLen = static_cast<size_t>(infoElem.content.size() * valueStep + 1);
+    char *buf = static_cast<char *>(calloc(inLen + 1, sizeof(char)));
     if (buf == nullptr) {
-                elem.content = CArrUI8{.head = nullptr, .size = 0};
-                info.infoElems[i] = elem;
-                continue;
+        return;
     }
     int pos = 0;
     for (size_t k = 0; k < len; ++k) {
         pos = (k << 1);
         if (snprintf_s(buf + pos, inLen - pos, inLen - pos - 1, "%02x", uStr[k]) < 0) {
             free(buf);
-                    buf = NULL;
-                    elem.content = CArrUI8{.head = nullptr, .size = 0};
-                    info.infoElems[i] = elem;
-                    continue;
+            buf = nullptr;
+            return;
         }
     }
-            elem.content = CArrUI8{.head = reinterpret_cast<uint8_t *>(buf), .size = inLen - 1}; // TODO check size
-            info.infoElems[i] = elem;
+    cinfo.content.head = reinterpret_cast<uint8_t *>(buf);
+    cinfo.content.size = inLen - 1;
+}
+
+static void NativeInfoElems2Cj(const std::vector<WifiInfoElem>& infoElems, CWifiScanInfo &info)
+{
+    info.infoElems = nullptr;
+    info.elemsSize = 0;
+    int64_t size = static_cast<int64_t>(infoElems.size());
+    if (size <= 0) {
+        return;
     }
+    info.infoElems = static_cast<CWifiInfoElem *>(malloc(sizeof(CWifiInfoElem) * size));
+    if (info.infoElems == nullptr) {
+        return;
+    }
+    info.elemsSize = size;
+    int64_t idx = 0;
+    for (auto& each : infoElems) {
+        info.infoElems[idx] = CWifiInfoElem{ .eid = each.id, .content = CArrUI8{.head = nullptr, .size = 0}};
+        SetInfoElemContent(each, info.infoElems[idx]);
+        idx++;
     }
 }
 
@@ -187,7 +215,7 @@ static int32_t ScanInfo2Cj(const std::vector<WifiScanInfo>& scanInfos, WifiScanI
         infos.size = size;
 
         uint32_t idx = 0;
-        for(auto& each : scanInfos) {
+        for (auto& each : scanInfos) {
             CWifiScanInfo info;
             info.ssid = MallocCString(each.ssid);
             info.bssid = MallocCString(each.bssid);
@@ -275,6 +303,38 @@ static int Str2EapMethod(const std::string &str)
     return 0;
 }
 
+static void EapConfig2C(WifiEapConfig &wifiEapConfig, CWifiEapConfig &eapConfig)
+{
+    eapConfig.eapMethod = Str2EapMethod(wifiEapConfig.eap);
+    eapConfig.phase2Method = static_cast<int>(wifiEapConfig.phase2Method);
+    eapConfig.identity = MallocCString(wifiEapConfig.identity);
+    eapConfig.anonymousIdentity = MallocCString(wifiEapConfig.anonymousIdentity);
+    eapConfig.password = MallocCString(wifiEapConfig.password);
+    eapConfig.caCertAlias = MallocCString(wifiEapConfig.caCertAlias);
+    eapConfig.caPath = MallocCString(wifiEapConfig.caCertPath);
+    eapConfig.clientCertAlias = MallocCString(wifiEapConfig.caCertAlias);
+    CArrUI8 arr{.head = nullptr, .size = 0};
+    int64_t size = wifiEapConfig.certEntry.size();
+    if (size > 0) {
+        arr.head = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * size));
+        if (arr.head != nullptr) {
+            uint32_t idx = 0;
+            for (auto& each : wifiEapConfig.certEntry) {
+                arr.head[idx] = each;
+                idx++;
+            }
+        }
+    }
+    eapConfig.certEntry = arr;
+    eapConfig.certPassword = MallocCString(wifiEapConfig.certPassword);
+    eapConfig.altSubjectMatch = MallocCString(wifiEapConfig.altSubjectMatch);
+    eapConfig.domainSuffixMatch = MallocCString(wifiEapConfig.domainSuffixMatch);
+    eapConfig.realm = MallocCString(wifiEapConfig.realm);
+    eapConfig.plmn = MallocCString(wifiEapConfig.plmn);
+    eapConfig.eapSubId = wifiEapConfig.eapSubId;
+    eapConfig.isNone = false;
+}
+
 static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
 {
     UpdateSecurityTypeAndPreSharedKey(config);
@@ -288,32 +348,7 @@ static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
     SecTypeCj type = ConvertKeyMgmtToSecType(config.keyMgmt);
     cfg.securityType = static_cast<int32_t>(type);
     if (type == SecTypeCj::SEC_TYPE_EAP || type == SecTypeCj::SEC_TYPE_EAP_SUITE_B) {
-        cfg.eapConfig.eapMethod = Str2EapMethod(config.wifiEapConfig.eap);
-        cfg.eapConfig.phase2Method = static_cast<int>(config.wifiEapConfig.phase2Method);
-        cfg.eapConfig.identity = MallocCString(config.wifiEapConfig.identity);
-        cfg.eapConfig.anonymousIdentity = MallocCString(config.wifiEapConfig.anonymousIdentity);
-        cfg.eapConfig.password = MallocCString(config.wifiEapConfig.password);
-        cfg.eapConfig.caCertAlias = MallocCString(config.wifiEapConfig.caCertAlias);
-        cfg.eapConfig.caPath = MallocCString(config.wifiEapConfig.caCertPath);
-        cfg.eapConfig.clientCertAlias = MallocCString(config.wifiEapConfig.caCertAlias); // ?
-        CArrUI8 arr{.head = nullptr, .size = 0};
-        int64_t size = config.wifiEapConfig.certEntry.size();
-        arr.head = static_cast<uint8_t *>(malloc(sizeof(uint8_t) * size));
-        if (arr.head != nullptr) {
-            uint32_t idx = 0;
-            for (auto& each : config.wifiEapConfig.certEntry) {
-                arr.head[idx] = each;
-                idx++;
-            }
-        }
-        cfg.eapConfig.certEntry = arr;
-        cfg.eapConfig.certPassword = MallocCString(config.wifiEapConfig.certPassword);
-        cfg.eapConfig.altSubjectMatch = MallocCString(config.wifiEapConfig.altSubjectMatch);
-        cfg.eapConfig.domainSuffixMatch = MallocCString(config.wifiEapConfig.domainSuffixMatch);
-        cfg.eapConfig.realm = MallocCString(config.wifiEapConfig.realm);
-        cfg.eapConfig.plmn = MallocCString(config.wifiEapConfig.plmn);
-        cfg.eapConfig.eapSubId = config.wifiEapConfig.eapSubId;
-        cfg.eapConfig.isNone = false;
+        EapConfig2C(config.wifiEapConfig, cfg.eapConfig);
     }
     if (type == SecTypeCj::SEC_TYPE_WAPI_CERT || type == SecTypeCj::SEC_TYPE_WAPI_PSK) {
         cfg.wapiConfig.wapiPskType = config.wifiWapiConfig.wapiPskType;
@@ -324,7 +359,6 @@ static void DeviceConfig2C(WifiDeviceConfig &config, CWifiDeviceConfig &cfg)
 }
 
 extern "C" {
-
 int32_t FfiWifiIsWifiActive(bool &ret)
 {
     if (cjWifiDevicePtr == nullptr) {
@@ -525,7 +559,9 @@ int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info)
     }
     WifiP2pGroupInfo groupInfo;
     ErrCode code = cjWifiP2pPtr->GetCurrentGroup(groupInfo);
-    if (code == WIFI_OPT_SUCCESS) {
+    if (code != WIFI_OPT_SUCCESS) {
+        return code;
+    }
     info.isP2pGo = groupInfo.IsGroupOwner();
     DeviceInfo2Cj(groupInfo.GetOwner(), info.ownerInfo);
     info.passphrase = MallocCString(groupInfo.GetPassphrase());
@@ -535,11 +571,16 @@ int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info)
     info.networkId = groupInfo.GetNetworkId();
     info.frequency = groupInfo.GetFrequency();
     info.clientSize = 0;
-        if (!groupInfo.IsClientDevicesEmpty()) {
+    info.clientDevices = nullptr;
+    if (groupInfo.IsClientDevicesEmpty()) {
+        return code;
+    }
     const std::vector<OHOS::Wifi::WifiP2pDevice>& vecDevices = groupInfo.GetClientDevices();
     int64_t size = static_cast<int64_t>(vecDevices.size());
     info.clientDevices = static_cast<CWifiP2pDevice *>(malloc(sizeof(CWifiP2pDevice) * size));
-            if (info.clientDevices != nullptr) {
+    if (info.clientDevices == nullptr) {
+        return code;
+    }
     info.clientSize = size;
     uint32_t idx = 0;
     for (auto& each : vecDevices) {
@@ -548,9 +589,6 @@ int32_t FfiWifiGetCurrentGroup(CWifiP2PGroupInfo &info)
         info.clientDevices[idx] = device;
         idx++;
     }
-            }
-        }
-    }
     return code;
 }
 
@@ -669,7 +707,8 @@ int32_t FfiWifiAddCandidateConfig(CWifiDeviceConfig cfg, int32_t &ret)
         config.wifiEapConfig.caCertPath = std::string(cfg.eapConfig.caPath);
         config.wifiEapConfig.clientCert = std::string(cfg.eapConfig.clientCertAlias);
         config.wifiEapConfig.privateKey = std::string(cfg.eapConfig.clientCertAlias);
-        config.wifiEapConfig.certEntry = std::vector<uint8_t>(cfg.eapConfig.certEntry.head, cfg.eapConfig.certEntry.head + cfg.eapConfig.certEntry.size);
+        config.wifiEapConfig.certEntry = std::vector<uint8_t>(cfg.eapConfig.certEntry.head,
+            cfg.eapConfig.certEntry.head + cfg.eapConfig.certEntry.size);
         if (strncpy_s(config.wifiEapConfig.certPassword, sizeof(config.wifiEapConfig.certPassword),
             cfg.eapConfig.certPassword, strlen(cfg.eapConfig.certPassword)) != EOK) {
             WIFI_LOGE("%{public}s: failed to copy", __func__);
@@ -706,14 +745,13 @@ WifiDeviceConfigArr FfiWifiGetCandidateConfigs(int32_t &code)
     int64_t size = static_cast<int64_t>(vecDeviceConfigs.size());
     if (code == WIFI_OPT_SUCCESS && size > 0) {
         WIFI_LOGI("Get candidate device configs size: %{public}zu", vecDeviceConfigs.size());
-        // transform
         arr.head = static_cast<CWifiDeviceConfig *>(malloc(sizeof(CWifiDeviceConfig) * size));
         if (arr.head == nullptr) {
             code = WIFI_OPT_FAILED;
             return arr;
         }
         arr.size = size;
-        for(int64_t i = 0; i < size; i++) {
+        for (int64_t i = 0; i < size; i++) {
             CWifiDeviceConfig cfg;
             DeviceConfig2C(vecDeviceConfigs[i], cfg);
             arr.head[i] = cfg;
@@ -739,6 +777,5 @@ int32_t FfiWifiWifiOff(char* type)
     }
     return CjEventRegister::GetInstance().UnRegister(eventType);
 }
-
-}
 }
+} //OHOS::Wifi