diff --git a/common/include/frame_info_const.h b/common/include/frame_info_const.h
index d1e4bf4dbe2f6efdeafc7d24d06f6aede8a416b1..d525abf0f1ee5d917f6f6d98133021a011558c99 100644
--- a/common/include/frame_info_const.h
+++ b/common/include/frame_info_const.h
@@ -19,30 +19,29 @@
 namespace OHOS {
 namespace RME {
 enum class FrameEvent {
-    FLUSH_ANIMATION,
-    FLUSH_BUILD,
-    FLUSH_LAYOUT,
-    FLUSH_RENDER,
-    FLUSH_RENDER_FINISH, // to add, do not realize
-    PROCESS_POST_FLUSH,
-    PROCESS_COMMANDS,
-    ANIMATE,
-    RENDER,
-    SEND_COMMANDS,
+    EVENT_BEGIN_FRAME,
+    EVENT_FLUSH_ANIMATION_START,
+    EVENT_FLUSH_ANIMATION_END,
+    EVENT_FLUSH_BUILD_START,
+    EVENT_FLUSH_BUILD_END,
+    EVENT_FLUSH_LAYOUT_START,
+    EVENT_FLUSH_LAYOUT_END,
+    EVENT_FLUSH_RENDER_START,
+    EVENT_FLUSH_RENDER_END,
+    EVENT_FLUSH_RENDER_FINISH_START,
+    EVENT_FLUSH_RENDER_FINISH_END,
+    EVENT_PROCESS_POST_FLUSH_START,
+    EVENT_PROCESS_COMMANDS_START,
+    EVENT_ANIMATE_START,
+    EVENT_RENDER_START,
+    EVENT_SEND_COMMANDS_START,
+    EVENT_END_FRAME,
     EVENT_SET_PARAM,
     EVENT_RTG_ENABLE,
     EVENT_BUFFER_COUNT,
     UNKNOWN,
 };
 
-enum class EventState {
-    EVENT_ENTER,
-    EVENT_CONSUMED,
-    EVENT_EXIT,
-    ENABLE,
-    DISABLE,
-};
-
 enum class SceneEvent {
     SCENE_INVALID = 0,
     VIDEO,
diff --git a/frameworks/core/frame_aware_collector/include/frame_msg_mgr.h b/frameworks/core/frame_aware_collector/include/frame_msg_mgr.h
index dfcaef330466321765c1086e43c7e6a387e0dac6..410b3d2a01c00c3fbdd6103b4169ff1f77d15b93 100644
--- a/frameworks/core/frame_aware_collector/include/frame_msg_mgr.h
+++ b/frameworks/core/frame_aware_collector/include/frame_msg_mgr.h
@@ -17,6 +17,7 @@
 #define FRAME_MSG_MGR_H
 
 #include <hilog/log.h>
+#include <map>
 
 #include "rme_log_domain.h"
 #include "frame_info_const.h"
@@ -32,12 +33,36 @@ public:
     FrameMsgMgr();
     ~FrameMsgMgr();
     bool Init();
-    void EventUpdate(FrameEvent eventType, EventState state);
+    void EventUpdate(FrameEvent eventType);
 private:
+    bool HandleFrameMsgKey(FrameEvent event);
+    void FrameMapKeyToFunc();
     void UpdateScene(SceneEvent scene);
-    void HandleDefaultEvent(FrameEvent event, EventState state);
     void SetSchedParam();
+
+    void HandleBeginFrame();
+    void BeginFlushAnimation();
+    void EndFlushAnimation();
+    void BeginFlushBuild();
+    void EndFlushBuild();
+    void BeginFlushLayout();
+    void EndFlushLayout();
+    void BeginFlushRender();
+    void EndFlushRender();
+    void BeginFlushRenderFinish();
+    void EndFlushRenderFinish();
+
+    void BeginProcessPostFlush();
+    void ProcessCommandsStart();
+    void AnimateStart();
+    void RenderStart();
+    void SendCommandsStart();
+    void HandleEndFrame();
+
     FrameSceneSched *GetSceneHandler() const;
+    typedef void (FrameMsgMgr:: *PHandle)(void);
+    std::map<FrameEvent, PHandle> m_frameMsgKeyToFunc;
+
     SceneEvent sceneType;
     RmeSceneSched *rmeScene;
 };
diff --git a/frameworks/core/frame_aware_collector/include/frame_scene_sched.h b/frameworks/core/frame_aware_collector/include/frame_scene_sched.h
index 66ae8f49f0117f4bee9455b571e60b91fdb39b2b..768c55722dc527bb33a1a78395991fdfb7da03d3 100644
--- a/frameworks/core/frame_aware_collector/include/frame_scene_sched.h
+++ b/frameworks/core/frame_aware_collector/include/frame_scene_sched.h
@@ -25,6 +25,8 @@ public:
     FrameSceneSched() {};
     virtual ~FrameSceneSched() = default;
 
+    virtual void HandleBeginFrame() = 0;
+    virtual void HandleEndFrame() = 0;
     virtual void BeginFlushAnimation() = 0;
     virtual void EndFlushAnimation() = 0;
     virtual void BeginFlushBuild() = 0;
diff --git a/frameworks/core/frame_aware_collector/include/rme_core_sched.h b/frameworks/core/frame_aware_collector/include/rme_core_sched.h
index cd9d48fbed9a769e4fcbfb3b0b2c61d70875549b..94afb6746cbef36ea0146787632963aa8daeb05b 100644
--- a/frameworks/core/frame_aware_collector/include/rme_core_sched.h
+++ b/frameworks/core/frame_aware_collector/include/rme_core_sched.h
@@ -28,6 +28,8 @@ public:
     ~RmeCoreSched();
 
     bool Init();
+    void HandleBeginFrame();
+    void HandleEndFrame();
     void BeginFlushAnimation();
     void EndFlushAnimation();
     void BeginFlushBuild();
diff --git a/frameworks/core/frame_aware_collector/include/rme_scene_sched.h b/frameworks/core/frame_aware_collector/include/rme_scene_sched.h
index d94660dc1753c291a6552a205aa22480da6d16c7..e66e702b6e7b5d49e94c41560348212613ead752 100644
--- a/frameworks/core/frame_aware_collector/include/rme_scene_sched.h
+++ b/frameworks/core/frame_aware_collector/include/rme_scene_sched.h
@@ -20,6 +20,8 @@
 #include "frame_window_mgr.h"
 #include "rme_core_sched.h"
 
+#include <string>
+
 namespace OHOS {
 namespace RME {
 class RmeSceneSched : public FrameSceneSched {
@@ -28,6 +30,9 @@ public:
     ~RmeSceneSched() override;
 
     bool Init();
+    void HandleBeginFrame() override;
+    void HandleEndFrame() override;
+
     void BeginFlushAnimation() override;
     void EndFlushAnimation() override;
 
diff --git a/frameworks/core/frame_aware_collector/src/frame_msg_mgr.cpp b/frameworks/core/frame_aware_collector/src/frame_msg_mgr.cpp
index 30964918f6ce97457a3cd9b71296bed66b3ccc64..05c489157d27a6d9067050ef97d671d4146cd484 100644
--- a/frameworks/core/frame_aware_collector/src/frame_msg_mgr.cpp
+++ b/frameworks/core/frame_aware_collector/src/frame_msg_mgr.cpp
@@ -22,7 +22,9 @@ IMPLEMENT_SINGLE_INSTANCE(FrameMsgMgr);
 
 FrameMsgMgr::FrameMsgMgr()
     : sceneType(SceneEvent::SLIDE), rmeScene(nullptr)
-{}
+{
+    FrameMapKeyToFunc();
+}
 
 FrameMsgMgr::~FrameMsgMgr()
 {
@@ -44,17 +46,60 @@ bool FrameMsgMgr::Init()
     return true;
 }
 
-void FrameMsgMgr::EventUpdate(FrameEvent event, EventState value)
+void FrameMsgMgr::EventUpdate(FrameEvent event)
 {
     switch (event) {
         case FrameEvent::EVENT_SET_PARAM:
             SetSchedParam();
             break;
         default:
-            HandleDefaultEvent(event, value);
-            break;    
+            HandleFrameMsgKey(event);
+            break;
+    }
+}
+
+bool FrameMsgMgr::HandleFrameMsgKey(FrameEvent event)
+{
+    std::map<FrameEvent, PHandle>::iterator iter;
+    iter = m_frameMsgKeyToFunc.find(event);
+    if (m_frameMsgKeyToFunc.end() == iter) {
+        RME_LOGE("[HandleFrameMsgKey]: search frameEvent:%{public}d failed!",
+            static_cast<int>(event));
+        return false;
     }
-    return;
+    PHandle pFunction = iter->second;
+    (this->*pFunction)();
+    return true;
+}
+
+void FrameMsgMgr::FrameMapKeyToFunc()
+{
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_BEGIN_FRAME] = &FrameMsgMgr::HandleBeginFrame;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_ANIMATION_START] = &FrameMsgMgr::BeginFlushAnimation;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_ANIMATION_END] = &FrameMsgMgr::EndFlushAnimation;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_BUILD_START] = &FrameMsgMgr::BeginFlushBuild;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_BUILD_END] = &FrameMsgMgr::EndFlushBuild;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_LAYOUT_START] = &FrameMsgMgr::BeginFlushLayout;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_LAYOUT_END] = &FrameMsgMgr::EndFlushLayout;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_RENDER_START] = &FrameMsgMgr::BeginFlushRender;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_RENDER_END] = &FrameMsgMgr::EndFlushRender;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_RENDER_FINISH_START] = &FrameMsgMgr::BeginFlushRenderFinish;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_FLUSH_RENDER_FINISH_END] = &FrameMsgMgr::EndFlushRenderFinish;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_PROCESS_POST_FLUSH_START] = &FrameMsgMgr::BeginProcessPostFlush;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_PROCESS_COMMANDS_START] = &FrameMsgMgr::ProcessCommandsStart;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_ANIMATE_START] = &FrameMsgMgr::AnimateStart;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_RENDER_START] = &FrameMsgMgr::RenderStart;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_SEND_COMMANDS_START] = &FrameMsgMgr::SendCommandsStart;
+    m_frameMsgKeyToFunc[FrameEvent::EVENT_END_FRAME] = &FrameMsgMgr::HandleEndFrame;
+}
+
+FrameSceneSched *FrameMsgMgr::GetSceneHandler() const
+{
+    if (sceneType == SceneEvent::SCENE_INVALID) {
+        RME_LOGE("[GetSceneHandler]:get nullptr sceneType %{public}d,", static_cast<int>(sceneType));
+        return nullptr;
+    }
+    return rmeScene;
 }
 
 void FrameMsgMgr::UpdateScene(SceneEvent scene)
