1. 重新梳理ConnectivityManagerImpl相关逻辑

2. 减少对NetworkCommissioningDriver的更改，重启后重连wifi动作移动到NetworkCommissioningDriver
3. matter重置时添加对BEKEN0-BEKEN4的清理
4. ble广播出错时先主动断开
5. 添加函数matter_factory_reset 提供cli重置matter接口

examples/lighting-app/beken/main/chipinterface.cpp

@@ -195,6 +195,9 @@ static void InitServer(intptr_t context)
     BkLightingMgr().Init(); 
     PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE));
 }
+extern "C" void matter_factory_reset(char *pcWriteBuffer, int xWriteBufferLen, int argc, char **argv ){
+    Server::GetInstance().ScheduleFactoryReset();
+}
 
 extern "C" void ChipTest(void)
 {

src/platform/Beken/NetworkCommissioningDriver.h

@@ -50,7 +50,7 @@ public:
     class WiFiNetworkIterator final : public NetworkIterator
     {
     public:
-        WiFiNetworkIterator(BekenWiFiDriver * aDriver);
+        WiFiNetworkIterator(BekenWiFiDriver * aDriver) : mDriver(aDriver) {}
         size_t Count() override;
         bool Next(Network & item) override;
         void Release() override { delete this; }
@@ -58,7 +58,7 @@ public:
 
     private:
         BekenWiFiDriver * mDriver;
-        uint8_t index;
+        bool mExhausted = false;
     };
 
     struct WiFiNetwork
@@ -67,9 +67,6 @@ public:
         uint8_t ssidLen = 0;
         char credentials[DeviceLayer::Internal::kMaxWiFiKeyLength];
         uint8_t credentialsLen = 0;
-        bool connected = false;
-        bool saved = false;
-        uint8_t count;
     };
 
     // BaseDriver
@@ -94,8 +91,8 @@ public:
                               uint8_t & outNetworkIndex) override;
     void ScanNetworks(ByteSpan ssid, ScanCallback * callback) override;
 
-    CHIP_ERROR ConnectWiFiNetwork();
-    void OnConnectWiFiNetwork(Status commissioningError, CharSpan debugText, int32_t interfaceStatus);
+    CHIP_ERROR ConnectWiFiNetwork(const char * ssid, uint8_t ssidLen, const char * key, uint8_t keyLen);
+    void OnConnectWiFiNetwork();
     void OnScanWiFiNetworkDone();
     void OnNetworkStatusChange();
 
@@ -113,7 +110,7 @@ private:
     bool NetworkMatch(const WiFiNetwork & network, ByteSpan networkId);
     CHIP_ERROR StartScanWiFiNetworks(ByteSpan ssid);
 
-    WiFiNetwork mNetwork;
+    WiFiNetworkIterator mWiFiIterator = WiFiNetworkIterator(this);
     WiFiNetwork mSavedNetwork;
     WiFiNetwork mStagingNetwork;
     ScanCallback * mpScanCallback;

src/platform/Beken/bk7231/BLEManagerImpl.cpp

@@ -1058,6 +1058,11 @@ void BLEManagerImpl::beken_ble_cmd_cb(ble_cmd_t cmd, ble_cmd_param_t * param)
         PlatformMgr().ScheduleWork(DriveBLEState, 0);
         break;
     case BLE_START_ADV: {
+        if (param->status != ERR_SUCCESS)
+        {
+            bk_ble_disconnect(param->cmd_idx, beken_ble_cmd_cb);
+            break;
+        }
         uint32_t bleAdvTimeoutMs;
         sInstance.mFlags.Set(Flags::kBEKENBLEADVStarted);
         if (sInstance.mFlags.Has(Flags::kAdvertisingIsFastADV)){
@@ -1084,6 +1089,7 @@ void BLEManagerImpl::beken_ble_cmd_cb(ble_cmd_t cmd, ble_cmd_param_t * param)
         PlatformMgr().ScheduleWork(DriveBLEState, 0);
         break;
     case BLE_CONN_DIS_CONN:
+        PlatformMgr().ScheduleWork(DriveBLEState, 0);
         break;
     default:
         break;

src/platform/Beken/bk7231/ConfigurationManagerImpl.cpp

@@ -281,6 +281,31 @@ void ConfigurationManagerImpl::DoFactoryReset(intptr_t arg)
     {
         ChipLogError(DeviceLayer, "ClearNamespace(ChipConfig) failed: %s", chip::ErrorStr(err));
     }
+    err = BekenConfig::ClearNamespace("BEKEN0");
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "ClearNamespace(BEKEN0) failed: %s", chip::ErrorStr(err));
+    }
+    err = BekenConfig::ClearNamespace("BEKEN1");
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "ClearNamespace(BEKEN1) failed: %s", chip::ErrorStr(err));
+    }
+    err = BekenConfig::ClearNamespace("BEKEN2");
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "ClearNamespace(BEKEN2) failed: %s", chip::ErrorStr(err));
+    }
+    err = BekenConfig::ClearNamespace("BEKEN3");
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "ClearNamespace(BEKEN3) failed: %s", chip::ErrorStr(err));
+    }
+    err = BekenConfig::ClearNamespace("BEKEN4");
+    if (err != CHIP_NO_ERROR)
+    {
+        ChipLogError(DeviceLayer, "ClearNamespace(BEKEN4) failed: %s", chip::ErrorStr(err));
+    }
 
     // Restart the system.
     ChipLogProgress(DeviceLayer, "System restarting");

