diff --git a/interfaces/innerkits/wm/window.h b/interfaces/innerkits/wm/window.h
index 2703d12b8de3b775841a98374eccdea81a74d7b8..d83a8379149c32fc39d756ab49d026f731ca0071 100644
--- a/interfaces/innerkits/wm/window.h
+++ b/interfaces/innerkits/wm/window.h
@@ -1376,6 +1376,13 @@ public:
      * @return True means floating window of app type, false means the opposite.
      */
     virtual bool IsFloatingWindowAppType() const { return false; }
+
+    /**
+     * @brief Is current window immersive or not.
+     *
+     * @return True means current app window is immersive, false means the opposite.
+     */
+    virtual bool IsImmersiveFullScreen() const { return false; }
 };
 }
 }
diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp b/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp
index 7f7feaa3089d466160d4b9f5fc3df2cb20ae340b..7f1dd8cbdc2d65368fdb25ceed7bc33414254fc8 100644
--- a/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp
+++ b/interfaces/kits/napi/window_runtime/window_napi/js_window.cpp
@@ -456,6 +456,13 @@ napi_value JsWindow::HideNonSystemFloatingWindows(napi_env env, napi_callback_in
     return (me != nullptr) ? me->OnHideNonSystemFloatingWindows(env, info) : nullptr;
 }
 
+napi_value JsWindow::IsImmersiveFullScreen(napi_env env, napi_callback_info info)
+{
+    WLOGI("IsImmersiveFullScreen");
+    JsWindow* me = CheckParamsAndGetThis<JsWindow>(env, info);
+    return (me != nullptr) ? me->OnIsImmersiveFullScreen(env, info) : nullptr;
+}
+
 napi_value JsWindow::SetWindowTouchable(napi_env env, napi_callback_info info)
 {
     WLOGI("SetTouchable");
@@ -3234,6 +3241,82 @@ napi_value JsWindow::OnRaiseAboveTarget(napi_env env, napi_callback_info info)
     return result;
 }
 