@@ -65,82 +110,180 @@ void FrameMsgMgr::UpdateScene(SceneEvent scene)
     sceneType = scene;
 }
 
-void FrameMsgMgr::HandleDefaultEvent(FrameEvent event, EventState value)
+void FrameMsgMgr::HandleBeginFrame()
 {
+    RME_LOGI("[HandleBeginFrame]:start");
     FrameSceneSched *scene = GetSceneHandler();
     if (scene == nullptr) {
-        RME_LOGE("[HandleDefaultEvent]:scene nullptr");
+        RME_LOGE("[HandleBeginFrame]:scene nullptr");
         return;
     }
-    switch (event) {
-        case FrameEvent::FLUSH_ANIMATION:
-            if (value == EventState::EVENT_ENTER) {
-                scene->BeginFlushAnimation();
-            } else {
-                scene->EndFlushAnimation();
-            }
-            break;
-        case FrameEvent::FLUSH_BUILD:
-            if (value == EventState::EVENT_ENTER) {
-                scene->BeginFlushBuild();
-            } else {
-                scene->EndFlushBuild();
-            }
-            break;
-        case FrameEvent::FLUSH_LAYOUT:
-            if (value == EventState::EVENT_ENTER) {
-                scene->BeginFlushLayout();
-            } else {
-                scene->EndFlushLayout();
-            }
-            break;
-        case FrameEvent::FLUSH_RENDER:
-            if (value == EventState::EVENT_ENTER) {
-                scene->BeginFlushRender();
-            } else {
-                scene->EndFlushRender();
-            }
-            break;
-        case FrameEvent::FLUSH_RENDER_FINISH:
-            if (value == EventState::EVENT_ENTER) {
-                scene->BeginFlushRenderFinish();
-            } else {
-                scene->EndFlushRenderFinish();
-            }
-        case FrameEvent::PROCESS_POST_FLUSH:
-            scene->BeginProcessPostFlush();
-            break;
-        case FrameEvent::PROCESS_COMMANDS:
-            scene->ProcessCommandsStart();
-            break;
-        case FrameEvent::ANIMATE:
-            scene->AnimateStart();
-            break;
-        case FrameEvent::RENDER:
-            scene->RenderStart();
-            break;
-        case FrameEvent::SEND_COMMANDS:
-            scene->SendCommandsStart();
-            break;
-        default:
-            RME_LOGE("[HandleDefaultEvent]: unknown event id: %{public}d, event state:%{public}d\n",
-                static_cast<int>(event), static_cast<int>(value));
-            return;
+    scene->HandleBeginFrame();
+}
+
+void FrameMsgMgr::BeginFlushAnimation()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginFlushAnimation]:scene nullptr");
+        return;
     }