src/platform/Beken/bk7231/ConnectivityManagerImpl.cpp

@@ -86,11 +86,6 @@ CHIP_ERROR ConnectivityManagerImpl::_Init()
 void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
 {
 #if CHIP_DEVICE_CONFIG_ENABLE_WIFI
-    if (event->Type >= DeviceEventType::kBKWiFiRW_EVT_STA_IDLE_Event &&
-        event->Type <= DeviceEventType::kBKWIFIRW_EVT_STA_GOT_IP_Event)
-    {
-        ChipLogProgress(DeviceLayer, "%s get event %d", __FUNCTION__,event->Type);
-    }
     switch (event->Type)
     {
     case DeviceEventType::kBKWiFiRW_EVT_STA_IDLE_Event:
@@ -118,7 +113,13 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event)
     default:
         break;
     }
-    DeviceLayer::SystemLayer().ScheduleWork(DriveStationState, NULL);
+
+    if (event->Type >= DeviceEventType::kBKWiFiRW_EVT_STA_IDLE_Event &&
+        event->Type <= DeviceEventType::kBKWIFIRW_EVT_STA_GOT_IP_Event)
+    {
+        ChipLogProgress(DeviceLayer, "%s get event %d", __FUNCTION__, event->Type);
+        DeviceLayer::SystemLayer().ScheduleWork(DriveStationState, NULL);
+    }
 #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI
 }
 
@@ -146,7 +147,6 @@ CHIP_ERROR ConnectivityManagerImpl::_SetWiFiStationMode(WiFiStationMode val)
                         WiFiStationModeToStr(val));
     }
     mWiFiStationMode = val;
-    DriveStationState();
 exit:
     return err;
 }
@@ -241,32 +241,25 @@ void ConnectivityManagerImpl::DriveStationState()
 {
     // connect preview network
     ChipLogProgress(DeviceLayer, "%s", __FUNCTION__);
-    static WiFiStationState preWiFiStationState = kWiFiStationState_NotConnected;
 
     if (mWiFiStationMode == kWiFiStationMode_Disabled)
     {
-        if (IsWiFiStationProvisioned() && mWiFiStationState == kWiFiStationState_NotConnected)
-        {
-            BekenWiFiDriver::GetInstance().ConnectWiFiNetwork();
-            SetWiFiStationMode(kWiFiStationMode_ApplicationControlled);
-        }
     }
     else
     {
         if (mWiFiStationState == kWiFiStationState_Connected)
         {
-            if (mWiFiStationMode != kWiFiStationMode_ApplicationControlled && preWiFiStationState != kWiFiStationState_Connected)
+            if (mWiFiStationMode != kWiFiStationMode_ApplicationControlled)
             {
-                BekenWiFiDriver::GetInstance().OnConnectWiFiNetwork(Status::kSuccess, CharSpan::fromCharString("connected"), 0);
+                SetWiFiStationMode(kWiFiStationMode_ApplicationControlled);
             }
             // OnStationConnected();
             UpdateInternetConnectivityState();
-            SetWiFiStationMode(kWiFiStationMode_Enabled);
+            BekenWiFiDriver::GetInstance().OnConnectWiFiNetwork();
         }
         else if (mWiFiStationState == kWiFiStationState_Disconnecting)
         {
             UpdateInternetConnectivityState();
-            preWiFiStationState = mWiFiStationState;
         }
         else if (mWiFiStationState == kWiFiStationState_Connecting_Failed)
         {
@@ -274,10 +267,10 @@ void ConnectivityManagerImpl::DriveStationState()
             {
                 SetWiFiStationMode(kWiFiStationMode_Disabled);
             }
-            BekenWiFiDriver::GetInstance().OnConnectWiFiNetwork(Status::kUnknownError, CharSpan::fromCharString("Error"), 0);
+            UpdateInternetConnectivityState();
+            BekenWiFiDriver::GetInstance().OnConnectWiFiNetwork();
         }
     }
-    preWiFiStationState = mWiFiStationState;
 }
 
 void ConnectivityManagerImpl::OnStationConnected()