+napi_value JsWindow::OnIsImmersiveFullScreen(napi_env env, napi_callback_info info)
+{
+    WMError errCode = WMError::WM_OK;
+    size_t argc = 4;
+    napi_value argv[4] = {nullptr};
+    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+    if (argc > 1) {
+        WLOGFE("Argc is invalid: %{public}zu", argc);
+        errCode = WMError::WM_ERROR_INVALID_PARAM;
+    }
+    wptr<Window> weakToken(windowToken_);
+    NapiAsyncTask::CompleteCallback complete =
+        [weakToken, errCode](napi_env env, NapiAsyncTask& task, int32_t status) {
+            auto weakWindow = weakToken.promote();
+            if (weakWindow == nullptr) {
+                WLOGFE("window is nullptr");
+                task.Reject(env, CreateJsError(env, static_cast<int32_t>(WMError::WM_ERROR_NULLPTR)));
+                return;
+            }
+            if (errCode != WMError::WM_OK) {
+                WLOGFE("window is nullptr or get invalid params");
+                task.Reject(env, CreateJsError(env, static_cast<int32_t>(errCode)));
+                return;
+            }
+
+            bool ret = weakWindow->IsImmersiveFullScreen();
+            task.Resolve(env, CreateJsValue(env, ret));
+            WLOGI("Window [%{public}u, %{public}s]. Judge immersive scene end, ret = %{public}d",
+                weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret);
+        };
+
+    napi_value lastParam = (argc == 0) ? nullptr : (GetType(env, argv[0]) == napi_function ? argv[0] : nullptr);
+    napi_value result = nullptr;
+    NapiAsyncTask::Schedule("JsWindow::OnIsImmersiveFullScreen",
+        env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
+    return result;
+}
+
+napi_value JsWindow::OnIsImmersiveFullScreen(napi_env env, napi_callback_info info)
+{
+    WMError errCode = WMError::WM_OK;
+    size_t argc = 4;
+    napi_value argv[4] = {nullptr};
+    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
+    if (argc > 1) {
+        WLOGFE("Argc is invalid: %{public}zu", argc);
+        errCode = WMError::WM_ERROR_INVALID_PARAM;
+    }
+    wptr<Window> weakToken(windowToken_);
+    NapiAsyncTask::CompleteCallback complete =
+        [weakToken, errCode](napi_env env, NapiAsyncTask& task, int32_t status) {
+            auto weakWindow = weakToken.promote();
+            if (weakWindow == nullptr) {
+                WLOGFE("window is nullptr");
+                task.Reject(env, CreateJsError(env, static_cast<int32_t>(WMError::WM_ERROR_NULLPTR)));
+                return;
+            }
+            if (errCode != WMError::WM_OK) {
+                WLOGFE("window is nullptr or get invalid params");
+                task.Reject(env, CreateJsError(env, static_cast<int32_t>(errCode)));
+                return;
+            }
+
+            bool ret = weakWindow->IsImmersiveFullScreen();
+            task.Resolve(env, CreateJsValue(env, ret));
+            WLOGI("Window [%{public}u, %{public}s]. Judge immersive scene end, ret = %{public}d",
+                weakWindow->GetWindowId(), weakWindow->GetWindowName().c_str(), ret);
+        };
+
+    napi_value lastParam = (argc == 0) ? nullptr : (GetType(env, argv[0]) == napi_function ? argv[0] : nullptr);
+    napi_value result = nullptr;
+    NapiAsyncTask::Schedule("JsWindow::OnIsImmersiveFullScreen",
+        env, CreateAsyncTaskWithLastParam(env, lastParam, nullptr, std::move(complete), &result));
+    return result;
+}
+
 napi_value JsWindow::OnSetWindowTouchable(napi_env env, napi_callback_info info)
 {
     WmErrorCode errCode = WmErrorCode::WM_OK;
@@ -4599,6 +4682,7 @@ void BindFunctions(napi_env env, napi_value object, const char *moduleName)
     BindNativeFunction(env, object, "raiseAboveTarget", moduleName, JsWindow::RaiseAboveTarget);
     BindNativeFunction(env, object, "hideNonSystemFloatingWindows", moduleName,
         JsWindow::HideNonSystemFloatingWindows);
+    BindNativeFunction(env, object, "isImmersiveFullScreen", moduleName, JsWindow::IsImmersiveFullScreen);
 }
 }  // namespace Rosen
 }  // namespace OHOS
diff --git a/interfaces/kits/napi/window_runtime/window_napi/js_window.h b/interfaces/kits/napi/window_runtime/window_napi/js_window.h
index a0b3e7c1b018c467639b5828b733b33e0d107943..6087dfd961d6895c06bd761b1bed8e76aebc79a6 100644
--- a/interfaces/kits/napi/window_runtime/window_napi/js_window.h
+++ b/interfaces/kits/napi/window_runtime/window_napi/js_window.h
@@ -104,6 +104,7 @@ public:
     static napi_value ResetAspectRatio(napi_env env, napi_callback_info info);
     static napi_value Minimize(napi_env env, napi_callback_info info);
     static napi_value RaiseAboveTarget(napi_env env, napi_callback_info info);
+    static napi_value IsImmersiveFullScreen(napi_env env, napi_callback_info info);
 
     // colorspace, gamut
     static napi_value IsSupportWideGamut(napi_env env, napi_callback_info info);
@@ -208,6 +209,7 @@ private:
     napi_value OnSetForbidSplitMove(napi_env env, napi_callback_info info);
     napi_value OnSnapshot(napi_env env, napi_callback_info info);
     napi_value OnSetSnapshotSkip(napi_env env, napi_callback_info info);
+    napi_value OnIsImmersiveFullScreen(napi_env env, napi_callback_info info);
 
     // animation Config
     napi_value OnOpacity(napi_env env, napi_callback_info info);
diff --git a/window_scene/session_manager/include/scene_session_manager.h b/window_scene/session_manager/include/scene_session_manager.h
index 961d028c29d152e2dc93086289774be97ae64c7a..8176ad26a3a47ebdc98051b6b871fe5d15609db3 100644
--- a/window_scene/session_manager/include/scene_session_manager.h
+++ b/window_scene/session_manager/include/scene_session_manager.h
@@ -204,6 +204,7 @@ public:
     sptr<SceneSession> FindSessionByAffinity(std::string affinity);
     void PreloadInLakeApp(const std::string& bundleName);
     void AddWindowDragHotArea(int32_t type, WSRect& area);