+    scene->BeginFlushAnimation();
 }
 
-void FrameMsgMgr::SetSchedParam()
+void FrameMsgMgr::EndFlushAnimation()
 {
-    RME_LOGI("[SetSchedParam]: set default sched param!");
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[EndFlushAnimation]:scene nullptr");
+        return;
+    }
+    scene->EndFlushAnimation();
 }
 
-FrameSceneSched *FrameMsgMgr::GetSceneHandler() const
+void FrameMsgMgr::BeginFlushBuild()
 {
-    if (sceneType == SceneEvent::SCENE_INVALID) {
-        RME_LOGE("[GetSceneHandler]:get nullptr sceneType %{public}d,", static_cast<int>(sceneType));
-        return nullptr;
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginFlushBuild]:scene nullptr");
+        return;
     }
-    return rmeScene;
+    scene->BeginFlushBuild();
+}
+
+void FrameMsgMgr::EndFlushBuild()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[EndFlushBuild]:scene nullptr");
+        return;
+    }
+    scene->EndFlushBuild();
+}
+
+void FrameMsgMgr::BeginFlushLayout()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginFlushLayout]:scene nullptr");
+        return;
+    }
+    scene->BeginFlushLayout();
+}
+
+void FrameMsgMgr::EndFlushLayout()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[EndFlushLayout]:scene nullptr");
+        return;
+    }
+    scene->EndFlushLayout();
+}
+
+void FrameMsgMgr::BeginFlushRender()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginFlushRender]:scene nullptr");
+        return;
+    }
+    scene->BeginFlushRender();
+}
+
+void FrameMsgMgr::EndFlushRender()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[EndFlushRender]:scene nullptr");
+        return;
+    }
+    scene->EndFlushRender();
+}
+
+void FrameMsgMgr::BeginFlushRenderFinish()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginFlushRenderFinish]:scene nullptr");
+        return;
+    }
+    scene->BeginFlushRenderFinish();
+}
+
+void FrameMsgMgr::EndFlushRenderFinish()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[EndFlushRenderFinish]:scene nullptr");
+        return;
+    }
+    scene->EndFlushRenderFinish();
+}
+
+void FrameMsgMgr::BeginProcessPostFlush()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[BeginProcessPostFlush]:scene nullptr");
+        return;
+    }
+    scene->BeginProcessPostFlush();
+}
+
+void FrameMsgMgr::ProcessCommandsStart()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[ProcessCommandsStart]:scene nullptr");
+        return;
+    }
+    scene->ProcessCommandsStart();
+}
+
+void FrameMsgMgr::AnimateStart()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[AnimateStart]:scene nullptr");
+        return;
+    }
+    scene->AnimateStart();
+}
+
+void FrameMsgMgr::RenderStart()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[RenderStart]:scene nullptr");
+        return;
+    }
+    scene->RenderStart();
+}
+
+void FrameMsgMgr::SendCommandsStart()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[SendCommandsStart]:scene nullptr");
+        return;
+    }
+    scene->SendCommandsStart();
+}
+
+void FrameMsgMgr::HandleEndFrame()
+{
+    FrameSceneSched *scene = GetSceneHandler();
+    if (scene == nullptr) {
+        RME_LOGE("[HandleEndFrame]:scene nullptr");
+        return;
+    }
+    scene->HandleEndFrame();
+}
+
+void FrameMsgMgr::SetSchedParam()
+{
+    RME_LOGI("[SetSchedParam]: set default sched param!");
 }
 } // namespace RME
 } // namespace OHOS