src/platform/Beken/bk7231/NetworkCommissioningWiFiDriver.cpp

@@ -45,7 +45,7 @@ bool BKScanResponseIterator::Next(WiFiScanResponse & item)
     }
     uint8_t ssidlenth = strlen(apList->ApList[mIternum].ssid);
     item.security.SetRaw(NC_SECURITYCONVERT(apList->ApList[mIternum].security));
-    item.ssidLen  = ssidlenth;
+    item.ssidLen = ssidlenth;
     item.channel  = apList->ApList[mIternum].channel;
     item.wiFiBand = chip::DeviceLayer::NetworkCommissioning::WiFiBand::k2g4;
     item.rssi     = apList->ApList[mIternum].ApPower;
@@ -56,44 +56,41 @@ bool BKScanResponseIterator::Next(WiFiScanResponse & item)
     return true;
 }
 
+
 CHIP_ERROR BekenWiFiDriver::Init(NetworkStatusChangeCallback * networkStatusChangeCallback)
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::Init\r\n");
-    CHIP_ERROR err = CHIP_NO_ERROR;
-
-    if (mNetwork.count == 0)
+    CHIP_ERROR err;
+    size_t ssidLen        = 0;
+    size_t credentialsLen = 0;
+    mSavedNetwork.ssidLen = 0;
+
+    err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiCredentialsKeyName, mSavedNetwork.credentials,
+                                                   sizeof(mSavedNetwork.credentials), &credentialsLen);
+    if (err == CHIP_ERROR_NOT_FOUND)
     {
-        size_t ssidLen        = 0;
-        size_t credentialsLen = 0;
-
-        err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiCredentialsKeyName, mNetwork.credentials, sizeof(mNetwork.credentials),
-                                                       &credentialsLen);
-        if (err == CHIP_NO_ERROR)
-        {
-            err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiSSIDKeyName, mNetwork.ssid, sizeof(mNetwork.ssid), &ssidLen);
-        }
-        if (err != CHIP_NO_ERROR)
-        {
-            mNetwork.credentialsLen = 0;
-            mNetwork.ssidLen        = 0;
-            mNetwork.connected      = false;
-            mNetwork.saved          = false;
-            mNetwork.count          = 0;
-        }
-        else
-        {
-            mNetwork.credentialsLen = credentialsLen;
-            mNetwork.ssidLen        = ssidLen;
-            mNetwork.connected      = false;
-            mNetwork.saved          = true;
-            mNetwork.count          = 1;
-        }
+        return CHIP_NO_ERROR;
     }
 
-    mpScanCallback         = nullptr;
-    mpConnectCallback      = nullptr;
-    mpStatusChangeCallback = networkStatusChangeCallback;
-
+    err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiSSIDKeyName, mSavedNetwork.ssid, sizeof(mSavedNetwork.ssid), &ssidLen);
+    if (err == CHIP_ERROR_NOT_FOUND)
+    {
+        return CHIP_NO_ERROR;
+    }
+    mSavedNetwork.credentialsLen = credentialsLen;
+    mSavedNetwork.ssidLen        = ssidLen;
+
+    mStagingNetwork              = mSavedNetwork;
+    mpScanCallback               = nullptr;
+    mpConnectCallback            = nullptr;
+    mpStatusChangeCallback       = networkStatusChangeCallback;
+    if (mStagingNetwork.ssidLen != 0)
+    {
+        ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled);
+        ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_ApplicationControlled);
+        ConnectWiFiNetwork(reinterpret_cast<const char *>(mStagingNetwork.ssid), mStagingNetwork.ssidLen,
+                           reinterpret_cast<const char *>(mStagingNetwork.credentials), mStagingNetwork.credentialsLen);
+    }
     return err;
 }
 