+    WSError IsImmersiveFullScreen();
 public:
     std::shared_ptr<TaskScheduler> GetTaskScheduler() {return taskScheduler_;};
 protected:
diff --git a/window_scene/session_manager/include/session_manager.h b/window_scene/session_manager/include/session_manager.h
index ce886417c036f338319ac855b6f71a8eec14d4da..8fdf49aaf6f025c2c10a13f693598bc12c54bdd9 100644
--- a/window_scene/session_manager/include/session_manager.h
+++ b/window_scene/session_manager/include/session_manager.h
@@ -46,6 +46,7 @@ public:
 
     sptr<ISceneSessionManager> GetSceneSessionManagerProxy();
     sptr<IScreenSessionManager> GetScreenSessionManagerProxy();
+    WMError IsImmersiveFullScreen();
 
 protected:
     SessionManager() = default;
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_interface.h b/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
index 36a0f151a8ade76616b6477d72136b5d89025a4f..5fd5f6dd0960e30ae4e57005d3eb967dc708b597 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_interface.h
@@ -87,6 +87,7 @@ public:
         TRANS_ID_REGISTER_COLLABORATOR,
         TRANS_ID_UNREGISTER_COLLABORATOR,
         TRANS_ID_UPDATE_TOUCHOUTSIDE_LISTENER,
+        TRANS_ID_IMMERSIVE_FULLSCREEN,
     };
 
     virtual WSError CreateAndConnectSpecificSession(const sptr<ISessionStage>& sessionStage,
@@ -133,6 +134,7 @@ public:
     virtual WSError RegisterIAbilityManagerCollaborator(int32_t type,
         const sptr<AAFwk::IAbilityManagerCollaborator> &impl) = 0;
     virtual WSError UnregisterIAbilityManagerCollaborator(int32_t type) = 0;
+    virtual WSError IsImmersiveFullScreen() = 0;
     // interfaces of IWindowManager
     WMError CreateWindow(sptr<IWindow>& window, sptr<WindowProperty>& property,
         const std::shared_ptr<RSSurfaceNode>& surfaceNode,
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h b/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
index 46d986824fcc8326dbff25d40fba050f03ebb588..ecb6feafd16824d50bbe46654544cc9bb7a0c6f8 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_proxy.h
@@ -78,6 +78,7 @@ public:
     WSError RegisterIAbilityManagerCollaborator(int32_t type,
         const sptr<AAFwk::IAbilityManagerCollaborator> &impl) override;
     WSError UnregisterIAbilityManagerCollaborator(int32_t type) override;
+    WSError IsImmersiveFullScreen() override;
 
 private:
     template<typename T>
diff --git a/window_scene/session_manager/include/zidl/scene_session_manager_stub.h b/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
index 5be96376e07dab45523d2e9e7c9512cfc4de2196..5d566f18867035ffe28cd51321a5b65803c6afc7 100644
--- a/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
+++ b/window_scene/session_manager/include/zidl/scene_session_manager_stub.h
@@ -77,6 +77,7 @@ private:
     int HandleRegisterCollaborator(MessageParcel &data, MessageParcel &reply);
     int HandleUnregisterCollaborator(MessageParcel &data, MessageParcel &reply);
     int HandleUpdateSessionTouchOutsideListener(MessageParcel& data, MessageParcel& reply);
+    int HandleIsImmersiveFullScreen(MessageParcel &data, MessageParcel &reply);
 };
 } // namespace OHOS::Rosen
 #endif // OHOS_ROSEN_WINDOW_SCENE_SESSION_MANAGER_STUB_H
\ No newline at end of file
diff --git a/window_scene/session_manager/src/scene_session_manager.cpp b/window_scene/session_manager/src/scene_session_manager.cpp
index 8d82ea3076fee299cdb57dd0e3fcc074425b1528..4f9777b42e704d7777b97fbdc94c7440d2c538ae 100644
--- a/window_scene/session_manager/src/scene_session_manager.cpp
+++ b/window_scene/session_manager/src/scene_session_manager.cpp
@@ -740,6 +740,43 @@ std::vector<sptr<SceneSession>> SceneSessionManager::GetSceneSessionVectorByType
     return sceneSessionVector;
 }
 