diff --git a/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp b/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp
index 298e9b4b0be3ff5fc74801835624dce922a19c82..7c8f75d2ed9205ec68cbd686940a714179283917 100644
--- a/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp
+++ b/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp
@@ -45,13 +45,18 @@ bool RmeCoreSched::Init()
     return ret;
 }
 
+void RmeCoreSched::HandleBeginFrame()
+{
+    RME_FUNCTION_TRACE();
+}
+
 void RmeCoreSched::BeginFlushAnimation()
 {
     m_pid = getpid();
     if (m_rtg == -1) {
         m_rtg = SearchRtgForTid(m_pid);
         if (m_rtg <= 0) {
-            RME_LOGE("[BeginFlushAnimation]:Search rtg empty!pid %{public}d,Rtg: %{public}d",
+            RME_LOGW("[BeginFlushAnimation]:Search rtg empty!pid %{public}d,Rtg: %{public}d",
                 m_pid, m_rtg);
             return;
         } else {
@@ -106,7 +111,7 @@ void RmeCoreSched::ProcessCommandsStart() {}
 void RmeCoreSched::AnimateStart()
 {
     if (m_rtg <= 0) {
-        RME_LOGE("[AnimateStart]: search rtg empty! Rtg:%{public}d, Pid:%{public}d", m_rtg, m_pid);
+        RME_LOGW("[AnimateStart]: search rtg empty! Rtg:%{public}d, Pid:%{public}d", m_rtg, m_pid);
         return;
     }
     m_renderTid = gettid();
@@ -124,13 +129,21 @@ void RmeCoreSched::RenderStart()
 
 void RmeCoreSched::SendCommandsStart()
 {
+    RmeTraceBegin(("FrameS-SetMargin:" + to_string(m_rtg) + " margin:" + to_string(MARGIN_THREE)).c_str());
+    SetMargin(m_rtg, MARGIN_THREE);
+    RmeTraceEnd();
+}
+
+void RmeCoreSched::HandleEndFrame()
+{
+    RME_FUNCTION_TRACE();
     if (m_rtg <= 0) {
-        RME_LOGW("[SendCommandStart]: search rtg empty! rtGrp:%{public}d, m_pid:%{public}d!",
+        RME_LOGW("[HandleEndFrame]: search rtg empty! rtGrp:%{public}d, m_pid:%{public}d!",
             m_rtg, m_pid);
         return;
     }
     int ret = EndFrameFreq(m_rtg);
-    RmeTraceBegin(("FrameS-EndFrameFreq-rtg:" + to_string(m_rtg)+" ret:" + to_string(ret)).c_str());
+    RmeTraceBegin(("FrameS-EndFrameFreq-rtg:" + to_string(m_rtg) + " ret:" + to_string(ret)).c_str());
     RmeTraceEnd();
 }
 } // namespace RME
diff --git a/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp b/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp
index aa3618023365c833bd91c7f9c98458e669094aca..a3571e6d099a321cc2c8397fdc0453dae9885a87 100644
--- a/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp
+++ b/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp
@@ -34,7 +34,6 @@ bool RmeSceneSched::Init()
         rmeCoreSched = new RmeCoreSched();
     }
 
-    curWorkingStatus = 1;
     if (rmeCoreSched == nullptr) {
         return false;
     }
@@ -42,11 +41,17 @@ bool RmeSceneSched::Init()
     return ret;
 }
 
+void RmeSceneSched::HandleBeginFrame()
+{
+    curWorkingStatus = 1;
+    FrameWindowMgr::GetInstance().SetStartFlag(true);
+    rmeCoreSched->HandleBeginFrame();
+    RmeTraceBegin(("FrameS-curWorkingStatus" + std::to_string(curWorkingStatus)).c_str());
+    RmeTraceEnd();
+}
+
 void RmeSceneSched::BeginFlushAnimation()
 {
-    if (!FrameWindowMgr::GetInstance().GetEnable()) {
-        return;
-    }
     if (curWorkingStatus == 1) {
         rmeCoreSched->BeginFlushAnimation();
     }
@@ -54,7 +59,7 @@ void RmeSceneSched::BeginFlushAnimation()
 
 void RmeSceneSched::EndFlushAnimation()
 {
-    if (curWorkingStatus ==  1) {
+    if (curWorkingStatus == 1) {
         rmeCoreSched->EndFlushAnimation();
     }
 }
@@ -149,5 +154,19 @@ void RmeSceneSched::SendCommandsStart()
         rmeCoreSched->SendCommandsStart();
     }
 }
+
+void RmeSceneSched::HandleEndFrame()
+{
+    if (curWorkingStatus == 0) {
+        return;
+    }
+    rmeCoreSched->HandleEndFrame();
+    if (FrameWindowMgr::GetInstance().GetStartFlag()) {
+        FrameWindowMgr::GetInstance().SetStartFlag(false);
+    }
+    curWorkingStatus = 0;
+    RmeTraceBegin(("FrameS-curWorkingStatus" + std::to_string(curWorkingStatus)).c_str());
+    RmeTraceEnd();
+}
 } // namespace RME
 } // namespace OHOS
diff --git a/interfaces/innerkits/frameintf/frame_ui_intf.cpp b/interfaces/innerkits/frameintf/frame_ui_intf.cpp
index f01980beba4008bc14bc02803d2b273a1f634064..f96f4c221e0423ee3d0fd425c7c1d3c10b16dfbf 100644
--- a/interfaces/innerkits/frameintf/frame_ui_intf.cpp
+++ b/interfaces/innerkits/frameintf/frame_ui_intf.cpp
@@ -57,7 +57,7 @@ void FrameUiIntf::BeginFlushAnimation() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_ANIMATION, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_ANIMATION_START);
 }
 
 void FrameUiIntf::EndFlushAnimation() const
