diff --git a/0001-feat-golang-ad.patch b/0001-feat-golang-ad.patch
new file mode 100644
index 0000000000000000000000000000000000000000..61eb0698d55b26749ef91dc2733becfa0b080581
--- /dev/null
+++ b/0001-feat-golang-ad.patch
@@ -0,0 +1,165 @@
+From e11eae509f944c2f0387d2dbf862dcd5763b84da Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?=E9=9B=86=E5=B7=9D?= <jichuan1@huawei.com>
+Date: Fri, 6 Sep 2024 16:35:20 +0800
+Subject: [PATCH] =?UTF-8?q?feat:=20golang=E6=9C=8D=E5=8A=A1=E6=8F=90?=
+ =?UTF-8?q?=E4=BE=9Bad=E6=8E=A5=E5=8F=A3?=
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Signed-off-by: 集川 <jichuan1@huawei.com>
+---
+ ide/server/main.go            | 75 ++++++++++++++++++++++++++++++++---
+ ide/server/server-config.json |  4 ++
+ ide/server/server-config.txt  |  1 -
+ ide/webpack.config.js         |  4 +-
+ 4 files changed, 75 insertions(+), 9 deletions(-)
+ create mode 100644 ide/server/server-config.json
+ delete mode 100644 ide/server/server-config.txt
+
+diff --git a/ide/server/main.go b/ide/server/main.go
+index 80a242fb..5de296ef 100644
+--- a/ide/server/main.go
++++ b/ide/server/main.go
+@@ -45,6 +45,7 @@ import (
+ 	"runtime"
+ 	"strconv"
+ 	"strings"
++	"sync"
+ 	"time"
+ )
+ 
+@@ -52,6 +53,7 @@ const HttpPort = 9000
+ 
+ var exPath string
+ var serveInfo string
++var msgPublishData MsgPublishData
+ var hdcPublicKey string
+ var hdcPrivateKey *rsa.PrivateKey
+ 
+@@ -178,6 +180,7 @@ func main() {
+ 		mux.HandleFunc("/application/hdcPublicKey", getHdcPublicKey)
+ 		mux.HandleFunc("/application/encryptHdcMsg", encryptHdcMsg)
+ 		mux.HandleFunc("/application/signatureHdcMsg", signatureHdcMsg)
++		mux.HandleFunc("/application/messagePublish", getMsgPublish)
+ 		fs := http.FileServer(http.Dir(exPath + "/"))
+ 		mux.Handle("/application/", http.StripPrefix("/application/", cors(fs, version)))
+ 		go func() {
+@@ -299,14 +302,74 @@ func signatureHdcMsg(w http.ResponseWriter, r *http.Request) {
+ 	}
+ }
+ 
+-func readReqServerConfig() string {
+-	readServerConfig, serverConfigErr := os.ReadFile(exPath + "/server-config.txt")
+-	if serverConfigErr != nil {
+-		serveInfo = ""
++func parseMsgPublishFile() {
++	msgPublishData.Mux.RLock()
++	defer msgPublishData.Mux.RUnlock()
++	exist, err := PathExists(msgPublishData.FilePath)
++	if err != nil || !exist {
++		return
++	}
++	buf, err := os.ReadFile(msgPublishData.FilePath)
++	if err != nil {
++		fmt.Println("read fail", err)
++		return
++	}
++	msgPublishData.Msg = string(buf)
++}
++
++func getMsgPublish(w http.ResponseWriter, r *http.Request) {
++	w.Header().Set("Access-Control-Allow-Origin", "*")
++	w.Header().Set("Content-Type", "text/json")
++	msgPublishData.Mux.Lock()
++	data := msgPublishData.Msg
++	msgPublishData.Mux.Unlock()
++	if len(data) == 0 {
++		resp(&w)(false, -1, "msg failed", nil)
+ 	} else {
+-		serveInfo = string(readServerConfig)
++		resp(&w)(true, 0, "success", map[string]interface{}{
++			"data": data,
++		})
++	}
++}
++
++type ServerConfig struct {
++	ServeInfo      string `json:"ServeInfo"`
++	MsgPublishFile string `json:"MsgPublishFile"`
++}
++
++type MsgPublishData struct {
++	FilePath string
++	Msg      string
++	Mux      sync.RWMutex
++}
++
++func loopUpdateMsgPublishData() {
++	loopTime := 30 * time.Second
++	timer := time.NewTimer(loopTime)
++	for {
++		select {
++		case <-timer.C:
++			parseMsgPublishFile()
++		}
++		timer.Reset(loopTime)
++	}
++}
++
++func readReqServerConfig() {
++	serverConfigBuffer, err := os.ReadFile(exPath + "/server-config.json")
++	if err != nil {
++		return
++	}
++	var sc ServerConfig
++	err = json.Unmarshal(serverConfigBuffer, &sc)
++	if err != nil {
++		return
+ 	}
+-	return serveInfo
++	serveInfo = sc.ServeInfo
++	msgPublishData.Mux.RLock()
++	msgPublishData.FilePath = sc.MsgPublishFile
++	msgPublishData.Mux.RUnlock()
++	go loopUpdateMsgPublishData()
+ }
+ 
+ func mapToJson(m map[string]interface{}) (string, error) {
+diff --git a/ide/server/server-config.json b/ide/server/server-config.json
+new file mode 100644
+index 00000000..637b4034
+--- /dev/null
++++ b/ide/server/server-config.json
+@@ -0,0 +1,4 @@
++{
++    "ServeInfo": "127.0.0.1:9100/statistics",
++    "MsgPublishFile": ""
++}
+\ No newline at end of file
+diff --git a/ide/server/server-config.txt b/ide/server/server-config.txt
+deleted file mode 100644
+index fde29681..00000000
+--- a/ide/server/server-config.txt
++++ /dev/null
+@@ -1 +0,0 @@
+-127.0.0.1:9100/statistics
+\ No newline at end of file
+diff --git a/ide/webpack.config.js b/ide/webpack.config.js
+index f7702c1c..55397917 100644
+--- a/ide/webpack.config.js
++++ b/ide/webpack.config.js
+@@ -168,8 +168,8 @@ const config = {
+           to: 'wasm.json',
+         },
+         {
+-          from: './server/server-config.txt',
+-          to: 'server-config.txt',
++          from: './server/server-config.json',
++          to: 'server-config.json',
+         },
+       ],
+     }),
+-- 
+2.34.1
+
diff --git a/ide/server/main.go b/ide/server/main.go
index 80a242fb8889f8f3dd94a01c3f16edf8bdd1b4a7..530ff115573a70338e10786ec5502b39091784da 100644
--- a/ide/server/main.go
+++ b/ide/server/main.go
@@ -45,6 +45,7 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -52,6 +53,7 @@ const HttpPort = 9000
 
 var exPath string
 var serveInfo string
+var msgPublishData MsgPublishData
 var hdcPublicKey string
 var hdcPrivateKey *rsa.PrivateKey
 
@@ -178,6 +180,7 @@ func main() {
 		mux.HandleFunc("/application/hdcPublicKey", getHdcPublicKey)
 		mux.HandleFunc("/application/encryptHdcMsg", encryptHdcMsg)
 		mux.HandleFunc("/application/signatureHdcMsg", signatureHdcMsg)
+		mux.HandleFunc("/application/messagePublish", getMsgPublish)
 		fs := http.FileServer(http.Dir(exPath + "/"))
 		mux.Handle("/application/", http.StripPrefix("/application/", cors(fs, version)))
 		go func() {
@@ -299,14 +302,79 @@ func signatureHdcMsg(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func readReqServerConfig() string {
-	readServerConfig, serverConfigErr := os.ReadFile(exPath + "/server-config.txt")
-	if serverConfigErr != nil {
-		serveInfo = ""
+func parseMsgPublishFile() {
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Printf("parseMsgPublishFile happen panic, content is %+v\n", r)
+		}
+	}()
+	msgPublishData.Mux.Lock()
+	defer msgPublishData.Mux.Unlock()
+	exist, err := PathExists(msgPublishData.FilePath)
+	if err != nil || !exist {
+		return
+	}
+	buf, err := os.ReadFile(msgPublishData.FilePath)
+	if err != nil {
+		fmt.Println("read fail", err)
+		return
+	}
+	msgPublishData.Msg = string(buf)
+}
+
+func getMsgPublish(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Content-Type", "text/json")
+	msgPublishData.Mux.RLock()
+	data := msgPublishData.Msg
+	msgPublishData.Mux.RUnlock()
+	if len(data) == 0 {
+		resp(&w)(false, -1, "msg failed", nil)
 	} else {
-		serveInfo = string(readServerConfig)
+		resp(&w)(true, 0, "success", map[string]interface{}{
+			"data": data,
+		})
+	}
+}
+
+type ServerConfig struct {
+	ServeInfo      string `json:"ServeInfo"`
+	MsgPublishFile string `json:"MsgPublishFile"`
+}
+
+type MsgPublishData struct {
+	FilePath string
+	Msg      string
+	Mux      sync.RWMutex
+}
+
+func loopUpdateMsgPublishData() {
+	loopTime := 5 * time.Minute
+	timer := time.NewTimer(5 * time.Second)
+	for {
+		select {
+		case <-timer.C:
+			parseMsgPublishFile()
+		}
+		timer.Reset(loopTime)
+	}
+}
+
+func readReqServerConfig() {
+	serverConfigBuffer, err := os.ReadFile(exPath + "/server-config.json")
+	if err != nil {
+		return
+	}
+	var sc ServerConfig
+	err = json.Unmarshal(serverConfigBuffer, &sc)
+	if err != nil {
+		return
 	}
-	return serveInfo
+	serveInfo = sc.ServeInfo
+	msgPublishData.Mux.Lock()
+	msgPublishData.FilePath = sc.MsgPublishFile
+	msgPublishData.Mux.Unlock()
+	go loopUpdateMsgPublishData()
 }
 
 func mapToJson(m map[string]interface{}) (string, error) {
diff --git a/ide/server/server-config.json b/ide/server/server-config.json
new file mode 100644
index 0000000000000000000000000000000000000000..637b403495932e12805e858f50883d962caca8d4
--- /dev/null
+++ b/ide/server/server-config.json
@@ -0,0 +1,4 @@
+{
+    "ServeInfo": "127.0.0.1:9100/statistics",
+    "MsgPublishFile": ""
+}
\ No newline at end of file
diff --git a/ide/server/server-config.txt b/ide/server/server-config.txt
deleted file mode 100644
index fde296819b41b01eef3ffaef5c795bd5ab2c9569..0000000000000000000000000000000000000000
--- a/ide/server/server-config.txt
+++ /dev/null
@@ -1 +0,0 @@
-127.0.0.1:9100/statistics
\ No newline at end of file
diff --git a/ide/src/base-ui/chart/pie/LitChartPie.ts b/ide/src/base-ui/chart/pie/LitChartPie.ts
index 560893146b932e392852f614dc61fb57d4416385..252a537038a97fbd0be9493eb92d511124cf5b18 100644
--- a/ide/src/base-ui/chart/pie/LitChartPie.ts
+++ b/ide/src/base-ui/chart/pie/LitChartPie.ts
@@ -179,11 +179,13 @@ export class LitChartPie extends BaseElement {
       }
       this.updateHoverItemStatus(it);
       if (it.hover) {
-        this.showTip(
-          this.centerX || 0,
-          this.centerY || 0,
-          this.litChartPieConfig!.tip ? this.litChartPieConfig!.tip(it) : `${it.key}: ${it.value}`
-        );
+        if (this.centerX && this.centerX > 0 && this.centerY && this.centerY > 0) { 
+          this.showTip(
+            this.centerX - 40 || 0,
+            this.centerY || 0,
+            this.litChartPieConfig!.tip ? this.litChartPieConfig!.tip(it) : `${it.key}: ${it.value}`
+          );
+        }
       }
     });
     if (!hasHover) {
@@ -270,8 +272,8 @@ export class LitChartPie extends BaseElement {
           if (it.hover && this.litChartPieConfig) {
             this.litChartPieConfig.hoverHandler?.(it.obj);
             this.showTip(
-              ev.pageX - rect.left + 10,
-              ev.pageY - this.offsetTop - 10,
+              ev.pageX - rect.left > this.centerX! ? ev.pageX - rect.left - 165 : ev.pageX - rect.left + 10,
+              ev.pageY - this.offsetTop > this.centerY! ? ev.pageY - this.offsetTop - 50 : ev.pageY + (this.offsetTop - rect.top) - this.offsetTop + 20,
               this.litChartPieConfig.tip ? this.litChartPieConfig!.tip(it) : `${it.key}: ${it.value}`
             );
           }
diff --git a/ide/src/base-ui/loading/LitLoading.ts b/ide/src/base-ui/loading/LitLoading.ts
new file mode 100644
index 0000000000000000000000000000000000000000..f0b3fd56ec075f103e51a63644305bff678f4cf3
--- /dev/null
+++ b/ide/src/base-ui/loading/LitLoading.ts
@@ -0,0 +1,177 @@
+import { BaseElement, element } from '../BaseElement'
+
+@element('lit-loading')
+export class LitLoading extends BaseElement {
+
+    initHtml(): string {
+        return `
+            <style>
+            .loadEl {
+                display:flex;
+                flex-flow:column;
+                align-items:center;
+            }
+            .loading,.loading > div {
+                position: relative;
+                box-sizing: border-box;
+            }           
+                
+                .loading {
+                  display: block;
+                  font-size: 0;
+                  color: #000;
+                }
+                
+                .loading.la-dark {
+                  color:#333;
+                }
+                
+                .loading > div {
+                  display: inline-block;
+                  float: none;
+                  background-color: currentColor;
+                  border: 0 solid currentColor;
+                }
+                
+                .loading {
+                  width: 32px;
+                  height: 32px;
+                }
+                
+                .loading > div {
+                  position: absolute;
+                  top: 50%;
+                  left: 50%;
+                  width: 8px;
+                  height: 8px;
+                  margin-top: -4px;
+                  margin-left: -4px;
+                  border-radius: 100%;
+                  animation: ball-spin 1s infinite ease-in-out;
+                }
+                
+                .loading > div:nth-child(1) {
+                  top: 5%;
+                  left: 50%;
+                  animation-delay: -1.125s;
+                }
+                
+                .loading > div:nth-child(2) {
+                  top: 18.1801948466%;
+                  left: 81.8198051534%;
+                  animation-delay: -1.25s;
+                }
+                
+                .loading > div:nth-child(3) {
+                  top: 50%;
+                  left: 95%;
+                  animation-delay: -1.375s;
+                }   
+                
+                .loading > div:nth-child(4) {
+                  top: 81.8198051534%;
+                  left: 81.8198051534%;
+                  animation-delay: -1.5s;
+                }
+                
+                .loading > div:nth-child(5) {   
+                  top: 94.9999999966%;
+                  left: 50.0000000005%;
+                  animation-delay: -1.625s;
+                }
+                
+                .loading > div:nth-child(6) {
+                  top: 81.8198046966%;
+                  left: 18.1801949248%;
+                  animation-delay: -1.75s;
+                }
+                
+                .loading > div:nth-child(7) {
+                  top: 49.9999750815%;
+                  left: 5.0000051215%;
+                  animation-delay: -1.875s;
+                }
+                  .loading > div:nth-child(8) {
+                  top: 18.179464974%;
+                  left: 18.1803700518%;
+                  animation-delay: -2s;
+                }
+                
+                .loading.la-sm {
+                  width: 16px;
+                  height: 16px;
+                }
+                
+                .loading.la-sm > div {
+                  width: 4px;
+                  height: 4px;
+                  margin-top: -2px;
+                  margin-left: -2px;
+                }
+                
+                .loading.la-2x {
+                  width: 64px;
+                  height: 64px;
+                }
+                
+                .loading.la-2x > div {
+                  width: 16px;
+                  height: 16px;
+                  margin-top: -8px;
+                  margin-left: -8px;
+                }
+                
+                .loading.la-3x {
+                  width: 96px;
+                  height: 96px;
+                }
+                
+                .loading.la-3x > div {
+                  width: 24px;
+                  height: 24px;
+                  margin-top: -12px;
+                  margin-left: -12px;
+                }
+                
+                @keyframes ball-spin {
+                  0%,
+                  100% {
+                    opacity: 1;
+                    transform: scale(1);
+                  }
+                
+                  20% {
+                    opacity: 1;
+                  }
+                
+                  80% {
+                    opacity: 0;
+                    transform: scale(0);
+                  }
+                }
+
+                .loadingText {
+                    margin-top:20px;
+                }
+            </style>
+            <div class="loadEl">
+                <div class="loading" id="lit-loading">
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                    <div></div>
+                </div>
+                <div class="loadingText">
+                    加载中 ...
+                </div>
+            </div>
+            `;
+    }
+
+    initElements(): void {
+    }
+}
\ No newline at end of file
diff --git a/ide/src/base-ui/menu/LitMainMenu.ts b/ide/src/base-ui/menu/LitMainMenu.ts
index 89fa33020c8b5897c95d378e14488d07336d14fb..e5465cc75cf409c6e2bdbfcb113caeaeaeeab76c 100644
--- a/ide/src/base-ui/menu/LitMainMenu.ts
+++ b/ide/src/base-ui/menu/LitMainMenu.ts
@@ -95,6 +95,7 @@ const initHtmlStyle: string = `
             cursor: pointer;
             height: 47px;
             width: 48px;
+            color: #1E4EEA;
         }
         </style>
     `;
diff --git a/ide/src/base-ui/select/LitSelect.ts b/ide/src/base-ui/select/LitSelect.ts
index aad124e5c4d87417f569bb5ed2acf24fbeb63129..da9d3e108939c3e05f5f15476b50fb2f00c5b4bd 100644
--- a/ide/src/base-ui/select/LitSelect.ts
+++ b/ide/src/base-ui/select/LitSelect.ts
@@ -16,6 +16,7 @@
 import { BaseElement, element } from '../BaseElement';
 import { selectHtmlStr } from './LitSelectHtml';
 import { LitSelectOption } from './LitSelectOption';
+import { SpSystemTrace } from '../../trace/component/SpSystemTrace';
 
 @element('lit-select')
 export class LitSelect extends BaseElement {
@@ -45,6 +46,7 @@ export class LitSelect extends BaseElement {
       'border',
       'mode',
       'showSearchInput',
+      'tabSelect'
     ];
   }
 
@@ -471,7 +473,12 @@ export class LitSelect extends BaseElement {
 
   setOnkeydown(): void {
     // @ts-ignore
-    this.selectInputEl.onkeydown = (ev: unknown): void => {
+    this.selectInputEl.onkeydown = (ev: KeyboardEvent): void => {
+      ev.stopPropagation();
+    if (this.hasAttribute('tabselect')) {
+      // @ts-ignore
+      this.selectInputEl.readOnly = true;
+    } else {
       // @ts-ignore
       if (ev.key === 'Backspace') {
         if (this.isMultiple()) {
@@ -513,11 +520,12 @@ export class LitSelect extends BaseElement {
               })
             );
           }
-        } // @ts-ignore
+        }// @ts-ignore
       } else if (ev.key === '0' && ev.target.value.length === 1 && ev.target.value === '0') {
         // @ts-ignore
         ev.preventDefault();
       }
+    }
     };
   }
 
diff --git a/ide/src/base-ui/tabs/lit-tabs.ts b/ide/src/base-ui/tabs/lit-tabs.ts
index 75935c8f16a7ac1aea3e34401dbeae8a3be5657b..e2014306dca5b203152552f46d74d7e00b08fedd 100644
--- a/ide/src/base-ui/tabs/lit-tabs.ts
+++ b/ide/src/base-ui/tabs/lit-tabs.ts
@@ -17,6 +17,7 @@ import { element } from '../BaseElement';
 import { LitTabpane } from './lit-tabpane';
 import { SpStatisticsHttpUtil } from '../../statistics/util/SpStatisticsHttpUtil';
 import { LitTabsHtml } from './lit-tabs.html';
+import { shadowRootInput } from '../../trace/component/trace/base/shadowRootInput';
 
 @element('lit-tabs')
 export class LitTabs extends HTMLElement {
@@ -281,7 +282,6 @@ export class LitTabs extends HTMLElement {
         a.removeAttribute('data-selected');
       }
     });
-    let tbp = this.querySelector(`lit-tabpane[key='${key}']`);
     let panes = this.querySelectorAll<LitTabpane>('lit-tabpane');
     panes.forEach((a) => {
       if (a.key === key) {
@@ -292,8 +292,14 @@ export class LitTabs extends HTMLElement {
         a.style.display = 'none';
       }
     });
+    let tbp = this.querySelector(`lit-tabpane[key='${key}']`);
+    if (tbp) {  
+      setTimeout(() => {  
+        shadowRootInput.preventBubbling(tbp);
+      }, 500);
+    }
   }
-
+  
   byKeyIsValid(isValid: boolean, a: Element): void {
     if (isValid) {
       let span = a.querySelector('span') as HTMLSpanElement;
diff --git a/ide/src/doc/quickstart_parsing_ability.html b/ide/src/doc/quickstart_parsing_ability.html
index b495caf5a293832896040d6f78c036d57f5181ca..45ee591a2622877f6a0bed6af3bb7688fec8876d 100644
--- a/ide/src/doc/quickstart_parsing_ability.html
+++ b/ide/src/doc/quickstart_parsing_ability.html
@@ -877,6 +877,196 @@ Single file max size： trace文件分割的大小。
         <br />
         <img src="../figures/parsingability/tsmetric.jpg" alt="GitHub Logo" />
       </p>
+
+      <h3 class="mume-header fontColor" id="header-index-5">
+        Hangs抓取和展示说明
+      </h3>
+      <p class="fontColor">
+        挂起（hang）是离散用户交互中的明显延迟，并且它几乎总是主线程上长时间运行工作的结果。
+        仅当主线程在大约 50 毫秒到 100 毫秒或更长时间内无响应时，离散交互延迟才会开始变得明显。
+      </p>
+      <h4 class="mume-header fontColor">Hangs的抓取</h4>
+      <h4 class="mume-header fontColor">Hangs抓取配置参数</h4>
+      <p class="fontColor">
+        进入Probes config页面，打开Record mode开关，勾选notification可以抓取Hangs数据（此选项为默认勾选）。
+      </p>
+      <br />
+      <img src="../figures/parsingability/hangsrecord.jpg" alt="GitHub Logo" />
+      <p class="fontColor">
+        解析时需要打开Flags页面的Hangs Detection开关(Disabled切换为Enabled)。
+      </p>
+      <br />
+      <img src="../figures/parsingability/hangsdetection.jpg" alt="GitHub Logo" />
+      <h4 class="mume-header fontColor">Hangs展示说明</h4>
+      <p class="fontColor">
+        将抓取的trace文件导入到smartperf工具中，查看挂起的情况。
+      </p>
+      <h4 class="mume-header fontColor">泳道图展示</h4>
+      <img src="../figures/parsingability/hangstrace.jpg" alt="GitHub Logo" />
+      <h4 class="mume-header fontColor">类型说明</h4>
+      <img src="../figures/parsingability/hangsttype.jpg" alt="GitHub Logo" />
+      <p class="fontColor">
+        点击Hangs Detection开关下的选项可以选择展示的不同类型。
+      </p>
+      <p class="fontColor">
+        根据duration大小将hang划分为4个type，即Instant、Circumstantial、Micro、Severe。4个type分别对应时长为
+        33ms&lt;d&lt;100ms、100ms&le;d&lt;250ms、250ms&le;d&lt;500ms、500ms&le;d。
+      </p>
+      <p class="fontColor">
+        颜色按type由浅及深：Instant蓝色、Circumstantial黄色、Micro橙色、Severe红色。
+      </p>
+      <p class="fontColor">
+        选择不同类型展示出的泳道会不一样： 选择Instant会显示Instant、Circumstantial、Micro、Severe，如图一；
+        选择Circumstantial则显示Circumstantial、Micro、Severe，如图二，以此类推。
+      </p>
+      <img src="../figures/parsingability/Instant.jpg" alt="GitHub Logo" />
+      <p class="fontColor">
+        图一
+      </p>
+      <img src="../figures/parsingability/Circumstantial.jpg" alt="GitHub Logo" />
+      <p class="fontColor">
+        图二
+      </p>
+      <h4 class="mume-header fontColor">Hangs泳道图的点选功能</h4>
+      <p class="fontColor">
+        可以对hangs的各个slice进行点选，点选后在最下方的弹出层中会展示点选数据的统计的tab页。点击Hang type右侧蓝色箭头，会跳转到该hang对应的trace点。
+      </p>
+      <img src="../figures/parsingability/hangdetails.jpg" alt="GitHub Logo" />
+      <br />
+      <img src="../figures/parsingability/hangname.jpg" alt="GitHub Logo" />
+      <p class="fontColor">
+        Trace点的name依次对应tab页的Sender tid、Send time、Expect handle time、Task name/ID、Prio、Sender。
+      </p>
+      <ul class="fontColor">
+        <li>
+          <pre class="smartperf-text fontColor light">
+StartTime(Relative)：开始时间（相对时间）。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+StartTime(Absolute)：开始时间（绝对时间）。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Duration：持续时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Hang Type：挂起类型。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Sender tid：发送event的线程ID。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Send time：事件发送时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Expect handle time：期望事件开始时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Task name/Id：事件名/事件ID。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Prio：优先级。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Sender：发送者。
+</pre>
+        </li>
+      </ul>
+      <h4 class="mume-header fontColor">Hangs泳道图的框选功能</h4>
+      <p class="fontColor">
+        框选Hangs的泳道图，展示Hangs的tab页，右侧第一个下拉框可以选择类型，也能根据process ，sender去搜索。
+      </p>
+      <img src="../figures/parsingability/hangstab.jpg" alt="GitHub Logo" />
+      <ul class="fontColor">
+        <li>
+          <pre class="smartperf-text fontColor light">
+StartTime：开始时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Duration：持续时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Hang Type：挂起类型。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Process：进程名。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Sender tid：发送event的线程ID。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Send time：事件发送时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Expect handle time：期望事件开始时间。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Task name/Id：事件名/事件ID。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Prio：优先级。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Sender：发送者。
+</pre>
+        </li>
+      </ul>
+      <p class="fontColor">
+        框选Hangs的泳道图，展示Summary的tab页。
+      </p>
+      <img src="../figures/parsingability/Summary.jpg" alt="GitHub Logo" />
+      <ul class="fontColor">
+        <li>
+          <pre class="smartperf-text fontColor light">
+Type/Process/Hang：根据类型显示挂起情况。
+</pre>
+        </li>
+        <li>
+          <pre class="smartperf-text fontColor light">
+Count：各类型的数量。
+</pre>
+        </li>
+      </ul>
+      <h4 class="mume-header fontColor">Hangs归一化泳道</h4>
+      <p class="fontColor">
+        为了方便查看hangs数据，对不同进程下的hangs泳道进行了归一化处理
+      </p>
+      <img src="../figures/parsingability/normalization.jpg" alt="GitHub Logo" />
     </div>
 
     <script>
diff --git a/ide/src/figures/parsingability/Circumstantial.jpg b/ide/src/figures/parsingability/Circumstantial.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..14f992806d78f59211797839eb4105a1fa5eecdb
Binary files /dev/null and b/ide/src/figures/parsingability/Circumstantial.jpg differ
diff --git a/ide/src/figures/parsingability/Instant.jpg b/ide/src/figures/parsingability/Instant.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8398587009fe1ca939aff0dba83c88570b858f80
Binary files /dev/null and b/ide/src/figures/parsingability/Instant.jpg differ
diff --git a/ide/src/figures/parsingability/Summary.jpg b/ide/src/figures/parsingability/Summary.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..11bbd4df38426d6728d82aa2ee3d1b91d6954d1c
Binary files /dev/null and b/ide/src/figures/parsingability/Summary.jpg differ
diff --git a/ide/src/figures/parsingability/hangdetails.jpg b/ide/src/figures/parsingability/hangdetails.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..12d5ab51549134dba9ad7e7ed4d6a688cd6f8561
Binary files /dev/null and b/ide/src/figures/parsingability/hangdetails.jpg differ
diff --git a/ide/src/figures/parsingability/hangname.jpg b/ide/src/figures/parsingability/hangname.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..71225892a2811ff58525eb8a69aee2e2ebcbc681
Binary files /dev/null and b/ide/src/figures/parsingability/hangname.jpg differ
diff --git a/ide/src/figures/parsingability/hangsdetection.jpg b/ide/src/figures/parsingability/hangsdetection.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..153c356af18a93a8962355e6f6790d4b116ae017
Binary files /dev/null and b/ide/src/figures/parsingability/hangsdetection.jpg differ
diff --git a/ide/src/figures/parsingability/hangsrecord.jpg b/ide/src/figures/parsingability/hangsrecord.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..2e09ad1543662b5c016cd141216a225b15bc92ee
Binary files /dev/null and b/ide/src/figures/parsingability/hangsrecord.jpg differ
diff --git a/ide/src/figures/parsingability/hangstab.jpg b/ide/src/figures/parsingability/hangstab.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..3de0ca6c5a3437cf8c06451466bc035ac3a472b5
Binary files /dev/null and b/ide/src/figures/parsingability/hangstab.jpg differ
diff --git a/ide/src/figures/parsingability/hangstrace.jpg b/ide/src/figures/parsingability/hangstrace.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c5b657c5d53409d0a0db1b1a8a9fd74cf237c662
Binary files /dev/null and b/ide/src/figures/parsingability/hangstrace.jpg differ
diff --git a/ide/src/figures/parsingability/hangsttype.jpg b/ide/src/figures/parsingability/hangsttype.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..deed355e4e3d1de27125b3efe01bb85b94692e01
Binary files /dev/null and b/ide/src/figures/parsingability/hangsttype.jpg differ
diff --git a/ide/src/figures/parsingability/normalization.jpg b/ide/src/figures/parsingability/normalization.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ba8ade7a00e1c78ed0e27a517e3e23979bf9d11f
Binary files /dev/null and b/ide/src/figures/parsingability/normalization.jpg differ
diff --git a/ide/src/img/ai-analysis.png b/ide/src/img/ai-analysis.png
new file mode 100644
index 0000000000000000000000000000000000000000..6337c2722816df933e954a67d4190bdd892cd7b2
Binary files /dev/null and b/ide/src/img/ai-analysis.png differ
diff --git a/ide/src/img/ai_analysis.png b/ide/src/img/ai_analysis.png
new file mode 100644
index 0000000000000000000000000000000000000000..7c8adf8fabd13c0fcc6f6159c5dcb2ae24b66391
Binary files /dev/null and b/ide/src/img/ai_analysis.png differ
diff --git a/ide/src/img/header.png b/ide/src/img/header.png
new file mode 100644
index 0000000000000000000000000000000000000000..69b7cd152f5498098b446d50809e2cdcb073d7d4
Binary files /dev/null and b/ide/src/img/header.png differ
diff --git a/ide/src/img/history.png b/ide/src/img/history.png
new file mode 100644
index 0000000000000000000000000000000000000000..317a05410799f86d9f9e13ea5bdd3e09baea8cda
Binary files /dev/null and b/ide/src/img/history.png differ
diff --git a/ide/src/img/new_chat.png b/ide/src/img/new_chat.png
new file mode 100644
index 0000000000000000000000000000000000000000..6cb7b4224651689642c7330a0d347d610cfc179b
Binary files /dev/null and b/ide/src/img/new_chat.png differ
diff --git a/ide/src/img/nodata.png b/ide/src/img/nodata.png
new file mode 100644
index 0000000000000000000000000000000000000000..df590397151cb7044104c248ae2f9ebfb603b546
Binary files /dev/null and b/ide/src/img/nodata.png differ
diff --git a/ide/src/img/report.png b/ide/src/img/report.png
new file mode 100644
index 0000000000000000000000000000000000000000..b9fb737a198e7498a7a4b2528cb161602e173a5e
Binary files /dev/null and b/ide/src/img/report.png differ
diff --git a/ide/src/img/report_active.png b/ide/src/img/report_active.png
new file mode 100644
index 0000000000000000000000000000000000000000..405fa4d88d9abac3faf57646acaee3d8d946bc75
Binary files /dev/null and b/ide/src/img/report_active.png differ
diff --git a/ide/src/img/send.png b/ide/src/img/send.png
new file mode 100644
index 0000000000000000000000000000000000000000..0f8b939b67cee3dd6213c4be2120b01d18d16ad5
Binary files /dev/null and b/ide/src/img/send.png differ
diff --git a/ide/src/img/sigh.png b/ide/src/img/sigh.png
new file mode 100644
index 0000000000000000000000000000000000000000..315e3190c3a62f3f627b473c7681a74e09aa01f0
Binary files /dev/null and b/ide/src/img/sigh.png differ
diff --git a/ide/src/img/talk.png b/ide/src/img/talk.png
new file mode 100644
index 0000000000000000000000000000000000000000..8b57a5dec1b8d742047b9f92e366ac1d154b0f52
Binary files /dev/null and b/ide/src/img/talk.png differ
diff --git a/ide/src/img/talk_active.png b/ide/src/img/talk_active.png
new file mode 100644
index 0000000000000000000000000000000000000000..6f6cad9fc3da96684e64009af1771108150479f7
Binary files /dev/null and b/ide/src/img/talk_active.png differ
diff --git a/ide/src/statistics/util/SpStatisticsHttpBean.ts b/ide/src/statistics/util/SpStatisticsHttpBean.ts
index dedd1123f6afded8d5e26e969a3ab8025eedf083..6d5f69d318118b4f543f59d685e0330015da46dc 100644
--- a/ide/src/statistics/util/SpStatisticsHttpBean.ts
+++ b/ide/src/statistics/util/SpStatisticsHttpBean.ts
@@ -23,3 +23,9 @@ export interface BurialPointRequestBody {
 export interface EventData {
   plugin?: Array<string>;
 }
+
+export interface pluginUsage {
+  eventData: {
+    plugin: Array<string>;
+  }
+}
diff --git a/ide/src/statistics/util/SpStatisticsHttpUtil.ts b/ide/src/statistics/util/SpStatisticsHttpUtil.ts
index c2cb7975b0976aa0c0ebcc6b4e631da18702580b..001ab515714aef38e165c0eae177552a319586c8 100644
--- a/ide/src/statistics/util/SpStatisticsHttpUtil.ts
+++ b/ide/src/statistics/util/SpStatisticsHttpUtil.ts
@@ -14,7 +14,7 @@
  */
 
 import { warn } from '../../log/Log';
-import { BurialPointRequestBody } from './SpStatisticsHttpBean';
+import { BurialPointRequestBody, pluginUsage } from './SpStatisticsHttpBean';
 
 export class SpStatisticsHttpUtil {
   static requestServerInfo: string = '';
@@ -47,8 +47,7 @@ export class SpStatisticsHttpUtil {
       };
       req.open(
         'GET',
-        `${window.location.protocol}//${window.location.host.split(':')[0]}:${
-          window.location.port
+        `${window.location.protocol}//${window.location.host.split(':')[0]}:${window.location.port
         }/application/serverInfo`,
         true
       );
@@ -122,7 +121,7 @@ export class SpStatisticsHttpUtil {
           }
         });
       })
-      .catch((err) => {});
+      .catch((err) => { });
     setTimeout(() => {
       fetch(`https://${SpStatisticsHttpUtil.requestServerInfo}/${requestUrl}`, {
         method: 'post',
@@ -134,8 +133,8 @@ export class SpStatisticsHttpUtil {
           visitId: visitId,
         }),
       })
-        .catch((err) => {})
-        .then((resp) => {});
+        .catch((err) => { })
+        .then((resp) => { });
     }, 1800000);
   }
 
@@ -162,9 +161,25 @@ export class SpStatisticsHttpUtil {
       body: JSON.stringify(requestBody),
     })
       .catch((err) => {
-        this.handleRequestException();
       })
-      .then((resp) => {});
+      .then((resp) => { });
+  }
+
+  static recordPluginUsage(requsetBody: pluginUsage) {
+    fetch(`https://${SpStatisticsHttpUtil.requestServerInfo}/recordPluginUsage`, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(requsetBody),
+    }).then(res => {
+    }).catch(err => {
+      this.handleRequestException();
+    });
+  }
+
+  static getNotice() {
+    return fetch(`${document.URL}messagePublish`);
   }
 
   static getCorrectRequestTime(): number {
@@ -173,4 +188,39 @@ export class SpStatisticsHttpUtil {
     }
     return Date.now() + SpStatisticsHttpUtil.timeDiff;
   }
+
+  // ai对话接口--获取token
+  static async getAItoken() {
+    let token = ''
+    await window.fetch(`https://${window.location.host}/takeToken`, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }).then(async (res) => {
+      let resp = await res.text();
+      let resj = await JSON.parse(resp);
+      token = resj.token;
+    }).catch(() => { });
+    return token;
+  }
+
+  // ai对话接口--问答
+  // @ts-ignore
+  static async askAi(requestBody) {
+    let answer = '';
+    let res = await window.fetch(`https://${window.location.host}/ask`, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(requestBody)
+    })
+    // 用状态码判断statu = 200?
+    let resp = await res.text();
+    let resj = await JSON.parse(resp);
+    answer = resj.chatbot_reply;
+    return answer;
+  }
 }
+
diff --git a/ide/src/trace/SpApplication.ts b/ide/src/trace/SpApplication.ts
index 71fe515fbbc68ca1ae1c05d47d2256fad681e0ac..ed72661feed96045cd012c210a246ed2591da214 100644
--- a/ide/src/trace/SpApplication.ts
+++ b/ide/src/trace/SpApplication.ts
@@ -16,6 +16,7 @@
 import { BaseElement, element } from '../base-ui/BaseElement';
 import '../base-ui/menu/LitMainMenu';
 import '../base-ui/icon/LitIcon';
+import '../base-ui/loading/LitLoading'
 import { SpMetrics } from './component/SpMetrics';
 import { SpHelp } from './component/SpHelp';
 import './component/SpHelp';
@@ -80,6 +81,12 @@ import { SpThirdParty } from './component/SpThirdParty';
 import './component/SpThirdParty';
 import { cancelCurrentTraceRowHighlight } from './component/SpSystemTrace.init';
 import './component/SpBubblesAI';
+import './component/SpAiAnalysisPage';
+import { shadowRootInput } from './component/trace/base/shadowRootInput';
+import { WebSocketManager } from '../webSocket/WebSocketManager';
+import { SpAiAnalysisPage } from './component/SpAiAnalysisPage';
+import './component/SpAdvertisement'
+import { toUSVString } from 'util';
 
 @element('sp-application')
 export class SpApplication extends BaseElement {
@@ -148,6 +155,8 @@ export class SpApplication extends BaseElement {
   private contentCenterOption: HTMLDivElement | undefined | null;
   private contentRightOption: HTMLDivElement | undefined | null;
   private childComponent: Array<unknown> | undefined | null;
+  private spAiAnalysisPage: SpAiAnalysisPage | undefined | null;
+  private aiAnalysis: HTMLImageElement | undefined | null;
   private keyCodeMap = {
     61: true,
     107: true,
@@ -291,6 +300,7 @@ export class SpApplication extends BaseElement {
     this.litRecordSearch = this.shadowRoot?.querySelector('#lit-record-search') as LitSearch;
     this.sidebarButton = this.shadowRoot?.querySelector('.sidebar-button');
     this.chartFilter = this.shadowRoot?.querySelector('.chart-filter') as TraceRowConfig;
+    this.aiAnalysis = this.shadowRoot?.querySelector('.ai_analysis') as HTMLImageElement;
     this.cutTraceFile = this.shadowRoot?.querySelector('.cut-trace-file') as HTMLImageElement;
     this.exportRecord = this.shadowRoot?.querySelector('.export-record') as LitIcon;
     this.longTracePage = this.shadowRoot!.querySelector('.long_trace_page') as HTMLDivElement;
@@ -306,6 +316,7 @@ export class SpApplication extends BaseElement {
     this.contentRightOption = this.shadowRoot?.querySelector<HTMLDivElement>('.content-right-option');
     this.contentLeftOption = this.shadowRoot?.querySelector<HTMLDivElement>('.content-left-option');
     this.contentCenterOption = this.shadowRoot?.querySelector<HTMLDivElement>('.content-center-option');
+    this.spAiAnalysisPage = this.shadowRoot!.querySelector('#sp-ai-analysis') as SpAiAnalysisPage;
     this.initElementsAttr();
     this.initEvents();
     this.initRecordEvents();
@@ -317,12 +328,21 @@ export class SpApplication extends BaseElement {
     this.initGlobalEvents();
     this.initDocumentListener();
     this.initElementsEnd();
+    this.connectWebSocket();
+  }
+  private connectWebSocket(): void {
+    document.addEventListener('DOMContentLoaded', function () {//
+      WebSocketManager.getInstance();
+    });
   }
-
   private initElementsEnd(): void {
     let urlParams = new URL(window.location.href).searchParams;
+    let jsonStr = '';
+    if (urlParams && urlParams.get('json')) {
+      jsonStr = decodeURIComponent(window.location.href.split('&').reverse()[0].split('=')[1]);
+    }
     if (urlParams && urlParams.get('trace') && urlParams.get('link')) {
-      this.openLineFileHandler(urlParams);
+      this.openLineFileHandler(urlParams, jsonStr);
     } else if (urlParams && urlParams.get('action')) {
       this.helpClick(urlParams!);
     } else {
@@ -353,6 +373,7 @@ export class SpApplication extends BaseElement {
       this.spSystemTrace,
       this.spRecordTrace,
       this.spWelcomePage,
+      this.spAiAnalysisPage,
       this.spMetrics,
       this.spQuerySQL,
       this.spSchedulingAnalysis,
@@ -590,6 +611,9 @@ export class SpApplication extends BaseElement {
     this.customColor!.setAttribute('hidden', '');
     this.longTracePage!.style.display = 'none';
     this.litSearch!.style.marginLeft = '0px';
+    // 诊断的db标记重置
+    SpAiAnalysisPage.isRepeatedly = false;
+    this.spAiAnalysisPage!.style.display = 'none';
     let pageListDiv = this.shadowRoot?.querySelector('.page-number-list') as HTMLDivElement;
     pageListDiv.innerHTML = '';
     this.openFileInit();
@@ -601,6 +625,7 @@ export class SpApplication extends BaseElement {
     let fileName = ev.name;
     this.traceFileName = fileName;
     let showFileName = fileName.lastIndexOf('.') === -1 ? fileName : fileName.substring(0, fileName.lastIndexOf('.'));
+    window.sessionStorage.setItem('fileName', showFileName);
     TraceRow.rangeSelectObject = undefined;
     //@ts-ignore
     let typeStr = ev.slice(0, 100);
@@ -654,7 +679,7 @@ export class SpApplication extends BaseElement {
     }
   }
 
-  private openLineFileHandler(urlParams: URLSearchParams): void {
+  private openLineFileHandler(urlParams: URLSearchParams, jsonStr: string): void {
     Utils.currentTraceMode = TraceMode.NORMAL;
     this.openFileInit();
     this.openMenu(false);
@@ -664,7 +689,12 @@ export class SpApplication extends BaseElement {
       urlParams.get('trace') as string,
       downloadLineFile,
       (arrayBuf, fileName, showFileName, fileSize) => {
-        this.handleWasmMode(new File([arrayBuf], fileName), showFileName, fileSize, fileName);
+        if (fileName.split('.').reverse()[0] === 'db') {
+          this.wasm = false;
+          this.handleSqliteMode(new File([arrayBuf], fileName), showFileName, fileSize, fileName, jsonStr);
+        } else {
+          this.handleWasmMode(new File([arrayBuf], fileName), showFileName, fileSize, fileName, jsonStr);
+        }
       },
       (localPath) => {
         let path = urlParams.get('trace') as string;
@@ -977,7 +1007,7 @@ export class SpApplication extends BaseElement {
     history.pushState({}, '', window.location.origin + window.location.pathname);
   }
 
-  private handleSqliteMode(ev: unknown, showFileName: string, fileSize: number, fileName: string): void {
+  private handleSqliteMode(ev: unknown, showFileName: string, fileSize: number, fileName: string, jsonStr?: string): void {
     let fileSizeStr = (fileSize / 1048576).toFixed(1);
     postLog(fileName, fileSizeStr);
     document.title = `${showFileName} (${fileSizeStr}M)`;
@@ -1000,6 +1030,9 @@ export class SpApplication extends BaseElement {
             if (this.markJson) {
               window.publish(window.SmartEvent.UI.ImportRecord, this.markJson);
             }
+            if (jsonStr) {
+              window.publish(window.SmartEvent.UI.ImportRecord, jsonStr);
+            }
             this.mainMenu!.menus!.splice(2, this.mainMenu!.menus!.length > 2 ? 1 : 0, {
               collapsed: false,
               title: 'Current Trace',
@@ -1069,7 +1102,7 @@ export class SpApplication extends BaseElement {
     };
   }
 
-  private handleWasmMode(ev: unknown, showFileName: string, fileSize: number, fileName: string): void {
+  private handleWasmMode(ev: unknown, showFileName: string, fileSize: number, fileName: string, jsonStr?: string): void {
     this.litSearch!.setPercent('', 1);
     if (fileName.endsWith('.json')) {
       this.progressEL!.loading = true;
@@ -1100,6 +1133,9 @@ export class SpApplication extends BaseElement {
         if (this.markJson) {
           window.publish(window.SmartEvent.UI.ImportRecord, this.markJson);
         }
+        if (jsonStr) {
+          window.publish(window.SmartEvent.UI.ImportRecord, jsonStr);
+        }
       };
       threadPool.init('wasm').then((res) => {
         let reader: FileReader = new FileReader();
@@ -1926,6 +1962,52 @@ export class SpApplication extends BaseElement {
     this.cutTraceFile!.addEventListener('click', (ev) => {
       this.croppingFile(this.progressEL!, this.litSearch!);
     });
+
+    this.aiAnalysis!.addEventListener('click', (ev) => {
+      if (this.spAiAnalysisPage!.style.visibility === 'hidden') {
+        this.spAiAnalysisPage!.style.display = 'block';
+        this.spAiAnalysisPage!.style.visibility = 'visible';
+      } else {
+        this.spAiAnalysisPage!.style.visibility = 'hidden';
+        this.spAiAnalysisPage!.style.display = 'none';
+      }
+    })
+
+    // 鼠标拖动改变大小
+    this.aiPageResize()
+  }
+
+  private aiPageResize() {
+    const resizableDiv = this.spAiAnalysisPage!;
+    let isResizing = false;
+
+    resizableDiv.addEventListener('mousemove', (e) => {
+      if (Math.abs(e.clientX - resizableDiv.getBoundingClientRect().left) < 5) {
+        resizableDiv.style.cursor = 'e-resize';
+      } else {
+        resizableDiv.style.cursor = 'default';
+      }
+    })
+
+    resizableDiv.addEventListener('mousedown', function (e) {
+      isResizing = true;
+      if (e.clientX - resizableDiv.getBoundingClientRect().left < 5) {
+        document.addEventListener('mousemove', changeAiWidth);
+      }
+      document.addEventListener('mouseup', mouseUp);
+    });
+
+
+    function changeAiWidth(e: any) {
+      resizableDiv.style.cursor = 'e-resize';
+      resizableDiv.style.width = window.innerWidth - e.clientX + 'px';
+    }
+
+    function mouseUp() {
+      isResizing = false;
+      document.removeEventListener('mousemove', changeAiWidth);
+      document.removeEventListener('mouseup', mouseUp);
+    }
   }
 
   private filterRowConfigClickHandle(): void {
@@ -2097,6 +2179,8 @@ export class SpApplication extends BaseElement {
       }
       if (node === showNode) {
         showNode.style.visibility = 'visible';
+        let recordSetting = document.querySelector("body > sp-application")?.shadowRoot?.querySelector("#sp-record-trace")?.shadowRoot?.querySelector("#app-content > record-setting");
+        shadowRootInput.preventBubbling(recordSetting!);
       } else {
         (node! as HTMLElement).style.visibility = 'hidden';
       }
@@ -2406,6 +2490,13 @@ export class SpApplication extends BaseElement {
           this.itemIconLoading(mainMenu, 'Current Trace', 'Download Database', false);
           clearInterval(timer);
         }, 4000);
+        // 存入缓存
+        caches.open(`${fileName}`).then((cache) => {
+          let headers = new Headers();
+          headers.append('Content-type', 'application/octet-stream');
+          headers.append('Content-Transfer-Encoding', 'binary');
+          return cache.put(`${fileName}`, new Response(reqBufferDB, { status: 200 }));
+        })
       },
       'download-db'
     );
diff --git a/ide/src/trace/SpApplicationPublicFunc.ts b/ide/src/trace/SpApplicationPublicFunc.ts
index 0c977163ba1a68ea86bc10037149962afd984339..071c4934dab68813ae700bc23f90984b624439a3 100644
--- a/ide/src/trace/SpApplicationPublicFunc.ts
+++ b/ide/src/trace/SpApplicationPublicFunc.ts
@@ -184,7 +184,7 @@ export const applicationHtml: string = `
             fill: currentColor;
             overflow: hidden;
             font-size: 20px;
-            color: var(--dark-color1,#47A7E0);
+            color: #1E4EEA;
          }
         :host([chart_filter]) .chart-filter {
             display: grid;
@@ -325,9 +325,28 @@ export const applicationHtml: string = `
         .page-number-list {
             display: flex;
         }
+
+        #sp-ai-analysis {
+            top:0px;
+            right:0px;
+            position:absolute;
+            z-index:9999;
+            min-width:430px;
+            max-width:75%;
+            width:430px;
+            height:740px;
+            box-shadow:3px 0px 14px #000;
+            border-radius:8px;
+            background-color:#fff;
+            padding:10px 10px 10px 5px;
+            user-select:none;
+            box-sizing:border-box;
+            visibility:hidden;
+        }
         </style>
         <div class="root" style="position: relative;">
             <sp-bubble-ai style="visibility: visible; top:50%;right:2px;position: absolute;z-index: 1000" id="sp-bubbles"></sp-bubble-ai>
+            <sp-advertisement style="bottom:2px;right:2px;position: absolute;z-index: 10086" id= "sp-advertisement"></sp-advertisement>
             <lit-main-menu id="main-menu" class="menu" data=''></lit-main-menu>
             <sp-keyboard style="width:100%;height:100%;overflow:auto;visibility:hidden;top:0px;left:0px;right:0;bottom:0px;position:absolute;z-index: 8888" id="sp-keyboard">
             </sp-keyboard>
@@ -368,6 +387,7 @@ export const applicationHtml: string = `
                     </div>
                 </div>
                 <div class = "content-right-option" style="display: flex;flex-flow: nowrap;text-align: right;position: absolute;right: 1.2em;cursor: pointer;top: 17px"">
+                  <img class="ai_analysis" title="Display Template" src="img/ai-analysis.png" style="margin-left: 0.8em;width:16px;height:16px">
                   <lit-icon class="export-record" title="Download Mark Trace" name="download" size="16" style="margin-left: 0.8em;"></lit-icon>
                   <img class="cut-trace-file" title="Cut Trace File" src="img/menu-cut.svg" style="margin-left: 0.8em;">
                   <img class="filter-config" title="Display Template" src="img/config_filter.png" style="margin-left: 0.8em;">
@@ -377,6 +397,8 @@ export const applicationHtml: string = `
             <div id="app-content" class="content">
                 <sp-welcome style="visibility:visible;top:0px;left:0px;position:absolute;z-index: 100" id="sp-welcome">
                 </sp-welcome>
+                <sp-ai-analysis id="sp-ai-analysis">
+                </sp-ai-analysis>
                 <sp-system-trace style="visibility:hidden;z-index: 101;" id="sp-system-trace">
                 </sp-system-trace>
                 <sp-record-trace style="overflow:auto;width:100%;height:100%;visibility:hidden;top:0px;left:0px;right:0;bottom:0px;position:absolute;z-index: 102" id="sp-record-trace">
diff --git a/ide/src/trace/bean/BoxSelection.ts b/ide/src/trace/bean/BoxSelection.ts
index cac944009fe2bfc80c982e89ae88bd29a4455cc0..2d45cda705556a40491a2eb0607bd62a3afa3623 100644
--- a/ide/src/trace/bean/BoxSelection.ts
+++ b/ide/src/trace/bean/BoxSelection.ts
@@ -70,6 +70,10 @@ export class SelectionParam {
     ((arg: unknown) => Promise<Array<unknown>> | undefined) | undefined
   >();
   dmaFenceNameData: Array<String> = [];//新增框选dma_fence数据
+  xpowerMapData: Map<string, ((arg: unknown) => Promise<Array<unknown>> | undefined) | undefined> = new Map<
+  string,
+  ((arg: unknown) => Promise<Array<unknown>> | undefined) | undefined
+>();
   hangMapData: Map<string, ((arg: unknown) => Promise<Array<unknown>> | undefined) | undefined> = new Map();
   irqCallIds: Array<number> = [];
   softIrqCallIds: Array<number> = [];
@@ -368,7 +372,12 @@ export class SelectionParam {
         filterFunc.funName!.indexOf('H:Task ') >= 0;
       // @ts-ignore
       let taskData = it.dataListCache.filter((taskData: FuncStruct) => {
-        taskData!.tid = parseInt(it.rowId!);
+        taskData!.tid = isNaN(Number(it.rowId!)) && typeof it.rowId! === 'string' ?  
+         (function() {  
+           const match = (it.rowId!).match(/-(\d+)/);  
+           return match ? parseInt(match[1]) : undefined; 
+         })() :  
+         parseInt(it.rowId!);
         return isIntersect(taskData, TraceRow.rangeSelectObject!);
       });
       if (taskData.length > 0) {
@@ -1128,6 +1137,7 @@ export class SelectionParam {
         it.rangeSelect = true;
         it.checkType = '2';
         this.clockMapData.set(it.rowId || '', it.getCacheData);
+        it.rowType === TraceRow.ROW_TYPE_DMA_FENCE && this.dmaFenceNameData.push(it.rowId!);
       });
     }
     if (it.rowType === TraceRow.ROW_TYPE_CLOCK) {
@@ -1143,6 +1153,20 @@ export class SelectionParam {
     }
   }
 
+  // @ts-ignore
+  pushXpower(it: TraceRow<unknown>, sp: SpSystemTrace): void {  
+    if (it.rowType === TraceRow.ROW_TYPE_XPOWER) {
+      it.childrenList.forEach((it) => {
+        it.rangeSelect = true;
+        it.checkType = '2';
+        this.xpowerMapData.set(it.rowId || '', it.getCacheData);
+      });
+    }
+    if (it.rowType === TraceRow.ROW_TYPE_XPOWER_SYSTEM) {
+      this.xpowerMapData.set(it.rowId || '', it.getCacheData);
+    }
+  }
+
   // @ts-ignore
   pushHang(it: TraceRow<unknown>, sp: SpSystemTrace): void {
     if (it.rowType === TraceRow.ROW_TYPE_HANG_GROUP) {
@@ -1274,6 +1298,7 @@ export class SelectionParam {
     this.pushLogs(it, sp);
     this.pushHiSysEvent(it, sp);
     this.pushSampleData(it);
+    this.pushXpower(it, sp);
   }
 }
 
diff --git a/ide/src/trace/component/SpAdvertisement.html.ts b/ide/src/trace/component/SpAdvertisement.html.ts
new file mode 100644
index 0000000000000000000000000000000000000000..eff483fb212eebf82e8c5502a70356d94d0202c0
--- /dev/null
+++ b/ide/src/trace/component/SpAdvertisement.html.ts
@@ -0,0 +1,40 @@
+import { LitIcon } from "../../base-ui/icon/LitIcon";
+
+export const SpAdvertisementHtml = `<style>
+        #sp-advertisement {
+          background-color:#fff;
+          display:none;
+          max-width: 400px;
+          border-radius: 5px;
+          border:1px solid galy;
+          box-shadow: 0px 0px 10px #d9d9d9;
+          cursor: pointer;
+          padding:15px 5px 5px 5px;
+          font-family: "HarmonyOS Sans SC", "Arial", sans-serif;
+        }
+        #close { 
+          position:absolute;
+          right:0px;
+          top:0px;
+          padding:1px 2px;
+          border-top-right-radius:5px;
+          color:#999;
+        }
+        #close:hover {
+          background-color:#999;
+          color:#666;
+          font-weight:bold;
+        }
+        #notice {
+          color:red;
+          word-wrap: break-word;    
+          overflow-wrap: break-word;
+          line-height:30px;
+          padding-right:15px;
+        }
+        </style>
+        <div class="sp-advertisement" id="sp-advertisement">
+            <lit-icon name="close" size="18px" id = "close"></lit-icon>
+            <div id="notice"></div>
+        </div>
+    `;
\ No newline at end of file
diff --git a/ide/src/trace/component/SpAdvertisement.ts b/ide/src/trace/component/SpAdvertisement.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0dbe0136f99875bf97571d6d377b3b947b19c09a
--- /dev/null
+++ b/ide/src/trace/component/SpAdvertisement.ts
@@ -0,0 +1,60 @@
+import { BaseElement, element } from '../../base-ui/BaseElement';
+import { SpAdvertisementHtml } from "./SpAdvertisement.html";
+import { SpStatisticsHttpUtil } from '../../statistics/util/SpStatisticsHttpUtil';
+
+@element('sp-advertisement')
+export class SpAdvertisement extends BaseElement {
+    private advertisementEL: HTMLElement | undefined | null;
+    private closeEL: HTMLElement | undefined | null;
+    private noticeEl: HTMLElement | undefined | null;
+    private message: string = '';
+
+    initElements(): void {
+        // 整个广告
+        this.advertisementEL = document.querySelector("body > sp-application")?.shadowRoot?.
+            querySelector("#sp-advertisement")?.shadowRoot?.querySelector("#sp-advertisement");
+        // 关闭按钮
+        this.closeEL = document.querySelector("body > sp-application")?.shadowRoot?.
+            querySelector("#sp-advertisement")?.shadowRoot?.querySelector("#close");
+        // 公告内容
+        this.noticeEl = document.querySelector("body > sp-application")?.shadowRoot?.
+            querySelector("#sp-advertisement")?.shadowRoot?.querySelector("#notice");
+        this.getMessage();
+        setInterval(() => {
+            this.getMessage();
+        }, 10000);
+        this.closeEL?.addEventListener('click', () => {
+            this.advertisementEL!.style!.display = 'none';
+        })
+    }
+
+    private getMessage() {
+        SpStatisticsHttpUtil.getNotice().then(res => {
+            res.text().then((it) => {
+                let resp = JSON.parse(it);
+                if (resp && resp.data && resp.data.data && resp.data.data !== this.message && resp.data.data !== '') {
+                    this.message = resp.data.data;
+                    if (this.message.startsWith('图片:')) {
+                        this.noticeEl!.style.display = "flex";
+                        this.noticeEl!.style.justifyContent = "center";
+                        this.noticeEl!.innerHTML = `<img src ="${this.message.substring(3, this.message.length)}" style="height:150px" 
+                    alt = "图片加载失败"></img>`
+                    } else if (this.message.startsWith('链接:')) {
+                        this.noticeEl!.style.height = "auto";
+                        this.noticeEl!.style.color = "#000";
+                        this.noticeEl!.innerHTML = `链接：<a href = "${this.message.substring(3, this.message.length)}" target = "black">
+                    ${this.message.substring(3, this.message.length)}</a>`
+                    } else {
+                        this.noticeEl!.style.color = "red";
+                        this.noticeEl!.innerHTML = this.message;
+                    }
+                    this.advertisementEL!.style!.display = 'block';
+                }
+            });
+        })
+    }
+
+    initHtml(): string {
+        return SpAdvertisementHtml;
+    }
+}
\ No newline at end of file
diff --git a/ide/src/trace/component/SpAiAnalysisPage.html.ts b/ide/src/trace/component/SpAiAnalysisPage.html.ts
new file mode 100644
index 0000000000000000000000000000000000000000..c7806a71cec3b8229eeae99560596326cdc63667
--- /dev/null
+++ b/ide/src/trace/component/SpAiAnalysisPage.html.ts
@@ -0,0 +1,500 @@
+export const SpAiAnalysisPageHtml = `
+<div class="chatBox">
+        <h3 class="chatTitle" style="color:#35a1db">
+            HiSmartPerf AI助手
+        </h3>
+        <div class="chatWindow">
+            <div class="ask_question">
+                <div class="aiMessage message">
+                    <div class="aiHeader headerDiv">
+                        <img src="img/logo.png" class="headerImg"/>
+                    </div>
+                    <div class="systemSay">
+                        有什么可以帮助您吗？
+                        <div class="aiTriangle"></div>
+                    </div>
+                    <div class="clear"></div>
+                </div>
+            </div>
+            <div class="report_details">
+                <div class="selectionBox">
+                    <div class="startBox">
+                        <div class="timeTip"></div>
+                        开始时间：
+                        <span class="startTime"></span>
+                    </div>
+                    <div class="endBox">
+                        <div class="timeTip"></div>
+                        结束时间：
+                        <span class="endTime"></span>
+                    </div>
+                </div>
+                <div class="analysisList" style="height: 84%;padding-right: 10px;">
+                    <div class="analysis-header">
+                        <h3
+                            style="text-align: center;background-color: #4894f3;padding: 10px 0px;color: #fff;border-radius:2px;margin:0">
+                            分析报告
+                        </h3>
+                    </div>
+                    <div class="no-data">
+                        <img src="../application/img/nodata.png" />
+                        <div>
+                            暂无数据
+                        </div>
+                    </div>
+                    <div class="loginTip">
+                        <img src="img/sigh.png" style="margin-right: 8px;width: 18px;"/>未连接
+                    </div>
+                    <div class="data-record"></div>
+                </div>
+                <div class="report-button">
+                    <div class="analysisBtn button">
+                        一键诊断
+                    </div>
+                    <div class="downloadBtn button" style="display: none;">报告下载</div>
+                </div>
+            </div>
+            <div class="chatInputBox">
+                <div class="chatConfig">
+                    <div class="right-box">
+                        <div class="history">
+                            <img src="img/history.png" style="margin-right: 10px;"/>
+                            <div class="config-tip hisTip">
+                                历史记录
+                            </div>
+                        </div>
+                        <div class="newChat">
+                            <img src="img/new_chat.png"/>
+                            <div class="config-tip">
+                                新建聊天
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div class="chatInput">
+                    <textarea class="inputText" placeholder="请输入消息"></textarea>
+                    <img src="img/send.png" class="sendImg">
+                </div>
+            </div>
+        </div>
+    </div>
+    <div class="rightTabBar">
+        <div class="chatBar active">
+            <img src="img/talk_active.png" class="chatInon"/>
+            <div class="chatBarTitle">聊天</div>
+        </div>
+        <div class="report">
+            <img src="img/report.png" class="chatInon"/>
+            <div class="chatBarTitle">诊断</div>
+        </div>
+    </div>
+    <style>
+    .report_details {
+        width: 98%;
+        height: 100%;
+        display: none;
+        position: relative;
+    }
+
+    .report-button {
+        position: absolute;
+        bottom: 0;
+        right: 0;
+    }
+
+    .usersay {
+        max-width: 70%;
+        background: #4baf50;
+        border-radius: 4px;
+        float: right;
+        line-height: 20px;
+        text-overflow: ellipsis;
+        word-break: break-all;
+        display: -webkit-box;
+        -webkit-box-orient: vertical;
+        font-size: 12px;
+        padding: 5px 10px;
+        margin-top: 10px;
+        margin-right: 10px;
+        position: relative;
+        text-align: justify;
+        color: #fff;
+    }
+
+    .userTriangle {
+        width: 0px;
+        height: 0px;
+        border-left: solid 8px #4baf50;
+        border-top: solid 5px rgba(255, 255, 255, 0);
+        border-bottom: solid 5px rgba(255, 255, 255, 0);
+        position: absolute;
+        right: -8px;
+        top: 8px;
+    }
+
+    .systemSay {
+        max-width: 70%;
+        border-radius: 4px;
+        background-color: #fe7300;
+        float: left;
+        line-height: 20px;
+        text-overflow: ellipsis;
+        word-break: break-all;
+        display: -webkit-box;
+        -webkit-box-orient: vertical;
+        font-size: 12px;
+        padding: 5px 10px;
+        margin-top: 10px;
+        position: relative;
+        text-align: justify;
+        color: #fff;
+    }
+
+    .aiTriangle {
+        width: 0px;
+        height: 0px;
+        border-right: solid 8px #fe7300;
+        border-top: solid 5px rgba(255, 255, 255, 0);
+        border-bottom: solid 5px rgba(255, 255, 255, 0);
+        position: absolute;
+        left: -7px;
+        top: 8px;
+    }
+
+    .chatBox {
+        height: 100%;
+        padding-left: 5px;
+        padding-bottom: 10px;
+        padding-right: 40px;
+    }
+
+    .chatTitle {
+        margin: 0;
+        height: 50px;
+        line-height: 50px;
+    }
+
+    .chatWindow {
+        height: 92%;
+        padding: 0 10px 20px;
+        border-radius: 10px;
+        position: relative;
+        background: rgba(235, 235, 235, 0)
+    }
+
+    .ask_question {
+        overflow-y: auto;
+        overflow-x:hidden;
+        height: 77%;
+        padding-right: 10px;
+    }
+
+    .chatConfig {
+        width: 100%;
+        height: 24%;
+        position: relative;
+        margin-top: 10px;
+        border-top: 1px solid rgba(255, 255, 255, .3);
+    }
+
+    .chatConfig img {
+        width: 20px;
+    }
+
+    .chatConfig img:hover+.config-tip {
+        display: block;
+    }
+
+    .chatInput {
+        position: relative;
+        width: 100%;
+        height: 127px;
+        border-radius: 10px;
+        text-align: justify;
+    }
+
+    .right-box {
+        position: absolute;
+        display: flex;
+        right: 0;
+        top: 10px;
+    }
+
+    .history,
+    .newChat {
+        position: relative;
+    }
+
+    .config-tip {
+        background-color: rgba(0, 0, 0, .8);
+        padding: 5px 10px;
+        color: #fff;
+        position: absolute;
+        top: -30px;
+        left: -24px;
+        border-radius: 5px;
+        width: 52px;
+        text-align: center;
+        font-size: 12px;
+        z-index: 9999;
+        display: none;
+    }
+
+    .message {
+        width: 100%;
+    }
+
+    .inputText {
+        height: 100%;
+        width: 100%;
+        resize: none;
+        padding: 10px;
+        padding-right: 5px;
+        background-color: #fcfcfc;
+        border-radius: 10px;
+        text-align: justify;
+        box-sizing: border-box;
+        border: none;
+        font-weight: 400;
+        line-height: 20px;
+    }
+
+    .chatInputBox {
+        padding-right: 10px;
+        height: 20%;
+    }
+
+    .sendImg {
+        position: absolute;
+        bottom: 10px;
+        right: 30px;
+        cursor: pointer;
+        width: 20px;
+        height: 20px;
+    }
+
+    img {
+        cursor: pointer;
+    }
+
+    .rightTabBar {
+        text-align: center;
+        position: absolute;
+        width: 50px;
+        top: 0;
+        right: 0;
+        height: 100%;
+        padding-top: 50px;
+        font-size: 12px;
+        background-color: #fcfcfc;
+        color: #000;
+        box-sizing:border-box;
+    }
+
+    .chatBarTitle {
+        font-size: 12px;
+        height: 30px;
+        line-height: 20px;
+        cursor: pointer;
+    }
+
+    .rightTabBar img {
+        width: 20px;
+    }
+
+    .logo {
+        position: absolute;
+        top: 150px;
+        left: 120px;
+        width: 100px;
+        height: 100px;
+
+    }
+
+    .logo img {
+        width: 100%;
+    }
+
+    .report {
+        padding-top: 10px;
+    }
+
+    .headerDiv {
+        width: 30px;
+        height: 30px;
+        border-radius: 50%;
+        border: 1px solid galy;
+        margin-top: 10px;
+    }
+
+    .userHeader {
+        float: right;
+        background-image: url('img/header.png');
+        background-size:40px;
+        background-position:-5px -5px;
+    }
+
+    .clear {
+        clear: both;
+    }
+
+    .aiHeader {
+        float: left;
+        margin-right: 10px;
+        background-image: url('img/logo1.png');
+        background-size: cover;
+    }
+
+    .headerImg {
+        width: 30px;
+        height: 30px;
+    }
+
+    ::-webkit-scrollbar {
+        width: 2px;
+    }
+
+    ::-webkit-scrollbar-track {
+        background: rgba(0,0,0,0.3);
+        border-radius: 3px;
+    }
+
+    ::-webkit-scrollbar-thumb {
+        background: #272624;
+        border-radius: 3px;
+    }
+
+    ::-webkit-scrollbar-thumb:hover {
+        background: #272624;
+        border-radius: 3px;
+    }
+
+    ::-webkit-scrollbar-thumb:active {
+        background: #272624;
+        border-radius: 3px;
+    }
+
+    .history::title {
+        background-color: #dcdfe6;
+    }
+
+    textarea:focus {
+        outline: none;
+    }
+
+    textarea::placeholder {
+        color: #000;
+    }
+
+    .active {
+        color: #35a1db;
+    }
+
+    .analysisList {
+        overflow: hidden;
+        overflow-y: auto;
+    }
+
+    .analysisItem {
+        width: 100%;
+        letter-spacing: 1.5px;
+        border-radius: 3px;
+        margin-top: 20px;
+        line-height: 20px;
+        position: relative;
+    }
+
+    .title {
+        font-size: 14px;
+        font-weight: 700;
+        background-color: rgba(133, 111, 216, 0.8);
+        padding: 10px 5px;
+        color: #fff;
+    }
+
+    .item-name {
+        font-size: 14px;
+        font-weight: 700;
+    }
+
+    .item {
+        margin-top: 3px;
+        background-color: rgba(212, 227, 227, 0.5);
+        padding: 10px 5px;
+        font-size: 12px;
+        word-break: break-all;
+        font-size: 12px;
+    }
+
+    .two {
+        background-color: rgba(209, 179, 179, 0.5);
+    }
+
+    .button {
+        padding: 3px 35px;
+        height: 26px;
+        background-color: #4290f2;
+        border-radius: 10px;
+        text-align: center;
+        line-height: 26px;
+        color: #fff;
+        font-size: 14px;
+        display: inline-block;
+        cursor: pointer;
+    }
+
+    .no-data {
+        text-align: center;
+        margin-top: 20%;
+    }
+
+    .loginTip {
+        visibility: hidden;
+        position: absolute;
+        top: 45%;
+        left: 38%;
+        padding: 5px 15px;
+        background-color: rgba(0, 0, 0, .8);
+        border-radius: 2px;
+        color: #fff;
+        display: flex;
+        align-items: center;
+        font-size: 12px;
+    }
+
+    .loadingItem {
+        height: 100px;
+        position: relative;
+        width: 100%;
+        margin-top: 20px;
+    }
+
+    @keyframes opcityliner {
+        from {
+            opacity: 0;
+        }
+
+        to {
+            opacity: 1;
+        }
+    }
+
+    .selectionBox div {
+        display: flex;
+        align-items: center;
+        margin-bottom: 10px;
+    }
+
+    .timeTip {
+        width: 10px;
+        height: 10px;
+        border-radius: 5px;
+        background-color: #61da61;
+        margin: 0 10px 0 0 !important;
+    }
+
+    p {
+      margin:0;
+    }
+</style>
+`
\ No newline at end of file
diff --git a/ide/src/trace/component/SpAiAnalysisPage.ts b/ide/src/trace/component/SpAiAnalysisPage.ts
new file mode 100644
index 0000000000000000000000000000000000000000..82662bd4d71e036c37f43ee445484f97c5f289cb
--- /dev/null
+++ b/ide/src/trace/component/SpAiAnalysisPage.ts
@@ -0,0 +1,425 @@
+import { BaseElement, element } from '../../base-ui/BaseElement';
+import { SpStatisticsHttpUtil } from '../../statistics/util/SpStatisticsHttpUtil';
+import { threadPool } from '../database/SqlLite';
+import { SpAiAnalysisPageHtml } from './SpAiAnalysisPage.html'
+import { getTimeString } from './trace/sheet/TabPaneCurrentSelection';
+import { WebSocketManager } from '../../webSocket/WebSocketManager';
+import { TypeConstants } from '../../webSocket/Constants';
+import { TraceRow } from './trace/base/TraceRow';
+import { SpSystemTrace } from './SpSystemTrace';
+import { Type } from './setting/bean/ProfilerServiceTypes';
+
+@element('sp-ai-analysis')
+export class SpAiAnalysisPage extends BaseElement {
+    private askQuestion: Element | null | undefined;
+    private aiAnswerBox: HTMLDivElement | null | undefined;
+    private newChatEl: HTMLImageElement | null | undefined;
+    private chatWindow: HTMLDivElement | null | undefined;
+    private inputEl: HTMLTextAreaElement | null | undefined;
+    private chatImg: HTMLImageElement | null | undefined;
+    private reportBar: HTMLImageElement | null | undefined;
+    private reportImg: HTMLImageElement | null | undefined;
+    private sendImg: HTMLImageElement | null | undefined;
+    private draftBtn: HTMLDivElement | null | undefined;
+    private downloadBtn: HTMLDivElement | null | undefined;
+    private draftList: HTMLDivElement | null | undefined;
+    private noDataEl: HTMLDivElement | null | undefined;
+    private loginTipEl: HTMLDivElement | null | undefined;
+    private loadingItem: HTMLDivElement | null | undefined;
+    private startTimeEl: HTMLSpanElement | null | undefined;
+    private endTimeEl: HTMLSpanElement | null | undefined;
+    private question: string = '';
+    private token: string = '';
+    // 是否点击了新建聊天
+    private isNewChat: boolean = false;
+    isCtrlDown: boolean = false;
+    static isRepeatedly: boolean = false;
+    // 拼接下载内容
+    private reportContent: string = '';
+    private md: unknown;
+    // 监听选中时间范围变化
+    static selectChangeListener(startTime: number, endTime: number) {
+        let startEl = document.querySelector("body > sp-application")!.shadowRoot!.querySelector("#sp-ai-analysis")!.shadowRoot?.querySelector("div.chatBox > div > div.report_details > div.selectionBox > div.startBox > span");
+        startEl!.innerHTML = getTimeString(startTime).toString();
+        let endEl = document.querySelector("body > sp-application")!.shadowRoot!.querySelector("#sp-ai-analysis")!.shadowRoot?.querySelector("div.chatBox > div > div.report_details > div.selectionBox > div.endBox > span");
+        endEl!.innerHTML = getTimeString(endTime).toString();
+    }
+    initElements(): void {
+        this.md = require('markdown-it')({
+            html: true,
+            typographer: true
+        });
+        let chatBar = this.shadowRoot?.querySelector('.chatBar');
+        this.askQuestion = this.shadowRoot?.querySelector('.ask_question');
+        this.reportBar = this.shadowRoot?.querySelector('.report');
+        let reportDetails = this.shadowRoot?.querySelector('.report_details');
+        let chatInputBox = this.shadowRoot?.querySelector('.chatInputBox');
+        this.chatWindow = this.shadowRoot?.querySelector('.ask_question');
+        this.inputEl = this.shadowRoot?.querySelector('.inputText');
+        this.chatImg = this.shadowRoot?.querySelector('.chatBar')?.getElementsByTagName('img')[0];
+        this.reportImg = this.shadowRoot?.querySelector('.report')?.getElementsByTagName('img')[0];
+        this.sendImg = document.querySelector("body > sp-application")!.shadowRoot!.querySelector("#sp-ai-analysis")!.shadowRoot?.querySelector("div.chatInputBox > div.chatInput > img");
+        this.newChatEl = document.querySelector("body > sp-application")!.shadowRoot!.querySelector("#sp-ai-analysis")!.shadowRoot?.querySelector("div.chatBox > div > div.chatInputBox > div.chatConfig > div > div.newChat > img");
+        // 诊断按钮
+        this.draftBtn = this.shadowRoot?.querySelector('.analysisBtn');
+        // 下载报告按钮
+        this.downloadBtn = this.shadowRoot?.querySelector('.downloadBtn');
+        // 报告列表
+        this.draftList = this.shadowRoot?.querySelector('.data-record');
+        // 空数据页面
+        this.noDataEl = this.shadowRoot?.querySelector('.no-data');
+        // 未连接提示弹窗
+        this.loginTipEl = this.shadowRoot?.querySelector('.loginTip');
+        // 时间展示区域
+        this.startTimeEl = this.shadowRoot?.querySelector('.startTime');
+        this.startTimeEl!.innerHTML = getTimeString(TraceRow.range?.startNS!);
+        this.endTimeEl = this.shadowRoot?.querySelector('.endTime');
+        this.endTimeEl!.innerHTML = getTimeString(TraceRow.range?.endNS!);
+
+        // 发送消息图标点击事件
+        this.sendImg?.addEventListener('click', () => {
+            this.sendMessage();
+        })
+
+        // 新建对话按钮点击事件
+        this.newChatEl?.addEventListener('click', () => {
+            this.isNewChat = true;
+            this.token = '';
+            this.askQuestion!.innerHTML = '';
+            this.createAiChatBox('有什么可以帮助您的吗？');
+        })
+
+        // 输入框发送消息
+        this.inputEl?.addEventListener('keydown', (e) => {
+            if (e.key.toLocaleLowerCase() === 'control' || e.keyCode === 17) {
+                this.isCtrlDown = true;
+            }
+            if (this.isCtrlDown) {
+                if (e.key.toLocaleLowerCase() === 'enter') {
+                    this.inputEl!.value += '\n';
+                }
+            } else {
+                if (e.key.toLocaleLowerCase() === 'enter') {
+                    this.sendMessage();
+                    // 禁止默认的回车换行
+                    e.preventDefault();
+                };
+            };
+        });
+
+        // 输入框聚焦/失焦--防止触发页面快捷键
+        this.inputEl?.addEventListener('focus', () => {
+            SpSystemTrace.isAiAsk = true;
+        });
+
+        this.inputEl?.addEventListener('blur', () => {
+            SpSystemTrace.isAiAsk = false;
+        })
+
+        // 监听浏览器刷新，清除db数据
+        window.onbeforeunload = function () {
+            caches.delete(`${window.localStorage.getItem('fileName')}.db`);
+            sessionStorage.removeItem('fileName');
+        }
+
+        // 监听ctrl抬起
+        this.inputEl?.addEventListener('keyup', (e) => {
+            if (e.key.toLocaleLowerCase() === 'control' || e.keyCode === 17) {
+                this.isCtrlDown = false;
+            };
+        });
+
+        // 下载诊断报告按钮监听
+        this.downloadBtn?.addEventListener('click', (e) => {
+            let a = document.createElement('a');
+            a.href = URL.createObjectURL(new Blob([this.reportContent]));
+            a.download = window.sessionStorage.getItem('fileName')! + '诊断报告';
+            a.click();
+        })
+
+        // 诊断按钮
+        this.draftBtn?.addEventListener('click', async (e) => {
+            // 取消已经存在的诊断
+            this.draftList!.innerHTML = '';
+            // 没有登陆，弹窗提示，退出逻辑
+            if (!WebSocketManager.getInstance()?.isReady()) {
+                this.loginTipEl!.style.visibility = 'visible';
+                setTimeout(() => {
+                    this.loginTipEl!.style.visibility = 'hidden';
+                }, 1000);
+                return;
+            }
+            // 同一个trace非第一次诊断，无需再发db文件过去
+            if (SpAiAnalysisPage.isRepeatedly) {
+                this.initiateDiagnosis();
+            } else {
+                // 首次诊断
+                WebSocketManager.getInstance()!.registerMessageListener(TypeConstants.DIAGNOSIS_TYPE, this.webSocketCallBack);
+                // 看缓存中有没有db，没有的话拿一个进行诊断并存缓存
+                let fileName = sessionStorage.getItem('fileName');
+                caches.match(`${fileName}.db`).then(async (res) => {
+                    if (!res) {
+                        this.cacheDb(fileName);
+                    }
+                    WebSocketManager.getInstance()!.sendMessage(TypeConstants.DIAGNOSIS_TYPE, TypeConstants.SENDDB_CMD, new TextEncoder().encode(await res!.text()));
+                });
+            };
+            // 隐藏nodata
+            this.noDataEl!.style.display = 'none';
+            // 加载中的loading模块
+            let loadingDiv = document.createElement('div');
+            loadingDiv.className = 'loadingBox';
+            loadingDiv.innerHTML = '<lit-loading style="position:absolute;top:45%;left:45%;z-index:999"></lit-loading>';
+            let loadingItem = document.createElement('div');
+            loadingItem.className = 'loadingItem';
+            this.loadingItem = loadingItem;
+            loadingItem!.appendChild(loadingDiv);
+            this.draftList?.appendChild(loadingItem);
+        })
+
+        // 侧边栏诊断点击事件 *************优化，考虑多个按钮
+        this.reportBar!.addEventListener('click', () => {
+            this.reportImg!.src = 'img/report_active.png';
+            this.chatImg!.src = 'img/talk.png';
+            this.reportBar!.classList.add('active');
+            chatBar!.classList.remove('active');
+            //@ts-ignore
+            this.askQuestion!.style.display = 'none';
+            //@ts-ignore
+            chatInputBox!.style.display = 'none';
+            //@ts-ignore
+            reportDetails!.style.display = 'block';
+        });
+
+        // 侧边栏聊天点击事件
+        chatBar!.addEventListener('click', () => {
+            this.reportImg!.src = 'img/report.png';
+            this.chatImg!.src = 'img/talk_active.png';
+            this.reportBar!.classList.remove('active');
+            chatBar!.classList.add('active');
+            //@ts-ignore
+            this.askQuestion!.style.display = 'block';
+            //@ts-ignore
+            chatInputBox!.style.display = 'block';
+            //@ts-ignore
+            reportDetails!.style.display = 'none';
+        });
+
+
+    }
+
+    // 点击诊断之后，重置
+    reset() {
+        this.reportContent = '';
+        this.downloadBtn!.style.display = 'none';
+    }
+
+    // 发送消息
+    async sendMessage() {
+        if (this.inputEl!.value != '') {
+            if (this.isNewChat) {
+                this.isNewChat = false;
+            }
+            this.question = JSON.parse(JSON.stringify(this.inputEl!.value));
+            this.createChatBox();
+            this.createAiChatBox('AI智能分析中...');
+            this.chatWindow!.scrollTop = this.chatWindow!.scrollHeight;
+            // 没有token
+            if (this.token === '') {
+                this.token = await SpStatisticsHttpUtil.getAItoken();
+                if (this.token === '') {
+                    this.aiAnswerBox!.firstElementChild!.innerHTML = '获取token失败';
+                    return;
+                }
+            }
+            this.answer();
+        }
+    }
+
+    // ai对话
+    async answer() {
+        let requestBody = {
+            token: this.token,
+            question: this.question,
+            collection: 'smart_perf_test',
+            scope: 'smartperf'
+        };
+        let answer = await SpStatisticsHttpUtil.askAi(requestBody);
+        if (answer !== '') {
+            if (!this.isNewChat) {
+                // @ts-ignore
+                this.aiAnswerBox!.firstElementChild!.innerHTML = this.md!.render(answer);
+                // 滚动条滚到底部
+                this.chatWindow!.scrollTop = this.chatWindow!.scrollHeight;
+            }
+        } else {
+            this.aiAnswerBox!.firstElementChild!.innerHTML = '服务器异常';
+            this.chatWindow!.scrollTop = this.chatWindow!.scrollHeight;
+        }
+    }
+
+    // 创建用户聊天对话气泡
+    createChatBox() {
+        // 生成头像
+        let headerDiv = document.createElement('div');
+        headerDiv.className = 'userHeader headerDiv';
+        // 生成聊天内容框
+        let newQuestion = document.createElement('div');
+        newQuestion.className = "usersay";
+        // @ts-ignore
+        newQuestion!.innerHTML = this.inputEl!.value;
+        // 生成聊天气泡三角
+        let triangleDiv = document.createElement('div');
+        newQuestion.appendChild(triangleDiv);
+        triangleDiv.className = 'userTriangle';
+        // 单条消息模块，最大的div,包含头像、消息、清除浮动元素
+        let newMessage = document.createElement('div');
+        newMessage.className = 'usermessage message';
+        // @ts-ignore
+        this.inputEl!.value = '';
+        newMessage.appendChild(headerDiv);
+        newMessage.appendChild(newQuestion);
+        let claerDiv = document.createElement('div');
+        claerDiv.className = 'clear';
+        newMessage.appendChild(claerDiv);
+        this.askQuestion?.appendChild(newMessage);
+    }
+
+    // 创建ai助手聊天对话气泡
+    createAiChatBox(aiText: string) {
+        // 生成ai头像
+        let headerDiv = document.createElement('div');
+        headerDiv.className = 'aiHeader headerDiv';
+        headerDiv.innerHTML = `<img class='headerImg' src = "img/logo.png" title=""></img>`
+        let newQuestion = document.createElement('div');
+        newQuestion.className = "systemSay";
+        // @ts-ignore
+        newQuestion!.innerHTML = `<div>${aiText}</div>`;
+        let triangleDiv = document.createElement('div');
+        newQuestion.appendChild(triangleDiv);
+        triangleDiv.className = 'aiTriangle';
+        let newMessage = document.createElement('div');
+        newMessage.className = 'aiMessage message';
+        newMessage.appendChild(headerDiv);
+        newMessage.appendChild(newQuestion);
+        let claerDiv = document.createElement('div');
+        claerDiv.className = 'clear';
+        this.aiAnswerBox = newQuestion;
+        newMessage.appendChild(claerDiv);
+        this.askQuestion?.appendChild(newMessage);
+    }
+
+    // 页面渲染诊断结果
+    async renderData(dataList: any) {
+        for (let i = 0; i < dataList.length; i++) {
+            let itemDiv = document.createElement('div');
+            itemDiv!.style.visibility = 'hidden';
+            itemDiv.className = 'analysisItem';
+            // 生成标题
+            let titleDiv = document.createElement('div');
+            titleDiv.className = 'title item-name';
+            titleDiv!.innerText = `问题${i + 1}:${dataList[i].type}`;
+            // 生成时间
+            let timeDiv = document.createElement('div');
+            timeDiv.className = 'item two';
+            // 获取每一个诊断项的时间
+            let timeList = new Array();
+            dataList[i].trace_info.forEach((v: any) => {
+                timeList.push(getTimeString(v.ts / 1000000));
+            });
+            timeDiv!.innerHTML = `<span class="item-name">发生时间：</span>${timeList.join(',')}`
+            // 生成问题原因
+            let reasonDiv = document.createElement('div');
+            reasonDiv.className = 'item';
+            reasonDiv!.innerHTML = `<span class="item-name">问题原因：</span>${dataList[i].description}`;
+            itemDiv.appendChild(titleDiv);
+            itemDiv.appendChild(timeDiv);
+            itemDiv.appendChild(reasonDiv);
+            // 生成优化建议
+            let suggestonDiv = document.createElement('div');
+            suggestonDiv.className = 'item two';
+            let suggestionText = '';
+            this.token = await SpStatisticsHttpUtil.getAItoken();
+            suggestionText = await this.getSuggestion(dataList[i].description, itemDiv, suggestonDiv);
+            this.reportContent += `问题${i + 1}:${dataList[i].type}\n\n时间：${timeList.join(',')}\n\n问题原因：${dataList[i].description}\n\n优化建议：${suggestionText}\n\n\n`;
+        }
+        this.loadingItem!.style.display = 'none';
+        this.downloadBtn!.style.display = 'inline-block';
+    }
+
+    // 发送请求获取优化建议并渲染页面
+    async getSuggestion(description: string, itemDiv: HTMLDivElement | null | undefined, suggestonDiv: HTMLDivElement | null | undefined) {
+        let suggestion = await SpStatisticsHttpUtil.askAi({
+            token: this.token,
+            question: description + ',请问该怎么优化？',
+            collection: ''
+        });
+        suggestonDiv!.innerHTML = `<span class="item-name">优化建议：</span>${suggestion}`;
+        itemDiv!.appendChild(suggestonDiv!);
+        // 吧loading放到最后面
+        this.draftList!.insertBefore(itemDiv!, this.loadingItem!);
+        itemDiv!.style.visibility = 'visible';
+        itemDiv!.style.animation = 'opcityliner 3s';
+        return suggestion;
+    }
+
+    cacheDb(fileName: string | null) {
+        threadPool.submit(
+            'download-db',
+            '',
+            {},
+            (reqBufferDB: Uint8Array) => {
+                // 存入缓存
+                caches.open(`${fileName}.db`).then((cache) => {
+                    let headers = new Headers();
+                    headers.append('Content-Type', 'application/octet-stream');
+                    headers.append('Content-Transfer-Encoding', 'binary')
+                    return cache
+                        .put(
+                            `${fileName}.db`,
+                            new Response(reqBufferDB, {
+                                status: 200,
+                            })
+                        );
+                });
+            },
+            'download-db'
+        );
+    }
+
+    // websocket通信回调注册
+    webSocketCallBack = (cmd: number, result: Uint8Array) => {
+        const decoder = new TextDecoder();
+        const jsonString = decoder.decode(result);
+        let jsonRes = JSON.parse(jsonString);
+        // db文件写入成功
+        if (cmd === 2) {
+            SpAiAnalysisPage.isRepeatedly = true;
+            this.initiateDiagnosis();
+        }
+        // 诊断结果，resultCode===0:失败；resultCode===1:成功
+        if (cmd === 4) {
+            //     需要处理
+            if (jsonRes.resultCode !== 0) {
+                console.log('错误');
+            }
+            let dataList = JSON.parse(jsonRes.resultMessage);
+            // 整理数据,渲染数据
+            this.renderData(dataList);
+        }
+    }
+
+    // 发起诊断
+    initiateDiagnosis() {
+        let requestBodyObj = {
+            type: 0
+        }
+        let requestBodyString = JSON.stringify(requestBodyObj);
+        let requestBody = new TextEncoder().encode(requestBodyString);
+        WebSocketManager.getInstance()!.sendMessage(TypeConstants.DIAGNOSIS_TYPE, TypeConstants.DIAGNOSIS_CMD, requestBody);
+    }
+
+    initHtml(): string {
+        return SpAiAnalysisPageHtml;
+    }
+}
\ No newline at end of file
diff --git a/ide/src/trace/component/SpBubblesAI.ts b/ide/src/trace/component/SpBubblesAI.ts
index 662accae3df516213f7abdfa4e81a49bc392c211..64aa9e5ef3ddbb71ab26022724594ae0b9fe823d 100644
--- a/ide/src/trace/component/SpBubblesAI.ts
+++ b/ide/src/trace/component/SpBubblesAI.ts
@@ -16,6 +16,7 @@
 import { BaseElement, element } from '../../base-ui/BaseElement';
 import { SpBubblesAIHtml } from './SpBubblesAI.html';
 import { FlagsConfig, Params } from './SpFlags';
+import { SpStatisticsHttpUtil } from '../../statistics/util/SpStatisticsHttpUtil';
 
 @element('sp-bubble-ai')
 export class SpBubblesAI extends BaseElement {
@@ -23,6 +24,11 @@ export class SpBubblesAI extends BaseElement {
     const xiaoLubanEl: HTMLElement | undefined | null = this.shadowRoot?.querySelector('#xiao-luban-help');
     xiaoLubanEl?.addEventListener('click', () => {
       this.xiaoLubanEvent();
+      let requestBody = {
+        action: 'AItrace',
+        event: 'AItrace'
+      };
+      SpStatisticsHttpUtil.addOrdinaryVisitAction(requestBody);
     });
     let isShowXiaoLuban: boolean = FlagsConfig.getFlagsConfigEnableStatus('xiaoLuBan');
     if (isShowXiaoLuban) {
diff --git a/ide/src/trace/component/SpFlags.ts b/ide/src/trace/component/SpFlags.ts
index 308ee5c24821e205a25ee4083c3e6b19ccae0e70..8baafef9324ce5b0aed66099fc6c834a9768b81d 100644
--- a/ide/src/trace/component/SpFlags.ts
+++ b/ide/src/trace/component/SpFlags.ts
@@ -45,6 +45,7 @@ const CONFIG_STATE: unknown = {
 @element('sp-flags')
 export class SpFlags extends BaseElement {
   private bodyEl: HTMLElement | undefined | null;
+  private xiaoLubanEl: Element | null | undefined;
 
   initElements(): void {
     let parentElement = this.parentNode as HTMLElement;
@@ -81,20 +82,24 @@ export class SpFlags extends BaseElement {
       }
       configSelect.appendChild(configOption);
     });
+    // 页面刷新时，选项并未改变，小鲁班也应当展示
+    this.xiaoLubanEl = document.querySelector('sp-application')?.shadowRoot?.querySelector('#sp-bubbles')
+      ?.shadowRoot?.querySelector('#xiao-luban-help');
+    if (configSelect.title === 'AI' && configSelect.selectedOptions[0].value === 'Enabled') {
+      this.xiaoLubanEl?.setAttribute('enabled', '');
+    }
     configSelect.addEventListener('change', () => {
       this.flagSelectListener(configSelect);
       if (configSelect.title === 'AI') {
         let userIdInput: HTMLInputElement | null | undefined = this.shadowRoot?.querySelector('#user_id_input');
-        let xiaoLubanEl: Element | null | undefined = document.querySelector('sp-application')?.shadowRoot?.querySelector('#sp-bubbles')
-          ?.shadowRoot?.querySelector('#xiao-luban-help');
         if (configSelect.selectedOptions[0].value === 'Enabled') {
           if (userIdInput?.value === '') {
             userIdInput.style.border = '1px solid red';
           }
-          xiaoLubanEl?.setAttribute('enabled', '');
+          this.xiaoLubanEl?.setAttribute('enabled', '');
         } else {
           userIdInput!.style.border = '1px solid #ccc';
-          xiaoLubanEl?.removeAttribute('enabled');
+          this.xiaoLubanEl?.removeAttribute('enabled');
         }
       }
     });
diff --git a/ide/src/trace/component/SpHelp.ts b/ide/src/trace/component/SpHelp.ts
index c9d040f17e12250e4ced6a8a1ffaf9a6d02492a8..229f9c915fc23c3ed05a629fa1866a30837845fc 100644
--- a/ide/src/trace/component/SpHelp.ts
+++ b/ide/src/trace/component/SpHelp.ts
@@ -77,6 +77,17 @@ export class SpHelp extends BaseElement {
       if (value.title === 'SmartPerf') {
         value.style.display = 'none';
       }
+      if (value.title === 'TS栈') { 
+        value.style.display = 'none';
+      }
+      if (value.title === '内存') {
+        let items = value.querySelectorAll<LitMainMenuItem>('lit-main-menu-item');
+        items.forEach((i) => {
+          if (i.title === 'Js Memory抓取和展示说明') {
+            i.style.display = 'none';
+          }
+        });
+      }
     });
     let urlParams = new URL(window.location.href).searchParams;
     if (urlParams && urlParams.get('action') && urlParams.get('action')!.length > 4) {
diff --git a/ide/src/trace/component/SpRecordConfigModel.ts b/ide/src/trace/component/SpRecordConfigModel.ts
index 91c87f0b1b48f25a6de1d632c3bc6eff9014bfe7..c49ba3c8071ff7d25cc92825988629d4d1dcfd98 100644
--- a/ide/src/trace/component/SpRecordConfigModel.ts
+++ b/ide/src/trace/component/SpRecordConfigModel.ts
@@ -44,6 +44,7 @@ import { SpHisysEvent } from './setting/SpHisysEvent';
 import { SpArkTs } from './setting/SpArkTs';
 import { SpHilogRecord } from './setting/SpHilogRecord';
 import { SpFFRTConfig } from './setting/SpFFRTConfig';
+import { SpXPowerRecord } from './setting/SpXPowerRecord';
 
 export const MEM_INFO = [
   'MEMINFO_ACTIVE',
@@ -904,4 +905,25 @@ export function createTraceEvents(traceConfig: Array<string>): Array<string> {
   return ftraceEventsArray;
 }
 
+export function createXPowerConfig( 
+  spXPower: SpXPowerRecord,
+  request: CreateSessionRequest
+): void {
+  if (!spXPower.recordXPower) {
+    return;
+  }
+  let type = spXPower.getXpowerConfig();
+  let typeList: Array<string> = [];
+  typeList = type!.split(",");
+  let xPowerConfig = {
+    messageType: typeList
+  }
+  request.pluginConfigs.push({
+    pluginName: 'xpower-plugin',
+    sampleInterval: 1000,
+    is_protobuf_serialize: true,
+    configData: xPowerConfig,
+  });
+}
+
 let hasMonitorMemory = false;
diff --git a/ide/src/trace/component/SpRecordTrace.ts b/ide/src/trace/component/SpRecordTrace.ts
index 0565d1c1c2092c640c59ef3cc70634950768e27c..f7f7c00134c646e8489fe4115700dcda67ff7d9f 100644
--- a/ide/src/trace/component/SpRecordTrace.ts
+++ b/ide/src/trace/component/SpRecordTrace.ts
@@ -47,6 +47,7 @@ import { SpStatisticsHttpUtil } from '../../statistics/util/SpStatisticsHttpUtil
 import { SpArkTs } from './setting/SpArkTs';
 import { SpWebHdcShell } from './setting/SpWebHdcShell';
 import { SpHilogRecord } from './setting/SpHilogRecord';
+import { SpXPowerRecord } from './setting/SpXPowerRecord';
 import { LongTraceDBUtils } from '../database/LongTraceDBUtils';
 import {
   createFpsPluginConfig,
@@ -61,9 +62,11 @@ import {
   createHiSystemEventPluginConfig,
   createArkTsConfig,
   createHiLogConfig, createFFRTPluginConfig,
+  createXPowerConfig,
 } from './SpRecordConfigModel';
 import { SpRecordTraceHtml } from './SpRecordTrace.html';
 import { SpFFRTConfig } from './setting/SpFFRTConfig';
+import { shadowRootInput } from '../../trace/component/trace/base/shadowRootInput';
 
 const DEVICE_NOT_CONNECT =
   '<div>1.请确认抓取设备上是否已勾选并确认总是允许smartPerf-Host调试的弹窗</div>' +
@@ -102,6 +105,7 @@ export class SpRecordTrace extends BaseElement {
   private spRecordTemplate: SpRecordTemplate | undefined;
   private spArkTs: SpArkTs | undefined;
   private spHiLog: SpHilogRecord | undefined;
+  private spXPower: SpXPowerRecord | undefined;
   private spFFRTConfig: SpFFRTConfig | undefined;
   private ftraceSlider: LitSlider | undefined | null;
   private spWebShell: SpWebHdcShell | undefined;
@@ -617,6 +621,7 @@ export class SpRecordTrace extends BaseElement {
     this.spHiSysEvent = new SpHisysEvent();
     this.spArkTs = new SpArkTs();
     this.spHiLog = new SpHilogRecord();
+    this.spXPower = new SpXPowerRecord();
     this.spFFRTConfig = new SpFFRTConfig();
     this.spWebShell = new SpWebHdcShell();
     this.spRecordTemplate = new SpRecordTemplate(this);
@@ -788,6 +793,9 @@ export class SpRecordTrace extends BaseElement {
         this.MenuItemEbpfHtml = th;
       }
       this.menuGroup!.appendChild(th);
+      if (item.title === 'Ark Ts') { 
+        this.menuGroup!.removeChild(th);
+      }
     });
   }
 
@@ -861,6 +869,7 @@ export class SpRecordTrace extends BaseElement {
       clickHandler: (): void => {
         this.appContent!.innerHTML = '';
         this.appContent!.append(configPage);
+        shadowRootInput.preventBubbling(configPage);
         this.freshMenuItemsStatus(title);
         if (clickHandlerFun) {
           clickHandlerFun(this);
@@ -891,6 +900,7 @@ export class SpRecordTrace extends BaseElement {
       this.buildMenuItem('Ark Ts', 'file-config', this.spArkTs!),
       this.buildMenuItem('FFRT', 'file-config', this.spFFRTConfig!),
       this.buildMenuItem('Hilog', 'realIntentionBulb', this.spHiLog!),
+      this.buildMenuItem('Xpower', 'externaltools', this.spXPower!), 
     ];
   }
 
@@ -1395,6 +1405,7 @@ export class SpRecordTrace extends BaseElement {
       createArkTsConfig(this.spArkTs!, this.recordSetting!, request);
       createHiLogConfig(reportingFrequency, this.spHiLog!, request);
       createFFRTPluginConfig(this.spFFRTConfig!, SpRecordTrace.selectVersion, request);
+      createXPowerConfig(this.spXPower!, request);
     }
     return request;
   };
diff --git a/ide/src/trace/component/SpSystemTrace.event.ts b/ide/src/trace/component/SpSystemTrace.event.ts
index ab442e53e6efde80940f36c33de6b0d5e6e59714..cded71deb44aad2208bf002cb5c05e5e4ce0d949 100644
--- a/ide/src/trace/component/SpSystemTrace.event.ts
+++ b/ide/src/trace/component/SpSystemTrace.event.ts
@@ -53,6 +53,8 @@ import { Utils } from './trace/base/Utils';
 import { BaseStruct } from '../bean/BaseStruct';
 import { GpuCounterStruct, gpuCounterStructOnClick } from '../database/ui-worker/ProcedureWorkerGpuCounter';
 import { HangStructOnClick } from '../database/ui-worker/ProcedureWorkerHang';
+import { XpowerStruct, XpowerStructOnClick } from '../database/ui-worker/ProcedureWorkerXpower'; 
+import { SpAiAnalysisPage } from './SpAiAnalysisPage';
 
 function timeoutJudge(sp: SpSystemTrace): number {
   let timeoutJudge = window.setTimeout((): void => {
@@ -381,6 +383,7 @@ function allStructOnClick(clickRowType: string, sp: SpSystemTrace, row?: TraceRo
     .then(() => CpuStateStructOnClick(clickRowType, sp, entry as CpuStateStruct))
     .then(() => CpuFreqLimitsStructOnClick(clickRowType, sp, entry as CpuFreqLimitsStruct))
     .then(() => ClockStructOnClick(clickRowType, sp, entry as ClockStruct))
+    .then(() => XpowerStructOnClick(clickRowType, sp, entry as XpowerStruct))
     .then(() => HangStructOnClick(clickRowType, sp, scrollToFunc(sp)))
     .then(() => DmaFenceStructOnClick(clickRowType, sp, entry as DmaFenceStruct))
     .then(() => SnapshotStructOnClick(clickRowType, sp, row as TraceRow<SnapshotStruct>, entry as SnapshotStruct))
@@ -415,6 +418,8 @@ function allStructOnClick(clickRowType: string, sp: SpSystemTrace, row?: TraceRo
       }
     })
     .catch((e): void => { });
+  // @ts-ignore
+  SpAiAnalysisPage.selectChangeListener(entry.startTime || entry.startTs, (entry.startTime! || entry.startTs) + entry.dur)
 }
 export default function spSystemTraceOnClickHandler(
   sp: SpSystemTrace,
@@ -608,7 +613,7 @@ export function spSystemTraceDocumentOnMouseOut(sp: SpSystemTrace, ev: MouseEven
 
 export function spSystemTraceDocumentOnKeyPress(this: unknown, sp: SpSystemTrace, ev: KeyboardEvent): void {
   SpSystemTrace.isKeyUp = false;
-  if (!sp.loadTraceCompleted) {
+  if (!sp.loadTraceCompleted || SpSystemTrace.isAiAsk) {
     return;
   }
   let keyPress = ev.key.toLocaleLowerCase();
@@ -835,14 +840,12 @@ export function spSystemTraceDocumentOnKeyUp(sp: SpSystemTrace, ev: KeyboardEven
         })
       );
     } else {
-      if (sp.focusTarget === '') {
-        sp.dispatchEvent(
-          new CustomEvent('trace-next-data', {
-            detail: {},
-            composed: false,
-          })
-        );
-      }
+      sp.dispatchEvent(
+        new CustomEvent('trace-next-data', {
+          detail: {},
+          composed: false,
+        })
+      );
     }
     document.addEventListener('keydown', sp.documentOnKeyDown);
   }
diff --git a/ide/src/trace/component/SpSystemTrace.init.ts b/ide/src/trace/component/SpSystemTrace.init.ts
index 93f6d623a01265e443021ac0c17a20bfd0f3c984..337a4c425960a80df130ebf2d36a5f5889b56e26 100644
--- a/ide/src/trace/component/SpSystemTrace.init.ts
+++ b/ide/src/trace/component/SpSystemTrace.init.ts
@@ -503,6 +503,7 @@ function selectHandler(sp: SpSystemTrace): void {
       }
       sp.refreshCanvas(true);
       if (!SportRuler.isMouseInSportRuler) {
+        sp.traceSheetEL?.setMode('max');
         sp.traceSheetEL?.setMode('hidden');
       }
       return;
@@ -510,6 +511,7 @@ function selectHandler(sp: SpSystemTrace): void {
     let checkRows = rows;
     if (!refreshCheckBox) {
       checkRows = [
+        ...rows,
         // @ts-ignore
         ...sp.shadowRoot!.querySelectorAll<TraceRow<unknown>>(`trace-row[check-type='2']`),
         ...sp.favoriteChartListEL!.getAllSelectCollectRows(),
@@ -551,6 +553,7 @@ function selectHandlerRows(sp: SpSystemTrace, rows: Array<TraceRow<unknown>>): v
         event: event,
       });
     }
+    sp.setParentCheckStatus(it);
   });
   if (selection.diskIOipids.length > 0 && !selection.diskIOLatency) {
     selection.promiseList.push(
@@ -723,7 +726,6 @@ export function documentInitEvent(sp: SpSystemTrace): void {
   document.addEventListener('triangle-flag', triangleFlagHandler(sp));
   document.addEventListener('number_calibration', numberCalibrationHandler(sp));
   document.addEventListener('flag-change', flagChangeHandler(sp));
-  document.addEventListener('remarksFocus-change', remarksFocuseChangeHandler(sp));
   document.addEventListener('slices-change', slicesChangeHandler(sp));
   if (sp.timerShaftEL?.collecBtn) {
     sp.timerShaftEL.collecBtn.onclick = (): void => {
@@ -739,13 +741,6 @@ export function documentInitEvent(sp: SpSystemTrace): void {
   document.addEventListener('collect', collectHandler(sp));
 }
 
-function remarksFocuseChangeHandler(sp: SpSystemTrace): (event: unknown) => void {
-  return function (event: unknown): void {
-    // @ts-ignore
-    sp.focusTarget = event.detail;
-  };
-}
-
 export function spSystemTraceInitElement(sp: SpSystemTrace): void {
   window.subscribe(window.SmartEvent.UI.LoadFinishFrame, () => sp.drawAllLines());
   sp.traceSheetEL = sp.shadowRoot?.querySelector<TraceSheet>('.trace-sheet');
diff --git a/ide/src/trace/component/SpSystemTrace.ts b/ide/src/trace/component/SpSystemTrace.ts
index 8445cf3bf6f0fb5e9536b62a1a9ac06fc7d90307..b522663aefe5be6c4081de51c002a1513104a971 100644
--- a/ide/src/trace/component/SpSystemTrace.ts
+++ b/ide/src/trace/component/SpSystemTrace.ts
@@ -136,6 +136,7 @@ import { SpProcessChart } from './chart/SpProcessChart';
 import { LitSearch } from './trace/search/Search';
 import { LitTable } from '../../base-ui/table/lit-table';
 import { HangStruct } from '../database/ui-worker/ProcedureWorkerHang';
+import { SpAiAnalysisPage } from './SpAiAnalysisPage';
 
 function dpr(): number {
   return window.devicePixelRatio || 1;
@@ -226,12 +227,12 @@ export class SpSystemTrace extends BaseElement {
   static currentStartTime: number = 0;
   static retargetIndex: number = 0;
   prevScrollY: number = 0;
-  focusTarget: string = '';
   wakeupListTbl: LitTable | undefined | null;
   _checkclick: boolean = false; //判断点击getWakeupList按钮
   docomList: Array<number> = [];
   repaintList: Array<number> = [];
   presentList: Array<number> = [];
+  static isAiAsk: boolean = false;
 
   set snapshotFile(data: FileInfo) {
     this.snapshotFiles = data;
@@ -559,6 +560,9 @@ export class SpSystemTrace extends BaseElement {
         )
       );
     }
+    if (!TraceRow.rangeSelectObject && !this.isSlectStruct()) {
+      SpAiAnalysisPage.selectChangeListener(TraceRow.range?.startNS!, TraceRow.range?.endNS!)
+    }
     //在rowsEL显示范围内的 trace-row组件将收到时间区间变化通知
     this.linkNodes.forEach((it) => {
       it[0].x = ns2xByTimeShaft(it[0].ns, this.timerShaftEL!);
@@ -568,6 +572,37 @@ export class SpSystemTrace extends BaseElement {
     this.visibleRows.forEach((it) => (it.needRefresh = true));
     this.refreshCanvas(false, 'rangeChange');
   };
+  isSlectStruct() {
+    return CpuStruct.selectCpuStruct ||
+      CpuStruct.wakeupBean ||
+      CpuFreqStruct.selectCpuFreqStruct ||
+      ThreadStruct.selectThreadStruct ||
+      ThreadStruct.isClickPrio ||
+      FuncStruct.selectFuncStruct ||
+      SpHiPerf.selectCpuStruct ||
+      CpuStateStruct.selectStateStruct ||
+      CpuFreqLimitsStruct.selectCpuFreqLimitsStruct ||
+      ClockStruct.selectClockStruct ||
+      IrqStruct.selectIrqStruct ||
+      JankStruct.selectJankStruct ||
+      HeapStruct.selectHeapStruct ||
+      AppStartupStruct.selectStartupStruct ||
+      SoStruct.selectSoStruct ||
+      HeapSnapshotStruct.selectSnapshotStruct ||
+      FrameSpacingStruct.selectFrameSpacingStruct ||
+      FrameAnimationStruct.selectFrameAnimationStruct ||
+      FrameDynamicStruct.selectFrameDynamicStruct ||
+      JsCpuProfilerStruct.selectJsCpuProfilerStruct ||
+      SnapshotStruct.selectSnapshotStruct ||
+      HiPerfCallChartStruct.selectStruct ||
+      AllAppStartupStruct.selectStartupStruct ||
+      LtpoStruct.selectLtpoStruct ||
+      HitchTimeStruct.selectHitchTimeStruct ||
+      SampleStruct.selectSampleStruct ||
+      PerfToolStruct.selectPerfToolStruct ||
+      GpuCounterStruct.selectGpuCounterStruct ||
+      DmaFenceStruct.selectDmaFenceStruct;
+  }
   top: number = 0;
   handler: number = -1;
   rowsElOnScroll = (e: unknown): void => {
@@ -1000,14 +1035,12 @@ export class SpSystemTrace extends BaseElement {
           })
         );
       } else {
-        if (this.focusTarget === '') {
-          this.dispatchEvent(
-            new CustomEvent('trace-next-data', {
-              detail: { down: true },
-              composed: false,
-            })
-          );
-        }
+        this.dispatchEvent(
+          new CustomEvent('trace-next-data', {
+            detail: { down: true },
+            composed: false,
+          })
+        );
       }
     }
   };
@@ -1131,9 +1164,6 @@ export class SpSystemTrace extends BaseElement {
       const selectList = [];
       const unSelectList = [];
       for (const child of childrenList) {
-        if (child.offsetParent === null) {
-          continue;
-        }
         if (child.checkType === '2') {
           selectList.push(child);
         } else {
@@ -1166,13 +1196,22 @@ export class SpSystemTrace extends BaseElement {
   // @ts-ignore
   selectChangeHandler = (row: TraceRow<unknown>): void => {
     this.setParentCheckStatus(row);
+    // @ts-ignore
+    const foldSelectParentRowList: Array<TraceRow<unknown>> = this.shadowRoot!.querySelectorAll<TraceRow<unknown>>("trace-row[check-type='1']");
+    // @ts-ignore
+    const foldSelectRowList: Array<TraceRow<unknown>> = [];
+    // @ts-ignore
+    foldSelectParentRowList.length && foldSelectParentRowList.forEach((item) => item.childrenList.filter((child: { checkType: string }) => child!.checkType === '2' && foldSelectRowList.push(child)));
     const rows = [
+      ...foldSelectRowList,
       // @ts-ignore
       ...this.shadowRoot!.querySelectorAll<TraceRow<unknown>>("trace-row[check-type='2']"),
       ...this.favoriteChartListEL!.getAllSelectCollectRows(),
     ];
     this.isSelectClick = true;
-    this.rangeSelect.rangeTraceRow = rows; // @ts-ignore
+    this.rangeSelect.rangeTraceRow = rows;
+    this.rangeSelect.checkRowsName(this.rangeSelect.rangeTraceRow);
+    // @ts-ignore
     let changeTraceRows: Array<TraceRow<unknown>> = [];
     if (this.rangeTraceRow!.length < rows.length) {
       // @ts-ignore
@@ -1294,6 +1333,7 @@ export class SpSystemTrace extends BaseElement {
     });
     this.rangeSelect.rangeTraceRow = [];
     TraceRow.rangeSelectObject = undefined;
+    SpAiAnalysisPage.selectChangeListener(TraceRow.range?.startNS!, TraceRow.range?.endNS!);
     this.selectStructNull();
     this.wakeupListNull();
     this.observerScrollHeightEnable = false;
diff --git a/ide/src/trace/component/chart/SpAbilityMonitorChart.ts b/ide/src/trace/component/chart/SpAbilityMonitorChart.ts
index 7ce449782d216537656da6bf1cdea5c9349eed86..dd6358fc85f5ba223669b4e0ce674cce8c992dd2 100644
--- a/ide/src/trace/component/chart/SpAbilityMonitorChart.ts
+++ b/ide/src/trace/component/chart/SpAbilityMonitorChart.ts
@@ -43,6 +43,7 @@ import { MemoryConfig } from '../../bean/MemoryConfig';
 import { queryMemoryMaxData } from '../../database/sql/Memory.sql';
 import { queryDiskIoMaxData, queryNetWorkMaxData } from '../../database/sql/SqlLite.sql';
 import { queryAbilityExits, queryCPuAbilityMaxData, queryPurgeableSysData } from '../../database/sql/Ability.sql';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 const networkNameList: Array<string> = ['Bytes In/Sec', 'Bytes Out/Sec', 'Packets In/Sec', 'Packets Out/Sec'];
 const memoryNameList: Array<string> = ['MemoryTotal', 'Cached', 'SwapTotal'];
 const diskIONameList: Array<string> = ['Bytes Read/Sec', 'Bytes Written/Sec', 'Read Ops/Sec', 'Written Ops/Sec'];
@@ -93,6 +94,13 @@ export class SpAbilityMonitorChart {
     }
     if (this.hasTable(result, 'trace_diskio')) {
       await this.initDiskAbility(processRow);
+      // 统计diskio插件
+      let requestBody = {
+        eventData: {
+          plugin: ['diskio-plugin']
+        }
+      };
+      SpStatisticsHttpUtil.recordPluginUsage(requestBody);
     }
     if (this.hasTable(result, 'trace_network')) {
       await this.initNetworkAbility(processRow);
diff --git a/ide/src/trace/component/chart/SpArkTsChart.ts b/ide/src/trace/component/chart/SpArkTsChart.ts
index 02125153da1b1e1bf72728e1164e9a3d62da9334..ece549344366b7b030a517b4187ec2b162a63a6a 100644
--- a/ide/src/trace/component/chart/SpArkTsChart.ts
+++ b/ide/src/trace/component/chart/SpArkTsChart.ts
@@ -29,6 +29,7 @@ import { cpuProfilerDataSender } from '../../database/data-trafic/ArkTsSender';
 import { queryJsCpuProfilerConfig, queryJsCpuProfilerData } from '../../database/sql/Cpu.sql';
 import { queryJsMemoryData } from '../../database/sql/Memory.sql';
 import { type HeapSample } from '../../../js-heap/model/DatabaseStruct';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 const TYPE_SNAPSHOT = 0;
 const TYPE_TIMELINE = 1;
@@ -156,6 +157,13 @@ export class SpArkTsChart implements ParseListener {
       if (this.jsCpuProfilerRow && jsCpu.length > 0) {
         this.cpuProfilerSupplierFrame();
       }
+      // 统计arkTs插件
+      let requsetBody = {
+        eventData:{
+          plugin:['arkts-plugin']
+        }
+      };
+      SpStatisticsHttpUtil.recordPluginUsage(requsetBody);
     }
   }
 
diff --git a/ide/src/trace/component/chart/SpChartManager.ts b/ide/src/trace/component/chart/SpChartManager.ts
index a852490e04703fb9da1a9fdf35edca557d3645ae..9adf92fdfcc28cfff8a43c8e3d840d8a4c141ace 100644
--- a/ide/src/trace/component/chart/SpChartManager.ts
+++ b/ide/src/trace/component/chart/SpChartManager.ts
@@ -29,6 +29,7 @@ import { SpSdkChart } from './SpSdkChart';
 import { SpHiSysEnergyChart } from './SpHiSysEnergyChart';
 import { VmTrackerChart } from './SpVmTrackerChart';
 import { SpClockChart } from './SpClockChart';
+import { SpXpowerChart } from './SpXpowerChart';
 import { SpIrqChart } from './SpIrqChart';
 import { renders } from '../../database/ui-worker/ProcedureWorker';
 import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU';
@@ -80,6 +81,7 @@ export class SpChartManager {
   private hiSyseventChart: SpHiSysEnergyChart;
   private smapsChart: VmTrackerChart;
   private clockChart: SpClockChart;
+  private xpowerChart: SpXpowerChart;
   private irqChart: SpIrqChart;
   private spAllAppStartupsChart!: SpAllAppStartupsChart;
   private SpLtpoChart!: SpLtpoChart;
@@ -124,6 +126,7 @@ export class SpChartManager {
     this.spGpuCounterChart = new SpGpuCounterChart(trace);
     this.spUserFileChart = new SpUserFileChart(trace);
     this.spImportUserPluginsChart = new SpImportUserPluginsChart(trace);
+    this.xpowerChart = new SpXpowerChart(trace);
   }
   async initPreprocessData(progress: Function): Promise<void> {
     progress('load data dict', 50);
@@ -199,6 +202,8 @@ export class SpChartManager {
     }
     progress('Clock init', 82);
     await this.clockChart.init();
+    progress('Xpower init', 83);
+    await this.xpowerChart.init();
     progress('Irq init', 84);
     await this.irqChart.init();
     progress('SpSegmentationChart inin', 84.5);
diff --git a/ide/src/trace/component/chart/SpCpuChart.ts b/ide/src/trace/component/chart/SpCpuChart.ts
index 872c6bb09bbf8bfd8d38abfb6bf8cc1341585730..689b4a0bd7b293bf5b30cde7a9436accdf9cd5ac 100644
--- a/ide/src/trace/component/chart/SpCpuChart.ts
+++ b/ide/src/trace/component/chart/SpCpuChart.ts
@@ -23,6 +23,7 @@ import { Utils } from '../trace/base/Utils';
 import { cpuDataSender } from '../../database/data-trafic/CpuDataSender';
 import { queryCpuCount, queryCpuMax, queryCpuSchedSlice } from '../../database/sql/Cpu.sql';
 import { rowThreadHandler } from './SpChartManager';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export class SpCpuChart {
   private trace: SpSystemTrace;
@@ -92,6 +93,13 @@ export class SpCpuChart {
     this.initSchedSliceData(cpuSchedSlice, traceId);
     info('Cpu trace row data size is: ', array.length);
     if (array && array.length > 0 && array[0]) {
+      // 有cpu泳道，统计ftrace插件，cpu插件
+      let requestBody = {
+        eventData: {
+          plugin: ['ftrace-plugin', 'cpu-plugin']
+        }
+      };
+      SpStatisticsHttpUtil.recordPluginUsage(requestBody);
       //@ts-ignore
       let cpuMax = array[0].cpu + 1;
       Utils.getInstance().setCpuCount(cpuMax, traceId);
diff --git a/ide/src/trace/component/chart/SpEBPFChart.ts b/ide/src/trace/component/chart/SpEBPFChart.ts
index ade1dd6870b165e3ff33715d6a4d408cc72c8f5b..366470a42099b2d7e4450dc5390190000f8928fe 100644
--- a/ide/src/trace/component/chart/SpEBPFChart.ts
+++ b/ide/src/trace/component/chart/SpEBPFChart.ts
@@ -24,6 +24,7 @@ import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU';
 import { diskIoSender, fileSysVMSender, fileSystemSender } from '../../database/data-trafic/EBPFSender';
 import { hasFileSysData } from '../../database/sql/Memory.sql';
 import { getDiskIOProcess } from '../../database/sql/SqlLite.sql';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export class SpEBPFChart {
   private trace: SpSystemTrace;
@@ -55,6 +56,13 @@ export class SpEBPFChart {
           await this.initDiskIOLatency(folder);
           await this.initProcessDiskIOLatency(folder);
         }
+        // 统计ebpf插件
+        let requsetBody = {
+          eventData: {
+            plugin: ['hiebpf-plugin']
+          }
+        };
+        SpStatisticsHttpUtil.recordPluginUsage(requsetBody);
       }
     }
   }
diff --git a/ide/src/trace/component/chart/SpHiPerf.ts b/ide/src/trace/component/chart/SpHiPerf.ts
index 1a52aa9b3f11fb530893b5041327c9a3a21305ed..bcf66335d02f7592c3fb0337541c4469b1003280 100644
--- a/ide/src/trace/component/chart/SpHiPerf.ts
+++ b/ide/src/trace/component/chart/SpHiPerf.ts
@@ -47,6 +47,7 @@ import {
   queryPerfThread,
 } from '../../database/sql/Perf.sql';
 import { renders } from '../../database/ui-worker/ProcedureWorker';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export interface ResultData {
   existA: boolean | null | undefined;
@@ -87,6 +88,13 @@ export class SpHiPerf {
     this.eventTypeId = -2; //@ts-ignore
     this.maxCpuId = this.cpuData.length > 0 ? this.cpuData[0].cpu_id : -Infinity;
     if (this.cpuData.length > 0) {
+      // 统计hiperf插件
+      let requestBody = {
+        eventData: {
+          plugin: ['hiperf-plugin']
+        }
+      };
+      SpStatisticsHttpUtil.recordPluginUsage(requestBody);
       await this.initFolder();
       await this.initCallChart();
       await this.initCpuMerge();
diff --git a/ide/src/trace/component/chart/SpHiSysEventChart.ts b/ide/src/trace/component/chart/SpHiSysEventChart.ts
index 6381ef78502f4139b75201105ee02f48c8fd4fcf..87b7534b11f038ad9c099006ce81aca7c6b5aece 100644
--- a/ide/src/trace/component/chart/SpHiSysEventChart.ts
+++ b/ide/src/trace/component/chart/SpHiSysEventChart.ts
@@ -19,6 +19,7 @@ import { renders } from '../../database/ui-worker/ProcedureWorker';
 import { HiSysEventRender, HiSysEventStruct } from '../../database/ui-worker/ProcedureWorkerHiSysEvent';
 import { hiSysEventDataSender } from '../../database/data-trafic/HiSysEventDataSender';
 import { queryHiSysEventData } from '../../database/sql/Perf.sql';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export class SpHiSysEventChart {
   private trace: SpSystemTrace;
@@ -34,6 +35,13 @@ export class SpHiSysEventChart {
     }
     let eventRow = await this.initRow();
     this.trace.rowsEL?.appendChild(eventRow);
+    // 统计hiSysevent插件
+    let requestBody = {
+      eventData:{
+        plugin:['hisysevent']
+      }
+    };
+    SpStatisticsHttpUtil.recordPluginUsage(requestBody);
   }
 
   async initRow(): Promise<TraceRow<HiSysEventStruct>> {
diff --git a/ide/src/trace/component/chart/SpLogChart.ts b/ide/src/trace/component/chart/SpLogChart.ts
index 45680a87670dd66b0355437356c1991bf254a472..898fe37e2a2dcee784a9e58b339f5cb262b170df 100644
--- a/ide/src/trace/component/chart/SpLogChart.ts
+++ b/ide/src/trace/component/chart/SpLogChart.ts
@@ -19,6 +19,7 @@ import { renders } from '../../database/ui-worker/ProcedureWorker';
 import { LogRender, LogStruct } from '../../database/ui-worker/ProcedureWorkerLog';
 import { LogDataSender } from '../../database/data-trafic/LogDataSender';
 import { queryLogData } from '../../database/sql/SqlLite.sql';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export class SpLogChart {
   private trace: SpSystemTrace;
@@ -34,6 +35,13 @@ export class SpLogChart {
     }
     let folder = await this.initFolder();
     this.trace.rowsEL?.appendChild(folder);
+    // 统计hilog插件
+    let requestBody = {
+      eventData:{
+        plugin:['hilog-plugin']
+      }
+    };
+    SpStatisticsHttpUtil.recordPluginUsage(requestBody);
   }
 
   async initFolder(): Promise<TraceRow<LogStruct>> {
diff --git a/ide/src/trace/component/chart/SpNativeMemoryChart.ts b/ide/src/trace/component/chart/SpNativeMemoryChart.ts
index bf02eaab7ec652fc688f4a6bd4fc776a3596ed6b..53f703517bf1ee6daafbf3c4b0475126f5daed5f 100644
--- a/ide/src/trace/component/chart/SpNativeMemoryChart.ts
+++ b/ide/src/trace/component/chart/SpNativeMemoryChart.ts
@@ -31,6 +31,7 @@ import { queryNativeHookProcess, queryNativeHookStatisticsCount } from '../../da
 import { queryHeapGroupByEvent } from '../../database/sql/SqlLite.sql';
 import { queryNativeMemoryRealTime } from '../../database/sql/Memory.sql';
 import { queryBootTime } from '../../database/sql/Clock.sql';
+import { SpStatisticsHttpUtil } from '../../../statistics/util/SpStatisticsHttpUtil';
 
 export class SpNativeMemoryChart {
   static EVENT_HEAP: Array<NativeEventHeap> = [];
@@ -181,6 +182,13 @@ export class SpNativeMemoryChart {
     if (nativeProcess.length === 0) {
       return;
     }
+    // 有native_memory进程，统计nativehook插件
+    let requestBody = {
+      eventData: {
+        plugin: ['nativehook']
+      }
+    };
+    SpStatisticsHttpUtil.recordPluginUsage(requestBody);
     await this.initNativeMemory();
     await nativeMemoryChartDataCacheSender(
       nativeProcess.map((it) => it.ipid),
diff --git a/ide/src/trace/component/chart/SpProcessChart.ts b/ide/src/trace/component/chart/SpProcessChart.ts
index 9a5ea1156ec827595a0ae43630e4bc3c42314e2d..e316dcd5cefd66feddec1a7b31db16dbecfd0ba2 100644
--- a/ide/src/trace/component/chart/SpProcessChart.ts
+++ b/ide/src/trace/component/chart/SpProcessChart.ts
@@ -58,6 +58,8 @@ import { HangStruct } from '../../database/ui-worker/ProcedureWorkerHang';
 import { hangDataSender } from '../../database/data-trafic/HangDataSender';
 import { SpHangChart } from './SpHangChart';
 import { queryHangData } from '../../database/sql/Hang.sql';
+import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU';
+import { renders } from '../../database/ui-worker/ProcedureWorker';
 
 const FOLD_HEIGHT = 24;
 export class SpProcessChart {
@@ -96,6 +98,7 @@ export class SpProcessChart {
   static asyncFuncCache: unknown[] = [];
   static threadStateList: Map<string, unknown> = new Map();
   static processRowSortMap: Map<string, unknown> = new Map();
+  private sameThreadFolder!: TraceRow<ProcessStruct>;
 
   private hangProcessSet: Set<number> = new Set();
   constructor(trace: SpSystemTrace) {
@@ -566,7 +569,7 @@ export class SpProcessChart {
         this.addThreadList(it, processRow, expectedRow, actualRow, soRow, startupRow, traceId); //@ts-ignore
         this.addProcessMemInfo(it, processRow); //@ts-ignore
         this.addAsyncFunction(it, processRow);//@ts-ignore
-        this.addProcessMemInfo(it, processRow);
+        this.addAsyncCatFunction(it, processRow);
       } else {
         //@ts-ignore
         this.addAsyncFunction(it, processRow); //@ts-ignore
@@ -1060,7 +1063,7 @@ export class SpProcessChart {
   }
 
   //add thread list
-  addThreadList(
+  async addThreadList(
     it: { pid: number | null; processName: string | null },
     pRow: TraceRow<ProcessStruct>,
     expectedRow: TraceRow<JankStruct> | null,
@@ -1068,11 +1071,145 @@ export class SpProcessChart {
     soRow: TraceRow<SoStruct> | undefined,
     startupRow: TraceRow<AppStartupStruct> | undefined,
     traceId?: string
-  ): void {
+  ): Promise<void> {
     let threads = this.processThreads.filter((thread) => thread.pid === it.pid && thread.tid !== 0);
+    const sameThreadCounts: Record<string, number> = {}; //同名thread添加子进程  
+    const sameThreadList: any[] = [];
+    const differentThreadList: any[] = [];
+    threads.forEach(item => {
+      const sameThread = item.threadName;
+      if (sameThread !== undefined) {
+        if (sameThread in sameThreadCounts) {
+          sameThreadCounts[sameThread]++;
+        } else {
+          sameThreadCounts[sameThread] = 1;
+        }
+      }
+    });
+
+    threads.forEach((item) => {
+      const sameThread = item.threadName;
+      if (sameThreadCounts[sameThread!] > 128) {
+        sameThreadList.push(item);
+      } else {
+        differentThreadList.push(item);
+      }
+    });
+
+    differentThreadList.length && this.addDifferentThread(it, pRow, expectedRow, actualRow, soRow, startupRow, differentThreadList, traceId!);
+    if (sameThreadList.length) {
+      let sameThreadFolder = await this.initSameThreadFolder(it, pRow, sameThreadList, traceId!);
+      if (sameThreadFolder) {
+        pRow.addChildTraceRow(this.sameThreadFolder);
+      }
+      await this.initSameThreadData(sameThreadFolder, it, expectedRow, actualRow, soRow, startupRow, sameThreadList, traceId);
+    }
+  }
+
+  initSameThreadFolder(it: { pid: number | null; processName: string | null }, pRow: TraceRow<ProcessStruct>, list: Array<any>, traceId?: string) {
+    let sameThreadRow = TraceRow.skeleton<ProcessStruct>();
+    sameThreadRow.rowId = 'sameThreadProcess';
+    sameThreadRow.rowParentId = `${it.pid}`;
+    sameThreadRow.rowHidden = !pRow.expansion;
+    sameThreadRow.rowType = TraceRow.ROW_TYPE_THREAD_NAME;
+    sameThreadRow.folder = true;
+    sameThreadRow.name = list[0].threadName;
+    sameThreadRow.folderPaddingLeft = 20;
+    sameThreadRow.style.height = '40px';
+    sameThreadRow.style.width = '100%';
+    sameThreadRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
+    sameThreadRow.selectChangeHandler = this.trace.selectChangeHandler;
+    sameThreadRow.supplierFrame = (): Promise<Array<ProcessStruct>> =>
+      new Promise<Array<ProcessStruct>>((resolve) => resolve([]));
+    sameThreadRow.onThreadHandler = (useCache): void => {
+      let context: CanvasRenderingContext2D;
+      if (sameThreadRow.currentContext) {
+        context = sameThreadRow.currentContext;
+      } else {
+        context = sameThreadRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
+      }
+      sameThreadRow.canvasSave(context);
+      if (sameThreadRow.expansion) {
+        // @ts-ignore
+        context?.clearRect(0, 0, sameThreadRow.frame.width, sameThreadRow.frame.height);
+      } else {
+        (renders.empty as EmptyRender).renderMainThread(
+          {
+            context: context,
+            useCache: useCache,
+            type: '',
+          },
+          sameThreadRow
+        );
+      }
+      sameThreadRow.canvasRestore(context, this.trace);
+    };
+    this.sameThreadFolder = sameThreadRow;
+    return this.sameThreadFolder;
+  }
+
+  async initSameThreadData(sameThreadFolder: TraceRow<ProcessStruct>, it: { pid: number | null; processName: string | null },
+    expectedRow: TraceRow<JankStruct> | null,
+    actualRow: TraceRow<JankStruct> | null,
+    soRow: TraceRow<SoStruct> | undefined,
+    startupRow: TraceRow<AppStartupStruct> | undefined, sameThreadList: Array<any>, traceId?: string): Promise<void> {
+    let tRowArr: Array<TraceRow<BaseStruct>> = [];
+    for (let j = 0; j < sameThreadList.length; j++) {
+      let thread = sameThreadList[j];
+      let tRow = TraceRow.skeleton<ThreadStruct>(this.traceId);
+      tRow.rowId = `${thread.tid}`;
+      tRow.rowType = TraceRow.ROW_TYPE_THREAD;
+      tRow.rowParentId = sameThreadFolder.rowId;
+      tRow.rowHidden = !sameThreadFolder.expansion;
+      tRow.index = j;
+      tRow.style.height = '18px';
+      tRow.style.width = '100%';
+      tRow.name = `${thread.threadName || 'Thread'} ${thread.tid}`;
+      tRow.namePrefix = `${thread.threadName || 'Thread'}`;
+      tRow.setAttribute('children', '');
+      tRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
+      tRow.selectChangeHandler = this.trace.selectChangeHandler;
+      tRow.findHoverStruct = (): void => this.threadRowFindHoverStruct(tRow);
+      tRow.supplierFrame = async (): Promise<Array<ThreadStruct>> => {
+        const res = await threadDataSender(thread.tid || 0, it.pid || 0, tRow, this.traceId);
+        if (res === true) {
+          return [];
+        }
+        let rs = res as ThreadStruct[];
+        if (rs.length <= 0 && !tRow.isComplete) {
+          this.trace.refreshCanvas(true);
+        }
+        return rs;
+      };
+      tRow.onThreadHandler = rowThreadHandler<ThreadRender>(
+        'thread',
+        'context',
+        {
+          type: `thread ${thread.tid} ${thread.threadName}`,
+          translateY: tRow.translateY,
+        },
+        tRow,
+        this.trace
+      );
+      this.insertRowToDoc(it, j, thread, sameThreadFolder, tRow, sameThreadList, tRowArr, actualRow, expectedRow, startupRow, soRow);
+      this.addFuncStackRow(it, thread, j, sameThreadList, tRowArr, tRow, sameThreadFolder, sameThreadFolder.rowId!);
+      if ((thread.switchCount || 0) === 0) {
+        tRow.rowDiscard = true;
+      }
+      sameThreadFolder.addChildTraceRow(tRow);
+    }
+  }
+
+  addDifferentThread(it: { pid: number | null; processName: string | null },
+    pRow: TraceRow<ProcessStruct>,
+    expectedRow: TraceRow<JankStruct> | null,
+    actualRow: TraceRow<JankStruct> | null,
+    soRow: TraceRow<SoStruct> | undefined,
+    startupRow: TraceRow<AppStartupStruct> | undefined,
+    list: Array<any>, traceId?: string) {
     let tRowArr: Array<TraceRow<BaseStruct>> = [];
-    for (let j = 0; j < threads.length; j++) {
-      let thread = threads[j];
+    for (let j = 0; j < list.length; j++) {
+      let thread = list[j];
       let tRow = TraceRow.skeleton<ThreadStruct>(this.traceId);
       tRow.rowId = `${thread.tid}`;
       tRow.rowType = TraceRow.ROW_TYPE_THREAD;
@@ -1108,8 +1245,8 @@ export class SpProcessChart {
         tRow,
         this.trace
       );
-      this.insertRowToDoc(it, j, thread, pRow, tRow, threads, tRowArr, actualRow, expectedRow, startupRow, soRow);
-      this.addFuncStackRow(it, thread, j, threads, tRowArr, tRow, pRow);
+      this.insertRowToDoc(it, j, thread, pRow, tRow, list, tRowArr, actualRow, expectedRow, startupRow, soRow);
+      this.addFuncStackRow(it, thread, j, list, tRowArr, tRow, pRow);
       if ((thread.switchCount || 0) === 0) {
         tRow.rowDiscard = true;
       }
@@ -1185,6 +1322,7 @@ export class SpProcessChart {
     threadRowArr: Array<unknown>,
     threadRow: TraceRow<ThreadStruct>,
     processRow: TraceRow<ProcessStruct>,
+    parentId?: string
   ): void {
     //@ts-ignore
     if (this.threadFuncMaxDepthMap.get(`${thread.upid}-${thread.tid}`) !== undefined) {
@@ -1197,7 +1335,7 @@ export class SpProcessChart {
       funcRow.rowType = TraceRow.ROW_TYPE_FUNC;
       funcRow.enableCollapseChart(FOLD_HEIGHT, this.trace); //允许折叠泳道图
       //@ts-ignore
-      funcRow.rowParentId = `${process.pid}`;
+      funcRow.rowParentId = parentId ? parentId : `${process.pid}`;
       funcRow.rowHidden = !processRow.expansion;
       funcRow.checkType = threadRow.checkType;
       funcRow.style.width = '100%';
diff --git a/ide/src/trace/component/chart/SpXpowerChart.ts b/ide/src/trace/component/chart/SpXpowerChart.ts
new file mode 100644
index 0000000000000000000000000000000000000000..21d63b0b4bf3c78b27cd70e61d5bf7f5df5638f0
--- /dev/null
+++ b/ide/src/trace/component/chart/SpXpowerChart.ts
@@ -0,0 +1,252 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+import { SpSystemTrace } from '../SpSystemTrace';
+import { TraceRow } from '../trace/base/TraceRow';
+import { renders } from '../../database/ui-worker/ProcedureWorker';
+import { info } from '../../../log/Log';
+import { XpowerRender, XpowerStruct } from '../../database/ui-worker/ProcedureWorkerXpower';
+import { ColorUtils } from '../trace/base/ColorUtils';
+import { EmptyRender } from '../../database/ui-worker/cpu/ProcedureWorkerCPU';
+import { xpowerDataSender } from '../../database/data-trafic/XpowerDataSender';
+import { queryXpowerData, queryXpowerMeasureData } from '../../database/sql/Xpower.sql';
+import { BaseStruct } from '../../bean/BaseStruct';
+
+export class SpXpowerChart {
+    private readonly trace: SpSystemTrace;
+    private rowFolder!: TraceRow<BaseStruct>;
+    private systemFolder!: TraceRow<BaseStruct>;
+
+    constructor(trace: SpSystemTrace) {
+        this.trace = trace;
+    }
+
+    async init(traceId?: string): Promise<void> {
+        let XpowerMeasureData = await queryXpowerMeasureData(traceId);
+        if (XpowerMeasureData.length <= 0) {
+            return;
+        }
+        let xpowerList = await queryXpowerData(traceId);
+        if (xpowerList.length <= 0) {
+            return;
+        }
+        await this.initXpowerFolder(traceId);
+        await this.initSystemFolder(traceId);
+        await this.initSystemData(this.systemFolder, xpowerList, traceId);
+    }
+
+    initXpowerFolder = async (traceId?: string): Promise<void> => {
+        let xpowerFolder = TraceRow.skeleton(traceId);
+        xpowerFolder.rowId = 'Xpowers';
+        xpowerFolder.index = 0;
+        xpowerFolder.rowType = TraceRow.ROW_TYPE_XPOWER;
+        xpowerFolder.rowParentId = '';
+        xpowerFolder.style.height = '40px';
+        xpowerFolder.folder = true;
+        xpowerFolder.name = 'Xpower';
+        xpowerFolder.favoriteChangeHandler = this.trace.favoriteChangeHandler;
+        xpowerFolder.selectChangeHandler = this.trace.selectChangeHandler;
+        xpowerFolder.supplier = (): Promise<BaseStruct[]> => new Promise<Array<BaseStruct>>((resolve) => resolve([]));
+        xpowerFolder.onThreadHandler = (useCache): void => {
+            xpowerFolder.canvasSave(this.trace.canvasPanelCtx!);
+            if (xpowerFolder.expansion) {
+                this.trace.canvasPanelCtx?.clearRect(0, 0, xpowerFolder.frame.width, xpowerFolder.frame.height);
+            } else {
+                (renders.empty as EmptyRender).renderMainThread(
+                    {
+                        context: this.trace.canvasPanelCtx,
+                        useCache: useCache,
+                        type: '',
+                    },
+                    xpowerFolder
+                );
+            }
+            xpowerFolder.canvasRestore(this.trace.canvasPanelCtx!, this.trace);
+        };
+        this.rowFolder = xpowerFolder;
+        this.trace.rowsEL?.appendChild(xpowerFolder);
+    }
+
+    initSystemFolder = async (traceId?: string): Promise<void> => {
+        let systemFolder = TraceRow.skeleton(traceId);
+        systemFolder.rowId = 'system';
+        systemFolder.rowParentId = 'Xpowers';
+        systemFolder.rowHidden = !this.rowFolder.expansion;
+        systemFolder.rowType = TraceRow.ROW_TYPE_XPOWER_SYSTEM;
+        systemFolder.folder = true;
+        systemFolder.name = 'System';
+        systemFolder.folderPaddingLeft = 20;
+        systemFolder.style.height = '40px';
+        systemFolder.favoriteChangeHandler = this.trace.favoriteChangeHandler;
+        systemFolder.selectChangeHandler = this.trace.selectChangeHandler;
+        systemFolder.supplier = (): Promise<BaseStruct[]> => new Promise<Array<BaseStruct>>((resolve) => resolve([]));
+        systemFolder.onThreadHandler = (useCache): void => {
+            systemFolder.canvasSave(this.trace.canvasPanelCtx!);
+            if (systemFolder.expansion) {
+                this.trace.canvasPanelCtx?.clearRect(0, 0, systemFolder.frame.width, systemFolder.frame.height);
+            } else {
+                (renders.empty as EmptyRender).renderMainThread(
+                    {
+                        context: this.trace.canvasPanelCtx,
+                        useCache: useCache,
+                        type: '',
+                    },
+                    systemFolder
+                );
+            }
+            systemFolder.canvasRestore(this.trace.canvasPanelCtx!, this.trace);
+        };
+        this.systemFolder = systemFolder;
+        this.rowFolder?.addChildTraceRow(systemFolder);
+    }
+
+    private xpowerSupplierFrame(
+        traceRow: TraceRow<XpowerStruct>,
+        it: {
+            name: string;
+            num: number;
+            maxValue?: number;
+        },
+    ): void {
+        traceRow.supplierFrame = (): Promise<XpowerStruct[]> => {
+            let promiseData = null;
+            // @ts-ignore
+            promiseData = xpowerDataSender(it.name, traceRow);
+            if (promiseData === null) {
+                // @ts-ignore
+                return new Promise<Array<unknown>>((resolve) => resolve([]));
+            } else {
+                // @ts-ignore
+                return promiseData.then((resultXpower: Array<unknown>) => {
+                    for (let j = 0; j < resultXpower.length; j++) {
+                        // @ts-ignore
+                        if ((resultXpower[j].value || 0) > it.maxValue!) {
+                            // @ts-ignore
+                            it.maxValue = resultXpower[j].value || 0;
+                        }
+                        if (j > 0) {
+                            // @ts-ignore
+                            resultXpower[j].delta = (resultXpower[j].value || 0) - (resultXpower[j - 1].value || 0);
+                        } else {
+                            // @ts-ignore
+                            resultXpower[j].delta = 0;
+                        }
+                    }
+                    return resultXpower;
+                });
+            }
+        };
+    }
+
+    private xpowerThreadHandler(
+        traceRow: TraceRow<XpowerStruct>,
+        it: {
+            name: string;
+            num: number;
+            maxValue?: number;
+        },
+        xpowerId: number
+    ): void {
+        traceRow.onThreadHandler = (useCache): void => {
+            let context: CanvasRenderingContext2D;
+            if (traceRow.currentContext) {
+                context = traceRow.currentContext;
+            } else {
+                context = traceRow.collect ? this.trace.canvasFavoritePanelCtx! : this.trace.canvasPanelCtx!;
+            }
+            traceRow.canvasSave(context);
+            (renders.xpower as XpowerRender).renderMainThread(
+                {
+                    context: context,
+                    useCache: useCache,
+                    type: it.name,
+                    maxValue: it.maxValue === 0 ? 1 : it.maxValue!,
+                    index: xpowerId,
+                    maxName: it.maxValue!.toString()
+                },
+                traceRow
+            );
+            traceRow.canvasRestore(context, this.trace);
+        };
+    }
+
+    async initSystemData(folder: TraceRow<BaseStruct>, xpowerList: Array<{
+        name: string;
+        num: number;
+        maxValue?: number;
+    }>, traceId?: string): Promise<void> {
+        info('xpowerList data size is: ', xpowerList!.length);
+        XpowerStruct.maxValue = xpowerList.map((item) => item.num).reduce((a, b) => Math.max(a, b));
+        for (let i = 0; i < xpowerList.length; i++) {
+            const it = xpowerList[i];
+            it.maxValue = 0;
+            let traceRow = TraceRow.skeleton<XpowerStruct>(traceId);
+            traceRow.rowId = it.name;
+            traceRow.rowType = TraceRow.ROW_TYPE_XPOWER_SYSTEM;
+            traceRow.rowParentId = folder.rowId;
+            traceRow.style.height = '40px';
+            traceRow.name = it.name;
+            traceRow.rowHidden = !folder.expansion;
+            traceRow.folderTextLeft = 40;
+            traceRow.xpowerRowTitle = this.convertTitle(it.name);
+            traceRow.setAttribute('children', '');
+            traceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler;
+            traceRow.selectChangeHandler = this.trace.selectChangeHandler;
+            this.xpowerSupplierFrame(traceRow, it);
+            traceRow.getCacheData = (args: unknown): Promise<XpowerStruct[]> | undefined => {
+                let result: Promise<XpowerStruct[]> | undefined;
+                result = xpowerDataSender(it.name, traceRow, args);
+                return result;
+            };
+            traceRow.focusHandler = (ev): void => {
+                this.trace?.displayTip(
+                    traceRow,
+                    XpowerStruct.hoverXpowerStruct,
+                    `<span>${it.name === 'ThermalReport.ShellTemp' ? XpowerStruct.hoverXpowerStruct?.value! :
+                        ColorUtils.formatNumberComma(XpowerStruct.hoverXpowerStruct?.value!)}</span>`
+                );
+            };
+            traceRow.findHoverStruct = (): void => {
+                XpowerStruct.hoverXpowerStruct = traceRow.getHoverStruct();
+            };
+            this.xpowerThreadHandler(traceRow, it, i);
+            folder.addChildTraceRow(traceRow);
+        }
+    }
+
+    convertTitle(title: string): string {
+        switch (title) {
+            case 'Battery.Capacity':
+                return '电池容量(单位mAh)';
+            case 'Battery.Charge':
+                return '充电状态(充电1,非充电0)';
+            case 'Battery.GasGauge':
+                return '电池剩余电量(单位mAh)';
+            case 'Battery.Level':
+                return '电池百分比';
+            case 'Battery.RealCurrent':
+                return '实时电流(单位mAh,充电时为正数,耗电时为负数)';
+            case 'Battery.Screen':
+                return '屏幕状态(亮屏1,灭屏0)';
+            case 'ThermalReport.ShellTemp':
+                return '外壳温度(单位℃)';
+            case 'ThermalReport.ThermalLevel':
+                return '温度等级';
+            default:
+                return title;
+        }
+    }
+
+}
diff --git a/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts b/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts
index 60c2065b5ab149dba88c9da69c6e7bb2577f12ba..0251cc69276e027012ce97fd7b07111f0d23bc40 100644
--- a/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts
+++ b/ide/src/trace/component/schedulingAnalysis/TabCpuAnalysis.html.ts
@@ -71,7 +71,7 @@ export const TabCpuAnalysisHtml = `
             <div class="cpu_usage" id="cpu_usage_table"></div>
             <div class="cpu-statistics">
                 <div>CPU Statistics By Duration</div>
-                <lit-select default-value="1" id="scheduling_select">
+                <lit-select default-value="1" id="scheduling_select" tabselect>
                     <lit-select-option value="1">CPU Idle</lit-select-option>
                     <lit-select-option value="2">CPU Frequency</lit-select-option>
                     <lit-select-option value="3">CPU Irq</lit-select-option>
diff --git a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts
index d934781d059702e72758af4a61c778f1417dbc17..c48d8f45fa5c0a1abd1edd28bf8574d6a24f4c72 100644
--- a/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts
+++ b/ide/src/trace/component/schedulingAnalysis/Top20FrequencyThread.html.ts
@@ -45,7 +45,7 @@ export const Top20FrequencyThreadHtml = `
         <lit-progress-bar id="loading" style="height: 1px;width: 100%" loading></lit-progress-bar>
         <div style="padding: 15px">
                     Thread Search
-                    <lit-select default-value="1" id="thread_select" show-search placement="bottom"></lit-select>
+                    <lit-select default-value="1" id="thread_select" placement="bottom" tabselect></lit-select>
         </div>
         <table-no-data id="nodata" contentHeight="500px">
         <div class="root">
diff --git a/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10LongestRunTimeProcess.ts b/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10LongestRunTimeProcess.ts
index 77da6c9ebea66cacdbac1df123a457d4eabeb4d7..93f066ce45d12c67398e03b601863b438a5255ea 100644
--- a/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10LongestRunTimeProcess.ts
+++ b/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10LongestRunTimeProcess.ts
@@ -111,7 +111,7 @@ export class Top10LongestRunTimeProcess extends BaseElement {
       const pStr: string | null = this.processMap.get(arr[i].pid!)!;
       const tStr: string | null = this.threadMap.get(arr[i].tid!)!;
       result.push({
-        NO: i + 1,
+        no: i + 1,
         pid: arr[i].pid || this.processId,
         pName: pStr === null ? 'Process ' : pStr,
         dur: arr[i].dur,
@@ -154,8 +154,11 @@ export class Top10LongestRunTimeProcess extends BaseElement {
       color: (a): string => {
         return '#0a59f7';
       },
-      hoverHandler: (data): void => {
+      hoverHandler: (no): void => {
+        let data: unknown = result.find((it) => it.no === no);
         if (data) {
+          // @ts-ignore
+          data.isHover = true;
           this.processRunTimeTbl!.setCurrentHover(data);
         } else {
           this.processRunTimeTbl!.mouseOut();
@@ -198,8 +201,11 @@ export class Top10LongestRunTimeProcess extends BaseElement {
       color: (a): string => {
         return '#0a59f7';
       },
-      hoverHandler: (data): void => {
+      hoverHandler: (no): void => {
+        let data: unknown = result.find((it) => it.no === no);
         if (data) {
+          // @ts-ignore
+          data.isHover = true;
           this.threadRunTimeTbl!.setCurrentHover(data);
         } else {
           this.threadRunTimeTbl!.mouseOut();
@@ -262,10 +268,6 @@ export class Top10LongestRunTimeProcess extends BaseElement {
         this.callBack.bind(this),
         data.pid
       );
-      data.isSelected = true;
-      if (evt.detail.callBack) {
-        evt.detail.callBack(true);
-      }
     });
     this.processRunTimeTbl!.addEventListener('column-click', (evt) => {
       // @ts-ignore
@@ -277,6 +279,12 @@ export class Top10LongestRunTimeProcess extends BaseElement {
       this.sortByColumn(evt.detail, this.threadRunTimeData);
       this.threadRunTimeTbl!.recycleDataSource = this.threadRunTimeData;
     });
+    this.processRunTimeTbl!.addEventListener('contextmenu', (ev) => { 
+      ev.preventDefault();
+    });
+    this.threadRunTimeTbl!.addEventListener('contextmenu', (ev) => {
+      ev.preventDefault();
+    });
     this.back?.addEventListener('click', (event) => {
       this.display_flag = true;
       this.display_pro!.style.display = 'block';
@@ -442,7 +450,7 @@ export class Top10LongestRunTimeProcess extends BaseElement {
               </div>
               <div class="tb_run_time" >
                 <lit-table id='tb-process-run-time' hideDownload style='height: auto'>
-                  <lit-table-column width='1fr' title='NO' data-index='NO' key='NO' align='flex-start' order></lit-table-column>
+                  <lit-table-column width='1fr' title='NO' data-index='no' key='no' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Process_Id' data-index='pid' key='pid' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Process_Name' data-index='pName' key='pName' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Run_Time(ns)' data-index='dur' key='dur' align='flex-start' order></lit-table-column>        
@@ -467,7 +475,7 @@ export class Top10LongestRunTimeProcess extends BaseElement {
               </div>
               <div class="tb_run_time" >
                 <lit-table id='tb-thread-run-time' hideDownload style='height: auto'>
-                  <lit-table-column width='1fr' title='NO' data-index='NO' key='NO' align='flex-start' order></lit-table-column>
+                  <lit-table-column width='1fr' title='NO' data-index='no' key='no' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Process_Id' data-index='pid' key='pid' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Thread_Id' data-index='tid' key='tid' align='flex-start' order></lit-table-column>
                   <lit-table-column width='1fr' title='Thread_Name' data-index='tName' key='tName' align='flex-start' order></lit-table-column>
@@ -483,7 +491,7 @@ export class Top10LongestRunTimeProcess extends BaseElement {
 }
 
 interface Top10RunTimeData {
-  NO?: number,
+  no?: number,
   pid?: number,
   tid?: number,
   pName?: string,
diff --git a/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10ProcessSwitchCount.ts b/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10ProcessSwitchCount.ts
index a709616fe9b079af175c411cea6694efe52fce33..6c195047b600e4120cd4c9b577126e7059571691 100644
--- a/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10ProcessSwitchCount.ts
+++ b/ide/src/trace/component/schedulingAnalysis/processAnalysis/Top10ProcessSwitchCount.ts
@@ -250,6 +250,9 @@ export class Top10ProcessSwitchCount extends BaseElement {
     this.back = this.shadowRoot!.querySelector<HTMLDivElement>('#back');
     this.clickEventListener();
     this.hoverEventListener();
+    this.addEventListener('contextmenu', (event) => {
+      event.preventDefault(); // 阻止默认的上下文菜单弹框
+    });
   }
 
   /**
@@ -269,18 +272,6 @@ export class Top10ProcessSwitchCount extends BaseElement {
         this.callBack.bind(this),
         data.pid
       );
-      data.isSelected = true;
-      if (evt.detail.callBack) {
-        evt.detail.callBack(true);
-      }
-    });
-    // @ts-ignore
-    this.threadSwitchCountTbl!.addEventListener('row-click', (evt: CustomEvent) => {
-      let data = evt.detail.data;
-      data.isSelected = true;
-      if (evt.detail.callBack) {
-        evt.detail.callBack(true);
-      }
     });
     this.processSwitchCountTbl!.addEventListener('column-click', (evt) => {
       // @ts-ignore
@@ -292,6 +283,7 @@ export class Top10ProcessSwitchCount extends BaseElement {
       this.sortByColumn(evt.detail, this.threadSwitchCountData);
       this.threadSwitchCountTbl!.recycleDataSource = this.threadSwitchCountData;
     });
+    
     this.back!.addEventListener('click', (event) => {
       this.display_flag = true;
       this.display_pro!.style.display = 'block';
diff --git a/ide/src/trace/component/setting/SpProbesConfig.ts b/ide/src/trace/component/setting/SpProbesConfig.ts
index 6b67ca7ba041a5c72857d1f643b1fc9251b811ff..79568fbfec90e695c9cb19fbeac14851eab3d01f 100644
--- a/ide/src/trace/component/setting/SpProbesConfig.ts
+++ b/ide/src/trace/component/setting/SpProbesConfig.ts
@@ -215,7 +215,7 @@ export class SpProbesConfig extends BaseElement {
     bufferSizeSlider.sliderStyle = {
       minRange: 2048,
       maxRange: 307200,
-      defaultValue: '20480',
+      defaultValue: '204800',
       resultUnit: 'KB',
       stepSize: 2,
       lineColor: 'var(--dark-color3,#46B1E3)',
diff --git a/ide/src/trace/component/setting/SpXPowerRecord.html.ts b/ide/src/trace/component/setting/SpXPowerRecord.html.ts
new file mode 100644
index 0000000000000000000000000000000000000000..8403bfc5eefcca6fe8f37a09c851004f2706fb4f
--- /dev/null
+++ b/ide/src/trace/component/setting/SpXPowerRecord.html.ts
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+export const SpXPowerRecordHtml = `
+<style>
+:host{
+    background: var(--dark-background3,#FFFFFF);
+    border-radius: 0 16px 16px 0;
+    display: inline-block;
+    width: 100%;
+    height: 100%;
+}
+.xpower-tracker {
+    font-size:16px;
+    margin-bottom: 30px;
+    padding-top: 30px;
+    padding-left: 54px;
+    margin-right: 30px;
+}
+.xpower-config-div {
+   width: 80%;
+   display: flex;
+   flex-direction: column;
+   margin-top: 5vh;
+   margin-bottom: 5vh;
+   gap: 25px;
+}
+
+.xpower-title {
+  text-align: center;
+  line-height: 40px;
+  font-weight: 700;
+  margin-right: 10px;
+  opacity: 0.9;
+  font-family: Helvetica-Bold;
+  font-size: 18px;
+}
+.xpower-switch {
+  display:inline;
+  float: right;
+  height: 38px;
+  margin-top: 10px;
+}
+.xpower-config-top {
+   display: none;
+   flex-direction: column;
+   margin-top: 5vh;
+   gap: 25px;
+}
+.config-title {
+  line-height: 40px;
+  font-weight: 700;
+  margin-right: 10px;
+  opacity: 0.9;
+  font-family: Helvetica-Bold;
+  font-size: 18px;
+  text-align: center;
+}
+.config-title-des {
+  line-height: 35px;
+  font-weight: 400;
+  opacity: 0.6;
+  font-family: Helvetica;
+  font-size: 14px;
+  text-align: center;
+}
+.xpower-config-top-title{
+  margin-bottom: 15px;
+}
+.record-type-input {
+    line-height: 20px;
+    font-weight: 400;
+    border: 1px solid var(--dark-background5,#ccc);
+    font-family: Helvetica;
+    font-size: 14px;
+    color: var(--dark-color1,#212121);
+    text-align: left;
+}
+.record-type-select {
+  border-radius: 15px;
+    width: 100%;
+}
+</style>
+
+<div class="xpower-tracker">
+    <div class="xpower-config-div">
+        <div>
+            <span class="xpower-title">Start Xpower Record</span>
+            <lit-switch class="xpower-switch"></lit-switch>
+        </div>
+        <div class="xpower-config-top">
+            <div class="xpower-config-top-title">
+                <span class="xpower-title config-title">MessageType</span>
+                <span class="config-title-des">Record MessageType</span>
+            </div>
+        </div>
+    </div>
+</div>
+        `;
+
diff --git a/ide/src/trace/component/setting/SpXPowerRecord.ts b/ide/src/trace/component/setting/SpXPowerRecord.ts
new file mode 100644
index 0000000000000000000000000000000000000000..dae8f9fe3d271b16962fe4de00ab597fc8570b83
--- /dev/null
+++ b/ide/src/trace/component/setting/SpXPowerRecord.ts
@@ -0,0 +1,152 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+import { BaseElement, element } from '../../../base-ui/BaseElement';
+import LitSwitch from '../../../base-ui/switch/lit-switch';
+import '../../../base-ui/select/LitAllocationSelect';
+
+import '../../../base-ui/switch/lit-switch';
+import { SpXPowerRecordHtml } from './SpXPowerRecord.html';
+import { LitSearch } from '../trace/search/Search';
+import { LitSelectV } from '../../../base-ui/select/LitSelectV';
+import { SpApplication } from '../../SpApplication';
+
+@element('sp-xpower')
+export class SpXPowerRecord extends BaseElement {
+    private xpowerSwitch: LitSwitch | undefined | null;
+    private configType: HTMLDivElement | undefined | null;
+    private typeSelect: LitSelectV | undefined | null;
+    private sp: SpApplication | undefined;
+    private inputEvent: HTMLInputElement | undefined;
+
+    get recordXPower(): boolean {
+        return this.xpowerSwitch!.checked;
+    }
+
+    initElements(): void {
+        this.initRecordXpowerConfig();
+        this.sp = document.querySelector('sp-application') as SpApplication;
+        this.typeSelect = this.shadowRoot?.querySelector<LitSelectV>("lit-select-v[title='MessageType']");
+        this.inputEvent = this.typeSelect!.shadowRoot?.querySelector('input') as HTMLInputElement;
+        this.xpowerSwitch = this.shadowRoot?.querySelector('.xpower-switch') as LitSwitch;
+        let xpowerConfigList = this.shadowRoot?.querySelectorAll<HTMLDivElement>('.xpower-config-top');
+        this.xpowerSwitch.addEventListener('change', () => {
+            let configVisibility = 'none';
+            if (this.xpowerSwitch?.checked) {
+                configVisibility = 'block';
+            }
+            if (xpowerConfigList) {
+                xpowerConfigList!.forEach((configEl) => {
+                    configEl.style.display = configVisibility;
+                });
+            }
+        });
+
+    }
+
+    private initRecordXpowerConfig(): void {
+        this.configType = this.shadowRoot?.querySelector('.xpower-config-top');
+        xpowerConfigList.forEach((config) => {
+            switch (config.type) {
+                case 'select-multiple':
+                    this.configTypeBySelectMultiple(config, this.configType!);
+                    break;
+                default:
+                    break;
+            }
+        })
+    }
+
+    private configTypeBySelectMultiple(config: unknown, recordXpowerDiv: HTMLDivElement): void {
+        let html = '';
+        //@ts-ignore
+        let placeholder = config.selectArray[0];
+        //@ts-ignore
+        if (config.title === 'MessageType') {
+            placeholder = 'NONE';
+        }
+        html += `<lit-select-v default-value="" rounded="" class="record-type-select config" 
+    mode="multiple" canInsert="" title="${
+            //@ts-ignore
+            config.title
+            }" rounded placement = "bottom" placeholder="${placeholder}">`;
+        //@ts-ignore
+        config.selectArray.forEach((value: string) => {
+            html += `<lit-select-option value="${value}">${value}</lit-select-option>`;
+        });
+        html += '</lit-select-v>';
+        recordXpowerDiv.innerHTML = recordXpowerDiv.innerHTML + html;
+    }
+
+    getXpowerConfig(): string | undefined {
+        let recordXpowerConfigVal = this.shadowRoot?.querySelectorAll<HTMLElement>('.config');
+        let xpowerConfig: string = ''
+        recordXpowerConfigVal!.forEach((value) => {
+            xpowerConfig = this.getXpowerConfigData(value, xpowerConfig);
+        });
+        return xpowerConfig;
+    }
+
+    private getXpowerConfigData(value: HTMLElement, xpowerConfig: string): string {
+        switch (value.title) {
+            case 'MessageType':
+                xpowerConfig = this.xpowerConfigByTypeList(xpowerConfig, value as LitSelectV);
+                break;
+        }
+        return xpowerConfig;
+    }
+
+    private xpowerConfigByTypeList(xpowerConfig: string, selectValue: LitSelectV): string {
+        xpowerConfig = selectValue.value
+        return xpowerConfig;
+    }
+
+    typeSelectMousedownHandler = (): void => {
+        this.typeSelect!.dataSource([], '');
+    };
+
+    typeSelectClickHandler = (): void => {
+        this.typeSelect?.dataSource(['REAL_BATTERY', 'THERMAL_REPORT'], '');
+    };
+
+    connectedCallback(): void {
+        this.inputEvent?.addEventListener('mousedown', this.typeSelectMousedownHandler);
+        this.inputEvent?.addEventListener('click', this.typeSelectClickHandler);
+    }
+
+    disconnectedCallback(): void {
+        super.disconnectedCallback();
+        this.inputEvent?.removeEventListener('mousedown', this.typeSelectMousedownHandler);
+        this.inputEvent?.removeEventListener('click', this.typeSelectClickHandler);
+    }
+
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void {
+        super.attributeChangedCallback(name, oldValue, newValue);
+    }
+
+    initHtml(): string {
+        return SpXPowerRecordHtml;
+    }
+}
+
+const xpowerConfigList = [
+    {
+        title: 'MessageType',
+        des: 'Select MessageType',
+        hidden: true,
+        type: 'select-multiple',
+        selectArray: [''],
+    }
+]
diff --git a/ide/src/trace/component/setting/bean/ProfilerServiceTypes.ts b/ide/src/trace/component/setting/bean/ProfilerServiceTypes.ts
index fc7cfc8387ed30969239f7824245bcb26c19eb15..af062455884bc38b089613f539574387e4227eae 100644
--- a/ide/src/trace/component/setting/bean/ProfilerServiceTypes.ts
+++ b/ide/src/trace/component/setting/bean/ProfilerServiceTypes.ts
@@ -81,7 +81,7 @@ export interface ProfilerPluginConfig<T> {
   pluginName: string;
   sampleInterval?: number;
   configData: T;
-  protobuf_serialize?: boolean;
+  is_protobuf_serialize?: boolean;
 }
 
 export interface HiebpfConfig {
diff --git a/ide/src/trace/component/setting/utils/PluginConvertUtils.ts b/ide/src/trace/component/setting/utils/PluginConvertUtils.ts
index aadd5ac5a418affbb6f0eddeeb2608548f16deb4..d953042ba3c869b3a6cd2ce6cf35321d4d64751f 100644
--- a/ide/src/trace/component/setting/utils/PluginConvertUtils.ts
+++ b/ide/src/trace/component/setting/utils/PluginConvertUtils.ts
@@ -229,6 +229,11 @@ export class PluginConvertUtils {
         text + ' '.repeat(spacesNumber).repeat(indentation + 1) + this.humpToSnake(key)
         //@ts-ignore
       }: ${arrValue.toString()}${this.crlf}`;
+      //@ts-ignore
+    } else if (arrValue.startsWith('REAL_BATTERY') || arrValue.startsWith('THERMAL_REPORT')) { 
+      text = `${text + ' '.repeat(spacesNumber).repeat(indentation + 1) + this.humpToSnake(key)
+        //@ts-ignore
+        }: ${arrValue.toString()}${this.crlf}`;
     } else {
       text = `${
         text + ' '.repeat(spacesNumber).repeat(indentation + 1) + this.humpToSnake(key)
diff --git a/ide/src/trace/component/trace/base/ColorUtils.ts b/ide/src/trace/component/trace/base/ColorUtils.ts
index 5904cf07c8f41b835d4a6fe1b1b0671abe694d1c..de811323a57af7757a1752d28445d3ea0ae34a73 100644
--- a/ide/src/trace/component/trace/base/ColorUtils.ts
+++ b/ide/src/trace/component/trace/base/ColorUtils.ts
@@ -226,7 +226,7 @@ export class ColorUtils {
         colorChange.push(parseInt(`0x${color.slice(i, i + 2)}`));
       }
       let grayLevel = colorChange[0] * 0.299 + colorChange[1] * 0.587 + colorChange[2] * 0.114;
-      if (grayLevel >= 150) {
+      if (grayLevel >= 100) {
         //浅色模式
         return '#000';
       } else {
diff --git a/ide/src/trace/component/trace/base/RangeSelect.ts b/ide/src/trace/component/trace/base/RangeSelect.ts
index 3749a8eae1ff4498ed743481d0ce8453bb704d98..c51de049b494f04476e04c1990be50efbeba02ea 100644
--- a/ide/src/trace/component/trace/base/RangeSelect.ts
+++ b/ide/src/trace/component/trace/base/RangeSelect.ts
@@ -21,6 +21,7 @@ import './Extension';
 import { SpSystemTrace } from '../../SpSystemTrace';
 import { SpLtpoChart } from '../../chart/SpLTPO';
 import { isEmpty, isNotEmpty } from './Extension';
+import { SpAiAnalysisPage } from '../../SpAiAnalysisPage';
 
 export class RangeSelect {
   private rowsEL: HTMLDivElement | undefined | null;
@@ -72,7 +73,7 @@ export class RangeSelect {
     this.rangeTraceRow = [];
     this.isMouseDown = true;
     TraceRow.rangeSelectObject = undefined;
-  } 
+  }
 
   mouseUp(mouseEventUp?: MouseEvent): void {
     if (mouseEventUp) {
@@ -106,6 +107,12 @@ export class RangeSelect {
         } else if (row.getAttribute('name')?.startsWith('Present')) {
           this.filterPresentData(row, this.trace?.presentList);
         }
+      } else if (
+        row.getAttribute('row-type') === 'process' &&
+        row.getAttribute('name')?.startsWith('render_service') &&
+        Array.isArray(row.childrenList)
+      ) {
+        this.checkRowsName(row.childrenList);
       }
     });
   }
@@ -279,6 +286,7 @@ export class RangeSelect {
           rangeSelect.endNS = RangeSelect.SetNS(it, endX);
         }
         TraceRow.rangeSelectObject = rangeSelect;
+        SpAiAnalysisPage.selectChangeListener(rangeSelect.startNS!, rangeSelect.endNS!);
         it.rangeSelect = true;
         result = true;
       } else {
diff --git a/ide/src/trace/component/trace/base/TraceRow.ts b/ide/src/trace/component/trace/base/TraceRow.ts
index ccae04b42e278f4916e8fbe85ead8691493c8ce1..93943404f02ed7f0e38ee81fedfaae6ae82342e0 100644
--- a/ide/src/trace/component/trace/base/TraceRow.ts
+++ b/ide/src/trace/component/trace/base/TraceRow.ts
@@ -78,6 +78,7 @@ export class TraceRow<T extends BaseStruct> extends HTMLElement {
   static ROW_TYPE_APP_STARTUP = 'app-startup';
   static ROW_TYPE_STATIC_INIT = 'static-init';
   static ROW_TYPE_THREAD = 'thread';
+  static ROW_TYPE_THREAD_NAME = 'sameThread_process';
   static ROW_TYPE_MEM = 'mem';
   static ROW_TYPE_VIRTUAL_MEMORY_GROUP = 'virtual-memory-group';
   static ROW_TYPE_VIRTUAL_MEMORY = 'virtual-memory-cell';
@@ -121,6 +122,8 @@ export class TraceRow<T extends BaseStruct> extends HTMLElement {
   static ROW_TYPE_HANG = 'hang';
   static ROW_TYPE_HANG_INNER = 'hang-inner';
   static ROW_TYPE_CLOCK = 'clock';
+  static ROW_TYPE_XPOWER = 'xpower';
+  static ROW_TYPE_XPOWER_SYSTEM = 'xpower-system';
   static ROW_TYPE_IRQ_GROUP = 'irq-group';
   static ROW_TYPE_IRQ = 'irq';
   static ROW_TYPE_JANK = 'janks';
@@ -868,6 +871,10 @@ export class TraceRow<T extends BaseStruct> extends HTMLElement {
     this.nameEL!.style.marginLeft = `${value}px`;
   }
 
+  set xpowerRowTitle(value: string) { 
+    this.nameEL!.title = `${value}`;
+  }
+
   initElements(): void {
     this.rootEL = this.shadowRoot?.querySelector('.root');
     this.checkBoxEL = this.shadowRoot?.querySelector<LitCheckBox>('.lit-check-box');
diff --git a/ide/src/trace/component/trace/base/TraceRowConfig.ts b/ide/src/trace/component/trace/base/TraceRowConfig.ts
index d0fd6d9ebf1d94895cc2722210f116df87a9f2ef..4825070b29fa37be01c8325d5a169d1c6579bb84 100644
--- a/ide/src/trace/component/trace/base/TraceRowConfig.ts
+++ b/ide/src/trace/component/trace/base/TraceRowConfig.ts
@@ -889,6 +889,12 @@ export class TraceRowConfig extends BaseElement {
           if (configCheckBox.checked) {
             item.setAttribute('scene', '');
             item.removeAttribute('row-hidden');
+            item.childrenList.forEach(v => {
+              if (v.hasAttribute('row-hidden')) {
+                v.setAttribute('scene', '');
+                v.removeAttribute('row-hidden');
+              }
+            });
           } else {
             item.expansion = false;
             item.removeAttribute('scene');
diff --git a/ide/src/trace/component/trace/base/TraceSheet.ts b/ide/src/trace/component/trace/base/TraceSheet.ts
index 155cc6c8d589a08444656580891445a5175e0ec5..dbd71a4dff81f35e6b4fed8185074caf0ca8900e 100644
--- a/ide/src/trace/component/trace/base/TraceSheet.ts
+++ b/ide/src/trace/component/trace/base/TraceSheet.ts
@@ -34,6 +34,7 @@ import { CpuStateStruct } from '../../../database/ui-worker/cpu/ProcedureWorkerC
 import { type HangStruct } from '../../../database/ui-worker/ProcedureWorkerHang';
 import { type ClockStruct } from '../../../database/ui-worker/ProcedureWorkerClock';
 import { type DmaFenceStruct } from '../../../database/ui-worker/ProcedureWorkerDmaFence';
+import { type XpowerStruct } from '../../../database/ui-worker/ProcedureWorkerXpower';
 import { type IrqStruct } from '../../../database/ui-worker/ProcedureWorkerIrq';
 import { type JankStruct } from '../../../database/ui-worker/ProcedureWorkerJank';
 import { type HeapStruct } from '../../../database/ui-worker/ProcedureWorkerHeap';
@@ -545,9 +546,7 @@ export class TraceSheet extends BaseElement {
       if (files) {
         let fileList: Array<File> = [];
         for (let file of files) {
-          if (file.name.endsWith('.so')) {
-            fileList.push(file);
-          }
+          fileList.push(file);
         }
         if (fileList.length > 0) {
           importFileBt!.disabled = true;
@@ -692,6 +691,8 @@ export class TraceSheet extends BaseElement {
   displayDmaFenceData = (data: DmaFenceStruct, rowData: unknown): void =>//展示tab页内容
     // @ts-ignore
     this.displayTab<TabPaneCurrentSelection>('current-selection').setDmaFenceData(data, rowData);
+  displayXpowerData = (data: XpowerStruct): Promise<void> =>
+    this.displayTab<TabPaneCurrentSelection>('current-selection').setXpowerData(data); 
   displayPerfToolsData = (data: PerfToolStruct): void =>
     this.displayTab<TabPaneCurrentSelection>('current-selection').setPerfToolsData(data);
   displayIrqData = (data: IrqStruct): void =>
@@ -1182,7 +1183,7 @@ export class TraceSheet extends BaseElement {
     param.name = e.detail.allName ? e.detail.allName : [e.detail.name];//@ts-ignore2
     param.isJumpPage = true;// @ts-ignore
     param.isSummary = e.detail.allName ? true : false;
-    (pane.children.item(0) as TabPaneSliceChild).data = {param: param, selection: this.selection};
+    (pane.children.item(0) as TabPaneSliceChild).data = { param: param, selection: this.selection };
   }
 
   clearMemory(): void {
diff --git a/ide/src/trace/component/trace/base/TraceSheetConfig.ts b/ide/src/trace/component/trace/base/TraceSheetConfig.ts
index 263c391ae09f448de2ad961c2313eda6acba7a00..fbd8969a4e707b4e6aaccbfdd33aeb3817f0aa4b 100644
--- a/ide/src/trace/component/trace/base/TraceSheetConfig.ts
+++ b/ide/src/trace/component/trace/base/TraceSheetConfig.ts
@@ -64,6 +64,7 @@ import { TabPaneFreqLimit } from '../sheet/freq/TabPaneFreqLimit';
 import { TabPaneCpuFreqLimits } from '../sheet/freq/TabPaneCpuFreqLimits';
 import { TabpaneNMCalltree } from '../sheet/native-memory/TabPaneNMCallTree';
 import { TabPaneClockCounter } from '../sheet/clock/TabPaneClockCounter';
+import { TabPaneXpowerCounter } from '../sheet/xpower/TabPaneXpowerCounter';
 import { TabPaneHang } from '../sheet/hang/TabPaneHang';
 import { TabPaneHangSummary } from '../sheet/hang/TabPaneHangSummary';
 import { TabPaneIrqCounter } from '../sheet/irq/TabPaneIrqCounter';
@@ -252,6 +253,11 @@ export let tabConfig: {
     type: TabPaneClockCounter,
     require: (param: SelectionParam) => param.clockMapData.size > 0,
   },
+  'box-xpower-counters': { 
+    title: 'Xpower Counters',
+    type: TabPaneXpowerCounter,
+    require: (param: SelectionParam) => param.xpowerMapData.size > 0,
+  },
   'box-hang': {
     title: 'Hangs',
     type: TabPaneHang,
diff --git a/ide/src/trace/component/trace/base/shadowRootInput.ts b/ide/src/trace/component/trace/base/shadowRootInput.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fa3459267f6437aaff46bf622074da96e958a50a
--- /dev/null
+++ b/ide/src/trace/component/trace/base/shadowRootInput.ts
@@ -0,0 +1,46 @@
+import { BaseElement } from "../../../../base-ui/BaseElement";
+
+/*
+ * Copyright (C) 2024 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.
+ */
+export class shadowRootInput {
+    public static preventBubbling(page: BaseElement | Element) {
+        let pageInputList = shadowRootInput.findInputListInShadowDOM(page);
+        pageInputList.forEach(input => {
+            input.addEventListener('keydown', (e) => e.stopPropagation());
+            input.addEventListener('keyup', (e) => e.stopPropagation());
+        });
+    }
+    public static findInputListInShadowDOM(startNode: BaseElement | Element | null) {
+        let queue: (Element | null)[] = [startNode];
+        let inputList: Element[] = [];
+        while (queue.length > 0) {
+            let currentNode = queue.shift(); // 从队列中取出一个节点  
+            if (!currentNode) continue;
+            if (currentNode.tagName === 'INPUT') {
+                inputList.push(currentNode);
+            }
+            if (currentNode.shadowRoot) {
+                Array.from(currentNode.shadowRoot.children).forEach(child => {
+                    queue.push(child);
+                });
+            }
+            Array.from(currentNode.children).forEach(child => {
+                queue.push(child);
+            });
+        }
+        // 返回所有找到的input元素  
+        return inputList;
+    }
+}
\ No newline at end of file
diff --git a/ide/src/trace/component/trace/sheet/TabPaneCurrent.ts b/ide/src/trace/component/trace/sheet/TabPaneCurrent.ts
index 7d2b3104140b00fe4656b5b2627aa8dbcaff48a8..22d9c57e68562fac6e6ea72be4b6e0770610954a 100644
--- a/ide/src/trace/component/trace/sheet/TabPaneCurrent.ts
+++ b/ide/src/trace/component/trace/sheet/TabPaneCurrent.ts
@@ -222,7 +222,6 @@ export class TabPaneCurrent extends BaseElement {
             enable: true,
           });
           document.dispatchEvent(new CustomEvent('slices-change', { detail: this.slicesTimeList[i - 1] }));
-          document.dispatchEvent(new CustomEvent('remarksFocus-change', { detail: 'remarks-focus' }));
 
           this.systemTrace?.refreshCanvas(true);
         }
@@ -245,7 +244,6 @@ export class TabPaneCurrent extends BaseElement {
           // @ts-ignore
           this.slicesTimeList[i - 1].text = event?.target.value;
           document.dispatchEvent(new CustomEvent('slices-change', { detail: this.slicesTimeList[i - 1] }));
-          document.dispatchEvent(new CustomEvent('remarksFocus-change', { detail: '' }));
           this.setTableData();
           this.systemTrace?.refreshCanvas(true);
         }
diff --git a/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts b/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts
index cd42a63181b529ce5f9874364625dad467512195..b002feaa2b91e0f13da8a20110b41f2a7d4983a5 100644
--- a/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts
+++ b/ide/src/trace/component/trace/sheet/TabPaneCurrentSelection.ts
@@ -66,6 +66,7 @@ import { threadPool, threadPool2 } from '../../../database/SqlLite';
 import { threadNearData } from '../../../database/data-trafic/SliceSender';
 import { HangStruct } from '../../../database/ui-worker/ProcedureWorkerHang';
 import { BaseStruct } from '../../../bean/BaseStruct';
+import {XpowerStruct} from '../../../database/ui-worker/ProcedureWorkerXpower'; 
 
 const INPUT_WORD =
   'This is the interval from when the task became eligible to run \n(e.g.because of notifying a wait queue it was a suspended on) to\n when it started running.';
@@ -420,13 +421,14 @@ export class TabPaneCurrentSelection extends BaseElement {
       }
       let processName = Utils.getInstance().getProcessMap().get(data.pid!);
       let threadName = Utils.getInstance().getThreadMap().get(data.tid!);
+      let dataTid = isNaN(data.tid!) ? 'NULL' : data.tid;
       list.push({
         name: 'Process',
         value: (this.transferString(processName ?? '') || 'NULL') + ' [' + data.pid + '] ',
       });
       list.push({
         name: 'Thread',
-        value: (this.transferString(threadName ?? '') || 'NULL') + ' [' + data.tid + '] ',
+        value: (this.transferString(threadName ?? '') || 'NULL') + ' [' + dataTid + '] ',
       });
       list.push({
         name: 'StartTime(Relative)',
@@ -808,6 +810,28 @@ export class TabPaneCurrentSelection extends BaseElement {
     this.currentSelectionTbl!.dataSource = list;
   }
 
+  async setXpowerData(data: XpowerStruct): Promise<void> {  
+    if (SpApplication.traceType.indexOf('SQLite') === -1) {
+      await this.setRealTime();
+    }
+    this.setTableHeight('auto');
+    this.tabCurrentSelectionInit('Counter Details');
+    let list: unknown[] = [];
+    list.push({
+      name: 'StartTime(Relative)',
+      value: getTimeString(data.startNS || 0),
+    });
+    this.createStartTimeNode(list, data.startNS || 0, CLOCK_TRANSF_BTN_ID, CLOCK_STARTTIME_ABSALUTED_ID);
+    list.push({
+      name: 'Value',
+      value: String(data.value).indexOf('.') > -1 ? data.value || 0 : ColorUtils.formatNumberComma(data.value || 0),
+    });
+    list.push({ name: 'Duration', value: getTimeString(data.dur || 0) });
+    this.currentSelectionTbl!.dataSource = list;
+    let startTimeAbsolute = (data.startNS || 0) + Utils.getInstance().getRecordStartNS();
+    this.addClickToTransfBtn(startTimeAbsolute, CLOCK_TRANSF_BTN_ID, CLOCK_STARTTIME_ABSALUTED_ID);
+  }
+
   async setHangData(data: HangStruct, sp: SpSystemTrace, scrollCallback: Function): Promise<void> {
     await this.setRealTime();
     this.setTableHeight('auto');
@@ -1232,7 +1256,7 @@ export class TabPaneCurrentSelection extends BaseElement {
       //@ts-ignore
       let currentThread = list.filter((item) => item.name === 'Thread')?.[0].value;//点击的当前线程
       let previouosWakeupThread = Utils.getInstance().getThreadMap().get(fromBean!.tid!) || 'Thread';//唤醒当前线程的上个线程
-      this.topChainStr = `-->${previouosWakeupThread}[${fromBean!.tid}]-->${currentThread}`;
+      this.topChainStr = `-->${previouosWakeupThread} [${fromBean!.tid}]-->${currentThread}`;
       this.getRWakeUpChain(fromBean);
     })
   }
@@ -1298,9 +1322,9 @@ export class TabPaneCurrentSelection extends BaseElement {
           it.stateDur = endTime! - it.startTime;
         }
         // @ts-ignore
-        str += '[' + it.value + ': ' + (it.stateDur || 0) / 1000 + ']' + ',';
+        str += '[' + it.value + ', ' + (it.stateDur || 0) / 1000 + ']' + ',';
       });
-      list.push({ name: 'Freq [KHz,μs]', value: str.substring(0, str.length - 1) });
+      list.push({ name: 'Freq [KHz, μs]', value: str.substring(0, str.length - 1) });
     }
     let slice = Utils.getInstance().getSchedSliceMap().get(`${data.id}-${data.startTime}`);
     if (slice) {
@@ -2050,7 +2074,7 @@ export class TabPaneCurrentSelection extends BaseElement {
         return;
       }
       //@ts-ignore
-      this.topChainStr = `-->${wakeupFrom!.thread}[${wakeupFrom!.tid}]` + this.topChainStr;//链的拼接
+      this.topChainStr = `-->${wakeupFrom!.thread} [${wakeupFrom!.tid}]` + this.topChainStr;//链的拼接
       // @ts-ignore
       this.getRWakeUpChain(wakeupFrom);
     });
diff --git a/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts b/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts
index f8d3d3c65dabcbbc65a3829bc3b7c22d02662a6f..7fa2a3c4e5a9edbbd17670d1b7c6baecb2b99749 100644
--- a/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts
+++ b/ide/src/trace/component/trace/sheet/TabPaneDataCut.ts
@@ -24,6 +24,8 @@ import { TabPaneFreqDataCut } from './frequsage/TabPaneFreqDataCut';
 import { TabPaneFreqStatesDataCut } from './states/TabPaneFreqStatesDataCut';
 import { TabPaneGpufreqDataCut } from './gpufreq/TabPaneGpufreqDataCut';
 import { TraceSheet } from '../base/TraceSheet';
+import { LitTabs } from '../../../../base-ui/tabs/lit-tabs';
+import { LitTabpane } from '../../../../base-ui/tabs/lit-tabpane';
 
 @element('tabpane-datacut')
 export class TabPaneDataCut extends BaseElement {
@@ -66,6 +68,9 @@ export class TabPaneDataCut extends BaseElement {
         this.tabContainer?.appendChild(this.currentTabPane);
         this.currentTabPane.data = this.currentSelection;
       }
+      let tabs = document.querySelector("body > sp-application")?.shadowRoot?.querySelector("#sp-system-trace")?.shadowRoot?.querySelector("div > trace-sheet")?.shadowRoot?.querySelector("#tabs") as LitTabs;
+      let pane = document.querySelector("body > sp-application")?.shadowRoot?.querySelector("#sp-system-trace")?.shadowRoot?.querySelector("div > trace-sheet")?.shadowRoot?.querySelector("#tabpane-datacut") as LitTabpane;
+      tabs.activeByKey(pane.key);
     }
   }
 
@@ -153,7 +158,7 @@ export class TabPaneDataCut extends BaseElement {
         </style>
         <div id="data_cut_tabpane_container" style="flex-grow: 1"></div>
         <div class="bottom_filter">
-            <lit-select id="tab-select" style="margin-left: 10px" placeholder="please choose"></lit-select>
+            <lit-select id="tab-select" style="margin-left: 10px" placeholder="please choose" tabselect></lit-select>
         </div>
         `;
   }
diff --git a/ide/src/trace/component/trace/sheet/TabPaneFilter.ts b/ide/src/trace/component/trace/sheet/TabPaneFilter.ts
index 6007e7bf026ead3342772dd6a9ca7295a1537016..65238dded8f956fbfa29465fc563c8f88c0e8406 100644
--- a/ide/src/trace/component/trace/sheet/TabPaneFilter.ts
+++ b/ide/src/trace/component/trace/sheet/TabPaneFilter.ts
@@ -403,7 +403,7 @@ export class TabPaneFilter extends BaseElement {
     if (thirdList) {
       this.setAttribute('third', '');
     }
-    thtml += `<lit-select show-search default-value="" id="third-select" class="spacing" placeholder="please choose">`;
+    thtml += `<lit-select default-value="" id="third-select" class="spacing" placeholder="please choose" tabselect>`;
     if (thirdList) {
       if (thirdTitle !== '') {
         thtml += `<lit-select-option  value="${thirdTitle}" disabled>${thirdTitle}</lit-select-option>`;
@@ -422,7 +422,7 @@ export class TabPaneFilter extends BaseElement {
     html: string
   ): string {
     if (secondList) {
-      html += `<lit-select show-search default-value="" id="second-select" class="spacing" placeholder="please choose">`;
+      html += `<lit-select default-value="" id="second-select" class="spacing" placeholder="please choose" tabselect>`;
       if (secondTitle !== '') {
         html += `<lit-select-option value="${secondTitle}" disabled>${secondTitle}</lit-select-option>`;
       }
@@ -440,7 +440,7 @@ export class TabPaneFilter extends BaseElement {
     html: string
   ): string {
     if (firstList) {
-      html += `<lit-select default-value="" id="first-select" class="spacing" placeholder="please choose">`;
+      html += `<lit-select default-value="" id="first-select" class="spacing" placeholder="please choose" tabselect>`;
       if (firstTitle !== '') {
         html += `<lit-select-option value="${firstTitle}" disabled>${firstTitle}</lit-select-option>`;
       }
diff --git a/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.html.ts b/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.html.ts
index fe9ac166850045c061147d67335dfc11cf0fcf8c..9462d4e103a6e4bc282843713f5ee2adb00c1ef1 100644
--- a/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.html.ts
+++ b/ide/src/trace/component/trace/sheet/TabPaneJsMemoryFilter.html.ts
@@ -63,6 +63,6 @@ export const TabPaneJsMemoryFilterHtml = `
     <input id="js-memory-filter-input" class="spacing" placeholder="Class filter" value=""/>
 </div>
 <div class='select-wrap'>
-    <lit-select id='comparison-select' title='Select View'></lit-select>
+    <lit-select id='comparison-select' title='Select View' tabselect></lit-select>
 </div>
 `;
diff --git a/ide/src/trace/component/trace/sheet/hiperf/TabPerfAsyncList.ts b/ide/src/trace/component/trace/sheet/hiperf/TabPerfAsyncList.ts
index af23595bbdeb2e650a699127f789c02c1a5f9999..748c0382bf9633245f69beac66fa336ed9960914 100644
--- a/ide/src/trace/component/trace/sheet/hiperf/TabPerfAsyncList.ts
+++ b/ide/src/trace/component/trace/sheet/hiperf/TabPerfAsyncList.ts
@@ -24,7 +24,6 @@ import { Utils } from '../../base/Utils';
 import { FrameChart } from '../../../chart/FrameChart';
 import { FilterData, TabPaneFilter } from '../TabPaneFilter';
 import { ChartMode } from '../../../../bean/FrameChartStruct';
-import { SpSystemTrace } from '../../../SpSystemTrace';
 
 @element('tabpane-perf-async')
 export class TabPanePerfAsync extends BaseElement {
@@ -444,17 +443,7 @@ export class TabPanePerfAsync extends BaseElement {
     this.progressEl = this.shadowRoot?.querySelector('.perf-async-progress') as LitProgressBar;
     this.asyncFilter = this.shadowRoot?.querySelector<TabPaneFilter>('#filter');
     this.asyncFrameChart = this.shadowRoot?.querySelector<FrameChart>('#framechart');
-    let spApplication = document.querySelector('body > sp-application');
-    let spSystemTrace = spApplication?.shadowRoot?.querySelector(
-      'div > div.content > sp-system-trace'
-    ) as SpSystemTrace;
     this.asyncFilter!.getFilterData(this.asyncListFilterGetFilter.bind(this));
-    this.asyncFilter?.addEventListener('focus', () => {
-      spSystemTrace.focusTarget = 'bottomUpInput';
-    });
-    this.asyncFilter?.addEventListener('blur', () => {
-      spSystemTrace.focusTarget = '';
-    });
     // 将主表绑定行点击事件，根据点击数据更新右侧的调用栈与被调用栈表格信息
     // @ts-ignore
     this.showTable?.addEventListener('row-click', (evt: CustomEvent) => {
diff --git a/ide/src/trace/component/trace/sheet/hiperf/TabPerfBottomUp.ts b/ide/src/trace/component/trace/sheet/hiperf/TabPerfBottomUp.ts
index ac9e87b14c10aec6b1c2ada52408fab286267863..e5de9abcd255f07125817709669a2a02edf8aa40 100644
--- a/ide/src/trace/component/trace/sheet/hiperf/TabPerfBottomUp.ts
+++ b/ide/src/trace/component/trace/sheet/hiperf/TabPerfBottomUp.ts
@@ -25,7 +25,6 @@ import { procedurePool } from '../../../../database/Procedure';
 import { type LitProgressBar } from '../../../../../base-ui/progress-bar/LitProgressBar';
 import { type PerfBottomUpStruct } from '../../../../bean/PerfBottomUpStruct';
 import { findSearchNode, HiPerfStruct } from '../../../../database/ui-worker/ProcedureWorkerCommon';
-import { SpSystemTrace } from '../../../SpSystemTrace';
 
 @element('tabpane-perf-bottom-up')
 export class TabpanePerfBottomUp extends BaseElement {
@@ -44,10 +43,6 @@ export class TabpanePerfBottomUp extends BaseElement {
     this.stackTable = this.shadowRoot?.querySelector('#stackTable') as LitTable;
     this.progressEL = this.shadowRoot?.querySelector('.progress') as LitProgressBar;
     this.bottomUpFilter = this.shadowRoot?.querySelector('#filter') as TabPaneFilter;
-    let spApplication = document.querySelector('body > sp-application');
-    let spSystemTrace = spApplication?.shadowRoot?.querySelector(
-      'div > div.content > sp-system-trace'
-    ) as SpSystemTrace;
     this.bottomUpTable!.addEventListener('row-click', (evt) => this.bottomUpTableRowClickHandler(evt));
     this.stackTable!.addEventListener('row-click', (evt) => this.stackTableRowClick(evt));
     this.bottomUpTable!.addEventListener('column-click', (evt) => this.bottomUpTableColumnClickHandler(evt));
@@ -64,12 +59,6 @@ export class TabpanePerfBottomUp extends BaseElement {
         this.setBottomUpTableData(this.bottomUpSource);
       }
     });
-    this.bottomUpFilter?.addEventListener('focus', () => {
-      spSystemTrace.focusTarget = 'bottomUpInput';
-    });
-    this.bottomUpFilter?.addEventListener('blur', () => {
-      spSystemTrace.focusTarget = '';
-    });
   }
 
   private getDataByWorker(val: SelectionParam, handler: (results: Array<PerfBottomUpStruct>) => void): void {
diff --git a/ide/src/trace/component/trace/sheet/hiperf/TabPerfProfile.ts b/ide/src/trace/component/trace/sheet/hiperf/TabPerfProfile.ts
index 06617249dafa86571973822b48d0f5a0e9b230aa..91a16eacd7b2962359cedc84c591134660c6b3b7 100644
--- a/ide/src/trace/component/trace/sheet/hiperf/TabPerfProfile.ts
+++ b/ide/src/trace/component/trace/sheet/hiperf/TabPerfProfile.ts
@@ -30,7 +30,6 @@ import { showButtonMenu } from '../SheetUtils';
 import '../../../../../base-ui/headline/lit-headline';
 import { LitHeadLine } from '../../../../../base-ui/headline/lit-headline';
 import { TabPerfProfileHtml } from './TabPerfProfile.html';
-import { SpSystemTrace } from '../../../SpSystemTrace';
 
 const InvertOptionIndex: number = 0;
 const hideSystemLibraryOptionIndex: number = 1;
@@ -304,10 +303,6 @@ export class TabpanePerfProfile extends BaseElement {
     this.perfProfileProgressEL = this.shadowRoot?.querySelector('.perf-profile-progress') as LitProgressBar;
     this.perfProfileFrameChart = this.shadowRoot?.querySelector<FrameChart>('#framechart');
     this.perfProfileLoadingPage = this.shadowRoot?.querySelector('.perf-profile-loading');
-    let spApplication = document.querySelector('body > sp-application');
-    let spSystemTrace = spApplication?.shadowRoot?.querySelector(
-      'div > div.content > sp-system-trace'
-    ) as SpSystemTrace;
     this.addEventListener('contextmenu', (event) => {
       event.preventDefault(); // 阻止默认的上下文菜单弹框
     });
@@ -320,12 +315,6 @@ export class TabpanePerfProfile extends BaseElement {
     this.perfProfilerFilter = this.shadowRoot?.querySelector<TabPaneFilter>('#filter');
     this.perfProfilerList = this.shadowRoot?.querySelector<LitTable>('#tb-perf-list');
     this.initPerfProfilerDataAndListener();
-    this.perfProfilerFilter?.addEventListener('focus', () => {
-      spSystemTrace.focusTarget = 'bottomUpInput';
-    });
-    this.perfProfilerFilter?.addEventListener('blur', () => {
-      spSystemTrace.focusTarget = '';
-    });
   }
 
   private initPerfProfilerDataAndListener(): void {
diff --git a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMCallTree.ts b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMCallTree.ts
index dc21ffc16a2487ab1983ce7e345db130c704b271..6d3eeb5763dea73db03d35113cda5869b5bb5efb 100644
--- a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMCallTree.ts
+++ b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMCallTree.ts
@@ -426,10 +426,6 @@ export class TabpaneNMCalltree extends BaseElement {
     });
     this.nmCallTreeFilter = this.shadowRoot?.querySelector<TabPaneFilter>('#nm-call-tree-filter');
     this.filesystemTbr = this.shadowRoot?.querySelector<LitTable>('#tb-filesystem-list');
-    let spApplication = document.querySelector('body > sp-application');
-    let spSystemTrace = spApplication?.shadowRoot?.querySelector(
-      'div > div.content > sp-system-trace'
-    ) as SpSystemTrace;
     let filterFunc = (nmCallTreeFuncData: unknown): void => {
       let nmCallTreeFuncArgs: unknown[] = []; // @ts-ignore
       if (nmCallTreeFuncData.type === 'check') {
@@ -461,12 +457,6 @@ export class TabpaneNMCalltree extends BaseElement {
     this.nmCallTreeFilter!.getCallTreeConstraintsData(this.getCallTreeConByNMCallTreeFilter.bind(this));
     this.nmCallTreeFilter!.getFilterData(this.getFilterDataByNMCallTreeFilter.bind(this));
     this.initCloseCallBackByHeadLine();
-    this.nmCallTreeFilter?.addEventListener('focus', () => {
-      spSystemTrace.focusTarget = 'bottomUpInput';
-    });
-    this.nmCallTreeFilter?.addEventListener('blur', () => {
-      spSystemTrace.focusTarget = '';
-    });
   }
 
   private getFilterDataByNMCallTreeFilter(nmCallTreeData: FilterData): void {
diff --git a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMStatstics.ts b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMStatstics.ts
index 062fb413b7366704f3d37028b73a1ca1a7452df1..9890791fff5223101f7eb10f010a04f75bb12752 100644
--- a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMStatstics.ts
+++ b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMStatstics.ts
@@ -187,6 +187,15 @@ export class TabPaneNMStatstics extends BaseElement {
         this.processHookData(hook, anonymous);
       }
     }
+    if (all?.maxStr === '' && all?.max === 0) { 
+      all.maxStr = Utils.getByteWithUnit(all?.max);
+    }
+    if (heap?.maxStr === '' && heap?.max === 0) {
+      heap.maxStr = Utils.getByteWithUnit(heap?.max);
+    }
+    if (anonymous?.maxStr === '' && anonymous?.max === 0) {
+      anonymous.maxStr = Utils.getByteWithUnit(anonymous?.max);
+    }
     if (all !== null) {
       this.updateHookData(all, arr);
     }
diff --git a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMemory.ts b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMemory.ts
index 46414ffaaa62b9b31a879559e23cbd85387a2ab2..bf838087eeb3f4a740fadcc74c51f6e9515c02a9 100644
--- a/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMemory.ts
+++ b/ide/src/trace/component/trace/sheet/native-memory/TabPaneNMemory.ts
@@ -195,6 +195,7 @@ export class TabPaneNMemory extends BaseElement {
         this.filterNativeType = `${typeIndexOf}`;
         this.rowSelectData = undefined;
         this.queryData(val, true);
+        this.fromStastics(val);
       });
     } else {
       //@ts-ignore
diff --git a/ide/src/trace/component/trace/sheet/process/TabPaneSlices.ts b/ide/src/trace/component/trace/sheet/process/TabPaneSlices.ts
index 9315103841d908b6104fa09f08b1aa42f29a40be..e876bacb8043a31a71ed2bf7051da952d19d2365 100644
--- a/ide/src/trace/component/trace/sheet/process/TabPaneSlices.ts
+++ b/ide/src/trace/component/trace/sheet/process/TabPaneSlices.ts
@@ -74,10 +74,6 @@ export class TabPaneSlices extends BaseElement {
     this.slicesTbl = this.shadowRoot?.querySelector<LitTable>('#tb-slices');
     this.slicesRange = this.shadowRoot?.querySelector('#time-range');
     let slicesInput = this.shadowRoot?.querySelector('#filterName');
-    let spApplication = document.querySelector('body > sp-application');
-    let spSystemTrace = spApplication?.shadowRoot?.querySelector(
-      'div > div.content > sp-system-trace'
-    ) as SpSystemTrace;
     this.slicesTbl!.addEventListener('column-click', (evt) => {
       // @ts-ignore
       this.sortByColumn(evt.detail);
@@ -102,12 +98,6 @@ export class TabPaneSlices extends BaseElement {
       // @ts-ignore
       this.findName(e.target.value);
     });
-    slicesInput?.addEventListener('focus', (e) => {
-      spSystemTrace.focusTarget = 'slicesInput';
-    });
-    slicesInput?.addEventListener('blur', (e) => {
-      spSystemTrace.focusTarget = '';
-    });
   }
 
   getSliceDb(
diff --git a/ide/src/trace/component/trace/sheet/xpower/TabPaneXpowerCounter.ts b/ide/src/trace/component/trace/sheet/xpower/TabPaneXpowerCounter.ts
new file mode 100644
index 0000000000000000000000000000000000000000..0271347c1fe0cd4967486e00c5b87b6dce3993fe
--- /dev/null
+++ b/ide/src/trace/component/trace/sheet/xpower/TabPaneXpowerCounter.ts
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+import { BaseElement, element } from '../../../../../base-ui/BaseElement';
+import { LitTable } from '../../../../../base-ui/table/lit-table';
+import { SelectionData, SelectionParam } from '../../../../bean/BoxSelection';
+import { resizeObserver } from '../SheetUtils';
+
+@element('tabpane-xpower-counter')
+export class TabPaneXpowerCounter extends BaseElement {
+  private xpowerCounterTbl: LitTable | null | undefined;
+  private xpowerCounterRange: HTMLLabelElement | null | undefined;
+  private xpowerCounterSource: Array<SelectionData> = [];
+
+  set data(xpowerCounterValue: SelectionParam) {
+    //@ts-ignore
+    this.xpowerCounterTbl?.shadowRoot?.querySelector('.table')?.style?.height = `${
+      this.parentElement!.clientHeight - 45
+    }px`;
+    this.xpowerCounterRange!.textContent = `Selected range: ${parseFloat(
+      ((xpowerCounterValue.rightNs - xpowerCounterValue.leftNs) / 1000000.0).toFixed(5)
+    )} ms`;
+    this.getCounterData(xpowerCounterValue).then();
+  }
+
+  async getCounterData(xpowerCounterValue: SelectionParam): Promise<void> {
+    let dataSource: Array<SelectionData> = [];
+    let collect = xpowerCounterValue.xpowerMapData;
+    let sumCount = 0;
+    this.xpowerCounterTbl!.loading = true;
+    for (let key of collect.keys()) {
+      let counters = collect.get(key);
+      let res = await counters?.({
+        startNS: xpowerCounterValue.leftNs,
+        endNS: xpowerCounterValue.rightNs,
+        queryAll: true,
+      });
+      let sd = this.createSelectCounterData(key, res || [], xpowerCounterValue.leftNs, xpowerCounterValue.rightNs);
+      sumCount += Number.parseInt(sd.count || '0');
+      dataSource.push(sd);
+    }
+    let sumData = new SelectionData();
+    sumData.count = sumCount.toString();
+    sumData.process = ' ';
+    dataSource.splice(0, 0, sumData);
+    this.xpowerCounterTbl!.loading = false;
+    this.xpowerCounterSource = dataSource;
+    this.xpowerCounterTbl!.recycleDataSource = dataSource;   
+  }
+
+  initElements(): void {
+    this.xpowerCounterTbl = this.shadowRoot?.querySelector<LitTable>('#tb-counter');
+    this.xpowerCounterRange = this.shadowRoot?.querySelector('#time-range');
+    this.xpowerCounterTbl!.addEventListener('column-click', (evt): void => {
+      // @ts-ignore
+      this.sortByColumn(evt.detail);
+    });
+  }
+
+  connectedCallback(): void {
+    super.connectedCallback();
+    resizeObserver(this.parentElement!, this.xpowerCounterTbl!);
+  }
+
+  initHtml(): string {
+    return `
+        <style>
+        .xpower-counter-label{
+            margin-bottom: 5px;
+        }
+        :host{
+            padding: 10px 10px;
+            display: flex;
+            flex-direction: column;
+        }
+        </style>
+        <label id="time-range" class="xpower-counter-label" style="width: 100%;height: 20px;text-align: end;font-size: 10pt;">Selected range:0.0 ms</label>
+        <lit-table id="tb-counter" style="height: auto">
+            <lit-table-column order title="Name" data-index="name" key="name"  align="flex-start" width="25%">
+            </lit-table-column>
+            <lit-table-column data-index="delta" order title="Delta value"  key="delta"  align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column title="Rate /s" key="rate" order data-index="rate" align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column title="Weighted avg value" order data-index="avgWeight" key="avgWeight"  align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column data-index="count" title="Count" order key="count"  align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column title="First value" data-index="first" order key="first"  align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column title="Last value" align="flex-start" order data-index="last" key="last" width="1fr">
+            </lit-table-column>
+            <lit-table-column title="Min value" key="min" data-index="min" order align="flex-start" width="1fr">
+            </lit-table-column>
+            <lit-table-column data-index="max" title="Max value" key="max"  order align="flex-start" width="1fr">
+            </lit-table-column>
+        </lit-table>
+        `;
+  }
+
+  createSelectCounterData(name: string, list: Array<unknown>, leftNs: number, rightNs: number): SelectionData {
+    let selectCounterData = new SelectionData();
+    if (list.length > 0) {
+      let range = rightNs - leftNs;
+      let first = list[0];
+      // @ts-ignore
+      selectCounterData.trackId = first.filterId;
+      selectCounterData.name = name;
+      // @ts-ignore
+      selectCounterData.first = `${first.value}`;
+      selectCounterData.count = `${list.length}`;
+      // @ts-ignore
+      selectCounterData.last = `${list[list.length - 1].value}`;
+      selectCounterData.delta = `${parseInt(selectCounterData.last) - parseInt(selectCounterData.first)}`;
+      selectCounterData.rate = (parseInt(selectCounterData.delta) / ((range * 1.0) / 1000000000)).toFixed(4);
+      // @ts-ignore
+      selectCounterData.min = `${first.value}`;
+      selectCounterData.max = '0';
+      let weightAvg = 0.0;
+      for (let i = 0; i < list.length; i++) {
+        let counter = list[i];
+        // @ts-ignore
+        if (counter.value < parseInt(selectCounterData.min)) {
+          // @ts-ignore
+          selectCounterData.min = counter.value.toString();
+        }
+        // @ts-ignore
+        if (counter.value > parseInt(selectCounterData.max)) {
+          // @ts-ignore
+          selectCounterData.max = counter.value.toString();
+        }
+        // @ts-ignore
+        let start = i === 0 ? leftNs : counter.startNS;
+        // @ts-ignore
+        let end = i === list.length - 1 ? rightNs : list[i + 1].startNS;
+        // @ts-ignore
+        weightAvg += counter.value * (((end - start) * 1.0) / range);
+      }
+      selectCounterData.avgWeight = weightAvg.toFixed(2);
+    }
+    return selectCounterData;
+  }
+
+  sortByColumn(detail: unknown): void {
+    // @ts-ignore
+    function compare(property, sort, type) {
+      return function (xpowerCounterLeftData: SelectionData, xpowerCounterRightData: SelectionData): number {
+        if (xpowerCounterLeftData.process === ' ' || xpowerCounterRightData.process === ' ') {
+          return 0;
+        }
+        if (type === 'number') {
+          return sort === 2 // @ts-ignore
+            ? parseFloat(xpowerCounterRightData[property]) - parseFloat(xpowerCounterLeftData[property]) // @ts-ignore
+            : parseFloat(xpowerCounterLeftData[property]) - parseFloat(xpowerCounterRightData[property]);
+        } else {
+          // @ts-ignore
+          if (xpowerCounterRightData[property] > xpowerCounterLeftData[property]) {
+            return sort === 2 ? 1 : -1;
+          } else {
+            // @ts-ignore
+            if (xpowerCounterRightData[property] === xpowerCounterLeftData[property]) {
+              return 0;
+            } else {
+              return sort === 2 ? -1 : 1;
+            }
+          }
+        }
+      };
+    }
+    // @ts-ignore
+    if (detail.key === 'name') {
+      // @ts-ignore
+      this.xpowerCounterSource.sort(compare(detail.key, detail.sort, 'string'));
+    } else {
+      // @ts-ignore
+      this.xpowerCounterSource.sort(compare(detail.key, detail.sort, 'number'));
+    }
+    this.xpowerCounterTbl!.recycleDataSource = this.xpowerCounterSource;
+  }
+}
diff --git a/ide/src/trace/component/trace/timer-shaft/TabPaneFlag.ts b/ide/src/trace/component/trace/timer-shaft/TabPaneFlag.ts
index 4b5c287a78be803adad842d8c4b5024a3daf7991..00c233f84904d6b78ae1a53ec3bb08e697c76659 100644
--- a/ide/src/trace/component/trace/timer-shaft/TabPaneFlag.ts
+++ b/ide/src/trace/component/trace/timer-shaft/TabPaneFlag.ts
@@ -191,7 +191,6 @@ export class TabPaneFlag extends BaseElement {
         // @ts-ignore
         this.flagList[index - 1].text = event?.target.value;
         document.dispatchEvent(new CustomEvent('flag-change', { detail: this.flagList[index - 1] }));
-        document.dispatchEvent(new CustomEvent('remarksFocus-change', { detail: 'remarks-focus' }));
         //   旗子颜色改变时，重绘泳道图
         this.systemTrace?.refreshCanvas(true);
       }
@@ -212,7 +211,6 @@ export class TabPaneFlag extends BaseElement {
         // @ts-ignore
         this.flagList[index - 1].text = event?.target.value;
         document.dispatchEvent(new CustomEvent('flag-change', { detail: this.flagList[index - 1] }));
-        document.dispatchEvent(new CustomEvent('remarksFocus-change', { detail: '' }));
         this.setTableData();
         //   旗子颜色改变时，重绘泳道图
         this.systemTrace?.refreshCanvas(true);
diff --git a/ide/src/trace/database/TabPaneFreqUsageWorker.ts b/ide/src/trace/database/TabPaneFreqUsageWorker.ts
index bd29255944c6505fbef960aef1f1a8115649ca4e..c5141e0bf5e8a785a98e95120647477c511a799f 100644
--- a/ide/src/trace/database/TabPaneFreqUsageWorker.ts
+++ b/ide/src/trace/database/TabPaneFreqUsageWorker.ts
@@ -185,6 +185,7 @@ function returnObj(
         consumpower: computorPower * item.dur,
         cpuload: (computorPower * item.dur) / (timeZones * maxCommpuPower) * PERCENT
       };
+      break;
     case 2:
       result = {
         thread: item.pid + '_' + item.tid,
@@ -196,6 +197,7 @@ function returnObj(
         consumpower: computorPower * (cpuFreqData.ts + cpuFreqData.dur - item.ts),
         cpuload: (computorPower * (cpuFreqData.ts + cpuFreqData.dur - item.ts)) / (timeZones * maxCommpuPower) * PERCENT
       };
+      break;
     case 3:
       result = {
         thread: item.pid + '_' + item.tid,
@@ -207,6 +209,7 @@ function returnObj(
         consumpower: computorPower * (item.dur + item.ts - cpuFreqData.ts),
         cpuload: (computorPower * (item.dur + item.ts - cpuFreqData.ts)) / (timeZones * maxCommpuPower) * PERCENT
       };
+      break;
     case 4:
       result = {
         thread: item.pid + '_' + item.tid,
@@ -218,6 +221,7 @@ function returnObj(
         consumpower: computorPower * cpuFreqData.dur,
         cpuload: (computorPower * cpuFreqData.dur) / (timeZones * maxCommpuPower) * PERCENT
       };
+      break;
     case 5:
       result = {
         thread: item.pid + '_' + item.tid,
@@ -229,6 +233,7 @@ function returnObj(
         consumpower: 0,
         cpuload: 0
       };
+      break;
   }
   return result;
 }
diff --git a/ide/src/trace/database/data-trafic/CommonArgs.ts b/ide/src/trace/database/data-trafic/CommonArgs.ts
index ef61ea0a063abd4961a2325fa269ee19eff167ab..2414a7dbdcbdf41c816c217d90040df9c09330ea 100644
--- a/ide/src/trace/database/data-trafic/CommonArgs.ts
+++ b/ide/src/trace/database/data-trafic/CommonArgs.ts
@@ -42,4 +42,5 @@ export interface Args {
   isPin: number;
   scratchId: number;
   minDur: number;
+  xpowerName: string;
 }
diff --git a/ide/src/trace/database/data-trafic/XpowerDataReceiver.ts b/ide/src/trace/database/data-trafic/XpowerDataReceiver.ts
new file mode 100644
index 0000000000000000000000000000000000000000..ac782f861c6a70d1eee81748a705a067464cc8eb
--- /dev/null
+++ b/ide/src/trace/database/data-trafic/XpowerDataReceiver.ts
@@ -0,0 +1,144 @@
+// Copyright (c) 2021 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.
+
+import { TraficEnum } from './utils/QueryEnum';
+import { filterDataByGroup } from './utils/DataFilter';
+import { xpowerList } from './utils/AllMemoryCache';
+import { Args } from './CommonArgs';
+
+export const chartXpowerDataSql = (args: Args): string => {
+  return `
+    select
+    xm.filter_id,
+    mf.name,
+    xm.ts - ${args.recordStartNS} as startNs,
+    xm.dur,
+    xm.value,
+    xm.type
+    from 
+    xpower_measure xm
+    left join
+    measure_filter mf
+    on
+    mf.id = xm.filter_id
+    left join 
+    trace_range r
+    where 
+    name = '${args.xpowerName}'
+    order by
+    startNs
+    `;
+};
+
+export function xpowerDataReceiver(data: unknown, proc: Function): void {
+  // @ts-ignore
+  if (data.params.trafic === TraficEnum.Memory) {
+    let res: unknown[];
+    let list: unknown[];
+    // @ts-ignore
+    if (!xpowerList.has(data.params.xpowerName)) {
+      // @ts-ignore
+      list = proc(chartXpowerDataSql(data.params));
+      for (let j = 0; j < list.length; j++) {
+        // @ts-ignore
+        if (list[j].name === 'ThermalReport.ShellTemp') {
+          // @ts-ignore
+          list[j].value = list[j].value / 1000;
+        }
+        if (j === list.length - 1) {
+          // @ts-ignore
+          list[j].dur = (data.params.totalNS || 0) - (list[j].startNs || 0);
+        } else {
+          // @ts-ignore
+          list[j].dur = (list[j + 1].startNs || 0) - (list[j].startNs || 0);
+        }
+      }
+      // @ts-ignore
+      xpowerList.set(data.params.xpowerName, list);
+    } else {
+      // @ts-ignore
+      list = xpowerList.get(data.params.xpowerName) || [];
+    }
+    // @ts-ignore
+    if (data.params.queryAll) {
+      //框选时候取数据，只需要根据时间过滤数据
+      res = (list || []).filter(
+        // @ts-ignore
+        (it) => it.startNs + it.dur >= data.params.selectStartNS && it.startNs <= data.params.selectEndNS
+      );
+    } else {
+      res = filterDataByGroup(
+        list || [],
+        'startNs',
+        'dur',
+        // @ts-ignore
+        data.params.startNS,
+        // @ts-ignore
+        data.params.endNS,
+        // @ts-ignore
+        data.params.width,
+        'value'
+      );
+    }
+    arrayBufferHandler(data, res, true);
+  } else {
+    // @ts-ignore
+    let sql = chartXpowerDataSql(data.params);
+    let res = proc(sql);
+    // @ts-ignore
+    arrayBufferHandler(data, res, data.params.trafic !== TraficEnum.SharedArrayBuffer);
+  }
+}
+
+function arrayBufferHandler(data: unknown, res: unknown[], transfer: boolean): void {
+  // @ts-ignore
+  let dur = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.dur);
+  // @ts-ignore
+  let startNS = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.startNS);
+  // @ts-ignore
+  let value = new Float64Array(transfer ? res.length : data.params.sharedArrayBuffers.value);
+  // @ts-ignore
+  let filterId = new Int32Array(transfer ? res.length : data.params.sharedArrayBuffers.filterId);
+  res.forEach((it, i) => {
+    // @ts-ignore
+    data.params.trafic === TraficEnum.ProtoBuffer && (it = it.xpowerData);
+    // @ts-ignore
+    dur[i] = it.dur;
+    // @ts-ignore
+    startNS[i] = it.startNs;
+    // @ts-ignore
+    filterId[i] = it.filterId;
+    // @ts-ignore
+    value[i] = it.value;
+  });
+
+  (self as unknown as Worker).postMessage(
+    {
+      // @ts-ignore
+      id: data.id,
+      // @ts-ignore
+      action: data.action,
+      results: transfer
+        ? {
+          dur: dur.buffer,
+          startNS: startNS.buffer,
+          value: value.buffer,
+          filterId: filterId.buffer,
+        }
+        : {},
+      len: res.length,
+      transfer: transfer,
+    },
+    transfer ? [dur.buffer, startNS.buffer, value.buffer, filterId.buffer] : []
+  );
+}
diff --git a/ide/src/trace/database/data-trafic/XpowerDataSender.ts b/ide/src/trace/database/data-trafic/XpowerDataSender.ts
new file mode 100644
index 0000000000000000000000000000000000000000..2f78d1d69328f78e813cfcf0be41ec8e0830f270
--- /dev/null
+++ b/ide/src/trace/database/data-trafic/XpowerDataSender.ts
@@ -0,0 +1,84 @@
+// Copyright (c) 2021 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.
+
+import { CHART_OFFSET_LEFT, MAX_COUNT, QueryEnum, TraficEnum } from './utils/QueryEnum';
+import { getThreadPool } from '../SqlLite';
+import { TraceRow } from '../../component/trace/base/TraceRow';
+import { XpowerStruct } from '../ui-worker/ProcedureWorkerXpower';
+import { Utils } from '../../component/trace/base/Utils';
+
+export function xpowerDataSender(
+  xpowerName: string = '',
+  row: TraceRow<XpowerStruct>,
+  args?: unknown,
+): Promise<XpowerStruct[]> {
+  let trafic: number = TraficEnum.Memory;
+  let width = row.clientWidth - CHART_OFFSET_LEFT;
+  if (trafic === TraficEnum.SharedArrayBuffer && !row.sharedArrayBuffers) {
+    row.sharedArrayBuffers = {
+      filterId: new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT * MAX_COUNT),
+      value: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
+      startNS: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
+      dur: new SharedArrayBuffer(Float64Array.BYTES_PER_ELEMENT * MAX_COUNT),
+    };
+  }
+  return new Promise((resolve, reject): void => {
+    getThreadPool(row.traceId).submitProto(
+      QueryEnum.XpowerData,
+      {
+        xpowerName: xpowerName,
+        startNS: TraceRow.range?.startNS || 0,
+        endNS: TraceRow.range?.endNS || 0,
+        totalNS: TraceRow.range?.totalNS || 0,
+        recordStartNS: Utils.getInstance().getRecordStartNS(row.traceId),
+        recordEndNS: Utils.getInstance().getRecordEndNS(row.traceId),
+        // @ts-ignore
+        queryAll: args && args.queryAll,
+        // @ts-ignore
+        selectStartNS: args ? args.startNS : 0,
+        // @ts-ignore
+        selectEndNS: args ? args.endNS : 0,
+        // @ts-ignore
+        selectTotalNS: args ? args.endNS - args.startNS : 0,
+        t: Date.now(),
+        width: width,
+        trafic: trafic,
+        sharedArrayBuffers: row.sharedArrayBuffers,
+      },
+      (res: unknown, len: number, transfer: boolean): void => {
+        resolve(arrayBufferHandler(transfer ? res : row.sharedArrayBuffers, len));
+      }
+    );
+  });
+}
+
+function arrayBufferHandler(buffers: unknown, len: number): XpowerStruct[] {
+  let outArr: XpowerStruct[] = [];
+  // @ts-ignore
+  let filterId = new Int32Array(buffers.filterId);
+  // @ts-ignore
+  let value = new Float64Array(buffers.value);
+  // @ts-ignore
+  let startNS = new Float64Array(buffers.startNS);
+  // @ts-ignore
+  let dur = new Float64Array(buffers.dur);
+  for (let i = 0; i < len; i++) {
+    outArr.push({
+      filterId: filterId[i],
+      value: value[i],
+      startNS: startNS[i],
+      dur: dur[i],
+    } as unknown as XpowerStruct);
+  }
+  return outArr;
+}
diff --git a/ide/src/trace/database/data-trafic/utils/AllMemoryCache.ts b/ide/src/trace/database/data-trafic/utils/AllMemoryCache.ts
index 2088bc1522f95fce42e4d5e53a7a80fcd335bf0a..8559007ca475c853bcee7b1be2c29e7532482ed8 100644
--- a/ide/src/trace/database/data-trafic/utils/AllMemoryCache.ts
+++ b/ide/src/trace/database/data-trafic/utils/AllMemoryCache.ts
@@ -58,6 +58,8 @@ export const hiLogList: Map<string, Array<unknown>> = new Map();
 export const energyList: Map<string, Array<unknown>> = new Map();
 //dma_fence 泳道图 memory 模式缓存
 export const dmaFenceList: Map<string, Array<unknown>> = new Map();
+//xpower 泳道 memory 模式缓存
+export const xpowerList: Map<string, Array<unknown>> = new Map();
 export function clearMemoryCache(data: unknown, proc: Function): void {
   sliceList.clear();
   cpuList.clear();
@@ -76,6 +78,7 @@ export function clearMemoryCache(data: unknown, proc: Function): void {
   hiSysEventList.clear();
   hiLogList.clear();
   energyList.clear();
+  xpowerList.clear(); 
   hiPerfCallChartClearCache(true);
   nativeMemoryCacheClear();
   resetVmTracker();
diff --git a/ide/src/trace/database/data-trafic/utils/ExecProtoForWorker.ts b/ide/src/trace/database/data-trafic/utils/ExecProtoForWorker.ts
index 8ead725cc196d39c166415ed61bacb60ac4a5b6f..1614cce5f6d863ca7865476eba63299b955aa87f 100644
--- a/ide/src/trace/database/data-trafic/utils/ExecProtoForWorker.ts
+++ b/ide/src/trace/database/data-trafic/utils/ExecProtoForWorker.ts
@@ -34,6 +34,7 @@ import { processStartupDataReceiver } from '../process//ProcessStartupDataReceiv
 import { processSoInitDataReceiver } from '../process//ProcessSoInitDataReceiver';
 import { processDeliverInputEventDataReceiver } from '../process//ProcessDeliverInputEventDataReceiver';
 import { processTouchEventDispatchDataReceiver } from '../process//ProcessTouchEventDispatchDataReceiver';
+import { xpowerDataReceiver } from '../XpowerDataReceiver';
 
 import {
   dmaDataReceiver,
@@ -159,4 +160,5 @@ traficHandlers.set(QueryEnum.SliceData, sliceReceiver);
 traficHandlers.set(QueryEnum.SliceSPTData, sliceSPTReceiver);
 traficHandlers.set(QueryEnum.dmaFenceData, dmaFenceReceiver);
 traficHandlers.set(QueryEnum.SliceChildBoxData, sliceSPTReceiver);
-traficHandlers.set(QueryEnum.ThreadNearData, sliceSPTReceiver);
\ No newline at end of file
+traficHandlers.set(QueryEnum.ThreadNearData, sliceSPTReceiver);
+traficHandlers.set(QueryEnum.XpowerData, xpowerDataReceiver);
\ No newline at end of file
diff --git a/ide/src/trace/database/data-trafic/utils/QueryEnum.ts b/ide/src/trace/database/data-trafic/utils/QueryEnum.ts
index b24135acc755adc5ebec29eb8c0aa116054c7397..508f9ba07301974e59d4a316c97360951079c542 100644
--- a/ide/src/trace/database/data-trafic/utils/QueryEnum.ts
+++ b/ide/src/trace/database/data-trafic/utils/QueryEnum.ts
@@ -91,6 +91,7 @@ export enum QueryEnum {
   SliceSPTData = 301,
   SliceChildBoxData = 302,
   ThreadNearData = 303,
+  XpowerData = 304,
 }
 export const MAX_COUNT = 2000;
 export enum TraficEnum {
diff --git a/ide/src/trace/database/sql/Xpower.sql.ts b/ide/src/trace/database/sql/Xpower.sql.ts
new file mode 100644
index 0000000000000000000000000000000000000000..94f19bba13523a4030ddef28a8b51c611f2eeb7f
--- /dev/null
+++ b/ide/src/trace/database/sql/Xpower.sql.ts
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+import { query } from '../SqlLite';
+// import { XpowerStruct } from '../ui-worker/ProcedureWorkerXpower';
+export const queryXpowerMeasureData = (traceId?: string): Promise<
+  Array<{
+    filter_id: number;
+  }>
+> =>
+  query(
+    'queryXpowerMeasureData',
+    `
+    select 
+        name 
+    from     
+        measure_filter mf
+    where
+        mf.type = 'xpower_filter'
+;
+`, {}, {traceId: traceId}
+  );
+export const queryXpowerData = (traceId?: string): Promise<
+  Array<{
+    name: string;
+    num: number;
+    maxValue?: number;
+  }>
+> =>
+  query(
+    'queryXpowerData',
+    `
+    select 
+        name,
+        COUNT(*) num 
+    from     
+        measure_filter mf
+    left join
+        xpower_measure xm
+    on
+        mf.id = xm.filter_id
+    where 
+        mf.type = 'xpower_filter'
+    group by name
+;
+`, {}, {traceId: traceId}
+  );
+
+
+
diff --git a/ide/src/trace/database/ui-worker/ProcedureWorker.ts b/ide/src/trace/database/ui-worker/ProcedureWorker.ts
index 0443c5b7336f0d634d8eaf2f4b196a0cc7566b95..d1bf4de3b1934b9ebd2dd569194deb371fe097e4 100644
--- a/ide/src/trace/database/ui-worker/ProcedureWorker.ts
+++ b/ide/src/trace/database/ui-worker/ProcedureWorker.ts
@@ -41,6 +41,7 @@ import { EnergyStateRender } from './ProcedureWorkerEnergyState';
 import { CpuFreqLimitRender } from './cpu/ProcedureWorkerCpuFreqLimits';
 import { HangRender } from './ProcedureWorkerHang';
 import { ClockRender } from './ProcedureWorkerClock';
+import { XpowerRender } from './ProcedureWorkerXpower';
 import { IrqRender } from './ProcedureWorkerIrq';
 import { JankRender } from './ProcedureWorkerJank';
 import { HeapTimelineRender } from './ProcedureWorkerHeapTimeline';
@@ -119,6 +120,7 @@ export let renders = {
   energyState: new EnergyStateRender(),
   hang: new HangRender(),
   clock: new ClockRender(),
+  xpower: new XpowerRender(), 
   irq: new IrqRender(),
   jank: new JankRender(),
   frameDynamicCurve: new FrameDynamicRender(),
diff --git a/ide/src/trace/database/ui-worker/ProcedureWorkerCommon.ts b/ide/src/trace/database/ui-worker/ProcedureWorkerCommon.ts
index f40f4f33959aeadb75aac235c9d1c9bed821ac17..7bcf30f051f9cfa88baafc5895ad34a0f1e1b053 100644
--- a/ide/src/trace/database/ui-worker/ProcedureWorkerCommon.ts
+++ b/ide/src/trace/database/ui-worker/ProcedureWorkerCommon.ts
@@ -1397,7 +1397,9 @@ function drawBrokenLineContext(
     rightEndpointX = x2 - wid;
     rightEndpointY = y2 + wid;
   } else {
+    // @ts-ignore
     x2 = brokenLineEnd.x - wid ?? 0;
+    // @ts-ignore
     x1 = brokenLineEnd.x - wid ?? 0;
     y1 = brokenLineStart.y ?? 0;
     leftEndpointX = x2 - wid;
diff --git a/ide/src/trace/database/ui-worker/ProcedureWorkerXpower.ts b/ide/src/trace/database/ui-worker/ProcedureWorkerXpower.ts
new file mode 100644
index 0000000000000000000000000000000000000000..41cf920dc1411516b2585abc1e1ac3e939ca51cf
--- /dev/null
+++ b/ide/src/trace/database/ui-worker/ProcedureWorkerXpower.ts
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+import { BaseStruct, dataFilterHandler, drawLoadingFrame, isFrameContainPoint, Render } from './ProcedureWorkerCommon';
+import { TraceRow } from '../../component/trace/base/TraceRow';
+import { ColorUtils } from '../../component/trace/base/ColorUtils';
+import { SpSystemTrace } from '../../component/SpSystemTrace';
+
+export class XpowerRender extends Render {
+  renderMainThread(
+    xpowerReq: {
+      context: CanvasRenderingContext2D;
+      useCache: boolean;
+      type: string;
+      maxValue: number;
+      index: number;
+      maxName: string;
+    },
+    row: TraceRow<XpowerStruct>
+  ): void {
+    XpowerStruct.index = xpowerReq.index;
+    let xpowerList = row.dataList;
+    let xpowerFilter = row.dataListCache;
+    dataFilterHandler(xpowerList, xpowerFilter, {
+      startKey: 'startNS',
+      durKey: 'dur',
+      startNS: TraceRow.range?.startNS ?? 0,
+      endNS: TraceRow.range?.endNS ?? 0,
+      totalNS: TraceRow.range?.totalNS ?? 0,
+      frame: row.frame,
+      paddingTop: 5,
+      useCache: xpowerReq.useCache || !(TraceRow.range?.refresh ?? false),
+    });
+    drawLoadingFrame(xpowerReq.context, xpowerFilter, row);
+    xpowerReq.context.beginPath();
+    let find = false;
+    for (let re of xpowerFilter) {
+      XpowerStruct.draw(xpowerReq.context, re, xpowerReq.maxValue);
+      if (row.isHover && re.frame && isFrameContainPoint(re.frame, row.hoverX, row.hoverY)) {
+        XpowerStruct.hoverXpowerStruct = re;
+        find = true;
+      }
+    }
+    if (!find && row.isHover) {
+      XpowerStruct.hoverXpowerStruct = undefined;
+    }
+    xpowerReq.context.closePath();
+    let s = xpowerReq.maxName;
+    let textMetrics = xpowerReq.context.measureText(s);
+    xpowerReq.context.globalAlpha = 0.8;
+    xpowerReq.context.fillStyle = '#f0f0f0';
+    xpowerReq.context.fillRect(0, 5, textMetrics.width + 8, 18);
+    xpowerReq.context.globalAlpha = 1;
+    xpowerReq.context.fillStyle = '#333';
+    xpowerReq.context.textBaseline = 'middle';
+    xpowerReq.context.fillText(s, 4, 5 + 9);
+  }
+}
+export function XpowerStructOnClick(
+  clickRowType: string,
+  sp: SpSystemTrace,
+  entry?: XpowerStruct,
+): Promise<unknown> {
+  return new Promise((resolve, reject) => {
+    if (clickRowType === TraceRow.ROW_TYPE_XPOWER_SYSTEM && (XpowerStruct.hoverXpowerStruct || entry)) {
+      XpowerStruct.selectXpowerStruct = entry || XpowerStruct.hoverXpowerStruct;
+      sp.traceSheetEL?.displayXpowerData(XpowerStruct.selectXpowerStruct!);
+      sp.timerShaftEL?.modifyFlagList(undefined);
+      reject(new Error());
+    } else {
+      resolve(null);
+    }
+  });
+}
+export class XpowerStruct extends BaseStruct {
+  static maxValue: number = 0;
+  static maxName: string = '';
+  static hoverXpowerStruct: XpowerStruct | undefined;
+  static selectXpowerStruct: XpowerStruct | undefined;
+  static index = 0;
+  filterId: number | undefined;
+  value: number | undefined;
+  startNS: number | undefined;
+  dur: number | undefined; //自补充，数据库没有返回
+  delta: number | undefined; //自补充，数据库没有返回
+
+  static draw(xpowerContext: CanvasRenderingContext2D, data: XpowerStruct, maxValue: number): void {
+    if (data.frame) {
+      let width = data.frame.width || 0;
+      xpowerContext.fillStyle = ColorUtils.colorForTid(XpowerStruct.index);
+      xpowerContext.strokeStyle = ColorUtils.colorForTid(XpowerStruct.index);
+      let drawHeight: number = Math.floor(((data.value || 0) * (data.frame.height || 0) * 1.0) / maxValue);
+      if (drawHeight === 0) {
+        drawHeight = 1;
+      }
+      if (XpowerStruct.isHover(data)) {
+        xpowerContext.lineWidth = 1;
+        xpowerContext.globalAlpha = 0.6;
+        xpowerContext.fillRect(data.frame.x, data.frame.y + data.frame.height - drawHeight, width, drawHeight);
+        xpowerContext.beginPath();
+        xpowerContext.arc(data.frame.x, data.frame.y + data.frame.height - drawHeight, 3, 0, 2 * Math.PI, true);
+        xpowerContext.fill();
+        xpowerContext.globalAlpha = 1.0;
+        xpowerContext.stroke();
+        xpowerContext.beginPath();
+        xpowerContext.moveTo(data.frame.x + 3, data.frame.y + data.frame.height - drawHeight);
+        xpowerContext.lineWidth = 3;
+        xpowerContext.lineTo(data.frame.x + width, data.frame.y + data.frame.height - drawHeight);
+        xpowerContext.stroke();
+      } else {
+        xpowerContext.lineWidth = 1;
+        xpowerContext.globalAlpha = 1.0;
+        xpowerContext.strokeRect(data.frame.x, data.frame.y + data.frame.height - drawHeight, width, drawHeight);
+        xpowerContext.globalAlpha = 0.6;
+        xpowerContext.fillRect(data.frame.x, data.frame.y + data.frame.height - drawHeight, width, drawHeight);
+      }
+    }
+    xpowerContext.globalAlpha = 1.0;
+    xpowerContext.lineWidth = 1;
+  }
+
+  static isHover(xpower: XpowerStruct): boolean {
+    return xpower === XpowerStruct.hoverXpowerStruct || xpower === XpowerStruct.selectXpowerStruct;
+  }
+}
diff --git a/ide/src/webSocket/Constants.ts b/ide/src/webSocket/Constants.ts
new file mode 100644
index 0000000000000000000000000000000000000000..60de653ce1bc4c5d417d897e2e133eb19f244d5b
--- /dev/null
+++ b/ide/src/webSocket/Constants.ts
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+export class Constants {
+    static INTERVAL_TIME = 30000;
+    static LOGIN_PARAM = { type: 0, cmd: 1 };
+    static LOGIN_CMD = 2;// cmd 2 有效 3无效
+}
+
+export class TypeConstants {
+    static LOGIN_TYPE = 0;// 先判断type  0（登录） 和 其他(业务)
+    static HEARTBEAT_TYPE = 1;
+    static DIAGNOSIS_TYPE = 8;
+    static SENDDB_CMD = 1;
+    static DIAGNOSIS_CMD = 3;
+}
\ No newline at end of file
diff --git a/ide/src/webSocket/Util.ts b/ide/src/webSocket/Util.ts
new file mode 100644
index 0000000000000000000000000000000000000000..b5a48210e85e9e3e511278f9b5f420178ac92f7b
--- /dev/null
+++ b/ide/src/webSocket/Util.ts
@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+
+const MSG_HEAD_LENGTH = 20;
+const TYPT_LENGTH = 1;
+const CMD_LENGTH = 2;
+const SESSION_ID_LENGTH = 1;
+const SESSION_LENGTH = 4;
+export class Utils {
+    // 模块传进来的数据
+    static encode(message: MessageParam) {
+        let splitUint64 = message.session ? Utils.splitUint64ToUint32s(BigInt(message.session!)) : { high32: 0, low32: 0 };// 需处理64bit(session)
+        let totalByteLength = MSG_HEAD_LENGTH + (message.data_lenght ? message.data_lenght : 0);
+        let combinedBuffer = new ArrayBuffer(totalByteLength);// 一个更大的ArrayBuffer，合并前20个字节和data
+        let headBuffer = new ArrayBuffer(MSG_HEAD_LENGTH);
+        let dataView = new DataView(headBuffer);
+        let index = 0;
+        dataView.setUint8(index, message.type!);
+        index += TYPT_LENGTH;
+        dataView.setUint16(index, message.cmd ? message.cmd : 0);
+        index += CMD_LENGTH;
+        dataView.setUint8(index, message.session_id ? message.session_id : 0);
+        index += SESSION_ID_LENGTH;
+        dataView.setUint32(index, splitUint64?.high32!);
+        index += SESSION_LENGTH;
+        dataView.setUint32(index, splitUint64?.low32!);
+        index += SESSION_LENGTH;
+        dataView.setUint32(index, message.data_lenght ? message.data_lenght : 0);
+        // 处理合并message.data
+        let existingArray = new Uint8Array(headBuffer); // 将处理好的前20个字节 
+        let combinedArray = new Uint8Array(combinedBuffer);
+        // 分别将前20个字节和data对应的字节流set至combinedBuffer
+        combinedArray.set(existingArray, 0);
+        combinedArray.set(message.data ? message.data : new Uint8Array(0), headBuffer.byteLength);
+        return combinedBuffer
+    }
+
+    // onmessage接收到的数据解码
+    public static decode(message: ArrayBuffer) {
+        let decode: MessageParam | undefined;
+        let dataView = new DataView(message);
+        let sessionHigh = dataView.getUint32(4);
+        let sessionLow = dataView.getUint32(8);
+        // 将两个 32 位部分组合成一个 64 位的 BigInt  
+        let session = BigInt(sessionHigh) << BigInt(32) | BigInt(sessionLow);
+        // 先将data所需的字节截取出来
+        let dataBytes = new Uint8Array(message, MSG_HEAD_LENGTH, message.byteLength - MSG_HEAD_LENGTH);
+        // 解码 session 的两个 32 位部分  
+        decode = {
+            type: dataView.getUint8(0),
+            cmd: dataView.getUint16(1),
+            session_id: dataView.getUint8(3),
+            session: session,
+            data_lenght: dataView.getUint32(12),
+            data: dataBytes
+        }
+        return decode
+    }
+
+    // 处理64bit 需要拆分成两个32bit
+    public static splitUint64ToUint32s(bigInt: bigint): { high32: number, low32: number } {
+        // 使用位运算提取高32位和低32位  
+        // 右移32位得到高32位，并与0xFFFFFFFF进行按位与操作以确保结果是32位无符号整数  
+        const high32 = Number((bigInt >> BigInt(32)) & BigInt(0xFFFFFFFF));
+        // 低32位可以直接与0xFFFFFFFF进行按位与操作  
+        const low32 = Number(bigInt & BigInt(0xFFFFFFFF));
+        return { high32, low32 };
+    }
+}
+export class MessageParam {
+    type: number | undefined;
+    cmd: number | undefined;
+    session_id?: number | undefined;
+    session?: bigint | undefined;
+    data_lenght?: number | undefined;
+    data?: Uint8Array | undefined
+}
\ No newline at end of file
diff --git a/ide/src/webSocket/WebSocketManager.ts b/ide/src/webSocket/WebSocketManager.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d2d17df841ea9398c7c7e035df93e485287d9792
--- /dev/null
+++ b/ide/src/webSocket/WebSocketManager.ts
@@ -0,0 +1,179 @@
+/*
+ * Copyright (C) 2024 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.
+ */
+import { Utils, MessageParam } from "./Util"
+import { Constants, TypeConstants } from "./Constants";
+
+export class WebSocketManager {
+    static instance: WebSocketManager | null | undefined = null;
+    url: string = 'ws://localhost:18080';//8080后期需要修改
+    private websocket: WebSocket | null | undefined = null;
+    private ready: boolean = false;
+    private distributeMap: Map<number, Function> = new Map<number, Function>();
+    private sessionId: number | null | undefined;
+    private session: bigint | null | undefined;
+    private heartbeatInterval: number | null | undefined;
+
+    constructor() {
+        if (WebSocketManager.instance) {
+            return WebSocketManager.instance;
+        }
+        WebSocketManager.instance = this;
+        //连接websocket
+        this.connectWebSocket();
+    }
+    //连接WebSocket
+    connectWebSocket(): void {
+        this.websocket = new WebSocket(this.url);
+        this.websocket.binaryType = "arraybuffer";
+        this.websocket.onopen = () => {
+            // 设置心跳定时器  
+            this.sendHeartbeat();
+            // 连接后登录
+            this.login();
+        };
+
+        //接受webSocket的消息
+        this.websocket.onmessage = (event) => {
+            // 先解码
+            let decode: MessageParam = Utils.decode(event.data);
+            if (decode.type === TypeConstants.HEARTBEAT_TYPE) {
+                return;
+            }
+            this.onmessage(decode!);
+        };
+
+        this.websocket.onerror = (error) => {
+            console.error('error:', error);
+        };
+
+        this.websocket.onclose = (event) => {
+            this.initLoginInfor();
+            this.clearHeartbeat();
+            this.reconnect(event);
+        };
+    }
+
+    /**
+     * 接收webSocket返回的buffer数据
+     * 分别处理登录、其他业务的数据
+     * 其他业务数据分发
+     */
+    onmessage(decode: MessageParam): void {
+        // 解码event  调decode
+        if (decode.type === TypeConstants.LOGIN_TYPE) {// 登录
+            if (decode.cmd === Constants.LOGIN_CMD) {
+                this.ready = true;
+                this.sessionId = decode.session_id;
+                this.session = decode.session;
+            }
+        } else {// type其他
+            for (let [key, callback] of this.distributeMap.entries()) {
+                if (key === decode.type) {
+                    callback(decode.cmd, decode.data);
+                }
+            };
+        }
+    }
+
+    // 登录
+    login(): void {
+        this.websocket!.send(Utils.encode(Constants.LOGIN_PARAM));
+    }
+
+    // 模块调
+    static getInstance(): WebSocketManager | null | undefined {
+        if (!WebSocketManager.instance) {
+            new WebSocketManager();
+        }
+        return WebSocketManager.instance
+    }
+
+    // WebSocket是否登录成功 
+    isReady(): boolean {
+        return this.ready
+    }
+
+    /** 
+     * 消息监听器
+     * listener是不同模块传来接收数据的函数
+     * 模块调用
+    */
+    registerMessageListener(type: number, callback: Function): void {
+        if (!this.distributeMap.has(type)) {
+            this.distributeMap.set(type, callback);
+        }
+    }
+
+    /**
+     * 传递数据信息至webSocket
+     * 模块调
+     */
+    sendMessage(type: number, cmd?: number, data?: Uint8Array): void {
+        // 检查WebSocket是否登录成功 
+        if (!this.ready) {// 改判断条件 ready
+            return;
+        }
+        let message: MessageParam = {
+            type: type,
+            cmd: cmd,
+            session_id: this.sessionId!,
+            session: this.session!,
+            data_lenght: data ? data.byteLength : undefined,
+            data: data
+        }
+        let encode = Utils.encode(message);
+        this.websocket!.send(encode!);
+    }
+
+    /**
+     * 传递数据信息至webSocket
+     * 模块调
+    */
+    reconnect(event: unknown) {
+        //@ts-ignore
+        if (event.wasClean) {// 正常关闭
+            return
+        }
+        // 未连接成功打开定时器
+        setTimeout(() => {
+            this.connectWebSocket();
+        }, Constants.INTERVAL_TIME)
+    }
+
+    // 定时检查心跳  
+    sendHeartbeat() {
+        this.heartbeatInterval = window.setInterval(() => {
+            this.sendMessage(TypeConstants.HEARTBEAT_TYPE)
+        }, Constants.INTERVAL_TIME)
+    }
+
+    /**
+     * 重连时初始化登录信息
+     * 在异常关闭时调用
+     */
+    initLoginInfor() {
+        this.ready = false;
+        this.sessionId = null;
+        this.session = null;
+    }
+
+    // 连接关闭时，清除心跳
+    clearHeartbeat() {        
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+}
diff --git a/ide/webpack.config.js b/ide/webpack.config.js
index f7702c1c82b76379cf96edcfdecceed0eaa24808..553979178bc65a77851d85ba0ad8a829d1dd0071 100644
--- a/ide/webpack.config.js
+++ b/ide/webpack.config.js
@@ -168,8 +168,8 @@ const config = {
           to: 'wasm.json',
         },
         {
-          from: './server/server-config.txt',
-          to: 'server-config.txt',
+          from: './server/server-config.json',
+          to: 'server-config.json',
         },
       ],
     }),
diff --git a/trace_streamer/pare_third_party.sh b/trace_streamer/pare_third_party.sh
index 74bea958df5310215fb72fc0e8035ebb513f6c73..f48b1c1231f19ba42d0c803ac9d0f3274fc9bdce 100755
--- a/trace_streamer/pare_third_party.sh
+++ b/trace_streamer/pare_third_party.sh
@@ -49,6 +49,19 @@ if [ ! -f "zlib/BUILD.gn" ];then
         $cp ../prebuilts/patch_zlib/zlibbuild.gn zlib/BUILD.gn
     fi
 fi
+
+if [ ! -f "bzip2/BUILD.gn" ];then
+    rm -rf bzip2
+    git clone --depth=1 git@gitee.com:openharmony/third_party_bzip2.git
+    if [ -d "third_party_bzip2" ];then
+        mv third_party_bzip2 bzip2
+        $cp ../prebuilts/patch_bzip2/bzip2build.gn bzip2/BUILD.gn
+        cd bzip2
+        ./install.sh `pwd`
+        cd ..
+    fi
+fi
+
 if [ ! -f "googletest/BUILD.gn" ];then
     rm -rf googletest
     git clone --depth=1 git@gitee.com:openharmony/third_party_googletest.git
@@ -143,7 +156,6 @@ if [ ! -f "hiperf/BUILD.gn" ];then
         $sed -i "/FRIEND_TEST/s/^\(.*\)$/\/\/\1/g" hiperf/include/symbols_file.h
         $sed -i "/FRIEND_TEST/s/^\(.*\)$/\/\/\1/g" hiperf/include/virtual_runtime.h
         $sed -i "/FRIEND_TEST/s/^\(.*\)$/\/\/\1/g" hiperf/include/report.h
-
         $sed -i "s/HIPERF_DEBUG/ALWAYSTRUE/g" hiperf/include/virtual_thread.h
         $sed -i "/using __s8 = char;/a #define unw_word_t uint64_t" hiperf/include/nonlinux/linux/types.h
         $sed -i '/^void Report::PrepareConsole(/,/^}/ s/^.*$/\/\/&/; /^void Report::PrepareConsole(/,/return;/ s/^[[:blank:]]*/    /' hiperf/src/report.cpp
diff --git a/trace_streamer/prebuilts/patch_bzip2/bzip2build.gn b/trace_streamer/prebuilts/patch_bzip2/bzip2build.gn
new file mode 100644
index 0000000000000000000000000000000000000000..4567043d0e89525d9bc54a1e8c5fc4b4f6a7d20e
--- /dev/null
+++ b/trace_streamer/prebuilts/patch_bzip2/bzip2build.gn
@@ -0,0 +1,42 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+# 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.
+
+import("//build/ohos.gni")
+
+config("bzip2_config") {
+  include_dirs = [ "." ]
+}
+
+ohos_source_set("bzip2_src") {
+  sources = [
+    "blocksort.c",
+    "bzlib.c",
+    "compress.c",
+    "crctable.c",
+    "decompress.c",
+    "huffman.c",
+    "randtable.c",
+  ]
+  configs += [ ":bzip2_config" ]
+
+  part_name = "bzip2"
+  subsystem_name = "thirdparty"
+}
+
+ohos_static_library("libbz2") {
+  deps = [ ":bzip2_src" ]
+  public_configs = [ ":bzip2_config" ]
+
+  part_name = "bzip2"
+  subsystem_name = "thirdparty"
+}
diff --git a/trace_streamer/prebuilts/patch_zlib/zlibbuild.gn b/trace_streamer/prebuilts/patch_zlib/zlibbuild.gn
index c05bff0d5fd9a6f9c6313db94e36ad2eaf7e08a4..b8916ad7ff3f2549a82773897a545611f6d5957f 100644
--- a/trace_streamer/prebuilts/patch_zlib/zlibbuild.gn
+++ b/trace_streamer/prebuilts/patch_zlib/zlibbuild.gn
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 import("//build/ohos.gni")
+import("../../build/ts.gni")
 
 config("zlib_config") {
   cflags = [
@@ -19,6 +20,7 @@ config("zlib_config") {
     "-Werror",
     "-Wno-strict-prototypes",
     "-Wimplicit-function-declaration",
+    "-D HAVE_BZIP2",
   ]
 }
 
@@ -60,7 +62,7 @@ ohos_source_set("libz") {
   ]
   configs += [ ":zlib_config" ]
   public_configs = [ ":zlib_public_config" ]
-
+  public_deps = [ "${THIRD_PARTY}/bzip2:libbz2" ]
   part_name = "zlib"
   subsystem_name = "thirdparty"
-}
\ No newline at end of file
+}
diff --git a/trace_streamer/src/base/BUILD.gn b/trace_streamer/src/base/BUILD.gn
index 70209b12c1c643a49e488f7253611a65277fe5db..f577bc201291bca06b9e72037d875ff4d7bdd6c9 100644
--- a/trace_streamer/src/base/BUILD.gn
+++ b/trace_streamer/src/base/BUILD.gn
@@ -16,7 +16,10 @@ import("../../build/ts.gni")
 ohos_source_set("base") {
   subsystem_name = "${OHOS_PROFILER_SUBSYS_NAME}"
   part_name = "${OHOS_PROFILER_PART_NAME}"
-  public_deps = [ "sqlite_ext:sqliteext" ]
+  public_deps = [
+    "${THIRD_PARTY}/zlib:libz",
+    "sqlite_ext:sqliteext",
+  ]
   include_dirs = [
     "../include",
     "${THIRD_PARTY}/sqlite/include",
diff --git a/trace_streamer/src/base/file.cpp b/trace_streamer/src/base/file.cpp
index 35a79cde2dd8e021f68df306ad4c11213c81c678..b632aa1733039645963e6b7098f7abcc56568dac 100644
--- a/trace_streamer/src/base/file.cpp
+++ b/trace_streamer/src/base/file.cpp
@@ -14,9 +14,10 @@
  */
 
 #include "file.h"
-#include <atomic>
 #include <cerrno>
 #include <fcntl.h>
+#include <fstream>
+#include <iostream>
 #include <sys/stat.h>
 #include <unistd.h>
 
@@ -26,6 +27,12 @@
 #include <io.h>
 #include <windows.h>
 #endif
+#if defined(is_linux) || defined(_WIN32)
+#include <filesystem>
+#endif
+#include "zlib.h"
+#include "contrib/minizip/zip.h"
+#include "contrib/minizip/unzip.h"
 
 namespace SysTuning {
 namespace base {
@@ -76,7 +83,7 @@ std::string GetExecutionDirectoryPath()
     return str.substr(0, str.find_last_of('/'));
 }
 #if defined(is_linux) || defined(_WIN32)
-std::vector<std::string> GetFilesNameFromDir(const std::string &path)
+std::vector<std::string> GetFilesNameFromDir(const std::string &path, bool onlyFileName)
 {
     std::vector<std::string> soFiles;
 
@@ -87,11 +94,136 @@ std::vector<std::string> GetFilesNameFromDir(const std::string &path)
         return soFiles;
     }
     // 遍历目录
-    for (const auto &entry : std::filesystem::directory_iterator(dirPath)) {
-        soFiles.emplace_back(entry.path().filename().string());
+    for (const auto &entry : std::filesystem::recursive_directory_iterator(dirPath)) {
+        if (entry.is_directory()) {
+            continue;
+        }
+        soFiles.emplace_back(onlyFileName ? entry.path().filename().string() : entry.path().string());
     }
     return soFiles;
 }
 #endif
+
+bool UnZipFile(const std::string &zipFile, std::string &traceFile)
+{
+    std::filesystem::path stdZipFile(zipFile);
+    // 检查文件是否存在
+    if (!std::filesystem::exists(stdZipFile)) {
+        TS_LOGI("!std::filesystem::exists(dirPath), dirPath: %s\n", zipFile.data());
+        return false;
+    }
+    std::ifstream zipIfstream(stdZipFile);
+    char buf[2];
+    zipIfstream.read(buf, 2);
+    if (buf[0] != 'P' || buf[1] != 'K') {
+        // 不是zip文件, 返回true走正常解析流程
+        return true;
+    } else {
+        auto unzipDirPath = stdZipFile.parent_path().append("tmp").string();
+        LocalUnzip(zipFile, unzipDirPath);
+        auto files = GetFilesNameFromDir(unzipDirPath, false);
+        if (files.size() == 1) {
+            traceFile = files[0];
+            return true;
+        }
+        return false;
+    }
+}
+
+bool LocalUnzip(const std::string &zipFile, const std::string &dstDir)
+{
+    int err = 0;
+    void *buf;
+    uInt size_buf;
+    // 创建 dstDir
+    if (std::filesystem::exists(dstDir)) {
+        std::filesystem::remove_all(dstDir);
+        std::filesystem::create_directories(dstDir);
+    }
+
+    // 打开zip文件
+    unzFile uf = unzOpen(zipFile.c_str());
+    if (uf == NULL) {
+        std::cout << "unzOpen error." << std::endl;
+        return false;
+    }
+
+    // 获取zip文件信息
+    unz_global_info gi;
+    err = unzGetGlobalInfo(uf, &gi);
+    if (err != UNZ_OK) {
+        std::cout << "unzGetGlobalInfo error." << std::endl;
+        return false;
+    }
+
+    size_buf = 512000000;
+    buf = (void *)malloc(size_buf);
+
+    // 遍历zip
+    for (int i = 0; i < gi.number_entry; i++) {
+        char filename_inzip[256];
+        unz_file_info file_info;
+        uLong ratio = 0;
+        const char *string_method = "";
+        char charCrypt = ' ';
+        err = unzGetCurrentFileInfo(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0);
+        if (err != UNZ_OK) {
+            std::cout << "error " << err << " with zipfile in unzGetCurrentFileInfo." << std::endl;
+            break;
+        }
+        std::string isdir;
+        std::string filename = filename_inzip;
+        if (filename.back() == '/' || filename.back() == '\\') {
+            //* 是目录，则创建目录
+            isdir = " is directory";
+            std::string dir = dstDir + "/" + filename;
+            if (!std::filesystem::exists(dir)) {
+                std::filesystem::create_directories(dir);
+            }
+        } else {
+            //* 是文件，打开 -> 读取 -> 写入解压文件 -> 关闭
+            isdir = " is file";
+
+            err = unzOpenCurrentFile(uf);
+            if (err != UNZ_OK) {
+                std::cout << "error " << err << " with zipfile in unzOpenCurrentFile." << std::endl;
+            } else {
+                std::string writefile = dstDir + "/" + filename;
+                std::filesystem::path fpath(writefile);
+                std::string par = fpath.parent_path().string();
+                if (!fpath.parent_path().empty() && !std::filesystem::exists(fpath.parent_path())) {
+                    std::filesystem::create_directories(fpath.parent_path());
+                }
+                err = unzReadCurrentFile(uf, buf, size_buf);
+                if (err < 0) {
+                    std::cout << "error " << err << " with zipfile in unzReadCurrentFile." << std::endl;
+                    break;
+                }
+                if (err > 0) {
+                    FILE *fout = fopen(writefile.c_str(), "wb");
+                    if (fwrite(buf, (unsigned)err, 1, fout) != 1) {
+                        std::cout << "error in writing extracted filee." << std::endl;
+                        err = UNZ_ERRNO;
+                        break;
+                    }
+                    fclose(fout);
+                }
+                unzCloseCurrentFile(uf);
+            }
+        }
+
+        if ((i + 1) < gi.number_entry) {
+            err = unzGoToNextFile(uf);
+            if (err != UNZ_OK) {
+                std::cout << "error " << err << " with zipfile in unzGoToNextFile." << std::endl;
+                break;
+            }
+        }
+    }
+
+    unzClose(uf);
+
+    return true;
+}
 } // namespace base
 } // namespace SysTuning
diff --git a/trace_streamer/src/base/file.h b/trace_streamer/src/base/file.h
index 6c7541c80443da5f8dc452320796eb3537c2f1f4..1e66055b289dd6439cc85318fde68da7223d7311 100644
--- a/trace_streamer/src/base/file.h
+++ b/trace_streamer/src/base/file.h
@@ -16,11 +16,9 @@
 #ifndef INCLUDE_TUNING_BASE_FILE_UTILS_H
 #define INCLUDE_TUNING_BASE_FILE_UTILS_H
 
-#if defined(is_linux) || defined(_WIN32)
-#include <filesystem>
-#endif
 #include <string>
 #include <vector>
+
 namespace SysTuning {
 namespace base {
 #define TS_PERMISSION_RW 0600
@@ -42,9 +40,14 @@ ssize_t Read(int32_t fd, uint8_t *dst, size_t dstSize);
 int32_t OpenFile(const std::string &path, int32_t flags, uint32_t mode = K_FILE_MODE_INVALID);
 
 std::string GetExecutionDirectoryPath();
+
 #if defined(is_linux) || defined(_WIN32)
-std::vector<std::string> GetFilesNameFromDir(const std::string &path);
+std::vector<std::string> GetFilesNameFromDir(const std::string &path, bool onlyFileName = true);
 #endif
+
+bool UnZipFile(const std::string &zipFile, std::string &traceFile);
+
+bool LocalUnzip(const std::string &zipFile, const std::string &dstDir);
 } // namespace base
 } // namespace SysTuning
 #endif // INCLUDE_TUNING_BASE_FILE_UTILS_H_
diff --git a/trace_streamer/src/base/index_map.cpp b/trace_streamer/src/base/index_map.cpp
index d271c09931388c15529155a563743926f8918dec..399a35b52217c3258578734d5b880f188b55bfaf 100644
--- a/trace_streamer/src/base/index_map.cpp
+++ b/trace_streamer/src/base/index_map.cpp
@@ -23,7 +23,7 @@ namespace SysTuning {
 namespace TraceStreamer {
 IndexMap::IndexMap(TableRowId start, TableRowId end) : end_(end), current_(start), start_(start) {}
 
-void IndexMap::CovertToIndexMap()
+void IndexMap::ConvertToIndexMap()
 {
     if (converted_) {
         indexType_ = INDEX_TYPE_OUTER_INDEX;
@@ -108,7 +108,7 @@ void IndexMap::FilterId(unsigned char op, sqlite3_value *argv)
         return;
     }
     if (HasData()) {
-        CovertToIndexMap();
+        ConvertToIndexMap();
     }
 
     auto v = static_cast<TableRowId>(sqlite3_value_int64(argv));
@@ -174,8 +174,8 @@ bool IndexMap::MergeIndexTypeId(IndexMap *other)
         start_ = std::min(start_, other->start_);
         end_ = std::max(end_, other->end_);
     } else if (start_ > other->start_) {
-        this->CovertToIndexMap();
-        other->CovertToIndexMap();
+        this->ConvertToIndexMap();
+        other->ConvertToIndexMap();
         const std::vector<TableRowId> b = other->rowIndex_;
         uint32_t bIndex = 0;
         uint32_t bSize = b.size();
@@ -185,8 +185,8 @@ bool IndexMap::MergeIndexTypeId(IndexMap *other)
         start_ = current_ = 0;
         end_ = rowIndex_.size();
     } else {
-        this->CovertToIndexMap();
-        other->CovertToIndexMap();
+        this->ConvertToIndexMap();
+        other->ConvertToIndexMap();
         std::vector<TableRowId> c = other->rowIndex_;
         uint32_t aIndex = 0;
         uint32_t aSize = rowIndex_.size();
@@ -201,8 +201,8 @@ bool IndexMap::MergeIndexTypeId(IndexMap *other)
 bool IndexMap::Merge(IndexMap *other)
 {
     TS_CHECK_TRUE_RET(MergeIndexTypeId(other) == false, true);
-    this->CovertToIndexMap();
-    other->CovertToIndexMap();
+    this->ConvertToIndexMap();
+    other->ConvertToIndexMap();
     const std::vector<TableRowId> b = other->rowIndex_;
     const std::vector<TableRowId> &a = rowIndex_;
     std::vector<TableRowId> c;
diff --git a/trace_streamer/src/base/index_map.h b/trace_streamer/src/base/index_map.h
index fb0d6fe07bdcc8d6196fb1c82caf172a9e33c7f3..8a576e698f147d375bed29955fa98b3fa6319c86 100644
--- a/trace_streamer/src/base/index_map.h
+++ b/trace_streamer/src/base/index_map.h
@@ -31,7 +31,7 @@ public:
     ~IndexMap() {}
 
     IndexMap(TableRowId start, TableRowId end);
-    void CovertToIndexMap();
+    void ConvertToIndexMap();
     static void Sort();
     void Print();
     void Init();
@@ -69,7 +69,7 @@ public:
     {
         filters_++;
         if (HasData()) {
-            CovertToIndexMap();
+            ConvertToIndexMap();
             remove = true;
         }
         rowIndexBak_.clear();
@@ -193,7 +193,7 @@ public:
         auto invalidValue = std::numeric_limits<T>::max();
         bool remove = false;
         if (HasData()) {
-            CovertToIndexMap();
+            ConvertToIndexMap();
             remove = true;
         }
 
diff --git a/trace_streamer/src/base/ts_common.h b/trace_streamer/src/base/ts_common.h
index 2d13eec27ace19a70701e16936c692decdf2e2c9..109dd2ecb454cf87b2c873ba851e8456931e991c 100644
--- a/trace_streamer/src/base/ts_common.h
+++ b/trace_streamer/src/base/ts_common.h
@@ -42,6 +42,7 @@ const uint64_t INVALID_CALL_CHAIN_ID = std::numeric_limits<uint64_t>::max();
 const size_t MAX_SIZE_T = std::numeric_limits<size_t>::max();
 const uint32_t INVALID_ID = std::numeric_limits<uint32_t>::max();
 const uint64_t SEC_TO_NS = 1000 * 1000 * 1000;
+const uint64_t MSEC_TO_NS = 1000 * 1000;
 const int32_t STR_DEFAULT_LEN = -1;
 const auto INVALID_CPU = INVALID_UINT32;
 const auto INVALID_TIME = INVALID_UINT64;
@@ -208,6 +209,7 @@ enum DataSourceType {
     DATA_SOURCE_TYPE_JSMEMORY,
     DATA_SOURCE_TYPE_JSMEMORY_CONFIG,
     DATA_SOURCE_TYPE_MEM_CONFIG,
+    DATA_SOURCE_TYPE_XPOWER,
     DATA_SOURCE_TYPE_STREAM
 };
 enum HookMemoryType { MALLOC = 0, MMAP = 1, FILE_PAGE_MSG = 2, MEMORY_USING_MSG = 3 };
diff --git a/trace_streamer/src/cfg/trace_streamer_config.cpp b/trace_streamer/src/cfg/trace_streamer_config.cpp
index f1718c6ab4a535990cf1dfaef62d2ab104426c21..1e1da266bda2e093dffbfcd5ba4cfe53f0221ec1 100644
--- a/trace_streamer/src/cfg/trace_streamer_config.cpp
+++ b/trace_streamer/src/cfg/trace_streamer_config.cpp
@@ -42,7 +42,7 @@ TraceStreamerConfig::TraceStreamerConfig()
         {MEM_VM_SIZE, MEM_INFO_VM_SIZE_DESC},   {MEM_VM_LOCKED, MEM_INFO_LOCKED_DESC},
         {MEM_VM_RSS, MEM_INFO_RSS_DESC},        {MEM_VM_ANON, MEM_INFO_RSS_ANON_DESC},
         {MEM_RSS_FILE, MEM_INFO_RSS_FILE_DESC}, {MEM_RSS_SHMEM, MEM_INFO_RSS_SCHEM_DESC},
-        {MEM_VM_SWAP, MEM_INFO_SWAP_DESC},      {MEM_VM_LOCKED, MEM_INFO_VIRT_DESC},
+        {MEM_VM_SWAP, MEM_INFO_SWAP_DESC},      {MEM_VM_VIRT, MEM_INFO_VIRT_DESC},
         {MEM_VM_HWM, MEM_INFO_HWM_DESC},        {MEM_OOM_SCORE_ADJ, MEM_INFO_SCORE_ADJ_DESC},
         {MEM_PURG_SUM, MEM_INFO_PURG_SUM_DESC}, {MEM_PURG_PIN, MEM_INFO_PURG_PIN_DESC},
         {MEM_GL_PSS, MEM_INFO_GL_PSS_DESC},     {MEM_GRAPH_PSS, MEM_INFO_GRAPH_PSS_DESC},
diff --git a/trace_streamer/src/cfg/trace_streamer_config.h b/trace_streamer/src/cfg/trace_streamer_config.h
index 7b4c28bd2ca8b5bdd7fe78de3604fbc58faa1f0c..c776d459b84b44e829a686ce2a150d9081abb629 100644
--- a/trace_streamer/src/cfg/trace_streamer_config.h
+++ b/trace_streamer/src/cfg/trace_streamer_config.h
@@ -126,13 +126,14 @@ enum SupportedTraceEventType {
 };
 enum MemInfoType {
     MEM_VM_SIZE,
+    MEM_VM_LOCKED,
     MEM_VM_RSS,
     MEM_VM_ANON,
     MEM_RSS_FILE,
     MEM_RSS_SHMEM,
     MEM_VM_SWAP,
-    MEM_VM_LOCKED,
     MEM_VM_HWM,
+    MEM_VM_VIRT,
     MEM_OOM_SCORE_ADJ,
     MEM_PURG_SUM,
     MEM_PURG_PIN,
diff --git a/trace_streamer/src/filter/app_start_filter.cpp b/trace_streamer/src/filter/app_start_filter.cpp
index 505ac90b6a3ce143ae2fc36855117bf5410113bd..bc9c9244f3f99a4322ec4fba1b45909b924755fc 100644
--- a/trace_streamer/src/filter/app_start_filter.cpp
+++ b/trace_streamer/src/filter/app_start_filter.cpp
@@ -17,9 +17,9 @@
 
 namespace SysTuning {
 namespace TraceStreamer {
-constexpr uint32_t INVAILD_DATA = 2;
+constexpr uint32_t INVALID_DATA = 2;
 constexpr uint32_t MIN_VECTOR_SIZE = 2;
-constexpr uint32_t VAILD_DATA_COUNT = 6;
+constexpr uint32_t VALID_DATA_COUNT = 6;
 APPStartupFilter::APPStartupFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter)
     : FilterBase(dataCache, filter), mAPPStartupData_(0)
 {
@@ -47,7 +47,7 @@ bool APPStartupFilter::CaclRsDataByPid(appMap &mAPPStartupData)
         }
         for (int m = 0; m < frameSliceData->Ipids().size(); m++) {
             if (itorSecond->second->ipid_ == frameSliceData->Ipids()[m] && !frameSliceData->Types()[m] &&
-                frameSliceData->Flags()[m] != INVAILD_DATA) {
+                frameSliceData->Flags()[m] != INVALID_DATA) {
                 auto startTime = sliceData.TimeStampData()[frameSliceData->CallStackIds()[m]];
                 auto callId = sliceData.CallIds()[frameSliceData->CallStackIds()[m]];
                 auto endTime = startTime + frameSliceData->Durs()[m];
@@ -106,7 +106,7 @@ void APPStartupFilter::AppendAssociatedData(DataIndex packedNameIndex,
     for (auto itorSecond = stagesData.begin(); itorSecond != stagesData.end(); ++itorSecond) {
         auto item = itorSecond;
         auto endTime = INVALID_UINT64;
-        if (item->first < VAILD_DATA_COUNT) {
+        if (item->first < VALID_DATA_COUNT) {
             int num = item->first + 1;
             if ((++item) != stagesData.end() && num == item->first) {
                 endTime = (item)->second->startTime_;
diff --git a/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.cpp b/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.cpp
index 7f256f003199619090916dc0746bfd59393ed857..936b1755dee2e150618a6635773afe25dda46894 100644
--- a/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.cpp
+++ b/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.cpp
@@ -23,7 +23,7 @@
 namespace SysTuning {
 namespace TraceStreamer {
 HiSysEventMeasureFilter::HiSysEventMeasureFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter)
-    : FilterBase(dataCache, filter), appKey_(INVALID_UINT64), appName_(INVALID_UINT64)
+    : FilterBase(dataCache, filter), appKey_(INVALID_UINT64)
 {
 }
 
@@ -272,7 +272,6 @@ DataIndex HiSysEventMeasureFilter::GetOrCreateFilterIdInternal(DataIndex appName
 void HiSysEventMeasureFilter::Clear()
 {
     appKey_.Clear();
-    appName_.Clear();
     eventSource_.clear();
 }
 } // namespace TraceStreamer
diff --git a/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.h b/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.h
index c55c9b7f147a25914b89260d171f976799b1b6c7..1bf60ba79701473a53e5e8235b59ed0de5c11e3b 100644
--- a/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.h
+++ b/trace_streamer/src/filter/hi_sysevent_filter/hi_sysevent_measure_filter.h
@@ -124,7 +124,6 @@ private:
     const uint64_t MSEC_TO_NS = 1000 * 1000;
     DataIndex GetOrCreateFilterIdInternal(DataIndex appNameId, DataIndex key);
     DoubleMap<DataIndex, DataIndex, DataIndex> appKey_;
-    DoubleMap<DataIndex, DataIndex, DataIndex> appName_;
     std::map<DataIndex, DataIndex> eventSource_;
     std::vector<std::string> eventsAccordingAppNames_ = {"POWER_IDE_BATTERY",
                                                          "POWER_IDE_CPU",
diff --git a/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp b/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp
index 6494113bdd890b6e06c28d05fe1a44fdfd7012d4..f6e185e3914fd813f6ed8e2a406d9b28fbdcb158 100644
--- a/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp
+++ b/trace_streamer/src/filter/hook_filter/native_hook_filter.cpp
@@ -15,6 +15,7 @@
 
 #include "native_hook_filter.h"
 #include "native_hook_config.pbreader.h"
+#include "ts_common.h"
 #include <cstddef>
 #include <cinttypes>
 namespace SysTuning {
@@ -37,7 +38,7 @@ NativeHookFilter::NativeHookFilter(TraceDataCache *dataCache, const TraceStreame
     addrToMmapEventRow_ = traceDataCache_->GetNativeHookData()->GetAddrToMmapEventRow();
 }
 
-void NativeHookFilter::ParseConfigInfo(ProtoReader::BytesView &protoData)
+void NativeHookFilter::ParseConfigInfo(ProtoReader::BytesView &protoData, uint64_t &statisticsInterval)
 {
     auto configReader = ProtoReader::NativeHookConfig_Reader(protoData);
     if (configReader.has_expand_pids() || (configReader.has_process_name() && configReader.has_pid())) {
@@ -47,6 +48,7 @@ void NativeHookFilter::ParseConfigInfo(ProtoReader::BytesView &protoData)
         isStatisticMode_ = true;
         isCallStackCompressedMode_ = true;
         isStringCompressedMode_ = true;
+        statisticsInterval = configReader.statistics_interval() * SEC_TO_NS;
     }
     if (configReader.has_response_library_mode() || configReader.has_offline_symbolization()) {
         isOfflineSymbolizationMode_ = true;
diff --git a/trace_streamer/src/filter/hook_filter/native_hook_filter.h b/trace_streamer/src/filter/hook_filter/native_hook_filter.h
index a010e9c50ff5fa9bcab34e010c964efe3aba0c6d..1d7f449a000923f9d89ff57e5ea358244c34b332 100644
--- a/trace_streamer/src/filter/hook_filter/native_hook_filter.h
+++ b/trace_streamer/src/filter/hook_filter/native_hook_filter.h
@@ -70,7 +70,7 @@ public:
 
 public:
     void MaybeParseNativeHookMainEvent(uint64_t timeStamp, std::unique_ptr<NativeHookMetaData> nativeHookMetaData);
-    void ParseConfigInfo(ProtoReader::BytesView &protoData);
+    void ParseConfigInfo(ProtoReader::BytesView &protoData, uint64_t &statisticsInterval);
     void AppendStackMaps(uint32_t ipid, uint32_t stackid, std::vector<uint64_t> &frames);
     void AppendFrameMaps(uint32_t ipid, uint32_t frameMapId, const ProtoReader::BytesView &bytesView);
     void AppendFilePathMaps(uint32_t ipid, uint32_t filePathId, uint64_t fileIndex);
@@ -158,7 +158,7 @@ private:
     std::unique_ptr<ProfilerPluginData> hookPluginData_ = nullptr;
     DoubleMap<uint32_t, uint32_t, uint64_t> ipidToSymIdToSymIndex_;
     DoubleMap<uint32_t, uint32_t, uint64_t> ipidToFilePathIdToFileIndex_;
-    DoubleMap<uint32_t, uint32_t, std::shared_ptr<const ProtoReader::BytesView>> ipidToFrameIdToFrameBytes_;
+    DoubleMap<uint32_t, uint64_t, std::shared_ptr<const ProtoReader::BytesView>> ipidToFrameIdToFrameBytes_;
     std::unordered_map<DataIndex, std::shared_ptr<std::set<size_t>>> filePathIndexToFrameTableRowMap_ = {};
     std::multimap<uint64_t, std::unique_ptr<NativeHookMetaData>> tsToMainEventsMap_ = {};
     std::map<uint64_t, std::shared_ptr<std::vector<uint64_t>>> reparseStackIdToFramesMap_ = {};
diff --git a/trace_streamer/src/filter/measure_filter.cpp b/trace_streamer/src/filter/measure_filter.cpp
index 1c9172fe829b637f368b138d6a9e37c7ea7bc197..3e193b67a11b778e38af39098ac2e0ae161678bd 100644
--- a/trace_streamer/src/filter/measure_filter.cpp
+++ b/trace_streamer/src/filter/measure_filter.cpp
@@ -15,73 +15,92 @@
 
 #include "measure_filter.h"
 #include "filter_filter.h"
+#include "measure_stdtype.h"
 #include "ts_common.h"
+#include <cstdint>
 
 namespace SysTuning {
 namespace TraceStreamer {
-MeasureFilter::MeasureFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter, FilterType e)
-    : FilterBase(dataCache, filter), tidStreamIdFilterIdMap_(INVALID_UINT64), filterType_(e)
+MeasureFilter::MeasureFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter)
+    : FilterBase(dataCache, filter)
 {
+    for (uint16_t i = 0; i < static_cast<uint16_t>(EnumMeasureFilter::MAX_COUNT); ++i) {
+        filterTypeMap_.emplace(static_cast<EnumMeasureFilter>(i), INVALID_UINT64);
+    }
 }
 
 MeasureFilter::~MeasureFilter() {}
 
-bool MeasureFilter::AppendNewMeasureData(uint64_t internalTid, DataIndex nameIndex, uint64_t timeStamp, int64_t value)
+bool MeasureFilter::AppendNewMeasureData(EnumMeasureFilter enumType,
+                                         uint64_t internalTid,
+                                         DataIndex nameIndex,
+                                         uint64_t timeStamp,
+                                         int64_t value)
 {
-    auto filterId = GetOrCreateFilterId(internalTid, nameIndex);
-    if (filterType_ == E_PROCESS_MEASURE_FILTER) {
-        traceDataCache_->GetProcessMeasureData()->AppendMeasureData(0, timeStamp, value, filterId);
+    auto filterId = GetOrCreateFilterId(enumType, internalTid, nameIndex);
+    Measure *measurePtr = nullptr;
+    if (enumType == EnumMeasureFilter::PROCESS) {
+        measurePtr = traceDataCache_->GetProcessMeasureData();
+    } else if (enumType == EnumMeasureFilter::XPOWER) {
+        measurePtr = traceDataCache_->GetXpowerMeasureData();
     } else {
-        auto row = traceDataCache_->GetMeasureData()->AppendMeasureData(0, timeStamp, value, filterId);
-        // if the filterId ever exists
-        auto filterIdToRow = traceDataCache_->GetMeasureData()->GetFilterIdToRow();
-        if (filterIdToRow->count(filterId)) {
-            traceDataCache_->GetMeasureData()->SetDur(filterIdToRow->at(filterId), timeStamp);
-            filterIdToRow->at(filterId) = row;
-        } else {
-            filterIdToRow->insert(std::make_pair(filterId, row));
-        }
+        measurePtr = traceDataCache_->GetMeasureData();
+    }
+    if (!measurePtr) {
+        return false;
     }
-    return value != 0;
+    auto row = measurePtr->AppendMeasureData(0, timeStamp, value, filterId);
+    // if the filterId ever exists
+    auto *filterIdToRow = measurePtr->GetFilterIdToRow();
+    if (filterIdToRow->count(filterId)) {
+        measurePtr->SetDur(filterIdToRow->at(filterId), timeStamp);
+        filterIdToRow->at(filterId) = row;
+    } else {
+        filterIdToRow->insert(std::make_pair(filterId, row));
+    }
+    return true;
 }
-uint32_t MeasureFilter::GetOrCreateFilterId(uint64_t internalTid, DataIndex nameIndex)
+uint32_t MeasureFilter::GetOrCreateFilterId(EnumMeasureFilter enumType, uint64_t internalTid, DataIndex nameIndex)
 {
-    auto filterId = tidStreamIdFilterIdMap_.Find(internalTid, nameIndex);
+    auto &tidStreamIdFilterIdMap = filterTypeMap_.at(enumType);
+    auto filterId = tidStreamIdFilterIdMap.Find(internalTid, nameIndex);
     if (filterId != INVALID_UINT64) {
         return static_cast<uint32_t>(filterId);
     }
 
     uint32_t newFilterId = streamFilters_->filterFilter_->AddFilter(
-        filterTypeValue.at(filterType_), traceDataCache_->GetDataFromDict(nameIndex), internalTid);
-    AddCertainFilterId(internalTid, nameIndex, newFilterId);
+        filterTypeValue.at(enumType), traceDataCache_->GetDataFromDict(nameIndex), internalTid);
+    tidStreamIdFilterIdMap.Insert(internalTid, nameIndex, newFilterId);
+    AddCertainFilterId(enumType, internalTid, nameIndex, newFilterId);
     return newFilterId;
 }
 
-void MeasureFilter::AddCertainFilterId(uint64_t internalTid, DataIndex nameIndex, uint64_t filterId)
+void MeasureFilter::AddCertainFilterId(EnumMeasureFilter enumType,
+                                       uint64_t internalTid,
+                                       DataIndex nameIndex,
+                                       uint64_t filterId)
 {
-    tidStreamIdFilterIdMap_.Insert(internalTid, nameIndex, filterId);
-
-    if (filterType_ == E_PROCESS_MEASURE_FILTER) {
+    if (enumType == EnumMeasureFilter::PROCESS) {
         traceDataCache_->GetProcessMeasureFilterData()->AppendNewFilter(
             static_cast<uint32_t>(filterId), static_cast<uint32_t>(nameIndex), static_cast<uint32_t>(internalTid));
-    } else if (filterType_ == E_CPU_MEASURE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CPU) {
         traceDataCache_->GetCpuMeasuresData()->AppendNewFilter(filterId, static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLOCK_RATE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLOCK_RATE) {
         traceDataCache_->GetClockEventFilterData()->AppendNewFilter(filterId, clockSetRateDataIndex_,
                                                                     static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLOCK_ENABLE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLOCK_ENABLE) {
         traceDataCache_->GetClockEventFilterData()->AppendNewFilter(filterId, clockEnableDataIndex_,
                                                                     static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLOCK_DISABLE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLOCK_DISABLE) {
         traceDataCache_->GetClockEventFilterData()->AppendNewFilter(filterId, clockDisableDataIndex_,
                                                                     static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLK_RATE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLK_RATE) {
         traceDataCache_->GetClkEventFilterData()->AppendNewFilter(filterId, clkSetRateDataIndex_,
                                                                   static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLK_ENABLE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLK_ENABLE) {
         traceDataCache_->GetClkEventFilterData()->AppendNewFilter(filterId, clkEnableDataIndex_,
                                                                   static_cast<uint32_t>(nameIndex), internalTid);
-    } else if (filterType_ == E_CLK_DISABLE_FILTER) {
+    } else if (enumType == EnumMeasureFilter::CLK_DISABLE) {
         traceDataCache_->GetClkEventFilterData()->AppendNewFilter(filterId, clkDisableDataIndex_,
                                                                   static_cast<uint32_t>(nameIndex), internalTid);
     }
diff --git a/trace_streamer/src/filter/measure_filter.h b/trace_streamer/src/filter/measure_filter.h
index 48b0df5dff6c26f33feef6c1586519c58b30ef4a..f964eae6a6769a6dbcb4851f3f9f0d2496a492b8 100644
--- a/trace_streamer/src/filter/measure_filter.h
+++ b/trace_streamer/src/filter/measure_filter.h
@@ -16,6 +16,7 @@
 #ifndef THREAD_MEASURE_FILTER_H
 #define THREAD_MEASURE_FILTER_H
 
+#include <cstdint>
 #include <map>
 #include <string_view>
 #include <tuple>
@@ -27,36 +28,48 @@
 
 namespace SysTuning {
 namespace TraceStreamer {
-enum FilterType {
-    E_PROCESS_MEASURE_FILTER,
-    E_CPU_MEASURE_FILTER,
-    E_CLOCK_RATE_FILTER,
-    E_CLOCK_ENABLE_FILTER,
-    E_CLOCK_DISABLE_FILTER,
-    E_CLK_RATE_FILTER,
-    E_CLK_ENABLE_FILTER,
-    E_CLK_DISABLE_FILTER
+enum class EnumMeasureFilter : uint16_t {
+    PROCESS,
+    CPU,
+    CLOCK_RATE,
+    CLOCK_ENABLE,
+    CLOCK_DISABLE,
+    CLK_RATE,
+    CLK_ENABLE,
+    CLK_DISABLE,
+    XPOWER,
+    MAX_COUNT,
 };
 
 class MeasureFilter : private FilterBase {
 public:
-    MeasureFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter, FilterType);
+    MeasureFilter(TraceDataCache *dataCache, const TraceStreamerFilters *filter);
     MeasureFilter(const MeasureFilter &) = delete;
     MeasureFilter &operator=(const MeasureFilter &) = delete;
     ~MeasureFilter() override;
-    bool AppendNewMeasureData(uint64_t internalTid, DataIndex nameIndex, uint64_t timeStamp, int64_t value);
-    uint32_t GetOrCreateFilterId(uint64_t internalTid, DataIndex nameIndex);
+    bool AppendNewMeasureData(EnumMeasureFilter enumType,
+                              uint64_t internalTid,
+                              DataIndex nameIndex,
+                              uint64_t timeStamp,
+                              int64_t value);
 
 private:
-    void AddCertainFilterId(uint64_t internalTid, DataIndex nameIndex, uint64_t filterId);
-    DoubleMap<uint64_t, DataIndex, uint64_t> tidStreamIdFilterIdMap_;
-    FilterType filterType_;
+    uint32_t GetOrCreateFilterId(EnumMeasureFilter enumType, uint64_t internalTid, DataIndex nameIndex);
+    void AddCertainFilterId(EnumMeasureFilter enumType, uint64_t internalTid, DataIndex nameIndex, uint64_t filterId);
+    std::map<EnumMeasureFilter, DoubleMap<uint64_t, DataIndex, uint64_t>> filterTypeMap_;
+    // DoubleMap<uint64_t, DataIndex, uint64_t> tidStreamIdFilterIdMap_;
 
-    const std::map<FilterType, std::string> filterTypeValue = {
-        {E_PROCESS_MEASURE_FILTER, "process_measure_filter"}, {E_CPU_MEASURE_FILTER, "cpu_measure_filter"},
-        {E_CLOCK_RATE_FILTER, "clock_rate_filter"},           {E_CLOCK_ENABLE_FILTER, "clock_enable_filter"},
-        {E_CLOCK_DISABLE_FILTER, "clock_disable_filter"},     {E_CLK_RATE_FILTER, "clk_rate_filter"},
-        {E_CLK_ENABLE_FILTER, "clk_enable_filter"},           {E_CLK_DISABLE_FILTER, "clk_disable_filter"}};
+    const std::map<EnumMeasureFilter, std::string> filterTypeValue = {
+        {EnumMeasureFilter::PROCESS, "process_measure_filter"},
+        {EnumMeasureFilter::CPU, "cpu_measure_filter"},
+        {EnumMeasureFilter::CLOCK_RATE, "clock_rate_filter"},
+        {EnumMeasureFilter::CLOCK_ENABLE, "clock_enable_filter"},
+        {EnumMeasureFilter::CLOCK_DISABLE, "clock_disable_filter"},
+        {EnumMeasureFilter::CLK_RATE, "clk_rate_filter"},
+        {EnumMeasureFilter::CLK_ENABLE, "clk_enable_filter"},
+        {EnumMeasureFilter::CLK_DISABLE, "clk_disable_filter"},
+        {EnumMeasureFilter::XPOWER, "xpower_filter"},
+    };
     const DataIndex clockSetRateDataIndex_ = traceDataCache_->GetDataIndex("clock_set_rate");
     const DataIndex clockEnableDataIndex_ = traceDataCache_->GetDataIndex("clock_enable");
     const DataIndex clockDisableDataIndex_ = traceDataCache_->GetDataIndex("clock_disable");
diff --git a/trace_streamer/src/main.cpp b/trace_streamer/src/main.cpp
index 8aff41ae6acd732aa4b8f0db8bd2b76b7a7f2b82..d44ce2031c162684a17be068c426733024ad8caf 100644
--- a/trace_streamer/src/main.cpp
+++ b/trace_streamer/src/main.cpp
@@ -272,12 +272,16 @@ bool SetFileSize(const std::string &traceFilePath)
 }
 int OpenAndParserFile(TraceStreamerSelector &ts, const std::string &traceFilePath)
 {
-    if (!SetFileSize(traceFilePath)) {
+    std::string filePath = traceFilePath;
+    if (!UnZipFile(traceFilePath, filePath)) {
+        return 1;
+    }
+    if (!SetFileSize(filePath)) {
         return 0;
     }
-    int fd(OpenFile(traceFilePath, O_RDONLY, G_FILE_PERMISSION));
+    int fd(OpenFile(filePath, O_RDONLY, G_FILE_PERMISSION));
     if (fd < 0) {
-        TS_LOGE("%s does not exist", traceFilePath.c_str());
+        TS_LOGE("%s does not exist", filePath.c_str());
         SetAnalysisResult(TRACE_PARSER_ABNORMAL);
         return 1;
     }
@@ -720,6 +724,7 @@ void Init(TraceStreamerSelector &ts, const TraceExportOption &traceExportOption)
 
 } // namespace TraceStreamer
 } // namespace SysTuning
+
 int main(int argc, char **argv)
 {
     TraceExportOption traceExportOption;
diff --git a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp
index b7b515d38c418323d127ee1a7ae691685e66bbcd..e82da207ba1e5c11e041dad23f5668f1261401a3 100644
--- a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp
+++ b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.cpp
@@ -30,7 +30,7 @@ PerfDataParser::PerfDataParser(TraceDataCache *dataCache, const TraceStreamerFil
       cmdlineIndex_(traceDataCache_->dataDict_.GetStringIndex("cmdline")),
       runingStateIndex_(traceDataCache_->dataDict_.GetStringIndex("Running")),
       suspendStatIndex_(traceDataCache_->dataDict_.GetStringIndex("Suspend")),
-      unkonwnStateIndex_(traceDataCache_->dataDict_.GetStringIndex("-")),
+      unknownStateIndex_(traceDataCache_->dataDict_.GetStringIndex("-")),
       pidAndStackHashToCallChainId_(INVALID_UINT32)
 {
     SymbolsFile::onRecording_ = false;
@@ -706,7 +706,7 @@ void PerfDataParser::UpdatePerfSampleData(uint32_t callChainId, std::unique_ptr<
     }
     UpdatePluginTimeRange(perfToTSClockType_.at(clockId_), sample->data_.time, newTimeStamp);
 
-    DataIndex threadStatIndex = unkonwnStateIndex_;
+    DataIndex threadStatIndex = unknownStateIndex_;
     auto threadState = report_->GetConfigName(sample->data_.id);
     if (threadState.compare(wakingEventName_) == 0) {
         threadStatIndex = runingStateIndex_;
diff --git a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h
index 5b6c28e63e683ccae13c7c03423b0aa6e8d6f982..8cbb5a820ed5a0aa2166405e8b0f0c37007a1f9b 100644
--- a/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h
+++ b/trace_streamer/src/parser/hiperf_parser/perf_data_parser.h
@@ -169,7 +169,7 @@ private:
     DataIndex cmdlineIndex_ = 0;
     DataIndex runingStateIndex_ = 0;
     DataIndex suspendStatIndex_ = 0;
-    DataIndex unkonwnStateIndex_ = 0;
+    DataIndex unknownStateIndex_ = 0;
     std::unordered_multimap<uint64_t, uint64_t> tidToPid_ = {};
     const std::map<uint32_t, uint32_t> perfToTSClockType_ = {{PERF_CLOCK_REALTIME, TS_CLOCK_REALTIME},
                                                              {PERF_CLOCK_MONOTONIC, TS_MONOTONIC},
diff --git a/trace_streamer/src/parser/pbreader_parser/BUILD.gn b/trace_streamer/src/parser/pbreader_parser/BUILD.gn
index cad38ce9f63531443c2893b4bb01843b4cbb0bdc..d038b3a9ab1d40d8f6c61fea19fc1dc99a79a06d 100644
--- a/trace_streamer/src/parser/pbreader_parser/BUILD.gn
+++ b/trace_streamer/src/parser/pbreader_parser/BUILD.gn
@@ -101,6 +101,7 @@ ohos_source_set("pbreader_parser_src") {
   if (enable_memory) {
     public_deps += [ "mem_parser:pbreader_mem_parser" ]
   }
+  public_deps += [ "xpower_parser:pbreader_xpower_parser" ]
   if (enable_hidump) {
     public_deps += [ "hidump_parser:pbreader_hidump_parser" ]
   }
diff --git a/trace_streamer/src/parser/pbreader_parser/hisysevent_parser/pbreader_hisysevent_parser.cpp b/trace_streamer/src/parser/pbreader_parser/hisysevent_parser/pbreader_hisysevent_parser.cpp
index ba0de3391e92f35820a0172e472feeb699fae35c..c644edb0c769700a963159cc728a215ba11d9072 100644
--- a/trace_streamer/src/parser/pbreader_parser/hisysevent_parser/pbreader_hisysevent_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/hisysevent_parser/pbreader_hisysevent_parser.cpp
@@ -40,7 +40,6 @@ void PbreaderHisyseventParser::Finish()
     }
 }
 
-static std::stringstream ss;
 void PbreaderHisyseventParser::Parse(ProtoReader::HisyseventInfo_Reader *tracePacket, uint64_t ts, bool &haveSplitSeg)
 {
     // parse hisysevent device state
diff --git a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp
index cf57cb6b7ce6a911da05652956e79a01a6b71717..a86c66f812442deb2dfdb86df6e77b8f0f401ad4 100644
--- a/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/htrace_parser/htrace_event_parser.cpp
@@ -725,8 +725,8 @@ bool HtraceEventParser::CpuIdleEvent(const EventInfo &event) const
         return false;
     }
 
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuIdleName_, event.timeStamp,
-                                                            config_.GetStateValue(newStateValue.value()));
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(), cpuIdleName_,
+                                                         event.timeStamp, config_.GetStateValue(newStateValue.value()));
 
     // Add cpu_idle event to raw_data_table
     traceDataCache_->GetRawData()->AppendRawData(event.timeStamp, RAW_CPU_IDLE, eventCpuValue.value(), 0);
@@ -750,8 +750,8 @@ bool HtraceEventParser::CpuFrequencyEvent(const EventInfo &event) const
         return false;
     }
 
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyName_, event.timeStamp,
-                                                            newStateValue.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
+                                                         cpuFrequencyName_, event.timeStamp, newStateValue.value());
     return true;
 }
 bool HtraceEventParser::CpuFrequencyLimitsEvent(const EventInfo &event) const
@@ -761,10 +761,10 @@ bool HtraceEventParser::CpuFrequencyLimitsEvent(const EventInfo &event) const
     uint32_t maxFreq = msg.max_freq();
     uint32_t minFreq = msg.min_freq();
     uint32_t eventCpuValue = msg.cpu_id();
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue, cpuFrequencyLimitMaxNameId, event.timeStamp,
-                                                            maxFreq);
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue, cpuFrequencyLimitMinNameId, event.timeStamp,
-                                                            minFreq);
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue,
+                                                         cpuFrequencyLimitMaxNameId, event.timeStamp, maxFreq);
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue,
+                                                         cpuFrequencyLimitMinNameId, event.timeStamp, minFreq);
     return true;
 }
 bool HtraceEventParser::SuspendResumeEvent(const EventInfo &event) const
@@ -817,7 +817,8 @@ bool HtraceEventParser::ClockSetRateEvent(const EventInfo &event) const
     ProtoReader::ClockSetRateFormat_Reader msg(event.detail);
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clockRateFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, event.timeStamp, msg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, msg.cpu_id(), nameIndex,
+                                                         event.timeStamp, msg.state());
     return true;
 }
 bool HtraceEventParser::ClockEnableEvent(const EventInfo &event) const
@@ -825,7 +826,8 @@ bool HtraceEventParser::ClockEnableEvent(const EventInfo &event) const
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
     ProtoReader::ClockEnableFormat_Reader msg(event.detail);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clockEnableFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, event.timeStamp, msg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_ENABLE, msg.cpu_id(), nameIndex,
+                                                         event.timeStamp, msg.state());
     return true;
 }
 bool HtraceEventParser::ClockDisableEvent(const EventInfo &event) const
@@ -833,7 +835,8 @@ bool HtraceEventParser::ClockDisableEvent(const EventInfo &event) const
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
     ProtoReader::ClockDisableFormat_Reader msg(event.detail);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clockDisableFilter_->AppendNewMeasureData(msg.cpu_id(), nameIndex, event.timeStamp, msg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, msg.cpu_id(), nameIndex,
+                                                         event.timeStamp, msg.state());
     return true;
 }
 bool HtraceEventParser::ClkSetRateEvent(const EventInfo &event) const
@@ -841,7 +844,8 @@ bool HtraceEventParser::ClkSetRateEvent(const EventInfo &event) const
     ProtoReader::ClkSetRateFormat_Reader msg(event.detail);
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_SET_RATE, STAT_EVENT_RECEIVED);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clkRateFilter_->AppendNewMeasureData(event.cpu, nameIndex, event.timeStamp, msg.rate());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLK_RATE, event.cpu, nameIndex,
+                                                         event.timeStamp, msg.rate());
     return true;
 }
 bool HtraceEventParser::ClkEnableEvent(const EventInfo &event) const
@@ -849,7 +853,8 @@ bool HtraceEventParser::ClkEnableEvent(const EventInfo &event) const
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_ENABLE, STAT_EVENT_RECEIVED);
     ProtoReader::ClkEnableFormat_Reader msg(event.detail);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clkEnableFilter_->AppendNewMeasureData(event.cpu, nameIndex, event.timeStamp, 1);
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLK_ENABLE, event.cpu, nameIndex,
+                                                         event.timeStamp, 1);
     return true;
 }
 bool HtraceEventParser::ClkDisableEvent(const EventInfo &event) const
@@ -857,7 +862,8 @@ bool HtraceEventParser::ClkDisableEvent(const EventInfo &event) const
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLK_DISABLE, STAT_EVENT_RECEIVED);
     ProtoReader::ClkDisableFormat_Reader msg(event.detail);
     DataIndex nameIndex = traceDataCache_->GetDataIndex(msg.name().ToStdString());
-    streamFilters_->clkDisableFilter_->AppendNewMeasureData(event.cpu, nameIndex, event.timeStamp, 0);
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLK_DISABLE, event.cpu, nameIndex,
+                                                         event.timeStamp, 0);
     return true;
 }
 
@@ -1006,7 +1012,7 @@ bool HtraceEventParser::OomScoreAdjUpdate(const EventInfo &event) const
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_OOM_SCORE_ADJ_UPDATE, STAT_EVENT_RECEIVED);
     ProtoReader::OomScoreAdjUpdateFormat_Reader msg(event.detail);
     auto ipid = streamFilters_->processFilter_->GetInternalPid(msg.pid());
-    streamFilters_->processMeasureFilter_->AppendNewMeasureData(ipid, oomScoreAdjName_, event.timeStamp,
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid, oomScoreAdjName_, event.timeStamp,
                                                                 msg.oom_score_adj());
     return true;
 }
diff --git a/trace_streamer/src/parser/pbreader_parser/mem_parser/pbreader_mem_parser.cpp b/trace_streamer/src/parser/pbreader_parser/mem_parser/pbreader_mem_parser.cpp
index 0f4ad0405d9bbf05047cf3dcc855daff2e6f0db9..9fff60a714ad913e624c1c5e86885b0b3453b2cb 100644
--- a/trace_streamer/src/parser/pbreader_parser/mem_parser/pbreader_mem_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/mem_parser/pbreader_mem_parser.cpp
@@ -141,20 +141,23 @@ void PbreaderMemParser::SpecialDataAddition(ProtoReader::ProcessMemoryInfo_Reade
 {
     // processMemoryInfo Special data addition
     if (processMemoryInfo.has_purg_sum_kb()) {
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_PURG_SUM), timeStamp, processMemoryInfo.purg_sum_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_PURG_SUM), timeStamp,
+                                                                         processMemoryInfo.purg_sum_kb());
     }
     if (processMemoryInfo.has_purg_pin_kb()) {
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_PURG_PIN), timeStamp, processMemoryInfo.purg_pin_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_PURG_PIN), timeStamp,
+                                                                         processMemoryInfo.purg_pin_kb());
     }
     if (processMemoryInfo.has_gl_pss_kb()) {
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_GL_PSS), timeStamp, processMemoryInfo.gl_pss_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::PROCESS, ipid, memNameDictMap_.at(MEM_GL_PSS), timeStamp, processMemoryInfo.gl_pss_kb());
     }
     if (processMemoryInfo.has_graph_pss_kb()) {
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_GRAPH_PSS), timeStamp, processMemoryInfo.graph_pss_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_GRAPH_PSS), timeStamp,
+                                                                         processMemoryInfo.graph_pss_kb());
     }
     if (hasValue) {
         streamFilters_->processFilter_->AddProcessMemory(ipid);
@@ -174,24 +177,31 @@ void PbreaderMemParser::ParseProcessInfo(const ProtoReader::MemoryData_Reader *t
         auto ipid = streamFilters_->processFilter_->UpdateOrCreateProcessWithName(
             processMemoryInfo.pid(), processMemoryInfo.name().ToStdString());
         uint32_t hasValue = 0;
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_SIZE), timeStamp, processMemoryInfo.vm_size_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_RSS), timeStamp, processMemoryInfo.vm_rss_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_ANON), timeStamp, processMemoryInfo.rss_anon_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_RSS_FILE), timeStamp, processMemoryInfo.rss_file_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_RSS_SHMEM), timeStamp, processMemoryInfo.rss_shmem_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_SWAP), timeStamp, processMemoryInfo.vm_swap_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_LOCKED), timeStamp, processMemoryInfo.vm_locked_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_VM_HWM), timeStamp, processMemoryInfo.vm_hwm_kb());
-        hasValue += streamFilters_->processMeasureFilter_->AppendNewMeasureData(
-            ipid, memNameDictMap_.at(MEM_OOM_SCORE_ADJ), timeStamp, processMemoryInfo.oom_score_adj());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_VM_SIZE), timeStamp,
+                                                                         processMemoryInfo.vm_size_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::PROCESS, ipid, memNameDictMap_.at(MEM_VM_RSS), timeStamp, processMemoryInfo.vm_rss_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_VM_ANON), timeStamp,
+                                                                         processMemoryInfo.rss_anon_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_RSS_FILE), timeStamp,
+                                                                         processMemoryInfo.rss_file_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_RSS_SHMEM), timeStamp,
+                                                                         processMemoryInfo.rss_shmem_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_VM_SWAP), timeStamp,
+                                                                         processMemoryInfo.vm_swap_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_VM_LOCKED), timeStamp,
+                                                                         processMemoryInfo.vm_locked_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::PROCESS, ipid, memNameDictMap_.at(MEM_VM_HWM), timeStamp, processMemoryInfo.vm_hwm_kb());
+        hasValue += streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, ipid,
+                                                                         memNameDictMap_.at(MEM_OOM_SCORE_ADJ),
+                                                                         timeStamp, processMemoryInfo.oom_score_adj());
 
         SpecialDataAddition(processMemoryInfo, timeStamp, ipid, hasValue);
     }
diff --git a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.cpp b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.cpp
index aaceb4cf444bbaa7b9736ea98a87599951dc9a43..3b28bdd32b50e8f009d84d02477db43b03f13817 100644
--- a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.cpp
@@ -172,9 +172,11 @@ void PbreaderNativeHookParser::Parse(PbreaderDataSegment &dataSeg, bool &haveSpl
               nativeHookMetaData->reader_->has_mmap_event() || nativeHookMetaData->reader_->has_munmap_event() ||
               nativeHookMetaData->reader_->has_statistics_event());
         hookBootTime_ = 0;
-        if (nativeHookMetaData->reader_->has_tv_sec() || nativeHookMetaData->reader_->has_tv_nsec()) {
+        if (!isCommData_ && (nativeHookMetaData->reader_->has_tv_sec() || nativeHookMetaData->reader_->has_tv_nsec())) {
             auto timeStamp = nativeHookMetaData->reader_->tv_nsec() + nativeHookMetaData->reader_->tv_sec() * SEC_TO_NS;
             hookBootTime_ = streamFilters_->clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, timeStamp);
+            UpdatePluginTimeRange(TS_CLOCK_REALTIME, timeStamp - statisticsInterval_,
+                                  hookBootTime_ - statisticsInterval_);
             UpdatePluginTimeRange(TS_CLOCK_REALTIME, timeStamp, hookBootTime_);
         }
         if (haveSplitSeg) {
@@ -196,7 +198,7 @@ void PbreaderNativeHookParser::Parse(PbreaderDataSegment &dataSeg, bool &haveSpl
 }
 void PbreaderNativeHookParser::ParseConfigInfo(PbreaderDataSegment &dataSeg)
 {
-    nativeHookFilter_->ParseConfigInfo(dataSeg.protoData);
+    nativeHookFilter_->ParseConfigInfo(dataSeg.protoData, statisticsInterval_);
 }
 void PbreaderNativeHookParser::FinishSplitNativeHook()
 {
diff --git a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h
index e13a90e41e310a740dbdd25438b6200c5e6b34d9..50d7ffdd7ca50aadf1c89c4370c64a320b04e247 100644
--- a/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h
+++ b/trace_streamer/src/parser/pbreader_parser/native_hook_parser/pbreader_native_hook_parser.h
@@ -60,6 +60,7 @@ private:
     std::unique_ptr<NativeHookFilter> nativeHookFilter_;
     uint64_t hookBootTime_ = 0;
     bool isCommData_ = false;
+    uint64_t statisticsInterval_ = 0;
 };
 } // namespace TraceStreamer
 } // namespace SysTuning
diff --git a/trace_streamer/src/parser/pbreader_parser/pbreader_clock_detail_parser.cpp b/trace_streamer/src/parser/pbreader_parser/pbreader_clock_detail_parser.cpp
index 76674e9356524c04bbdb17fa2f19cbea1ced7370..5a99d3a7595e826acade64c8b4718b65f423ca9a 100644
--- a/trace_streamer/src/parser/pbreader_parser/pbreader_clock_detail_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/pbreader_clock_detail_parser.cpp
@@ -82,9 +82,6 @@ void PbreaderClockDetailParser::Parse(const ProfilerTraceFileHeader *profilerTra
     if (profilerTraceFileHeader->data.boottime) {
         snapShot.push_back(SnapShot{TS_CLOCK_BOOTTIME, profilerTraceFileHeader->data.boottime});
     }
-    if (traceDataCache_->traceStartTime_ == std::numeric_limits<uint64_t>::max()) {
-        traceDataCache_->traceStartTime_ = profilerTraceFileHeader->data.boottime;
-    }
     TS_LOGI("clockid: TS_CLOCK_REALTIME, ts:%" PRIu64 "", profilerTraceFileHeader->data.realtime);
     if (profilerTraceFileHeader->data.realtime) {
         snapShot.push_back(SnapShot{TS_CLOCK_REALTIME, profilerTraceFileHeader->data.realtime});
diff --git a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp
index 921c87c358cd752f0d93e1be5f9a936dbd11a518..20ef95f9c80edb563c418736aa4eda81f448de4a 100644
--- a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp
+++ b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.cpp
@@ -83,6 +83,7 @@ PbreaderParser::PbreaderParser(TraceDataCache *dataCache, const TraceStreamerFil
 #ifdef ENABLE_STREAM_EXTEND
       pbreaderStreamParser_(std::make_unique<PbreaderStreamParser>(dataCache, filters)),
 #endif
+      xpowerParser_(std::make_unique<PbreaderXpowerParser>(dataCache, filters)),
       traceDataCache_(dataCache)
 {
     InitPluginNameIndex();
@@ -172,6 +173,8 @@ void PbreaderParser::InitPluginNameIndex()
     streamPluginIndex_ = traceDataCache_->GetDataIndex("stream-plugin");
     supportPluginNameIndex_.insert(streamPluginIndex_);
 #endif
+    xpowerPluginIndex_ = traceDataCache_->GetDataIndex("xpower-plugin");
+    supportPluginNameIndex_.insert(xpowerPluginIndex_);
 }
 
 #if defined(ENABLE_HIPERF) || defined(ENABLE_NATIVE_HOOK) || defined(ENABLE_EBPF)
@@ -434,6 +437,9 @@ void PbreaderParser::FilterData(PbreaderDataSegment &seg, bool isSplitFile)
         pbreaderStreamParser_->Parse(seg);
     }
 #endif
+    else if (seg.dataType == DATA_SOURCE_TYPE_XPOWER) {
+        xpowerParser_->Parse(seg, seg.timeStamp, seg.clockId);
+    }
     if (traceDataCache_->isSplitFile_ && haveSplitSeg) {
         mPbreaderSplitData_.emplace(splitFileOffset_, nextLength_ + packetSegLength_);
     }
@@ -601,6 +607,9 @@ void PbreaderParser::ParseDataByPluginName(PbreaderDataSegment &dataSeg,
         ParseStream(dataSeg);
     }
 #endif
+    else if (pulginNameIndex == xpowerPluginIndex_) {
+        ParseXpower(dataSeg);
+    }
 }
 
 void PbreaderParser::ParserData(PbreaderDataSegment &dataSeg, bool isSplitFile)
@@ -796,6 +805,12 @@ void PbreaderParser::ParseNetwork(PbreaderDataSegment &dataSeg)
     dataSeg.status = TS_PARSE_STATUS_PARSED;
 }
 #endif
+void PbreaderParser::ParseXpower(PbreaderDataSegment &dataSeg)
+{
+    dataSourceTypeNetworkClockid_ = TS_CLOCK_REALTIME;
+    dataSeg.dataType = DATA_SOURCE_TYPE_XPOWER;
+    dataSeg.status = TS_PARSE_STATUS_PARSED;
+}
 #ifdef ENABLE_DISKIO
 void PbreaderParser::ParseDiskIO(PbreaderDataSegment &dataSeg)
 {
diff --git a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h
index 644ab7c131e2b35423b778b09027b62889069592..2969d37126bf22db1fa4336dc5bd0844b8d7be39 100644
--- a/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h
+++ b/trace_streamer/src/parser/pbreader_parser/pbreader_parser.h
@@ -27,6 +27,7 @@
 #include "common_types.h"
 #include "common_types.pbreader.h"
 #include "clock_filter_ex.h"
+#include "pbreader_xpower_parser.h"
 #ifdef ENABLE_EBPF
 #include "ebpf_data_parser.h"
 #endif
@@ -222,6 +223,7 @@ private:
 #ifdef ENABLE_NETWORK
     void ParseNetwork(PbreaderDataSegment &dataSeg);
 #endif
+    void ParseXpower(PbreaderDataSegment &dataSeg);
 #ifdef ENABLE_DISKIO
     void ParseDiskIO(PbreaderDataSegment &dataSeg);
 #endif
@@ -358,6 +360,8 @@ private:
     DataIndex streamPluginIndex_;
     std::unique_ptr<PbreaderStreamParser> pbreaderStreamParser_;
 #endif
+    std::unique_ptr<PbreaderXpowerParser> xpowerParser_;
+    DataIndex xpowerPluginIndex_;
     std::unique_ptr<PbreaderDataSegment[]> dataSegArray_;
     std::atomic<bool> filterThreadStarted_{false};
     const int32_t maxSegArraySize = 10000;
diff --git a/trace_streamer/src/parser/pbreader_parser/xpower_parser/BUILD.gn b/trace_streamer/src/parser/pbreader_parser/xpower_parser/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..8a9b15d1851ac21a599f3781858ac12636d6dbb0
--- /dev/null
+++ b/trace_streamer/src/parser/pbreader_parser/xpower_parser/BUILD.gn
@@ -0,0 +1,30 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+# 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.
+import("//build/ohos.gni")
+import("../../../../build/ts.gni")
+
+config("xpower_parser_cfg") {
+  include_dirs = [ "." ]
+}
+
+ohos_static_library("pbreader_xpower_parser") {
+  subsystem_name = "${OHOS_PROFILER_SUBSYS_NAME}"
+  part_name = "${OHOS_PROFILER_PART_NAME}"
+  sources = [ "pbreader_xpower_parser.cpp" ]
+  include_dirs = [ "." ]
+  public_deps = [ "${OHOS_TRACE_STREAMER_PROTOS_DIR}/protos/types/plugins/xpower_data:xpower_data_reader" ]
+  public_configs = [
+    ":xpower_parser_cfg",
+    "../../:parser_base_cfg",
+  ]
+}
diff --git a/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.cpp b/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a729567b448d969b66997072df58cb65ee855636
--- /dev/null
+++ b/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.cpp
@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+ * 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 <cstdint>
+#include <string>
+
+#include "pbreader_xpower_parser.h"
+#include "clock_filter_ex.h"
+#include "measure_filter.h"
+#include "proto_reader_help.h"
+#include "ts_common.h"
+#include "xpower_plugin_result.pbreader.h"
+
+namespace SysTuning {
+namespace TraceStreamer {
+PbreaderXpowerParser::PbreaderXpowerParser(TraceDataCache *dataCache, const TraceStreamerFilters *ctx)
+    : EventParserBase(dataCache, ctx)
+{
+}
+
+PbreaderXpowerParser::~PbreaderXpowerParser()
+{
+    TS_LOGI("mem ts MIN:%llu, MAX:%llu", static_cast<unsigned long long>(GetPluginStartTime()),
+            static_cast<unsigned long long>(GetPluginEndTime()));
+}
+void PbreaderXpowerParser::Parse(PbreaderDataSegment &seg, uint64_t timestamp, BuiltinClocks clock)
+{
+    ProtoReader::OptimizeReport_Reader optimizeReport(seg.protoData.data_, seg.protoData.size_);
+    if (!optimizeReport.has_start_time() || !optimizeReport.has_end_time()) {
+        return;
+    }
+    auto startTime =
+        streamFilters_->clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, optimizeReport.start_time() * MSEC_TO_NS);
+    auto endTime =
+        streamFilters_->clockFilter_->ToPrimaryTraceTime(TS_CLOCK_REALTIME, optimizeReport.end_time() * MSEC_TO_NS);
+    if (timeSet_.find(startTime) != timeSet_.end()) {
+        return;
+    }
+    timeSet_.emplace(startTime);
+    UpdatePluginTimeRange(TS_CLOCK_BOOTTIME, startTime, startTime);
+    UpdatePluginTimeRange(TS_CLOCK_BOOTTIME, endTime, endTime);
+    traceDataCache_->UpdateTraceTime(startTime);
+    traceDataCache_->UpdateTraceTime(endTime);
+    if (optimizeReport.has_real_battery()) {
+        ProcessRealBattery(optimizeReport.real_battery(), startTime);
+    }
+    if (optimizeReport.has_thermal_report()) {
+        ProcessThermalReport(optimizeReport.thermal_report(), startTime);
+    }
+    if (optimizeReport.has_app_statistic()) {
+    }
+    if (optimizeReport.has_app_detail()) {
+    }
+}
+
+void PbreaderXpowerParser::ProcessRealBattery(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::RealBattery_Reader realBattery(bytesView);
+    auto capacity = realBattery.capacity();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaCapDataIndex_, timestamp,
+                                                         capacity);
+    auto charge = realBattery.charge();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaChaDataIndex_, timestamp,
+                                                         charge);
+    auto gasGauge = realBattery.gas_gauge();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaGasDataIndex_, timestamp,
+                                                         gasGauge);
+    auto level = realBattery.level();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaLevDataIndex_, timestamp,
+                                                         level);
+    auto screen = realBattery.screen();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaScrDataIndex_, timestamp,
+                                                         screen);
+    bool errorInfo = false;
+    auto realCurrent = realBattery.real_current(&errorInfo);
+    uint64_t count = 0;
+    while (realCurrent) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, rBaRealCurDataIndex_,
+                                                             timestamp + 100 * MSEC_TO_NS * count, *realCurrent);
+        realCurrent++;
+        count++;
+    }
+}
+
+void PbreaderXpowerParser::ProcessThermalReport(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::ThermalReport_Reader thermalReport(bytesView);
+    auto shellTemp = thermalReport.shell_temp();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, tReSheDataIndex_, timestamp,
+                                                         shellTemp);
+    auto thermalLevel = thermalReport.thermal_level();
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::XPOWER, 0, tReTheDataIndex_, timestamp,
+                                                         thermalLevel);
+}
+
+void PbreaderXpowerParser::ProcessAppStatistic(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppStatistic_Reader appStatistic(bytesView);
+    if (appStatistic.has_audio()) {
+        ProcessAppStatisticCommon(appStatistic.audio(), timestamp, audioStr_);
+    }
+    if (appStatistic.has_bluetooth()) {
+        ProcessAppStatisticCommon(appStatistic.bluetooth(), timestamp, bluetoothStr_);
+    }
+    if (appStatistic.has_camera()) {
+        ProcessAppStatisticCommon(appStatistic.camera(), timestamp, cameraStr_);
+    }
+    if (appStatistic.has_cpu()) {
+        ProcessAppStatisticCommon(appStatistic.cpu(), timestamp, cpuStr_);
+    }
+    if (appStatistic.has_display()) {
+        ProcessAppStatisticCommon(appStatistic.audio(), timestamp, displayStr_);
+    }
+    if (appStatistic.has_flashlight()) {
+        ProcessAppStatisticCommon(appStatistic.flashlight(), timestamp, flashlightStr_);
+    }
+    if (appStatistic.has_gpu()) {
+        ProcessAppStatisticCommon(appStatistic.gpu(), timestamp, gpuStr_);
+    }
+    if (appStatistic.has_location()) {
+        ProcessAppStatisticCommon(appStatistic.location(), timestamp, locationStr_);
+    }
+    if (appStatistic.has_wifiscan()) {
+        ProcessAppStatisticCommon(appStatistic.wifiscan(), timestamp, wifiscanStr_);
+    }
+    if (appStatistic.has_wifi()) {
+        ProcessAppStatisticCommon(appStatistic.wifi(), timestamp, wifiStr_);
+    }
+    if (appStatistic.has_modem()) {
+        ProcessAppStatisticCommon(appStatistic.modem(), timestamp, modemStr_);
+    }
+}
+
+void PbreaderXpowerParser::ProcessAppStatisticCommon(const ProtoReader::BytesView &bytesView,
+                                                     uint64_t timestamp,
+                                                     const std::string &name)
+{
+    ProtoReader::AppStatisticCommon_Reader appStatisticCommon(bytesView);
+    if (appStatisticCommon.has_energy()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0, traceDataCache_->GetDataIndex("AppStatistic|" + name + "|" + energyStr_),
+            timestamp, appStatisticCommon.energy());
+    }
+    if (appStatisticCommon.has_time()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0, traceDataCache_->GetDataIndex("AppStatistic|" + name + "|" + timeStr_),
+            timestamp, appStatisticCommon.time());
+    }
+}
+
+void PbreaderXpowerParser::ProcessAppDetail(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppDetail_Reader appDetail(bytesView);
+    if (appDetail.has_cpu()) {
+        ProcessAppDetailCpu(appDetail.cpu(), timestamp);
+    }
+    if (appDetail.has_gpu()) {
+        ProcessAppDetailGpu(appDetail.gpu(), timestamp);
+    }
+    if (appDetail.has_wifi()) {
+        ProcessAppDetailWifi(appDetail.wifi(), timestamp);
+    }
+    if (appDetail.has_display()) {
+        ProcessAppDetailDisplay(appDetail.display(), timestamp);
+    }
+}
+void PbreaderXpowerParser::ProcessAppDetailCpu(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppDetailCPU_Reader appDetailCPU(bytesView);
+    bool errorInfo = false;
+    auto threadName = appDetailCPU.thread_name();
+    auto threadLoad = appDetailCPU.thread_load(&errorInfo);
+    auto threadTime = appDetailCPU.thread_time(&errorInfo);
+    auto threadEnergy = appDetailCPU.thread_energy(&errorInfo);
+    while (threadName && threadLoad && threadTime && threadEnergy) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + cpuStr_ + "|thread-" + threadName->ToStdString() + "|" +
+                                          loadStr_),
+            timestamp, *threadLoad);
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + cpuStr_ + "|thread-" + threadName->ToStdString() + "|" +
+                                          timeStr_),
+            timestamp, *threadTime);
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + cpuStr_ + "|thread-" + threadName->ToStdString() + "|" +
+                                          energyStr_),
+            timestamp, *threadEnergy);
+        threadName++;
+        threadLoad++;
+        threadTime++;
+        threadEnergy++;
+    }
+}
+void PbreaderXpowerParser::ProcessAppDetailGpu(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppDetailGPU_Reader appDetailGPU(bytesView);
+    bool errorInfo = false;
+    auto frequency = appDetailGPU.frequency(&errorInfo);
+    auto idleTime = appDetailGPU.idle_time(&errorInfo);
+    auto runTime = appDetailGPU.run_time(&errorInfo);
+    while (frequency && idleTime && runTime) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + gpuStr_ + "|" + std::to_string(*frequency) + "Hz|" +
+                                          idleTimeStr_),
+            timestamp, *idleTime);
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + gpuStr_ + "|" + std::to_string(*frequency) + "Hz|" +
+                                          runTimeStr_),
+            timestamp, *runTime);
+        frequency++;
+        idleTime++;
+        runTime++;
+    }
+}
+void PbreaderXpowerParser::ProcessAppDetailWifi(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppDetailWifi_Reader appDetailWifi(bytesView);
+    if (appDetailWifi.has_tx_packets()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + wifiStr_ + "|" + txPacketsStr_), timestamp,
+            appDetailWifi.tx_packets());
+    }
+    if (appDetailWifi.has_rx_packets()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + wifiStr_ + "|" + txPacketsStr_), timestamp,
+            appDetailWifi.rx_packets());
+    }
+    if (appDetailWifi.has_tx_bytes()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + wifiStr_ + "|" + txBytesStr_), timestamp,
+            appDetailWifi.tx_bytes());
+    }
+    if (appDetailWifi.has_rx_bytes()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + wifiStr_ + "|" + txBytesStr_), timestamp,
+            appDetailWifi.rx_bytes());
+    }
+}
+
+void PbreaderXpowerParser::ProcessAppDetailDisplay(const ProtoReader::BytesView &bytesView, uint64_t timestamp)
+{
+    ProtoReader::AppDetailDisplay_Reader appDetailDisplay(bytesView);
+    if (appDetailDisplay.has_count_1hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count1hzStr_), timestamp,
+            appDetailDisplay.count_1hz());
+    }
+    if (appDetailDisplay.has_count_5hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count5hzStr_), timestamp,
+            appDetailDisplay.count_5hz());
+    }
+    if (appDetailDisplay.has_count_10hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count10hzStr_), timestamp,
+            appDetailDisplay.count_10hz());
+    }
+    if (appDetailDisplay.has_count_15hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count15hzStr_), timestamp,
+            appDetailDisplay.count_15hz());
+    }
+    if (appDetailDisplay.has_count_24hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count24hzStr_), timestamp,
+            appDetailDisplay.count_24hz());
+    }
+    if (appDetailDisplay.has_count_30hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count30hzStr_), timestamp,
+            appDetailDisplay.count_30hz());
+    }
+    if (appDetailDisplay.has_count_45hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count45hzStr_), timestamp,
+            appDetailDisplay.count_45hz());
+    }
+    if (appDetailDisplay.has_count_60hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count60hzStr_), timestamp,
+            appDetailDisplay.count_60hz());
+    }
+    if (appDetailDisplay.has_count_90hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count90hzStr_), timestamp,
+            appDetailDisplay.count_90hz());
+    }
+    if (appDetailDisplay.has_count_120hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count120hzStr_), timestamp,
+            appDetailDisplay.count_1hz());
+    }
+    if (appDetailDisplay.has_count_180hz()) {
+        streamFilters_->measureFilter_->AppendNewMeasureData(
+            EnumMeasureFilter::XPOWER, 0,
+            traceDataCache_->GetDataIndex(appDetailStr_ + "|" + displayStr_ + "|" + count180hzStr_), timestamp,
+            appDetailDisplay.count_180hz());
+    }
+}
+} // namespace TraceStreamer
+} // namespace SysTuning
diff --git a/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.h b/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..9300a783157b6f6493598027028634ef07806577
--- /dev/null
+++ b/trace_streamer/src/parser/pbreader_parser/xpower_parser/pbreader_xpower_parser.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+ * 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.
+ */
+#ifndef HTRACE_XPOWER_PARSER_H
+#define HTRACE_XPOWER_PARSER_H
+
+#include <cstdint>
+#include <unordered_set>
+#include "common_types.h"
+#include "event_parser_base.h"
+#include "htrace_plugin_time_parser.h"
+#include "trace_data_cache.h"
+#include "trace_streamer_filters.h"
+namespace SysTuning {
+namespace TraceStreamer {
+using namespace SysTuning::base;
+class PbreaderXpowerParser : public EventParserBase, public HtracePluginTimeParser {
+public:
+    PbreaderXpowerParser(TraceDataCache *dataCache, const TraceStreamerFilters *ctx);
+    ~PbreaderXpowerParser();
+    void Parse(PbreaderDataSegment &seg, uint64_t, BuiltinClocks clock);
+
+private:
+    void ProcessRealBattery(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessThermalReport(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppStatistic(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppStatisticCommon(const ProtoReader::BytesView &bytesView,
+                                   uint64_t timestamp,
+                                   const std::string &name);
+    void ProcessAppDetail(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppDetailCpu(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppDetailGpu(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppDetailWifi(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+    void ProcessAppDetailDisplay(const ProtoReader::BytesView &bytesView, uint64_t timestamp);
+
+    std::unordered_set<uint64_t> timeSet_;
+
+    // RealBattery
+    const DataIndex rBaCapDataIndex_ = traceDataCache_->GetDataIndex("Battery.Capacity");
+    const DataIndex rBaChaDataIndex_ = traceDataCache_->GetDataIndex("Battery.Charge");
+    const DataIndex rBaGasDataIndex_ = traceDataCache_->GetDataIndex("Battery.GasGauge");
+    const DataIndex rBaLevDataIndex_ = traceDataCache_->GetDataIndex("Battery.Level");
+    const DataIndex rBaScrDataIndex_ = traceDataCache_->GetDataIndex("Battery.Screen");
+    const DataIndex rBaRealCurDataIndex_ = traceDataCache_->GetDataIndex("Battery.RealCurrent");
+    // ThermalReport
+    const DataIndex tReSheDataIndex_ = traceDataCache_->GetDataIndex("ThermalReport.ShellTemp");
+    const DataIndex tReTheDataIndex_ = traceDataCache_->GetDataIndex("ThermalReport.ThermalLevel");
+    // AppStatistic
+    const std::string appStatisticStr_ = "AppStatistic";
+    const std::string audioStr_ = "audio";
+    const std::string bluetoothStr_ = "bluetooth";
+    const std::string cameraStr_ = "camera";
+    const std::string cpuStr_ = "cpu";
+    const std::string displayStr_ = "display";
+    const std::string flashlightStr_ = "flashlight";
+    const std::string gpuStr_ = "gpu";
+    const std::string locationStr_ = "location";
+    const std::string wifiscanStr_ = "wifiscan";
+    const std::string wifiStr_ = "wifi";
+    const std::string modemStr_ = "modem";
+    const std::string energyStr_ = "energy";
+    const std::string timeStr_ = "time";
+
+    // AppDetail
+    const std::string appDetailStr_ = "AppDetail";
+    const std::string loadStr_ = "load";
+    const std::string idleTimeStr_ = "idle_time";
+    const std::string runTimeStr_ = "run_time";
+    const std::string txPacketsStr_ = "tx_packets";
+    const std::string rxPacketsStr_ = "rx_packets";
+    const std::string txBytesStr_ = "tx_bytes";
+    const std::string rxBytesStr_ = "rx_bytes";
+    const std::string count1hzStr_ = "count_1hz";
+    const std::string count5hzStr_ = "count_5hz";
+    const std::string count10hzStr_ = "count_10hz";
+    const std::string count15hzStr_ = "count_15hz";
+    const std::string count24hzStr_ = "count_24hz";
+    const std::string count30hzStr_ = "count_30hz";
+    const std::string count45hzStr_ = "count_45hz";
+    const std::string count60hzStr_ = "count_60hz";
+    const std::string count90hzStr_ = "count_90hz";
+    const std::string count120hzStr_ = "count_120hz";
+    const std::string count180hzStr_ = "count_180hz";
+};
+} // namespace TraceStreamer
+} // namespace SysTuning
+
+#endif // HTRACE_XPOWER_PARSER_H
diff --git a/trace_streamer/src/parser/print_event_parser.cpp b/trace_streamer/src/parser/print_event_parser.cpp
index fb566945a9f42111cd5f87c26ea7de7c1a94fa52..f85de36ffbc9803ea353fb81bd02ddcd419db1e7 100644
--- a/trace_streamer/src/parser/print_event_parser.cpp
+++ b/trace_streamer/src/parser/print_event_parser.cpp
@@ -16,6 +16,7 @@
 #include "animation_filter.h"
 #include "clock_filter_ex.h"
 #include "frame_filter.h"
+#include "measure_filter.h"
 #include "stat_filter.h"
 #include "string_to_numerical.h"
 #include <cinttypes>
@@ -162,7 +163,7 @@ void PrintEventParser::ParseCreateEvent(uint64_t ts, const TracePoint &point)
     DataIndex nameIndex = traceDataCache_->GetDataIndex(point.name_);
     uint32_t internalPid = streamFilters_->processFilter_->GetInternalPid(point.tgid_);
     if (internalPid != INVALID_ID) {
-        streamFilters_->processMeasureFilter_->AppendNewMeasureData(internalPid, nameIndex, ts, point.value_);
+        streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::PROCESS, internalPid, nameIndex, ts, point.value_);
         streamFilters_->processFilter_->AddProcessMemory(internalPid);
     } else {
         streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_TRACING_MARK_WRITE, STAT_EVENT_DATA_INVALID);
diff --git a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp
index 1e3e8fe794a4d086b1da9781a1fe4b8c5186a5a9..e22021ff85893060a59b71d2cb1f70ad26a5612f 100644
--- a/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp
+++ b/trace_streamer/src/parser/ptreader_parser/bytrace_parser/bytrace_event_parser.cpp
@@ -374,8 +374,9 @@ bool BytraceEventParser::CpuIdleEvent(const ArgsMap &args, const BytraceLine &li
     }
     // Add cpu_idle event to raw_data_table
     auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuidleNameIndex, line.ts,
-                                                            config_.GetStateValue(newStateValue.value()));
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
+                                                         cpuidleNameIndex, line.ts,
+                                                         config_.GetStateValue(newStateValue.value()));
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_IDLE, STAT_EVENT_RECEIVED);
     return true;
 }
@@ -403,8 +404,8 @@ bool BytraceEventParser::CpuFrequencyEvent(const ArgsMap &args, const BytraceLin
     }
 
     auto cpuidleNameIndex = traceDataCache_->GetDataIndex(line.eventName.c_str());
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuidleNameIndex, line.ts,
-                                                            newStateValue.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
+                                                         cpuidleNameIndex, line.ts, newStateValue.value());
     return true;
 }
 bool BytraceEventParser::CpuFrequencyLimitsEvent(const ArgsMap &args, const BytraceLine &line) const
@@ -444,10 +445,10 @@ bool BytraceEventParser::CpuFrequencyLimitsEvent(const ArgsMap &args, const Bytr
         return false;
     }
 
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyLimitMaxNameId, line.ts,
-                                                            maxValue.value());
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpuValue.value(), cpuFrequencyLimitMinNameId, line.ts,
-                                                            minValue.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
+                                                         cpuFrequencyLimitMaxNameId, line.ts, maxValue.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpuValue.value(),
+                                                         cpuFrequencyLimitMinNameId, line.ts, minValue.value());
     return true;
 }
 
@@ -514,7 +515,8 @@ bool BytraceEventParser::SetRateEvent(const ArgsMap &args, const BytraceLine &li
     auto state = base::StrToInt<int64_t>(args.at("state"));
     uint64_t cpu = 0;
     DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
-    streamFilters_->clockRateFilter_->AppendNewMeasureData(cpu, nameIndex, line.ts, state.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, cpu, nameIndex, line.ts,
+                                                         state.value());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
     return true;
 }
@@ -530,7 +532,8 @@ bool BytraceEventParser::ClockEnableEvent(const ArgsMap &args, const BytraceLine
     auto state = base::StrToInt<int64_t>(args.at("state"));
     auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
     DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
-    streamFilters_->clockEnableFilter_->AppendNewMeasureData(cpuId.value(), nameIndex, line.ts, state.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_ENABLE, cpuId.value(), nameIndex,
+                                                         line.ts, state.value());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
     return true;
 }
@@ -545,7 +548,8 @@ bool BytraceEventParser::ClockDisableEvent(const ArgsMap &args, const BytraceLin
     auto state = base::StrToInt<int64_t>(args.at("state"));
     auto cpuId = base::StrToInt<uint64_t>(args.at("cpu_id"));
     DataIndex nameIndex = traceDataCache_->GetDataIndex(name);
-    streamFilters_->clockDisableFilter_->AppendNewMeasureData(cpuId.value(), nameIndex, line.ts, state.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, cpuId.value(), nameIndex,
+                                                         line.ts, state.value());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
     return true;
 }
diff --git a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp
index 08ee4994d99801f6a58224fed7f42be4bd671ed5..801a81f8bc344785c6827f39b00c3abc904c5c9e 100644
--- a/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp
+++ b/trace_streamer/src/parser/rawtrace_parser/cpu_detail_parser.cpp
@@ -474,8 +474,9 @@ bool CpuDetailParser::CpuIdleEvent(const RawTraceEventInfo &event) const
         return false;
     }
 
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpu.value(), cpuIdleIndex_, event.msgPtr->timestamp(),
-                                                            config_.GetStateValue(newState.value()));
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpu.value(), cpuIdleIndex_,
+                                                         event.msgPtr->timestamp(),
+                                                         config_.GetStateValue(newState.value()));
 
     // Add cpu_idle event to raw_data_table
     traceDataCache_->GetRawData()->AppendRawData(event.msgPtr->timestamp(), RAW_CPU_IDLE, eventCpu.value(), 0);
@@ -499,18 +500,20 @@ bool CpuDetailParser::CpuFrequencyEvent(const RawTraceEventInfo &event) const
         return false;
     }
 
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(eventCpu.value(), cpuFrequencyIndex_,
-                                                            event.msgPtr->timestamp(), newState.value());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, eventCpu.value(), cpuFrequencyIndex_,
+                                                         event.msgPtr->timestamp(), newState.value());
     return true;
 }
 bool CpuDetailParser::CpuFrequencyLimitsEvent(const RawTraceEventInfo &event) const
 {
     auto limitsMsg = event.msgPtr->cpu_frequency_limits_format();
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CPU_FREQUENCY_LIMITS, STAT_EVENT_RECEIVED);
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(limitsMsg.cpu_id(), cpuFrequencyLimitMaxIndex_,
-                                                            event.msgPtr->timestamp(), limitsMsg.max_freq());
-    streamFilters_->cpuMeasureFilter_->AppendNewMeasureData(limitsMsg.cpu_id(), cpuFrequencyLimitMinIndex_,
-                                                            event.msgPtr->timestamp(), limitsMsg.min_freq());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, limitsMsg.cpu_id(),
+                                                         cpuFrequencyLimitMaxIndex_, event.msgPtr->timestamp(),
+                                                         limitsMsg.max_freq());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CPU, limitsMsg.cpu_id(),
+                                                         cpuFrequencyLimitMinIndex_, event.msgPtr->timestamp(),
+                                                         limitsMsg.min_freq());
     return true;
 }
 bool CpuDetailParser::SuspendResumeEvent(const RawTraceEventInfo &event) const
@@ -687,8 +690,8 @@ bool CpuDetailParser::SetRateEvent(const RawTraceEventInfo &event) const
 {
     auto clockSetRateMsg = event.msgPtr->clock_set_rate_format();
     DataIndex nameIndex = traceDataCache_->GetDataIndex(clockSetRateMsg.name());
-    streamFilters_->clockRateFilter_->AppendNewMeasureData(clockSetRateMsg.cpu_id(), nameIndex,
-                                                           event.msgPtr->timestamp(), clockSetRateMsg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_RATE, clockSetRateMsg.cpu_id(),
+                                                         nameIndex, event.msgPtr->timestamp(), clockSetRateMsg.state());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_SET_RATE, STAT_EVENT_RECEIVED);
     return true;
 }
@@ -696,8 +699,8 @@ bool CpuDetailParser::ClockEnableEvent(const RawTraceEventInfo &event) const
 {
     auto clockEnableMsg = event.msgPtr->clock_enable_format();
     DataIndex nameIndex = traceDataCache_->GetDataIndex(clockEnableMsg.name());
-    streamFilters_->clockEnableFilter_->AppendNewMeasureData(clockEnableMsg.cpu_id(), nameIndex,
-                                                             event.msgPtr->timestamp(), clockEnableMsg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_ENABLE, clockEnableMsg.cpu_id(),
+                                                         nameIndex, event.msgPtr->timestamp(), clockEnableMsg.state());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_ENABLE, STAT_EVENT_RECEIVED);
     return true;
 }
@@ -705,8 +708,8 @@ bool CpuDetailParser::ClockDisableEvent(const RawTraceEventInfo &event) const
 {
     auto clockDisableMsg = event.msgPtr->clock_disable_format();
     DataIndex nameIndex = traceDataCache_->GetDataIndex(clockDisableMsg.name());
-    streamFilters_->clockDisableFilter_->AppendNewMeasureData(clockDisableMsg.cpu_id(), nameIndex,
-                                                              event.msgPtr->timestamp(), clockDisableMsg.state());
+    streamFilters_->measureFilter_->AppendNewMeasureData(EnumMeasureFilter::CLOCK_DISABLE, clockDisableMsg.cpu_id(),
+                                                         nameIndex, event.msgPtr->timestamp(), clockDisableMsg.state());
     streamFilters_->statFilter_->IncreaseStat(TRACE_EVENT_CLOCK_DISABLE, STAT_EVENT_RECEIVED);
     return true;
 }
diff --git a/trace_streamer/src/proto_reader/include/proto_reader.h b/trace_streamer/src/proto_reader/include/proto_reader.h
index a4c44490f1b82d17c20f780b85a8f0d300f02c5b..600b90445d6bac331ec2a3a824d388f8bbf22a5f 100644
--- a/trace_streamer/src/proto_reader/include/proto_reader.h
+++ b/trace_streamer/src/proto_reader/include/proto_reader.h
@@ -21,7 +21,6 @@
 #include <memory>
 #include <stdint.h>
 #include <string>
-
 #include "data_area.h"
 #include "log.h"
 #include "proto_reader_help.h"
diff --git a/trace_streamer/src/protos/types/plugins/xpower_data/BUILD.gn b/trace_streamer/src/protos/types/plugins/xpower_data/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..08b7147d3cb0526e6b2c3771ae1cc61a9b4210a0
--- /dev/null
+++ b/trace_streamer/src/protos/types/plugins/xpower_data/BUILD.gn
@@ -0,0 +1,87 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+# 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.
+
+import("//build/ohos.gni")
+import("../../../protos.gni")
+
+xpower_data_sources = [
+  "./xpower_plugin_config.proto",
+  "./xpower_plugin_result.proto",
+]
+
+#######################################################
+proto_out_dir = "$root_gen_dir/cpp/" + rebase_path(".", "//")
+proto_rel_out_dir = rebase_path(proto_out_dir, root_build_dir)
+
+xpower_data_codegen = []
+xpower_data_codegen_all = []
+xpower_data_codegen_reader = []
+foreach(proto, xpower_data_sources) {
+  name = get_path_info(proto, "name")
+  xpower_data_codegen += [
+    "$proto_out_dir/$name.pb.h",
+    "$proto_out_dir/$name.pb.cc",
+  ]
+  xpower_data_codegen_reader += [ "$proto_out_dir/${name}.pbreader.h" ]
+}
+xpower_data_codegen_all += xpower_data_codegen
+xpower_data_codegen_all += xpower_data_codegen_reader
+
+config("xpower_include_config") {
+  include_dirs = [ "$proto_out_dir" ]
+}
+
+#######################################################
+action("ts_xpower_data_cpp_gen") {
+  script = "${OHOS_TRACE_STREAMER_DIR_PROTOC}"
+  sources = xpower_data_sources
+  outputs = xpower_data_codegen_all
+  args = [
+    "$libc_dir_proto",
+    "$root_output_dir_proto",
+    "$proto_rel_out_dir",
+    "--cpp_out",
+    "$proto_rel_out_dir",
+    "--proto_path",
+    rebase_path(".", root_build_dir),
+  ]
+  args += rebase_path(sources, root_build_dir)
+  if (!use_wasm && !is_test && !is_fuzz) {
+    deps = [
+      "${OHOS_PROFILER_3RDPARTY_PROTOBUF_DIR}:protoc(${host_toolchain})",
+      "${SRC}/proto_reader/protoc_plugin:protoreader_plugin(${host_toolchain})",
+    ]
+  }
+}
+
+ohos_source_set("ts_xpower_data_cpp") {
+  subsystem_name = "${OHOS_PROFILER_SUBSYS_NAME}"
+  part_name = "${OHOS_PROFILER_PART_NAME}"
+  deps = [ ":ts_xpower_data_cpp_gen" ]
+  public_deps = [
+    "${OHOS_PROFILER_3RDPARTY_PROTOBUF_DIR}:protobuf_lite_static",
+    "${OHOS_PROFILER_3RDPARTY_PROTOBUF_DIR}:protobuf_static",
+  ]
+  include_dirs = [ "$proto_out_dir" ]
+  public_configs = [ ":xpower_include_config" ]
+  sources = xpower_data_codegen
+}
+
+ohos_source_set("xpower_data_reader") {
+  subsystem_name = "${OHOS_PROFILER_SUBSYS_NAME}"
+  part_name = "${OHOS_PROFILER_PART_NAME}"
+  deps = [ ":ts_xpower_data_cpp_gen" ]
+  include_dirs = [ "$proto_out_dir" ]
+  public_configs = [ ":xpower_include_config" ]
+  sources = xpower_data_codegen_reader
+}
diff --git a/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_config.proto b/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_config.proto
new file mode 100644
index 0000000000000000000000000000000000000000..ed8225ff832882fc7a891895013bf10384f3bf33
--- /dev/null
+++ b/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_config.proto
@@ -0,0 +1,31 @@
+// Copyright (c) Huawei Technologies Co., Ltd. 2021. All rights reserved.
+// 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.
+
+syntax = "proto3";
+
+option java_package = "ohos.devtools.datasources.transport.grpc.service";
+option optimize_for = LITE_RUNTIME;
+
+enum XpowerMessageType {
+    REAL_BATTERY = 0;
+    APP_STATISTIC = 1;
+    APP_DETAIL = 2;
+    COMPONENT_TOP = 3;
+    ABNORMAL_EVENTS = 4;
+    THERMAL_REPORT = 5;
+}
+
+message XpowerConfig {
+    string bundle_name = 1;
+    repeated XpowerMessageType message_type = 2;
+}
diff --git a/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_result.proto b/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_result.proto
new file mode 100644
index 0000000000000000000000000000000000000000..8469aa797fbb3828a6a44b916cd452d6d5a75765
--- /dev/null
+++ b/trace_streamer/src/protos/types/plugins/xpower_data/xpower_plugin_result.proto
@@ -0,0 +1,195 @@
+/*
+ * Copyright (c) Huawei Technologies Co., Ltd. 2023. All rights reserved.
+ * 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.
+ */
+
+syntax = "proto3";
+option java_package = "ohos.devtools.datasources.transport.grpc.service";
+option optimize_for = LITE_RUNTIME;
+
+message OptimizeReport {
+  int64 start_time = 1;                 //统计起始时间CLOCK_REALTIME类型
+  int64 end_time = 2;                   //统计结束时间CLOCK_REALTIME类型
+  string bundle_name = 3;               //调优应用包名（AppStatistic/AppDetail/AbnormalEvents必传，其他非必传）
+  uint32 message_type = 4;              //调优消息类型值累加（建议用于二进制位运算，判断是否包含某消息类型）
+  RealBattery real_battery = 5;         //电源信息统计，对应messageType为1（对应原hisysevent中的POWER_IDE_BATTERY上报）
+  AppStatistic app_statistic = 6;       //指定应用的各器件统计信息，对应messageType为2
+  AppDetail app_detail = 7;             //指定应用的各器件调优信息，对应messageType为4
+  ComponentTop component_top = 8;       //整机各器件的top应用信息，对应messageType为8（对应原hisysevent中的POWER_IDE_*上报）
+  AbnormalEvents abnormal_events = 9;   //指定应用的异常事件检测，对应messageType为16（应用异常快速检测，3min/次）
+  ThermalReport thermal_report = 10;    //5.0新增：热温度信息，对应messageType为32
+  int64 start_time_b = 11;              //5.0新增：统计起始时间CLOCK_BOOTTIME类型
+  int64 end_time_b = 12;                //5.0新增：统计结束时间CLOCK_BOOTTIME类型
+}
+
+message RealBattery {
+  int64 capacity = 1;   //电池容量
+  int64 charge = 2;     //充电状态
+  int64 current = 3;    //电池电流，计划日落，用real_current替代
+  int64 gas_gauge = 4;  //电池电量
+  int64 level = 5;      //电池百分比
+  int64 screen = 6;     //屏幕状态
+  repeated int32 real_current = 7;   //5.0新增：实时电流，100ms采集一次
+}
+
+message AppStatistic {
+  AppStatisticCommon audio = 1;       //指定应用的audio统计信息
+  AppStatisticCommon bluetooth = 2;   //指定应用的bluetooth统计信息
+  AppStatisticCommon camera = 3;      //指定应用的camera统计信息
+  AppStatisticCommon cpu = 4;         //指定应用的cpu统计信息
+  AppStatisticCommon display = 5;     //指定应用的display统计信息
+  AppStatisticCommon flashlight = 6;  //指定应用的flashlight统计信息
+  AppStatisticCommon gpu = 7;         //指定应用的gpu统计信息
+  AppStatisticCommon location = 8;    //指定应用的location统计信息
+  AppStatisticCommon wifiscan = 9;    //指定应用的wifiscan统计信息
+  AppStatisticCommon wifi = 10;       //5.0新增：指定应用的wifi流量统计信息
+  AppStatisticCommon modem = 11;      //5.0新增：指定应用的modem流量统计信息
+}
+
+message AppStatisticCommon {
+  int64 energy = 1;   //器件统计功耗
+  int64 time = 2;     //器件使用时长
+}
+
+message AppDetail {
+  AppDetailCPU cpu = 1;         //指定应用的cpu调优信息
+  AppDetailGPU gpu = 2;         //指定应用的gpu调优信息
+  AppDetailWifi wifi = 3;       //指定应用的wifi调优信息
+  AppDetailDisplay display = 4; //指定应用的display调优信息
+}
+
+message AppDetailCPU {
+  int32 thread_count = 1;           //指定应用的线程数
+  repeated int64 thread_load = 2;   //各线程负载
+  repeated string thread_name = 3;  //各线程名
+  repeated int64 thread_time = 4;   //各线程执行时长
+  repeated int64 thread_energy = 5; //各线程统计功耗
+}
+
+message AppDetailGPU {
+  int64 frequency_count = 1;    //GPU运行的频率数
+  repeated int64 frequency = 2; //GPU运行的频率
+  repeated int64 idle_time = 3; //对应频率的idea时长
+  repeated int64 run_time = 4;  //对应频率的运行时长
+}
+
+message AppDetailWifi {
+  int64 tx_packets = 1;   //wifi传输数据包
+  int64 rx_packets = 2;   //wifi接受数据包
+  int64 tx_bytes = 3;     //wifi传输字节数
+  int64 rx_bytes = 4;     //wifi接受字节数
+}
+
+message AppDetailDisplay {
+  int64 count_1hz = 1;      //刷新率在每秒1次的驻留时长
+  int64 count_5hz = 2;      //刷新率在每秒5次的驻留时长
+  int64 count_10hz = 3;     //刷新率在每秒10次的驻留时长
+  int64 count_15hz = 4;     //刷新率在每秒15次的驻留时长
+  int64 count_24hz = 5;     //刷新率在每秒24次的驻留时长
+  int64 count_30hz = 6;     //刷新率在每秒30次的驻留时长
+  int64 count_45hz = 7;     //刷新率在每秒45次的驻留时长
+  int64 count_60hz = 8;     //刷新率在每秒60次的驻留时长
+  int64 count_90hz = 9;     //刷新率在每秒90次的驻留时长
+  int64 count_120hz = 10;   //刷新率在每秒120次的驻留时长
+  int64 count_180hz = 11;   //刷新率在每秒180次的驻留时长
+}
+
+message ComponentTop {
+  ComponentTopCommon audio = 1;       //整机audio的top应用信息
+  ComponentTopCommon bluetooth = 2;   //整机bluetooth的top应用信息
+  ComponentTopCamera camera = 3;      //整机camera的top应用信息
+  ComponentTopCpu cpu = 4;            //整机cpu的top应用信息
+  ComponentTopDisplay display = 5;    //整机display的top应用信息
+  ComponentTopCommon flashlight = 6;  //整机flashlight的top应用信息
+  ComponentTopDisplay gpu = 7;        //整机gpu的top应用信息
+  ComponentTopCommon location = 8;    //整机location的top应用信息
+  ComponentTopCommon wifiscan = 9;    //整机wifiscan的top应用信息
+}
+
+message ComponentTopCommon {
+  int32 count = 1;                        //应用个数
+  repeated string appname = 2;            //应用包名
+  repeated int64 background_duration = 3; //后台使用时长
+  repeated int64 background_energy = 4;   //后台使用功耗值
+  repeated int64 foreground_duration = 5; //前台使用时长
+  repeated int64 foreground_energy = 6;   //前台使用功耗值
+  repeated int64 screen_off_duration = 7; //灭屏使用时长
+  repeated int64 screen_off_energy = 8;   //灭屏使用功耗值
+  repeated int64 screen_on_duration = 9;  //亮屏使用时长
+  repeated int64 screen_on_energy = 10;   //亮屏使用功耗值
+}
+
+message ComponentTopCamera {
+  int32 count = 1;                        //应用个数
+  repeated string appname = 2;            //应用包名
+  repeated int64 camera_id = 3;           //Camera类型，0：后置，1：前置
+  repeated int64 background_duration = 4; //后台使用时长
+  repeated int64 background_energy = 5;   //后台使用功耗值
+  repeated int64 foreground_duration = 6; //前台使用时长
+  repeated int64 foreground_energy = 7;   //前台使用功耗值
+  repeated int64 screen_off_duration = 8; //灭屏使用时长
+  repeated int64 screen_off_energy = 9;   //灭屏使用功耗值
+  repeated int64 screen_on_duration = 10; //亮屏使用时长
+  repeated int64 screen_on_energy = 11;   //亮屏使用功耗值
+}
+
+message ComponentTopCpu {
+  int32 count = 1;                        //应用个数
+  repeated string appname = 2;            //应用包名
+  repeated int64 uid = 3;                 //应用UID
+  repeated int64 background_duration = 4; //后台使用时长
+  repeated int64 background_energy = 5;   //后台使用功耗值
+  repeated int64 foreground_duration = 6; //前台使用时长
+  repeated int64 foreground_energy = 7;   //前台使用功耗值
+  repeated int64 screen_off_duration = 8; //灭屏使用时长
+  repeated int64 screen_off_energy = 9;   //灭屏使用功耗值
+  repeated int64 screen_on_duration = 10; //亮屏使用时长
+  repeated int64 screen_on_energy = 11;   //亮屏使用功耗值
+  repeated int64 load = 12;               //cpu占用率
+}
+
+message ComponentTopDisplay {
+  int32 count = 1;              //应用个数
+  repeated string appname = 2;  //应用包名
+  repeated int64 time = 3;      //应用使用时长
+  repeated int64 energy = 4;    //应用功耗值
+}
+
+message AbnormalEvents {
+  int64 anomaly_start_time = 1;             //异常检测起始时间
+  int64 anomaly_end_time = 2;               //异常检测结束时间
+  int32 count = 3;                          //检测到当前应用的异常数
+  repeated AbnormalEventInfo events = 4;    //各类异常详情数组
+}
+
+message AbnormalEventInfo {
+  enum AbnormalType {
+    CPU_BG_HEAVY_LOAD = 0;        //cpu后台高负载异常
+    CPU_FG_HEAVY_LOAD = 1;        //cpu前台高负载异常
+    CPU_HIGH_FREQUENCY = 2;       //cpu高频异常
+    GNSS_ENERGY = 3;              //Gnss高耗电异常
+    LOCATION_COUNTER = 4;         //频繁定位异常
+    WIFI_ENERGY = 5;              //Wifi高耗电异常
+  }
+  AbnormalType abnormal_type = 1;  //异常类型
+  int64 usage_time = 2;           //使用时长
+  int64 usage_energy = 3;         //使用功耗
+  int64 usage_load = 4;           //使用负载
+  int64 usage_freq = 5;           //使用频率
+  int32 usage_count = 6;          //使用次数
+}
+
+message ThermalReport {           //热温度信息
+  int64 shell_temp = 1;           //外壳温度
+  int64 thermal_level = 2;        //温度等级
+}
\ No newline at end of file
diff --git a/trace_streamer/src/rpc/rpc_server.cpp b/trace_streamer/src/rpc/rpc_server.cpp
index 924aebc07a5850331d2cd0c8cc5c9473d123c9ad..396aa27c469337c4f14f411d2a06928757fdd25f 100644
--- a/trace_streamer/src/rpc/rpc_server.cpp
+++ b/trace_streamer/src/rpc/rpc_server.cpp
@@ -20,6 +20,7 @@
 #include <functional>
 #if IS_WASM
 #include <filesystem>
+#include "file.h"
 #endif
 #include "common_types.h"
 #include "hilog_parser/ptreader_hilog_parser.h"
@@ -112,6 +113,33 @@ bool RpcServer::SaveAndParseFfrtData(const uint8_t *data, size_t len, ResultCall
     std::filesystem::remove_all(outTraceName);
     return true;
 }
+bool RpcServer::SaveAndParseZipTraceData(const uint8_t *data, size_t len, ResultCallBack resultCallBack, bool isFinish)
+{
+    auto zipFileName = "zipFile.zip";
+    static std::ofstream zipFile(zipFileName, std::ios::binary | std::ios::app);
+    if (!zipFile.is_open()) {
+        TS_LOGE("zipFile open filed!");
+        return false;
+    }
+    zipFile.write(reinterpret_cast<const char *>(data), len);
+    if (zipFile.fail() || zipFile.bad()) {
+        TS_LOGE("Failed to write data!");
+        zipFile.close();
+        return false;
+    }
+    if (!isFinish) {
+        return true;
+    }
+    zipFile.close();
+    std::string outTraceName;
+    UnZipFile(zipFileName, outTraceName);
+    if (!ReadAndParseData(outTraceName)) {
+        std::filesystem::remove_all(outTraceName);
+        return false;
+    }
+    std::filesystem::remove_all(outTraceName);
+    return true;
+}
 bool RpcServer::SendConvertedFfrtFile(const std::string &fileName, ResultCallBack resultCallBack)
 {
     if (!resultCallBack) {
@@ -265,6 +293,14 @@ bool RpcServer::DetermineSystrace(const uint8_t *data, size_t len)
     return false;
 }
 
+bool RpcServer::DetermineZipTrace(const uint8_t *data, size_t len)
+{
+    if (len < 2) {
+        return false;
+    }
+    return data[0] == 'P' && data[1] == 'K';
+}
+
 bool RpcServer::SendBytraceSplitFileData(SplitFileCallBack splitFileCallBack, int32_t isFinish)
 {
     int32_t firstPos = ts_->GetPtreaderParser()->MinSplitPos();
diff --git a/trace_streamer/src/rpc/rpc_server.h b/trace_streamer/src/rpc/rpc_server.h
index 645344f4ece4a04e5229afbd7e2fc2e2649195fa..dcba5d4227cbe578045ad031325e67356ba68b5f 100644
--- a/trace_streamer/src/rpc/rpc_server.h
+++ b/trace_streamer/src/rpc/rpc_server.h
@@ -73,12 +73,14 @@ public:
         return ffrtConvertEnabled_;
     };
     bool DetermineSystrace(const uint8_t *data, size_t len);
+    bool DetermineZipTrace(const uint8_t *data, size_t len);
 
 #ifdef ENABLE_RAWTRACE
     bool SendRawtraceSplitFileData(SplitFileCallBack splitFileCallBack, int32_t isFinish);
 #endif
 #ifdef IS_WASM
     bool SaveAndParseFfrtData(const uint8_t *data, size_t len, ResultCallBack resultCallBack, bool isFinish);
+    bool SaveAndParseZipTraceData(const uint8_t *data, size_t len, ResultCallBack resultCallBack, bool isFinish);
     bool ReadAndParseData(const std::string &filePath);
     bool SendConvertedFfrtFile(const std::string &fileName, ResultCallBack resultCallBack);
     void CreateFilePath(const std::string &filePath);
diff --git a/trace_streamer/src/rpc/wasm_func.cpp b/trace_streamer/src/rpc/wasm_func.cpp
index 031d2cddabc3554d1fab63d058f5c4dda37a5384..4a89700dbf547bb2633322f8c0a8a6a673da730c 100644
--- a/trace_streamer/src/rpc/wasm_func.cpp
+++ b/trace_streamer/src/rpc/wasm_func.cpp
@@ -51,6 +51,7 @@ ParseELFFunction g_parseELFCallback;
 uint8_t *g_fileNameBuf;
 uint32_t g_fileNameSize;
 bool g_isSystrace = false;
+bool g_isZipTrace = false;
 bool g_hasDeterminedSystrace = false;
 
 void ResultCallback(const std::string &jsonResult, int32_t finish)
@@ -79,6 +80,9 @@ EMSCRIPTEN_KEEPALIVE uint8_t *Initialize(uint32_t reqBufferSize,
                                          TLVReplyFunction replyTLVFunction,
                                          ReplyFunction ffrtConvertedReply)
 {
+    if (g_reqBuf != nullptr) {
+        delete[] g_reqBuf;
+    }
     g_reqBuf = new uint8_t[reqBufferSize];
     g_reqBufferSize = reqBufferSize;
     g_reply = replyFunction;
@@ -89,6 +93,9 @@ EMSCRIPTEN_KEEPALIVE uint8_t *Initialize(uint32_t reqBufferSize,
 
 EMSCRIPTEN_KEEPALIVE uint8_t *InitializeSplitFile(SplitFileFunction splitFileFunction, uint32_t reqBufferSize)
 {
+    if (g_splitFileBuf != nullptr) {
+        delete[] g_splitFileBuf;
+    }
     g_splitFile = splitFileFunction;
     g_splitFileBuf = new uint8_t[reqBufferSize];
     g_splitFileBufferSize = reqBufferSize;
@@ -114,6 +121,9 @@ EMSCRIPTEN_KEEPALIVE int TraceStreamerReciveFileEx(int32_t dataLen, int32_t isFi
 
 EMSCRIPTEN_KEEPALIVE uint8_t *InitializeParseConfig(uint32_t reqBufferSize)
 {
+    if (g_parserConfigBuf != nullptr) {
+        delete[] g_parserConfigBuf;
+    }
     g_parserConfigBuf = new uint8_t[reqBufferSize];
     g_parserConfigSize = reqBufferSize;
     return g_parserConfigBuf;
@@ -146,6 +156,9 @@ EMSCRIPTEN_KEEPALIVE int TraceStreamerLongTraceSplitFileEx(int dataLen, int32_t
 
 EMSCRIPTEN_KEEPALIVE uint8_t *InitFileName(ParseELFFunction parseELFCallback, uint32_t reqBufferSize)
 {
+    if (g_fileNameBuf != nullptr) {
+        delete[] g_fileNameBuf;
+    }
     g_parseELFCallback = parseELFCallback;
     if (reqBufferSize > NAME_MAX) {
         return nullptr;
@@ -173,6 +186,9 @@ void ThirdParySendDataCallback(const char *pluginData, int32_t len, int32_t comp
 EMSCRIPTEN_KEEPALIVE uint8_t *TraceStreamerSetThirdPartyDataDealer(SendDataCallBack sendDataCallBack,
                                                                    uint32_t reqBufferSize)
 {
+    if (g_sendDataBuf != nullptr) {
+        delete[] g_sendDataBuf;
+    }
     g_sendData = sendDataCallBack;
     g_sendDataBuf = new uint8_t[reqBufferSize];
     g_sendDataBufSize = reqBufferSize;
@@ -224,12 +240,15 @@ EMSCRIPTEN_KEEPALIVE int32_t TraceStreamerParseDataEx(int32_t dataLen, bool isFi
 {
     if (!g_hasDeterminedSystrace) {
         g_isSystrace = g_wasmTraceStreamer.DetermineSystrace(g_reqBuf, dataLen);
+        g_isZipTrace = g_wasmTraceStreamer.DetermineZipTrace(g_reqBuf, dataLen);
         g_hasDeterminedSystrace = true;
     }
     if (g_wasmTraceStreamer.GetFfrtConvertStatus() && g_isSystrace) {
 #if IS_WASM
         return g_wasmTraceStreamer.SaveAndParseFfrtData(g_reqBuf, dataLen, &FfrtConvertedResultCallback, isFinish);
 #endif
+    } else if (g_isZipTrace) {
+        return g_wasmTraceStreamer.SaveAndParseZipTraceData(g_reqBuf, dataLen, &FfrtConvertedResultCallback, isFinish);
     } else if (g_wasmTraceStreamer.ParseData(g_reqBuf, dataLen, nullptr, isFinish)) {
         return 0;
     }
diff --git a/trace_streamer/src/table/base/table_base.cpp b/trace_streamer/src/table/base/table_base.cpp
index 5ad82b7d79ec4ee3281275590b3e16a6ac5a0910..a273936718a822f233f5a06ace867b0d6f04a364 100644
--- a/trace_streamer/src/table/base/table_base.cpp
+++ b/trace_streamer/src/table/base/table_base.cpp
@@ -313,7 +313,7 @@ void TableBase::Cursor::FilterId(unsigned char op, sqlite3_value *argv)
         return;
     }
     if (indexMap_->HasData()) {
-        indexMap_->CovertToIndexMap();
+        indexMap_->ConvertToIndexMap();
     }
 
     auto v = static_cast<TableRowId>(sqlite3_value_int64(argv));
diff --git a/trace_streamer/src/table/ftrace/measure_table.cpp b/trace_streamer/src/table/ftrace/measure_table.cpp
index baf5e9f6d1c8e237274577e14bcea3de3b23f6f4..4dc4b6e61234b5bdb6fb9695954163ddd2e893c0 100644
--- a/trace_streamer/src/table/ftrace/measure_table.cpp
+++ b/trace_streamer/src/table/ftrace/measure_table.cpp
@@ -44,11 +44,15 @@ MeasureTable::Cursor::Cursor(const TraceDataCache *dataCache, TableBase *table)
                                                   ? dataCache->GetConstMeasureData().Size()
                                                   : (table->name_ == "process_measure"
                                                          ? dataCache->GetConstProcessMeasureData().Size()
-                                                         : dataCache->GetConstSysMemMeasureData().Size()))),
+                                                         : (table->name_ == "sys_mem_measure"
+                                                                ? dataCache->GetConstSysMemMeasureData().Size()
+                                                                : dataCache->GetConstXpowerMeasureData().Size())))),
       measureObj(table->name_ == "measure"
                      ? dataCache->GetConstMeasureData()
-                     : (table->name_ == "process_measure" ? dataCache->GetConstProcessMeasureData()
-                                                          : dataCache->GetConstSysMemMeasureData()))
+                     : (table->name_ == "process_measure"
+                            ? dataCache->GetConstProcessMeasureData()
+                            : (table->name_ == "sys_mem_measure" ? dataCache->GetConstSysMemMeasureData()
+                                                                 : dataCache->GetConstXpowerMeasureData())))
 {
 }
 
diff --git a/trace_streamer/src/table/ftrace/process_table.cpp b/trace_streamer/src/table/ftrace/process_table.cpp
index 48a4a65af6cc2ff26beff8c60bb3ccb7688f6c8b..5fbfcecb502317135f8c8f1cdd50b35a7a2713f5 100644
--- a/trace_streamer/src/table/ftrace/process_table.cpp
+++ b/trace_streamer/src/table/ftrace/process_table.cpp
@@ -186,7 +186,7 @@ void ProcessTable::Cursor::FilterPid(unsigned char op, uint64_t value)
 {
     bool remove = false;
     if (indexMap_->HasData()) {
-        indexMap_->CovertToIndexMap();
+        indexMap_->ConvertToIndexMap();
         remove = true;
     }
     switch (op) {
diff --git a/trace_streamer/src/trace_data/trace_data_cache.cpp b/trace_streamer/src/trace_data/trace_data_cache.cpp
index ee159f361dff26801e8e79a1bea458b9792f8e13..e9db3bfd59c05fedbd5cda1584754245e4ad6493 100644
--- a/trace_streamer/src/trace_data/trace_data_cache.cpp
+++ b/trace_streamer/src/trace_data/trace_data_cache.cpp
@@ -75,7 +75,6 @@
 #include "native_hook_frame_table.h"
 #include "native_hook_statistic_table.h"
 #include "native_hook_table.h"
-#include "native_hook_statistic_table.h"
 #include "network_table.h"
 #include "paged_memory_sample_table.h"
 #include "ebpf_data_structure.h"
@@ -160,6 +159,7 @@ void TraceDataCache::InitMeasureDB()
     TableBase::TableDeclare<MeasureTable>(*db_, this, "measure");
     TableBase::TableDeclare<MeasureTable>(*db_, this, "sys_mem_measure");
     TableBase::TableDeclare<MeasureTable>(*db_, this, "process_measure");
+    TableBase::TableDeclare<MeasureTable>(*db_, this, "xpower_measure");
     TableBase::TableDeclare<CpuMeasureFilterTable>(*db_, this, "cpu_measure_filter");
     TableBase::TableDeclare<FilterTable>(*db_, this, "measure_filter");
     TableBase::TableDeclare<ProcessMeasureFilterTable>(*db_, this, "process_measure_filter");
diff --git a/trace_streamer/src/trace_data/trace_data_cache_base.h b/trace_streamer/src/trace_data/trace_data_cache_base.h
index b2dde69a80e44f3fcda8024ba637a4c5051171c2..7c05e9eb8f50b43a425d20ed504eee71adf4aa72 100644
--- a/trace_streamer/src/trace_data/trace_data_cache_base.h
+++ b/trace_streamer/src/trace_data/trace_data_cache_base.h
@@ -141,6 +141,7 @@ public:
     Measure measureData_;
     Measure sysMemMeasureData_;
     Measure processMeasureData_;
+    Measure xpowerMeasureData_;
     CpuMeasureFilter cpuMeasureData_;
 
     StatAndInfo stat_;
diff --git a/trace_streamer/src/trace_data/trace_data_cache_reader.cpp b/trace_streamer/src/trace_data/trace_data_cache_reader.cpp
index 81d0c1b6e027f27e1941e399faa12c00a86fd9b7..3e04931eb71c088a39ed5526ce890e351dc2cb04 100644
--- a/trace_streamer/src/trace_data/trace_data_cache_reader.cpp
+++ b/trace_streamer/src/trace_data/trace_data_cache_reader.cpp
@@ -70,7 +70,10 @@ const Measure &TraceDataCacheReader::GetConstProcessMeasureData() const
 {
     return processMeasureData_;
 }
-
+const Measure &TraceDataCacheReader::GetConstXpowerMeasureData() const
+{
+    return xpowerMeasureData_;
+}
 const ThreadStateData &TraceDataCacheReader::GetConstThreadStateData() const
 {
     return threadStateData_;
diff --git a/trace_streamer/src/trace_data/trace_data_cache_reader.h b/trace_streamer/src/trace_data/trace_data_cache_reader.h
index dacfcc2f59ec08a891c8105e3009ff919bac0fde..4c152770098a68277e4aff871caed79eb5f71430 100644
--- a/trace_streamer/src/trace_data/trace_data_cache_reader.h
+++ b/trace_streamer/src/trace_data/trace_data_cache_reader.h
@@ -58,6 +58,7 @@ public:
     const Measure &GetConstMeasureData() const;
     const Measure &GetConstSysMemMeasureData() const;
     const Measure &GetConstProcessMeasureData() const;
+    const Measure &GetConstXpowerMeasureData() const;
     const ThreadStateData &GetConstThreadStateData() const;
     const SchedSlice &GetConstSchedSliceData() const;
     const CpuMeasureFilter &GetConstCpuMeasuresData() const;
diff --git a/trace_streamer/src/trace_data/trace_data_cache_writer.cpp b/trace_streamer/src/trace_data/trace_data_cache_writer.cpp
index 8439ab5740800e92f436a7b2aa0839de843b25fe..6405db2690781d76a33ff18bb745493e94184d92 100644
--- a/trace_streamer/src/trace_data/trace_data_cache_writer.cpp
+++ b/trace_streamer/src/trace_data/trace_data_cache_writer.cpp
@@ -127,7 +127,10 @@ Measure *TraceDataCacheWriter::GetProcessMeasureData()
 {
     return &processMeasureData_;
 }
-
+Measure *TraceDataCacheWriter::GetXpowerMeasureData()
+{
+    return &xpowerMeasureData_;
+}
 ThreadStateData *TraceDataCacheWriter::GetThreadStateData()
 {
     return &threadStateData_;
diff --git a/trace_streamer/src/trace_data/trace_data_cache_writer.h b/trace_streamer/src/trace_data/trace_data_cache_writer.h
index d916002e8699b86b3afe843c4e4ccc2492b35cf1..d7a588061f48f4fac61c8bcb321760bf43dcdbaa 100644
--- a/trace_streamer/src/trace_data/trace_data_cache_writer.h
+++ b/trace_streamer/src/trace_data/trace_data_cache_writer.h
@@ -45,6 +45,7 @@ public:
     Measure *GetMeasureData();
     Measure *GetSysMemMeasureData();
     Measure *GetProcessMeasureData();
+    Measure *GetXpowerMeasureData();
     ThreadStateData *GetThreadStateData();
     SchedSlice *GetSchedSliceData();
     CpuMeasureFilter *GetCpuMeasuresData();
diff --git a/trace_streamer/src/trace_streamer/trace_streamer_filters.h b/trace_streamer/src/trace_streamer/trace_streamer_filters.h
index 8b8bf1ad82d7de4e0c25323642cdcb719e9f6a1c..4e223e904e3d8c6bfded1cb37b62bfe4d702fdf3 100644
--- a/trace_streamer/src/trace_streamer/trace_streamer_filters.h
+++ b/trace_streamer/src/trace_streamer/trace_streamer_filters.h
@@ -51,15 +51,8 @@ public:
     std::unique_ptr<SliceFilter> sliceFilter_;
     std::unique_ptr<ProcessFilter> processFilter_;
     std::unique_ptr<CpuFilter> cpuFilter_;
-    std::unique_ptr<MeasureFilter> cpuMeasureFilter_;
-    std::unique_ptr<MeasureFilter> processMeasureFilter_;
+    std::unique_ptr<MeasureFilter> measureFilter_;
     std::unique_ptr<StatFilter> statFilter_;
-    std::unique_ptr<MeasureFilter> clockRateFilter_;
-    std::unique_ptr<MeasureFilter> clockEnableFilter_;
-    std::unique_ptr<MeasureFilter> clockDisableFilter_;
-    std::unique_ptr<MeasureFilter> clkRateFilter_;
-    std::unique_ptr<MeasureFilter> clkEnableFilter_;
-    std::unique_ptr<MeasureFilter> clkDisableFilter_;
     std::unique_ptr<BinderFilter> binderFilter_;
     std::unique_ptr<ArgsFilter> argsFilter_;
     std::unique_ptr<IrqFilter> irqFilter_;
diff --git a/trace_streamer/src/trace_streamer/trace_streamer_selector.cpp b/trace_streamer/src/trace_streamer/trace_streamer_selector.cpp
index ee33b9f588ff40a044def33b1f02b61c33890606..cce35f13c5c5487f642bda170e7b0ba27dc40424 100644
--- a/trace_streamer/src/trace_streamer/trace_streamer_selector.cpp
+++ b/trace_streamer/src/trace_streamer/trace_streamer_selector.cpp
@@ -150,27 +150,13 @@ void TraceStreamerSelector::InitFilter()
     streamFilters_->processFilter_ = std::make_unique<ProcessFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->clockFilter_ = std::make_unique<ClockFilterEx>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->filterFilter_ = std::make_unique<FilterFilter>(traceDataCache_.get(), streamFilters_.get());
-    streamFilters_->cpuMeasureFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CPU_MEASURE_FILTER);
-    streamFilters_->processMeasureFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_PROCESS_MEASURE_FILTER);
+    streamFilters_->measureFilter_ =
+        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->statFilter_ = std::make_unique<StatFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->binderFilter_ = std::make_unique<BinderFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->argsFilter_ = std::make_unique<ArgsFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->irqFilter_ = std::make_unique<IrqFilter>(traceDataCache_.get(), streamFilters_.get());
     streamFilters_->frameFilter_ = std::make_unique<FrameFilter>(traceDataCache_.get(), streamFilters_.get());
-    streamFilters_->clockRateFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_RATE_FILTER);
-    streamFilters_->clockEnableFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_ENABLE_FILTER);
-    streamFilters_->clockDisableFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLOCK_DISABLE_FILTER);
-    streamFilters_->clkRateFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_RATE_FILTER);
-    streamFilters_->clkEnableFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_ENABLE_FILTER);
-    streamFilters_->clkDisableFilter_ =
-        std::make_unique<MeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_CLK_DISABLE_FILTER);
     streamFilters_->sysEventMemMeasureFilter_ =
         std::make_unique<SystemEventMeasureFilter>(traceDataCache_.get(), streamFilters_.get(), E_SYS_MEMORY_FILTER);
     streamFilters_->sysEventVMemMeasureFilter_ = std::make_unique<SystemEventMeasureFilter>(