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/common/include/rtg_interface.h b/common/include/rtg_interface.h
index f409dc793eba752d6d798d1ebf80e0ecc0d42df8..68d5a6092bbbd183240452d6d51eb64709151075 100644
--- a/common/include/rtg_interface.h
+++ b/common/include/rtg_interface.h
@@ -27,8 +27,6 @@ using namespace std;
 #define MAX_SUBPROCESS_NUM 8
 #define MULTI_FRAME_NUM 5
 
-typedef int pid_t;
-
 struct rtg_enable_data {
     int enable;
     int len;
@@ -85,9 +83,8 @@ enum rtg_sched_cmdid {
     RTG_CTRL_MAX_NR,
 };
 
-extern "C"{
+extern "C" {
     int EnableRtg(bool flag);
-    //-----for frame rtg-----//
     int CreateNewRtgGrp(int prioType = 0, int rtNum = 0); // Return GrpId if success
     int AddThreadToRtg(int tid, int grpId, int prioType = 0);
     int AddThreadsToRtg(vector<int> tids, int grpId, int prioType = 0);
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..67d842b9a9f9dfcf0e2acdffe987b3177f186aea 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"
@@ -24,20 +25,42 @@
 
 namespace OHOS {
 namespace RME {
-class RmeSceneSched;
-
 class FrameMsgMgr {
     DECLARE_SINGLE_INSTANCE_BASE(FrameMsgMgr);
 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/frame_window_mgr.h b/frameworks/core/frame_aware_collector/include/frame_window_mgr.h
index 5e112c92ae2db90bf2cf3df5b2bbf0e8e8b05e9b..56860fc7c8212a0c6e38f92f3f78242a0405ef8d 100644
--- a/frameworks/core/frame_aware_collector/include/frame_window_mgr.h
+++ b/frameworks/core/frame_aware_collector/include/frame_window_mgr.h
@@ -32,7 +32,6 @@ private:
     int m_enable = -1;
     bool m_startFlag;
 };
-
 } // namespace RME
 } // namespace OHOS
 #endif
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..63b9c3e4c12a7594d8f5adcd70cba49b66660444 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,59 @@ 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 = 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 +109,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/frameworks/core/frame_aware_policy/include/rtg_msg_mgr.h b/frameworks/core/frame_aware_policy/include/rtg_msg_mgr.h
index e94761dbe0e47cc7eacf3c469e4b8a6b9f93560f..1725df099c72c9a847f6461a51d0b0ebe92c9b6b 100644
--- a/frameworks/core/frame_aware_policy/include/rtg_msg_mgr.h
+++ b/frameworks/core/frame_aware_policy/include/rtg_msg_mgr.h
@@ -26,7 +26,6 @@
 
 namespace OHOS {
 namespace RME {
-
 class RtgMsgMgr {
     DECLARE_SINGLE_INSTANCE(RtgMsgMgr);
 public:
@@ -38,7 +37,6 @@ public:
     void FpsChanged();
     void FocusChanged(const int pid, bool isFocus); // for multiwindow
 };
-
 } // RME
 } // OHOS
 #endif
diff --git a/frameworks/core/frame_aware_policy/src/para_config.cpp b/frameworks/core/frame_aware_policy/src/para_config.cpp
index 06f14f861854e0bf2f5ba866dcddef0e7efab8a2..1ac54cc89ee2bd3aed64b1849752cf25986c89a3 100644
--- a/frameworks/core/frame_aware_policy/src/para_config.cpp
+++ b/frameworks/core/frame_aware_policy/src/para_config.cpp
@@ -51,7 +51,7 @@ bool ParaConfig::IsXmlPrepared(const std::string& filePath)
             continue;
         }
     auto nodeName = curNodePtr->name; // char* to string
-        if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("log_open")) || 
+        if (!xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("log_open")) ||
             !xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("enable")) ||
             !xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("SOC")) ||
             !xmlStrcmp(nodeName, reinterpret_cast<const xmlChar*>("frame_sched_reset_count"))) {
@@ -114,11 +114,12 @@ void ParaConfig::ReadRenderType(const xmlNodePtr& root)
         RME_LOGE("[GetRenderType]: renderType read failed!");
         return;
     }
-    SplitString(std::string(reinterpret_cast<const char*>(context)), " ", m_renderTypeList, RENDER_TYPE_MAX_VALUE, "renderType");
+    SplitString(std::string(reinterpret_cast<const char*>(context)), " ",
+        m_renderTypeList, RENDER_TYPE_MAX_VALUE, "renderType");
     xmlFree(context);
 }
 