@@ -65,7 +65,7 @@ void FrameUiIntf::EndFlushAnimation() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_BUILD, EventState::EVENT_EXIT);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_ANIMATION_END);
 }
 
 void FrameUiIntf::BeginFlushBuild() const
@@ -73,7 +73,7 @@ void FrameUiIntf::BeginFlushBuild() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_BUILD, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_BUILD_START);
 }
 
 void FrameUiIntf::EndFlushBuild() const
@@ -81,7 +81,7 @@ void FrameUiIntf::EndFlushBuild() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_BUILD, EventState::EVENT_EXIT);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_BUILD_END);
 }
 
 void FrameUiIntf::BeginFlushLayout() const
@@ -89,7 +89,7 @@ void FrameUiIntf::BeginFlushLayout() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_LAYOUT, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_LAYOUT_START);
 }
 
 void FrameUiIntf::EndFlushLayout() const
@@ -97,7 +97,7 @@ void FrameUiIntf::EndFlushLayout() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_LAYOUT, EventState::EVENT_EXIT);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_LAYOUT_END);
 }
 
 void FrameUiIntf::BeginFlushRender() const
@@ -105,7 +105,7 @@ void FrameUiIntf::BeginFlushRender() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_RENDER, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_RENDER_START);
 }
 
 void FrameUiIntf::EndFlushRender() const