@@ -105,26 +102,17 @@ void BekenWiFiDriver::Shutdown()
 CHIP_ERROR BekenWiFiDriver::CommitConfiguration()
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::CommitConfiguration\r\n");
-    ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Put(kWiFiSSIDKeyName, mNetwork.ssid, mNetwork.ssidLen));
-    ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Put(kWiFiCredentialsKeyName, mNetwork.credentials,
-                                                                  mNetwork.credentialsLen));
-    mNetwork.saved = true;
+    ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Put(kWiFiSSIDKeyName, mStagingNetwork.ssid, mStagingNetwork.ssidLen));
+    ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Put(kWiFiCredentialsKeyName, mStagingNetwork.credentials,
+                                                                  mStagingNetwork.credentialsLen));
+    mSavedNetwork = mStagingNetwork;
     return CHIP_NO_ERROR;
 }
 
 CHIP_ERROR BekenWiFiDriver::RevertConfiguration()
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::RevertConfiguration\r\n");
-    mNetwork.ssidLen        = 0;
-    mNetwork.credentialsLen = 0;
-    mNetwork.connected      = false;
-    mNetwork.count          = 0;
-    if (mNetwork.saved)
-    {
-        mNetwork.saved = false;
-        ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Delete(kWiFiSSIDKeyName));
-        ReturnErrorOnFailure(PersistedStorage::KeyValueStoreMgr().Delete(kWiFiCredentialsKeyName));
-    }
+    mStagingNetwork = mSavedNetwork;
     return CHIP_NO_ERROR;
 }
 
@@ -141,19 +129,15 @@ Status BekenWiFiDriver::AddOrUpdateNetwork(ByteSpan ssid, ByteSpan credentials,
 
     outDebugText.reduce_size(0);
     outNetworkIndex = 0;
-    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::AddOrUpdateNetwork %d", mNetwork.count);
-    VerifyOrReturnError(mNetwork.count == 0, Status::kBoundsExceeded);
-    VerifyOrReturnError(credentials.size() <= sizeof(mNetwork.credentials), Status::kOutOfRange);
-    VerifyOrReturnError(ssid.size() <= sizeof(mNetwork.ssid), Status::kOutOfRange);
+    VerifyOrReturnError(mStagingNetwork.ssidLen == 0 || NetworkMatch(mStagingNetwork, ssid), Status::kBoundsExceeded);
+    VerifyOrReturnError(credentials.size() <= sizeof(mStagingNetwork.credentials), Status::kOutOfRange);
+    VerifyOrReturnError(ssid.size() <= sizeof(mStagingNetwork.ssid), Status::kOutOfRange);
 
-    memcpy(mNetwork.credentials, credentials.data(), credentials.size());
-    mNetwork.credentialsLen = static_cast<decltype(mNetwork.credentialsLen)>(credentials.size());
+    memcpy(mStagingNetwork.credentials, credentials.data(), credentials.size());
+    mStagingNetwork.credentialsLen = static_cast<decltype(mStagingNetwork.credentialsLen)>(credentials.size());
 
-    memcpy(mNetwork.ssid, ssid.data(), ssid.size());
-    mNetwork.ssidLen   = static_cast<decltype(mNetwork.ssidLen)>(ssid.size());
-    mNetwork.connected = false;
-    mNetwork.saved     = false;
-    mNetwork.count     = 1;
+    memcpy(mStagingNetwork.ssid, ssid.data(), ssid.size());
+    mStagingNetwork.ssidLen = static_cast<decltype(mStagingNetwork.ssidLen)>(ssid.size());
 
     return Status::kSuccess;
 }
@@ -164,10 +148,10 @@ Status BekenWiFiDriver::RemoveNetwork(ByteSpan networkId, MutableCharSpan & outD
 
     outDebugText.reduce_size(0);
     outNetworkIndex = 0;
-    VerifyOrReturnError(NetworkMatch(mNetwork, networkId), Status::kNetworkIDNotFound);
+    VerifyOrReturnError(NetworkMatch(mStagingNetwork, networkId), Status::kNetworkIDNotFound);
 
     // Use empty ssid for representing invalid network
-    mNetwork.count = 0;
+    mStagingNetwork.ssidLen = 0;
     return Status::kSuccess;
 }
 