-void ParaConfig::SplitString(const std::string& context, const std::string& character,std::vector<int> &mList, 
+void ParaConfig::SplitString(const std::string& context, const std::string& character, std::vector<int> &mList,
     const int maxVal, const std::string& attrName)
 {
     if (context == "") {
@@ -136,7 +137,7 @@ void ParaConfig::SplitString(const std::string& context, const std::string& char
     }
     mList.push_back(curVal);
 
-    toSplitStr = toSplitStr.substr(pos + 1,toSplitStr.size());
+    toSplitStr = toSplitStr.substr(pos + 1, toSplitStr.size());
     pos = toSplitStr.find(character);
     }
     RME_LOGI("[SplitString]:get data success!attr name:%{public}s", attrName.c_str());
@@ -162,12 +163,14 @@ void ParaConfig::ReadFrameConfig(const xmlNodePtr& root)
             std::string nodeName = reinterpret_cast<const char*>(curSubNode->name); // char* to string
             xmlChar* context = xmlNodeGetContent(curSubNode);
             if (context == nullptr) { // if one config wrong then this config dilscard.
-                RME_LOGE("[GetFrameConfig]: frame config get error! nodeName:%{public}s, key:%{public}s", nodeName.c_str(), key.c_str());
+                RME_LOGE("[GetFrameConfig]: frame config get error! nodeName:%{public}s, key:%{public}s",
+                    nodeName.c_str(), key.c_str());
                 xmlFree(context);
                 break;
             }
             frameConfigTmp[nodeName] = atoi(reinterpret_cast<const char*>(context));
-            RME_LOGI("[GetFrameConfig]: nodeName:%{public}s, val:%{public}s", nodeName.c_str(), reinterpret_cast<const char*>(context));
+            RME_LOGI("[GetFrameConfig]: nodeName:%{public}s, val:%{public}s",
+                nodeName.c_str(), reinterpret_cast<const char*>(context));
             xmlFree(context);
         }
         m_subEventConfig[key] = frameConfigTmp;
@@ -191,7 +194,7 @@ std::map<std::string, std::string> ParaConfig::GetGeneralConfig()
     return m_generalConfig;
 }
 
-std::map<std::string,std::map<std::string, int>> ParaConfig::GetSubEventConfig()
+std::map<std::string, std::map<std::string, int>> ParaConfig::GetSubEventConfig()
 {
     return m_subEventConfig;
 }
diff --git a/interfaces/innerkits/frameintf/frame_msg_intf.h b/interfaces/innerkits/frameintf/frame_msg_intf.h
index de317e1e8958626cc3d0fd7ce6004c3b7b9f989b..a417fa35f0cf764552bc1dc57f1339607a95a8a6 100644
--- a/interfaces/innerkits/frameintf/frame_msg_intf.h
+++ b/interfaces/innerkits/frameintf/frame_msg_intf.h
@@ -22,7 +22,6 @@
 
 namespace OHOS {
 namespace RME {
-
 class FrameMsgIntf {
 public:
     static FrameMsgIntf& GetInstance();
@@ -32,17 +31,13 @@ public:
     void ReportWindowFocus(const int pid, const int isFocus);
     void ReportProcessInfo(const int pid, const int tid, ThreadState state);
     void Stop();
-
 protected:
     FrameMsgIntf() = default;
     virtual ~FrameMsgIntf() = default;
     std::shared_ptr<AppExecFwk::EventHandler> threadHandler_;
-
 private:
     DISALLOW_COPY_AND_MOVE(FrameMsgIntf);
-
 };
-
 } // namespace RME
 } // namespace OHOS
 #endif
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;
 };
diff --git a/interfaces/innerkits/frameintf/rtg_interface.cpp b/interfaces/innerkits/frameintf/rtg_interface.cpp
index 17f940c1e08c1d2f15990d61fbcabcb2c17a20ef..a393463cc0f84f2d7310d3c08b1fb3f3ab9efd67 100644
--- a/interfaces/innerkits/frameintf/rtg_interface.cpp
+++ b/interfaces/innerkits/frameintf/rtg_interface.cpp
@@ -36,7 +36,7 @@ namespace {
 }
 DEFINE_RMELOG_INTELLISENSE("rtg_interface");
 
-#define RTG_SCHED_IPC_MAGIC 0xAB
+const char RTG_SCHED_IPC_MAGIC = 0xAB;
 
 #define CMD_ID_SET_ENABLE \
     _IOWR(RTG_SCHED_IPC_MAGIC, SET_ENABLE, struct rtg_enable_data)
diff --git a/test/unittest/phone/frame_msg_intf_test.cpp b/test/unittest/phone/frame_msg_intf_test.cpp
index 115c403ed106374e630da288ba7fa73d6ed5d022..49041044878e561bd6fe5f17ad06155aaf54ae2c 100644
--- a/test/unittest/phone/frame_msg_intf_test.cpp
+++ b/test/unittest/phone/frame_msg_intf_test.cpp
@@ -198,6 +198,5 @@ HWTEST_F(FrameMsgIntfTest, FrameMsgIntfReportProcessInfoRenderDiedFore, TestSize
     std::map<int, std::shared_ptr<AppInfo>> mapList2 = AppInfoMgr::GetInstance().GetForegroundApp();
     EXPECT_EQ(mapList2.count(pid_2), 1);
 }
-
 } // namespace RME
 } // namespace OHOS
diff --git a/test/unittest/phone/rtg_interface_test.cpp b/test/unittest/phone/rtg_interface_test.cpp
index 9e48d98d78359b93d292d0c38478b5d3e4d5bf9b..2d99fd0cbca47309403c5a3ebb56294eed58a7db 100644
--- a/test/unittest/phone/rtg_interface_test.cpp
+++ b/test/unittest/phone/rtg_interface_test.cpp
@@ -28,7 +28,7 @@ using namespace testing::ext;
 
 #define RTG_INTERFACE_SO_PATH "/system/lib/librtg_interface.z.so"
 
-enum rtg_type {
+enum rtg_type : int {
     VIP = 0,
     TOP_TASK_KEY,
     NORMAL_TASK,