diff --git a/wifi/interfaces/inner_api/wifi_msg.h b/wifi/interfaces/inner_api/wifi_msg.h
index 2ef7adb1a7964600c26607dccacb8893a80915a0..6c005c50177cd9a6fad130861ff289a08fd70e75 100644
--- a/wifi/interfaces/inner_api/wifi_msg.h
+++ b/wifi/interfaces/inner_api/wifi_msg.h
@@ -79,6 +79,15 @@ inline const std::string EAP_METHOD_AKA_PRIME = "AKA'";
 
 inline const int INVALID_NETWORK_SELECTION_DISABLE_TIMESTAMP = -1;
 
+enum SigLevel {
+    SIG_LEVEL_0 = 0,
+    SIG_LEVEL_1 = 1,
+    SIG_LEVEL_2 = 2,
+    SIG_LEVEL_3 = 3,
+    SIG_LEVEL_4 = 4,
+    SIG_LEVEL_MAX = 4,
+};
+
 enum WifiRestrictedType {
     MDM_BLOCKLIST = 0,
     MDM_WHITELIST = 1,
diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.cpp
index 232d9a500947df7b155f224fb16d81e5c55a9a85..617c1f277ded0dcde3cb437ca9cdafdb64eff8a8 100644
--- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.cpp
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.cpp
@@ -19,6 +19,8 @@
 #include "wifi_logger.h"
 #include "wifi_service_manager.h"
 #include "wifi_hisysevent.h"
+#include "wifi_settings.h"
+#include "wifi_config_center.h"
 #include <mutex>
 
 namespace OHOS {
@@ -34,9 +36,13 @@ constexpr int MIN_RSSI_VALUE_24G = -80;
 constexpr int MIN_RSSI_VALUE_5G = -77;
 constexpr int MIN_RSSI_VALUE_OUTDOOR_24G = -75;
 constexpr int MIN_RSSI_VALUE_OUTDOOR_5G = -72;
+constexpr int CONN_RSSI_CNT = 10;
 
 WifiSensorScene::WifiSensorScene() : scenario_(SCENARIO_UNKNOWN),
-    minRssi24G_(MIN_RSSI_VALUE_24G), minRssi5G_(MIN_RSSI_VALUE_5G) {}
+    minRssi24G_(MIN_RSSI_VALUE_24G), minRssi5G_(MIN_RSSI_VALUE_5G)
+{
+    InitCallback();
+}
 
 WifiSensorScene &WifiSensorScene::GetInstance()
 {
@@ -49,6 +55,93 @@ void WifiSensorScene::Init()
     RegisterSensorEnhCallback();
 }
 
+void WifiSensorScene::InitCallback()
+{
+    using namespace std::placeholders;
+    WIFI_LOGI("Enter InitCallback");
+    staCallback_.callbackModuleName = "WifiSensorScene";
+    staCallback_.OnStaConnChanged = [this](OperateResState state, const WifiLinkedInfo &linkedInfo, int32_t instId) {
+        this->DealStaConnChanged(state, linkedInfo, instId);
+    };
+    staCallback_.OnWifiHalSignalInfoChange = [this](const WifiSignalPollInfo &wifiSignalPollInfo) {
+        this->HandleSignalInfoChange(wifiSignalPollInfo);
+    };
+}
+
+void WifiSensorScene::DealStaConnChanged(OperateResState state, const WifiLinkedInfo &info, int instId)
+{
+    std::lock_guard<std::mutex> lock(staCbMutex_);
+    if (instId != INSTID_WLAN0 || info.networkId == INVALID_NETWORK_ID || info.bssid.empty() ||
+        (state != OperateResState::DISCONNECT_DISCONNECTED && state != OperateResState::CONNECT_AP_CONNECTED)) {
+        return;
+    }
+    if (state == OperateResState::DISCONNECT_DISCONNECTED) {
+        if (rssiCnt_ < CONN_RSSI_CNT) {
+            ReportLinkedQuality(0);
+        }
+        connScene_ = UNKNOW_SCENE;
+        rssiCnt_ = 0;
+        reportRssi_ = 0;
+        return;
+    }
+    IsOutdoorScene() ? connScene_ = OUTDOOR_SCENE : connScene_ = INDOOR_SCENE;
+}
+
+void WifiSensorScene::HandleSignalInfoChange(const WifiSignalPollInfo &wifiSignalPollInfo)
+{
+    WIFI_LOGD("Enter HandleSignalInfoChange");
+    std::lock_guard<std::mutex> lock(staCbMutex_);
+    if (rssiCnt_ == CONN_RSSI_CNT) {
+        ReportLinkedQuality(reportRssi_);
+    }
+    if (rssiCnt_ > CONN_RSSI_CNT) {
+        WIFI_LOGD("Current link has collected rssi data");
+        return;
+    }
+    rssiCnt_++;
+    reportRssi_ = wifiSignalPollInfo.signal < reportRssi_ ? wifiSignalPollInfo.signal : reportRssi_;
+}
+
+StaServiceCallback WifiSensorScene::GetStaCallback() const
+{
+    return staCallback_;
+}
+
+void WifiSensorScene::ReportLinkedQuality(int32_t rssi, int32_t instId)
+{
+    IodStatisticInfo iodStatisticInfo;
+    if (rssi == 0) {
+        WIFI_LOGI("Connection duration is short, connScene_: %{public}d", connScene_);
+        connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnShortTime++ : iodStatisticInfo.indoorConnShortTime++;
+        return;
+    }
+    WifiLinkedInfo linkedInfo;
+    WifiConfigCenter::GetInstance().GetLinkedInfo(linkedInfo);
+    int32_t signalLevel = WifiSettings::GetInstance().GetSignalLevel(rssi, linkedInfo.band, instId);
+    WIFI_LOGI("ReportLinkedQuality, connScene_: %{public}d, signalLevel: %{public}d", connScene_, signalLevel);
+    switch (signalLevel) {
+        case SIG_LEVEL_0:
+            connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnLevel0++ : iodStatisticInfo.indoorConnLevel0++;
+            break;
+        case SIG_LEVEL_1:
+            connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnLevel1++ : iodStatisticInfo.indoorConnLevel1++;
+            break;
+        case SIG_LEVEL_2:
+            connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnLevel2++ : iodStatisticInfo.indoorConnLevel2++;
+            break;
+        case SIG_LEVEL_3:
+            connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnLevel3++ : iodStatisticInfo.indoorConnLevel3++;
+            break;
+        case SIG_LEVEL_4:
+            connScene_ == OUTDOOR_SCENE ? iodStatisticInfo.outdoorConnLevel4++ : iodStatisticInfo.indoorConnLevel4++;
+            break;
+        default:
+            WIFI_LOGE("Invalid signal level");
+            break;
+    }
+    WriteIodHiSysEvent(iodStatisticInfo);
+}
+
 int WifiSensorScene::GetMinRssiThres(int frequency)
 {
     std::lock_guard<std::mutex> lock(mutex_);
@@ -61,7 +154,6 @@ int WifiSensorScene::GetMinRssiThres(int frequency)
         minRssi5G_ = MIN_RSSI_VALUE_5G;
     }
     int minRssi = frequency < MIN_5GHZ_BAND_FREQUENCY ? minRssi24G_ : minRssi5G_;
-    WIFI_LOGI("%{public}s scene %{public}d thres %{public}d", __FUNCTION__, scenario_, minRssi);
     return minRssi;
 }
 
diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.h
index bd62c3131876706c20d56134b6520d52cad74353..18ace0e4b8ecca2ee6a6afaf99d20ee9c4069c38 100644
--- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.h
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_common/wifi_sensor_scene.h
@@ -17,10 +17,17 @@
 #define OHOS_WIFI_SENSOR_SCENE_H
 
 #include <mutex>
+#include "sta_service_callback.h"
 
 namespace OHOS {
 namespace Wifi {
 
+enum ConnScene {
+    UNKNOW_SCENE = 0,
+    OUTDOOR_SCENE = 1,
+    INDOOR_SCENE = 2,
+};
+
 class WifiSensorScene {
 public:
     WifiSensorScene();
@@ -31,16 +38,27 @@ public:
     void Init();
     int GetMinRssiThres(int frequency);
     bool IsOutdoorScene();
+    StaServiceCallback GetStaCallback() const;
 private:
     void RegisterSensorEnhCallback();
     void SensorEnhCallback(int scenario);
+    void InitCallback();
+    void DealStaConnChanged(OperateResState state, const WifiLinkedInfo &info, int instId);
+    void HandleSignalInfoChange(const WifiSignalPollInfo &wifiSignalPollInfo);
+    void ReportLinkedQuality(int32_t rssi, int32_t instId = 0);
 
 private:
     std::mutex mutex_;
+    std::mutex staCbMutex_;
     int scenario_;
 
     int minRssi24G_;
     int minRssi5G_;
+
+    int rssiCnt_ = 0;
+    int connScene_ = UNKNOW_SCENE;
+    int reportRssi_ = 0;
+    StaServiceCallback staCallback_;
 };
 
 }  // namespace Wifi
diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp
index db3e7a9442c0f8122a18c96c203d5414f3456a27..ee6f2838e49d7c237e26f6e736b3ae0638ccc52c 100644
--- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_controller/wifi_service_scheduler.cpp
@@ -42,6 +42,7 @@
 #include "hal_device_manage.h"
 #endif
 #include "wifi_global_func.h"
+#include "wifi_sensor_scene.h"
 
 namespace OHOS {
 namespace Wifi {
@@ -592,6 +593,10 @@ ErrCode WifiServiceScheduler::InitStaServiceExtral(IStaService *pService, int in
         return WIFI_OPT_FAILED;
     }
 #endif
+    errCode = pService->RegisterStaServiceCallback(WifiSensorScene::GetInstance().GetStaCallback());
+    if (errCode != WIFI_OPT_SUCCESS) {
+        WIFI_LOGI("WifiSensorScene register sta service callback failed, ret=%{public}d!", static_cast<int>(errCode));
+    }
 #endif
     return WIFI_OPT_SUCCESS;
 }
diff --git a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h
index 15352391a0faa7c6686c466e8dfb58edbf907b1d..64fa54ef648a02af34ea56408aac687ec9e546af 100644
--- a/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h
+++ b/wifi/services/wifi_standard/wifi_framework/wifi_manage/wifi_pro/wifi_pro_common.h
@@ -56,15 +56,6 @@ enum WifiProCommond {
     EVENT_CONFIGURATION_CHANGED = 27,
 };
 
-enum SigLevel {
-    SIG_LEVEL_0 = 0,
-    SIG_LEVEL_1 = 1,
-    SIG_LEVEL_2 = 2,
-    SIG_LEVEL_3 = 3,
-    SIG_LEVEL_4 = 4,
-    SIG_LEVEL_MAX = 4,
-};
-
 inline const int32_t QUICK_SCAN_INTERVAL[NUM_5] = { 10000, 10000, 15000, 30000, 30000};
 inline const int32_t NORMAL_SCAN_INTERVAL[NUM_5] = { 15000, 15000, 30000, 60000, 60000};
 inline const int32_t QUICK_SCAN_MAX_COUNTER[NUM_5] = { 20, 20, 10, 10, 10};
diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn
index 6990a40e91828ee68409ca38be2edae8626677ef..12c75d18101e78a05fbaee85ddbfe7132b70584a 100644
--- a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn
+++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/BUILD.gn
@@ -128,6 +128,7 @@ ohos_unittest("manager_unittest") {
     "common/wifi_protect_test.cpp",
     "common/wifi_rdb_manager_test.cpp",
     "common/wifi_system_timer_test.cpp",
+    "common/wifi_sensor_scene_test.cpp",
     "mock_wifi_system_ability_listerner.cpp",
     "wifi_manager_test.cpp",
     "wifi_service_manager_test.cpp",
diff --git a/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/common/wifi_sensor_scene_test.cpp b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/common/wifi_sensor_scene_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a674b92999baeeac6b1882a6993fdab938513ce1
--- /dev/null
+++ b/wifi/test/wifi_standard/wifi_framework/wifi_manage/unittest/common/wifi_sensor_scene_test.cpp
@@ -0,0 +1,121 @@
+/*
+ * Copyright (C) 2025 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 <gtest/gtest.h>
+#include "wifi_sensor_scene.h"
+
+using ::testing::ext::TestSize;
+
+namespace OHOS {
+namespace Wifi {
+
+static std::string g_errLog = "wifiSensorTest";
+
+class WifiSensorSceneTest : public testing::Test {
+public:
+    static void SetUpTestCase() {}
+    static void TearDownTestCase() {}
+    virtual void SetUp() {}
+    virtual void TearDown() {}
+};
+
+HWTEST_F(WifiSensorSceneTest, InitTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().Init();
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, InitCallbackTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().InitCallback();
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, ReportLinkedQualityTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().ReportLinkedQuality(-60, 0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, ReportLinkedQualityTest02, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().ReportLinkedQuality(-73, 0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, ReportLinkedQualityTest03, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().ReportLinkedQuality(-80, 0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, ReportLinkedQualityTest04, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().ReportLinkedQuality(-86, 0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, ReportLinkedQualityTest05, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().ReportLinkedQuality(-90, 0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, GetMinRssiThresTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().GetMinRssiThres(2480);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, GetMinRssiThresTest02, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().GetMinRssiThres(5180);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, SensorEnhCallbackTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().scenario_ = -1;
+    WifiSensorScene::GetInstance().SensorEnhCallback(-1);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, SensorEnhCallbackTest02, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().scenario_ = -1;
+    WifiSensorScene::GetInstance().SensorEnhCallback(1);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, SensorEnhCallbackTest03, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().scenario_ = -1;
+    WifiSensorScene::GetInstance().SensorEnhCallback(0);
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, RegisterSensorEnhCallbackTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().RegisterSensorEnhCallback();
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+
+HWTEST_F(WifiSensorSceneTest, IsOutdoorSceneTest01, TestSize.Level1)
+{
+    WifiSensorScene::GetInstance().IsOutdoorScene();
+    EXPECT_FALSE(g_errLog.find("service is null") != std::string::npos);
+}
+}
+}
\ No newline at end of file
diff --git a/wifi/utils/inc/wifi_hisysevent.h b/wifi/utils/inc/wifi_hisysevent.h
index 837a153c403ee77e6765b913324d0db7b5cc0b7b..25be062a0803254e356e2fa33fdfa668685d73e6 100644
--- a/wifi/utils/inc/wifi_hisysevent.h
+++ b/wifi/utils/inc/wifi_hisysevent.h
@@ -123,6 +123,18 @@ struct IodStatisticInfo {
     int32_t out2InCnt = 0;
     int32_t outdoorFilterCnt = 0;
     int32_t outdoorAutoSelectCnt = 0;
+    int32_t outdoorConnLevel0 = 0;
+    int32_t outdoorConnLevel1 = 0;
+    int32_t outdoorConnLevel2 = 0;
+    int32_t outdoorConnLevel3 = 0;
+    int32_t outdoorConnLevel4 = 0;
+    int32_t indoorConnLevel0 = 0;
+    int32_t indoorConnLevel1 = 0;
+    int32_t indoorConnLevel2 = 0;
+    int32_t indoorConnLevel3 = 0;
+    int32_t indoorConnLevel4 = 0;
+    int32_t outdoorConnShortTime = 0;
+    int32_t indoorConnShortTime = 0;
 };
 
 void WriteWifiStateHiSysEvent(const std::string& serviceType, WifiOperType operType);
diff --git a/wifi/utils/src/wifi_hisysevent.cpp b/wifi/utils/src/wifi_hisysevent.cpp
index 3418dca71a01c5d41120cf61721d3471e3cb5324..2702f6359904200a3991ee22bef0d20d80fcc080 100644
--- a/wifi/utils/src/wifi_hisysevent.cpp
+++ b/wifi/utils/src/wifi_hisysevent.cpp
@@ -519,10 +519,23 @@ void WriteIodHiSysEvent(const IodStatisticInfo &iodStatisticInfo)
 {
     Json::Value root;
     Json::FastWriter writer;
-    root["OUTDOORFILTERCNT"] = iodStatisticInfo.outdoorFilterCnt;
-    root["OUTDOORSELECTWIFICNT"] = iodStatisticInfo.outdoorAutoSelectCnt;
-    root["INTOOUTDOORCNT"] = iodStatisticInfo.in2OutCnt;
-    root["OUTTOINDOORCNT"] = iodStatisticInfo.out2InCnt;
+    root["OUTDOOR_FILTER_CNT"] = iodStatisticInfo.outdoorFilterCnt;
+    root["OUTDOOR_SELECT_WIFI_CNT"] = iodStatisticInfo.outdoorAutoSelectCnt;
+    root["IN_TO_OUTDOOR_CNT"] = iodStatisticInfo.in2OutCnt;
+    root["OUT_TO_INDOOR_CNT"] = iodStatisticInfo.out2InCnt;
+    root["OUTDOOR_CONN_LEVEL0"] = iodStatisticInfo.outdoorConnLevel0;
+    root["OUTDOOR_CONN_LEVEL1"] = iodStatisticInfo.outdoorConnLevel1;
+    root["OUTDOOR_CONN_LEVEL2"] = iodStatisticInfo.outdoorConnLevel2;
+    root["OUTDOOR_CONN_LEVEL3"] = iodStatisticInfo.outdoorConnLevel3;
+    root["OUTDOOR_CONN_LEVEL4"] = iodStatisticInfo.outdoorConnLevel4;
+    root["INDOOR_CONN_LEVEL0"] = iodStatisticInfo.indoorConnLevel0;
+    root["INDOOR_CONN_LEVEL1"] = iodStatisticInfo.indoorConnLevel1;
+    root["INDOOR_CONN_LEVEL2"] = iodStatisticInfo.indoorConnLevel2;
+    root["INDOOR_CONN_LEVEL3"] = iodStatisticInfo.indoorConnLevel3;
+    root["INDOOR_CONN_LEVEL4"] = iodStatisticInfo.indoorConnLevel4;
+    root["OUTDOOR_CONN_SHORT"] = iodStatisticInfo.outdoorConnShortTime;
+    root["INDOOR_CONN_SHORT"] = iodStatisticInfo.indoorConnShortTime;
+    
     WriteEvent("WIFI_CHR_EVENT", "EVENT_NAME", "WIFI_IOD_STATISTIC", "EVENT_VALUE", writer.write(root));
 }
 }  // namespace Wifi