+WSError SceneSessionManager::IsImmersiveFullScreen() {
+    std::shared_lock<std::shared_mutex> lock(sceneSessionMapMutex_);
+    for (auto item = sceneSessionMap_.begin(); item != sceneSessionMap_.end(); ++item) {
+        auto sceneSession = item->second;
+        if (sceneSession == nullptr) {
+            WLOGFE("Session is nullptr");
+            continue;
+        }
+        auto windowType = sceneSession->GetWindowType();
+        if (!WindowHelper::IsMainWindow(windowType)) {
+            continue;
+        }
+        auto state = sceneSession->GetSessionState();
+        if (state != SessionState::STATE_FOREGROUND && state != SessionState::STATE_ACTIVE) {
+            continue;
+        }
+        auto windowMode = sceneSession->GetWindowMode();
+        if (windowMode != WindowMode::WINDOW_MODE_FULLSCREEN) {
+            continue;
+        }
+        auto property = sceneSession->GetSessionProperty();
+        if (property == nullptr) {
+            WLOGFE("Property is nullptr");
+            continue;
+        }
+        auto sysBarProperty = property->GetSystemBarProperty();
+        if (sysBarProperty[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ == false) {
+            WLOGFD("Current scene is immersive");
+            return WSError::WS_OK;
+        } else {
+            WLOGFD("Current scene is not immersive");
+            return WSError::WS_DO_NOTHING;
+        }
+    }
+    return WSError::WS_DO_NOTHING;
+}
+
 WSError SceneSessionManager::UpdateParentSessionForDialog(const sptr<SceneSession>& sceneSession,
     sptr<WindowSessionProperty> property)
 {
diff --git a/window_scene/session_manager/src/session_manager.cpp b/window_scene/session_manager/src/session_manager.cpp
index e9bfd22c1a7b859044b97682668fb87e43afc5be..e537124e224cc5139be0477e8c4a42e94e4fc410 100644
--- a/window_scene/session_manager/src/session_manager.cpp
+++ b/window_scene/session_manager/src/session_manager.cpp
@@ -240,4 +240,16 @@ WMError SessionManager::BindDialogTarget(uint64_t persistentId, sptr<IRemoteObje
     }
     return static_cast<WMError>(sceneSessionManagerProxy_->BindDialogTarget(persistentId, targetToken));
 }
+
+WMError SessionManager::IsImmersiveFullScreen()
+{
+    WLOGFD("IsImmersiveFullScreen");
+    std::lock_guard<std::recursive_mutex> lock(mutex_);
+    GetSceneSessionManagerProxy();
+    if (!sceneSessionManagerProxy_) {
+        WLOGFE("sceneSessionManagerProxy_ is nullptr");
+        return WMError::WM_DO_NOTHING;
+    }
+    return static_cast<WMError>(sceneSessionManagerProxy_->IsImmersiveFullScreen());
+}
 } // namespace OHOS::Rosen
diff --git a/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp b/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
index 37400a1838f04e51ae614e7fdaf79ce929001755..969b282f2c9b08004188e4123050ea6b0762d2ff 100644
--- a/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
+++ b/window_scene/session_manager/src/zidl/scene_session_manager_proxy.cpp
@@ -171,6 +171,25 @@ WSError SceneSessionManagerProxy::BindDialogTarget(uint64_t persistentId, sptr<I
     return static_cast<WSError>(ret);
 }
 