@@ -177,105 +161,81 @@ Status BekenWiFiDriver::ReorderNetwork(ByteSpan networkId, uint8_t index, Mutabl
     // Only one network is supported now
     outDebugText.reduce_size(0);
     VerifyOrReturnError(index == 0, Status::kOutOfRange);
-    VerifyOrReturnError(NetworkMatch(mNetwork, networkId), Status::kNetworkIDNotFound);
+    VerifyOrReturnError(NetworkMatch(mStagingNetwork, networkId), Status::kNetworkIDNotFound);
     return Status::kSuccess;
 }
 
-CHIP_ERROR BekenWiFiDriver::ConnectWiFiNetwork()
+CHIP_ERROR BekenWiFiDriver::ConnectWiFiNetwork(const char * ssid, uint8_t ssidLen, const char * key, uint8_t keyLen)
 {
-    if (mNetwork.count == 0)
-    {
-        CHIP_ERROR err = CHIP_NO_ERROR;
-        size_t ssidLen        = 0;
-        size_t credentialsLen = 0;
-
-        err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiCredentialsKeyName, mNetwork.credentials, sizeof(mNetwork.credentials),
-                                                       &credentialsLen);
-        if (err == CHIP_NO_ERROR)
-        {
-            err = PersistedStorage::KeyValueStoreMgr().Get(kWiFiSSIDKeyName, mNetwork.ssid, sizeof(mNetwork.ssid), &ssidLen);
-        }
-        if (err != CHIP_NO_ERROR)
-        {
-            mNetwork.credentialsLen = 0;
-            mNetwork.ssidLen        = 0;
-            mNetwork.connected      = false;
-            mNetwork.saved          = false;
-            mNetwork.count          = 0;
-        }
-        else
-        {
-            mNetwork.credentialsLen = credentialsLen;
-            mNetwork.ssidLen        = ssidLen;
-            mNetwork.connected      = false;
-            mNetwork.saved          = true;
-            mNetwork.count          = 1;
-        }
-    }
-    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::ConnectWiFiNetwork ssid:%s", mNetwork.ssid);
-    ReturnErrorOnFailure(ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled));
+    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::ConnectWiFiNetwork....ssid:%s", ssid);
 
     network_InitTypeDef_st network_cfg;
 
     memset(&network_cfg, 0, sizeof(network_InitTypeDef_st));
 
     network_cfg.wifi_mode = BK_STATION;
-    memcpy(network_cfg.wifi_ssid, mNetwork.ssid, mNetwork.ssidLen);
-    memcpy(network_cfg.wifi_key, mNetwork.credentials, mNetwork.credentialsLen);
+    memcpy(network_cfg.wifi_ssid, ssid, ssidLen);
+    memcpy(network_cfg.wifi_key, key, keyLen);
     network_cfg.dhcp_mode = DHCP_CLIENT;
     bk_wlan_start(&network_cfg);
-
+	
     return CHIP_NO_ERROR;
 }
 