@@ -113,7 +113,7 @@ void FrameUiIntf::EndFlushRender() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_RENDER, EventState::EVENT_EXIT);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_RENDER_END);
 }
 
 void FrameUiIntf::BeginFlushRenderFinish() const
@@ -121,7 +121,7 @@ void FrameUiIntf::BeginFlushRenderFinish() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_RENDER_FINISH, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_RENDER_FINISH_START);
 }
 
 void FrameUiIntf::EndFlushRenderFinish() const
@@ -129,7 +129,7 @@ void FrameUiIntf::EndFlushRenderFinish() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::FLUSH_RENDER_FINISH, EventState::EVENT_EXIT);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_FLUSH_RENDER_FINISH_END);
 }
 
 void FrameUiIntf::BeginProcessPostFlush() const
@@ -137,7 +137,7 @@ void FrameUiIntf::BeginProcessPostFlush() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::PROCESS_POST_FLUSH, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_PROCESS_POST_FLUSH_START);
 }
 
 void FrameUiIntf::ProcessCommandsStart() const
@@ -145,7 +145,7 @@ void FrameUiIntf::ProcessCommandsStart() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::PROCESS_COMMANDS, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_PROCESS_COMMANDS_START);
 }
 
 void FrameUiIntf::AnimateStart() const