+WSError SceneSessionManagerProxy::IsImmersiveFullScreen()
+{
+    MessageParcel data;
+    MessageParcel reply;
+    MessageOption option(MessageOption::TF_SYNC);
+    if (!data.WriteInterfaceToken(GetDescriptor())) {
+        WLOGFE("IsImmersiveFullScreen WriteInterfaceToken failed");
+        return WSError::WS_ERROR_IPC_FAILED;
+    }
+
+    if (Remote()->SendRequest(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_IMMERSIVE_FULLSCREEN),
+        data, reply, option) != ERR_NONE) {
+        WLOGFE("SendRequest failed");
+        return WSError::WS_ERROR_IPC_FAILED;
+    }
+    int32_t ret = reply.ReadInt32();
+    return static_cast<WSError>(ret);
+}
+
 WSError SceneSessionManagerProxy::UpdateSessionAvoidAreaListener(int32_t& persistentId, bool haveListener)
 {
     MessageParcel data;
diff --git a/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp b/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
index 4a50038ae4cb0245d423ba2bab964a0b2bb7e66c..65b717dba5bd0e7f9dfab921b23797f225f74017 100644
--- a/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
+++ b/window_scene/session_manager/src/zidl/scene_session_manager_stub.cpp
@@ -113,6 +113,8 @@ const std::map<uint32_t, SceneSessionManagerStubFunc> SceneSessionManagerStub::s
         &SceneSessionManagerStub::HandleUnregisterCollaborator),
     std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_UPDATE_TOUCHOUTSIDE_LISTENER),
         &SceneSessionManagerStub::HandleUpdateSessionTouchOutsideListener),
+    std::make_pair(static_cast<uint32_t>(SceneSessionManagerMessage::TRANS_ID_IMMERSIVE_FULLSCREEN),
+        &SceneSessionManagerStub::HandleIsImmersiveFullScreen),
 };
 
 int SceneSessionManagerStub::OnRemoteRequest(uint32_t code,
@@ -524,6 +526,14 @@ int SceneSessionManagerStub::HandleBindDialogTarget(MessageParcel &data, Message
     return ERR_NONE;
 }
 
+int SceneSessionManagerStub::HandleIsImmersiveFullScreen(MessageParcel &data, MessageParcel &reply)
+{
+    WLOGFI("run HandleIsImmersiveFullScreen!");
+    const WSError& ret = IsImmersiveFullScreen();
+    reply.WriteUint32(static_cast<uint32_t>(ret));
+    return ERR_NONE;
+}
+
 int SceneSessionManagerStub::HandleNotifyDumpInfoResult(MessageParcel &data, MessageParcel &reply)
 {
     WLOGFI("HandleNotifyDumpInfoResult");
diff --git a/wm/include/window_scene_session_impl.h b/wm/include/window_scene_session_impl.h
index 272bdc42ac6e81e44b76d94c246e3358da121a7c..cee01133f762d6b70b87eddd0d5b75dd7a59dbd0 100644
--- a/wm/include/window_scene_session_impl.h
+++ b/wm/include/window_scene_session_impl.h
@@ -76,6 +76,7 @@ public:
     WMError SetLayoutFullScreen(bool status) override;
     WMError SetFullScreen(bool status) override;
     WMError BindDialogTarget(sptr<IRemoteObject> targetToken) override;
+    bool IsImmersiveFullScreen() const override;
     static void UpdateConfigurationForAll(const std::shared_ptr<AppExecFwk::Configuration>& configuration);
     static sptr<Window> GetTopWindowWithContext(const std::shared_ptr<AbilityRuntime::Context>& context = nullptr);
     static sptr<Window> GetTopWindowWithId(uint32_t mainWinId);
diff --git a/wm/src/window_scene_session_impl.cpp b/wm/src/window_scene_session_impl.cpp
index 50da352e2ccb6f0fdb76b2236a7a83128d2f38df..0a9ad9e04bf00ede26987f22173e05f23fbb74c1 100644
--- a/wm/src/window_scene_session_impl.cpp
+++ b/wm/src/window_scene_session_impl.cpp
@@ -1877,6 +1877,15 @@ WMError WindowSceneSessionImpl::BindDialogTarget(sptr<IRemoteObject> targetToken
     return ret;
 }
 
+WMError WindowSceneSessionImpl::IsImmersiveFullScreen()
+{
+    WMError ret = SessionManager::GetInstance().IsImmersiveFullScreen();
+    if (ret != WMError::WM_OK) {
+        WLOGFE("Non immersive scene exists. errCode:%{public}d", static_cast<int32_t>(ret));
+    }
+    return ret;
+}
+
 WMError WindowSceneSessionImpl::SetTouchHotAreas(const std::vector<Rect>& rects)
 {
     if (property_ == nullptr) {