-void BekenWiFiDriver::OnConnectWiFiNetwork(Status commissioningError, CharSpan debugText, int32_t interfaceStatus)
+void BekenWiFiDriver::OnConnectWiFiNetwork()
 {
-    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::OnConnectWiFiNetwork");
-    if (ConnectivityMgr().IsWiFiStationConnected())
+    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::OnConnectWiFiNetwork\r\n");
+    if (mpConnectCallback)
     {
-        mNetwork.connected = true;
-    }
-    else
-    {
-        mNetwork.connected = false;
-    }
-    if (mpConnectCallback != nullptr)
-    {
-        mpConnectCallback->OnResult(commissioningError, debugText, interfaceStatus);
+        if (ConnectivityMgr().IsWiFiStationConnected())
+        {
+            mpConnectCallback->OnResult(Status::kSuccess, CharSpan(), 0);
+        }
+        else
+        {
+            mpConnectCallback->OnResult(Status::kUnknownError, CharSpan(), 0);
+        }
         mpConnectCallback = nullptr;
     }
-    else
-    {
-        ChipLogError(NetworkProvisioning, "mpConnectCallback is null");
-    }
 }
 
 void BekenWiFiDriver::ConnectNetwork(ByteSpan networkId, ConnectCallback * callback)
 {
-    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::ConnectNetwork");
+    ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::ConnectNetwork\r\n");
     CHIP_ERROR err          = CHIP_NO_ERROR;
     Status networkingStatus = Status::kSuccess;
 
-    VerifyOrExit(NetworkMatch(mNetwork, networkId), networkingStatus = Status::kNetworkIDNotFound);
+    VerifyOrExit(NetworkMatch(mStagingNetwork, networkId), networkingStatus = Status::kNetworkIDNotFound);
     VerifyOrExit(mpConnectCallback == nullptr, networkingStatus = Status::kUnknownError);
 
-    ConnectWiFiNetwork();
+    ConnectivityMgr().SetWiFiStationMode(ConnectivityManager::kWiFiStationMode_Enabled);
+    err               = ConnectWiFiNetwork(reinterpret_cast<const char *>(mStagingNetwork.ssid), mStagingNetwork.ssidLen,
+                             reinterpret_cast<const char *>(mStagingNetwork.credentials), mStagingNetwork.credentialsLen);
     mpConnectCallback = callback;
-    return;
 exit:
-    mpConnectCallback->OnResult(networkingStatus, CharSpan::fromCharString("id not found"), 0);
-    mpConnectCallback = nullptr;
+    if (err != CHIP_NO_ERROR)
+    {
+        networkingStatus = Status::kUnknownError;
+    }
+    if (networkingStatus != Status::kSuccess)
+    {
+        ChipLogError(NetworkProvisioning, "Failed to connect to WiFi network:%s", chip::ErrorStr(err));
+        mpConnectCallback = nullptr;
+        //chip::DeviceLayer::PlatformMgr().LockChipStack();
+        callback->OnResult(networkingStatus, CharSpan(), 0);
+        //chip::DeviceLayer::PlatformMgr().UnlockChipStack();
+    }
 }
 
 CHIP_ERROR GetConnectedNetwork(Network & network)
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::GetConnectedNetwork\r\n");
-    LinkStatusTypeDef wifi_setting = { 0 };
+    LinkStatusTypeDef wifi_setting={0};
     bk_wlan_get_link_status(&wifi_setting);
     uint8_t length = strnlen(reinterpret_cast<const char *>(wifi_setting.ssid), DeviceLayer::Internal::kMaxWiFiSSIDLength);
     memcpy(network.networkID, wifi_setting.ssid, length);
-    ChipLogProgress(NetworkProvisioning, "networkID:[%s][%d]\r\n", network.networkID, length);
-    network.networkIDLen = length; // yellan sizeof(network.networkID);
+    ChipLogProgress(NetworkProvisioning, "networkID:[%s][%d]\r\n",network.networkID,length);
+    network.networkIDLen = length;//yellan sizeof(network.networkID);
     return CHIP_NO_ERROR;
 }
 
@@ -300,7 +260,9 @@ void BekenWiFiDriver::OnNetworkStatusChange()
 
 CHIP_ERROR BekenWiFiDriver::SetLastDisconnectReason(const ChipDeviceEvent * event)
 {
-    // TODO Set from ConnectivityMgrImpl
+    //VerifyOrReturnError(event->Type == DeviceEventType::kRtkWiFiStationDisconnectedEvent, CHIP_ERROR_INVALID_ARGUMENT);
+    //mLastDisconnectedReason = wifi_get_last_error();
+    //TODO
     return CHIP_NO_ERROR;
 }
 
@@ -312,19 +274,19 @@ int32_t BekenWiFiDriver::GetLastDisconnectReason()
 CHIP_ERROR BekenWiFiDriver::StartScanWiFiNetworks(ByteSpan ssid)
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::StartScanWiFiNetworks\r\n");
-    CHIP_ERROR err = CHIP_NO_ERROR;
-    if (ssid.data()) // directed scanning
+    CHIP_ERROR err          = CHIP_NO_ERROR;
+    if (ssid.data())//directed scanning
     {
-        uint8_t * ssid_array = (uint8_t *) malloc(sizeof(uint8_t) * (ssid.size() + 1));
+        uint8_t *ssid_array = (uint8_t *)malloc(sizeof(uint8_t)*(ssid.size()+1));
         memcpy(ssid_array, ssid.data(), ssid.size());
         ssid_array[ssid.size()] = '\0';
         ChipLogProgress(NetworkProvisioning, "directed scanning... ssid:[%s]; %d\r\n", ssid_array, ssid.size());
         bk_wlan_start_assign_scan(&ssid_array, 1);
         free(ssid_array);
     }