@@ -153,7 +153,7 @@ void FrameUiIntf::AnimateStart() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::ANIMATE, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_ANIMATE_START);
 }
 
 void FrameUiIntf::RenderStart() const
@@ -161,17 +161,31 @@ void FrameUiIntf::RenderStart() const
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::RENDER, EventState::EVENT_ENTER);
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_RENDER_START);
 }
 
 void FrameUiIntf::SendCommandsStart() const
 {
-    RME_LOGI("[SendCommandsStart]:start");
     if (!inited) {
         return;
     }
-    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::SEND_COMMANDS, EventState::EVENT_ENTER);
-    RME_LOGI("[SendCommandsStart]:success");
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_SEND_COMMANDS_START);
+}
+
+void FrameUiIntf::BeginListFling() const
+{
+    if (!inited) {
+        return;
+    }
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_BEGIN_FRAME);
+}
+
+void FrameUiIntf::EndListFling() const
+{
+    if (!inited) {
+        return;
+    }
+    FrameMsgMgr::GetInstance().EventUpdate(FrameEvent::EVENT_END_FRAME);
 }
 
 extern "C" void Init()
@@ -258,5 +272,15 @@ extern "C" void SendCommandsStart()
 {
     FrameUiIntf::GetInstance().SendCommandsStart();
 }
+
+extern "C" void BeginListFling()
+{
+    FrameUiIntf::GetInstance().BeginListFling();
+}
+
+extern "C" void EndListFling()
+{
+    FrameUiIntf::GetInstance().EndListFling();
+}
 } // namespace RME
 } // namespace OHOS
diff --git a/interfaces/innerkits/frameintf/frame_ui_intf.h b/interfaces/innerkits/frameintf/frame_ui_intf.h
index 2801fbd65e994dd3e916f8a8b21510b1d597d264..fbdb42c955324c4fa45cb4f1f083b5592f79b4fe 100644
--- a/interfaces/innerkits/frameintf/frame_ui_intf.h
+++ b/interfaces/innerkits/frameintf/frame_ui_intf.h
@@ -42,6 +42,9 @@ public:
     void AnimateStart() const;
     void RenderStart() const;
     void SendCommandsStart() const;
+
+    void BeginListFling() const;
+    void EndListFling() const;
 private:
     bool inited = false;
 };