-    else // non-directed scanning
+    else//non-directed scanning
     {
-        ChipLogProgress(NetworkProvisioning, "non-directed scanning...\r\n");
+        ChipLogProgress(NetworkProvisioning, "non-directed scanning...\r\n" );
         bk_wlan_start_scan();
     }
     return CHIP_NO_ERROR;
@@ -333,14 +295,13 @@ CHIP_ERROR BekenWiFiDriver::StartScanWiFiNetworks(ByteSpan ssid)
 void BekenWiFiDriver::OnScanWiFiNetworkDone()
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::OnScanWiFiNetworkDone\r\n");
-    ScanResult_adv apList = { 0 }; // yellan 20220919
-    int scan_rst_ap_num   = 0;
-    if (wlan_sta_scan_result(&apList) == 0)
-    {
+    ScanResult_adv apList={0};//yellan 20220919
+    int scan_rst_ap_num = 0;
+    if (wlan_sta_scan_result(&apList) == 0) {
         scan_rst_ap_num = apList.ApNum;
-        ChipLogProgress(NetworkProvisioning, "Got ap count: %d\r\n", apList.ApNum);
+		ChipLogProgress(NetworkProvisioning,"Got ap count: %d\r\n", apList.ApNum);
     }
-    if (scan_rst_ap_num == 0)
+    if(scan_rst_ap_num == 0)
     {
         os_printf("NULL AP\r\n");
         GetInstance().mpScanCallback->OnFinished(Status::kSuccess, CharSpan(), nullptr);
@@ -359,10 +320,11 @@ void BekenWiFiDriver::OnScanWiFiNetworkDone()
     }
 }
 
-void scan_ap_cb(void * ctxt, uint8_t param)
+void scan_ap_cb(void *ctxt, uint8_t param)
 {
-    DeviceLayer::SystemLayer().ScheduleLambda(
-        []() { NetworkCommissioning::BekenWiFiDriver::GetInstance().OnScanWiFiNetworkDone(); });
+    DeviceLayer::SystemLayer().ScheduleLambda([]() {
+        NetworkCommissioning::BekenWiFiDriver::GetInstance().OnScanWiFiNetworkDone();
+    });
 }
 
 void BekenWiFiDriver::ScanNetworks(ByteSpan ssid, WiFiDriver::ScanCallback * callback)
@@ -380,33 +342,34 @@ void BekenWiFiDriver::ScanNetworks(ByteSpan ssid, WiFiDriver::ScanCallback * cal
     }
 }
 
-BekenWiFiDriver::WiFiNetworkIterator::WiFiNetworkIterator(BekenWiFiDriver * aDriver)
-{
-    mDriver = aDriver;
-    index   = 0;
-}
-
 size_t BekenWiFiDriver::WiFiNetworkIterator::Count()
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::WiFiNetworkIterator::Count\r\n");
-    return mDriver->mNetwork.count;
+    return mDriver->mStagingNetwork.ssidLen == 0 ? 0 : 1;
 }
 
 bool BekenWiFiDriver::WiFiNetworkIterator::Next(Network & item)
 {
     ChipLogProgress(NetworkProvisioning, "BekenWiFiDriver::WiFiNetworkIterator::Next\r\n");
-    if (index < mDriver->mNetwork.count)
+    if (mExhausted || mDriver->mStagingNetwork.ssidLen == 0)
     {
-        memcpy(item.networkID, mDriver->mNetwork.ssid, mDriver->mNetwork.ssidLen);
-        item.networkIDLen = mDriver->mNetwork.ssidLen;
-        item.connected    = mDriver->mNetwork.connected;
-        index++;
-        return true;
+        return false;
     }
-    else
+    memcpy(item.networkID, mDriver->mStagingNetwork.ssid, mDriver->mStagingNetwork.ssidLen);
+    item.networkIDLen = mDriver->mStagingNetwork.ssidLen;
+    item.connected    = false;
+    mExhausted        = true;
+    Network connectedNetwork={0};
+    CHIP_ERROR err = GetConnectedNetwork(connectedNetwork);
+    if (err == CHIP_NO_ERROR)
     {
-        return false;
+        if (connectedNetwork.networkIDLen == item.networkIDLen &&
+            memcmp(connectedNetwork.networkID, item.networkID, item.networkIDLen) == 0)
+        {
+            item.connected = true;
+        }
     }
+    return true;
 }
 
 } // namespace NetworkCommissioning