1/* 2 * Copyright (C) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import {SpSystemTrace} from "../SpSystemTrace.js"; 17import { 18 queryAnomalyData, queryHisystemEventExits, queryMaxStateValue, queryPowerData, querySmapsExits, 19 queryStateData, querySyseventAppName, 20 querySystemData 21} from "../../database/SqlLite.js"; 22import {info} from "../../../log/Log.js"; 23import {TraceRow} from "../trace/base/TraceRow.js"; 24import {procedurePool} from "../../database/Procedure.js"; 25import {Utils} from "../trace/base/Utils.js"; 26import { 27 EnergyAnomalyStruct, 28 EnergyPowerStruct, 29 EnergyStateStruct, 30 EnergySystemStruct 31} from "../../bean/EnergyStruct.js"; 32import {BaseStruct} from "../../bean/BaseStruct.js"; 33import {LitPopover} from "../../../base-ui/popover/LitPopoverV.js"; 34 35export class SpHiSysEventChart { 36 static app_name: string | null 37 private trace: SpSystemTrace; 38 private energyTraceRow: TraceRow<BaseStruct> | undefined; 39 40 constructor(trace: SpSystemTrace) { 41 this.trace = trace; 42 } 43 44 async init() { 45 let result = await queryHisystemEventExits(); 46 if (result.length <= 0) return; 47 await this.initEnergyRow(); 48 await this.initAnomaly(); 49 await this.initSystem(); 50 await this.initPower(); 51 await this.initState(); 52 } 53 54 private initEnergyRow = async () => { 55 let appNameFromTable = await querySyseventAppName(); 56 if (appNameFromTable.length > 0) { 57 SpHiSysEventChart.app_name = appNameFromTable[0].string_value; 58 } 59 this.energyTraceRow = new TraceRow<BaseStruct>({ 60 canvasNumber: 1, 61 alpha: false, 62 contextId: '2d', 63 isOffScreen: SpSystemTrace.isCanvasOffScreen 64 }); 65 let radioList; 66 let appNameList = this.energyTraceRow?.shadowRoot!.querySelector<LitPopover>("#appNameList"); 67 let addFlag = false; 68 appNameList?.addEventListener('click', () => { 69 let itemDiv = appNameList!.querySelector("div"); 70 if (!addFlag) { 71 for (let index = 0; index < appNameFromTable.length; index++) { 72 let div = document.createElement("div"); 73 div.setAttribute("style", "margin-bottom: 5px"); 74 let appName = appNameFromTable[index].string_value; 75 // @ts-ignore 76 let formatAppName = "appName" + index; 77 div.setAttribute("id", formatAppName); 78 div.innerHTML = "<input class='radio' name='processoption' " + (index == 0 ? "checked" : "") + " type='radio'" + 79 " app_name=" + formatAppName + " value= " + appName + ">" + appName; 80 itemDiv!.append(div); 81 this.energyTraceRow!.shadowRoot!.querySelector<HTMLDivElement>("#" + formatAppName)!.onclick = (e: any) => { 82 this.energyTraceRow?.shadowRoot!.querySelectorAll<HTMLInputElement>('input[type=radio][name=processoption]')!.forEach(item => { 83 if (item.checked) { 84 SpHiSysEventChart.app_name = item.getAttribute("value"); 85 } 86 }) 87 radioList = this.energyTraceRow?.shadowRoot!.querySelectorAll<HTMLInputElement>("input[type=radio][name=processoption]"); 88 if (radioList != undefined) { 89 for (let index = 0; index < radioList.length; index++) { 90 if (e.path[0].id == radioList[index]!.getAttribute("app_name")) { 91 SpHiSysEventChart.app_name = radioList[index]!.getAttribute("value"); 92 radioList[index]!.checked = true; 93 } 94 } 95 } 96 // @ts-ignore 97 appNameList!.visible = false 98 this.energyTraceRow?.click() 99 } 100 } 101 addFlag = true; 102 } 103 }) 104 this.energyTraceRow.rowId = `energy` 105 this.energyTraceRow.rowType = TraceRow.ROW_TYPE_ENERGY 106 this.energyTraceRow.rowParentId = ''; 107 this.energyTraceRow.folder = true; 108 this.energyTraceRow.name = 'Energy'; 109 this.energyTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 110 this.energyTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 111 this.energyTraceRow.supplier = () => new Promise<Array<any>>((resolve) => resolve([])); 112 this.energyTraceRow.onThreadHandler = (useCache) => { 113 procedurePool.submitWithName(`cpu0`, `energy-Group`, { 114 list: this.energyTraceRow!.must ? this.energyTraceRow!.dataList : undefined, 115 offscreen: this.energyTraceRow!.must ? this.energyTraceRow!.offscreen[0] : undefined, 116 xs: TraceRow.range?.xs, 117 dpr: this.energyTraceRow!.dpr, 118 isHover: this.energyTraceRow!.isHover, 119 hoverX: this.energyTraceRow!.hoverX, 120 hoverY: this.energyTraceRow!.hoverY, 121 flagMoveInfo: this.trace.hoverFlag, 122 flagSelectedInfo: this.trace.selectFlag, 123 canvasWidth: this.energyTraceRow!.canvasWidth, 124 canvasHeight: this.energyTraceRow!.canvasHeight, 125 isRangeSelect: this.energyTraceRow!.rangeSelect, 126 rangeSelectObject: TraceRow.rangeSelectObject, 127 useCache: useCache, 128 lineColor: this.energyTraceRow!.getLineColor(), 129 startNS: TraceRow.range?.startNS || 0, 130 endNS: TraceRow.range?.endNS || 0, 131 totalNS: TraceRow.range?.totalNS || 0, 132 slicesTime: TraceRow.range?.slicesTime, 133 range: TraceRow.range, 134 frame: this.energyTraceRow!.frame, 135 }, this.energyTraceRow!.must && this.energyTraceRow!.args.isOffScreen ? this.energyTraceRow!.offscreen[0] : undefined, (res: any, hover: any) => { 136 this.energyTraceRow!.must = false; 137 } 138 ) 139 } 140 this.trace.rowsEL?.appendChild(this.energyTraceRow!) 141 } 142 143 private initAnomaly = async () => { 144 let time = new Date().getTime() 145 let anomalyTraceRow = new TraceRow<EnergyAnomalyStruct>({ 146 canvasNumber: 1, 147 alpha: false, 148 contextId: '2d', 149 isOffScreen: SpSystemTrace.isCanvasOffScreen 150 }); 151 anomalyTraceRow.rowParentId = `energy` 152 anomalyTraceRow.rowHidden = true 153 anomalyTraceRow.rowId = "energy-anomaly" 154 anomalyTraceRow.rowType = TraceRow.ROW_TYPE_ANOMALY_ENERGY 155 anomalyTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 156 anomalyTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 157 anomalyTraceRow.setAttribute("height", `55px`); 158 let element = anomalyTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement; 159 element!.style.height = `55px`; 160 anomalyTraceRow.style.width = `100%`; 161 anomalyTraceRow.setAttribute('children', ''); 162 anomalyTraceRow.name = "Anomaly"; 163 anomalyTraceRow.supplier = () => queryAnomalyData() 164 anomalyTraceRow.onThreadHandler = (useCache) => { 165 procedurePool.submitWithName(`cpu0`, `energyAnomaly`, { 166 list: anomalyTraceRow.must ? anomalyTraceRow.dataList : undefined, 167 offscreen: anomalyTraceRow.must ? anomalyTraceRow.offscreen[0] : undefined, 168 xs: TraceRow.range?.xs, 169 dpr: anomalyTraceRow.dpr, 170 isHover: anomalyTraceRow.isHover, 171 hoverX: anomalyTraceRow.hoverX, 172 hoverY: anomalyTraceRow.hoverY, 173 flagMoveInfo: this.trace.hoverFlag, 174 flagSelectedInfo: this.trace.selectFlag, 175 canvasWidth: anomalyTraceRow.canvasWidth, 176 canvasHeight: anomalyTraceRow.canvasHeight, 177 hoverEnergyAnomalyStruct: EnergyAnomalyStruct.hoverEnergyAnomalyStruct, 178 selectEnergyAnomalyStruct: EnergyAnomalyStruct.selectEnergyAnomalyStruct, 179 isRangeSelect: anomalyTraceRow.rangeSelect, 180 rangeSelectObject: TraceRow.rangeSelectObject, 181 appName: SpHiSysEventChart.app_name, 182 useCache: useCache, 183 lineColor: anomalyTraceRow.getLineColor(), 184 startNS: TraceRow.range?.startNS || 0, 185 endNS: TraceRow.range?.endNS || 0, 186 totalNS: TraceRow.range?.totalNS || 0, 187 slicesTime: TraceRow.range?.slicesTime, 188 range: TraceRow.range, 189 frame: anomalyTraceRow.frame, 190 }, anomalyTraceRow.must && anomalyTraceRow.args.isOffScreen ? anomalyTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 191 anomalyTraceRow.must = false; 192 if (anomalyTraceRow.args.isOffScreen == true) { 193 if (anomalyTraceRow.isHover) { 194 EnergyAnomalyStruct.hoverEnergyAnomalyStruct = hover; 195 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_ANOMALY_ENERGY && it.name !== anomalyTraceRow.name).forEach(it => it.draw(true)); 196 } 197 return; 198 } 199 } 200 ) 201 } 202 this.trace.rowsEL?.appendChild(anomalyTraceRow) 203 let durTime = new Date().getTime() - time; 204 info('The time to load the anomaly is: ', durTime) 205 } 206 207 private initSystem = async () => { 208 let time = new Date().getTime() 209 let systemTraceRow = new TraceRow<EnergySystemStruct>({ 210 canvasNumber: 1, 211 alpha: false, 212 contextId: '2d', 213 isOffScreen: SpSystemTrace.isCanvasOffScreen 214 }); 215 systemTraceRow.rowParentId = `energy` 216 systemTraceRow.rowHidden = true 217 systemTraceRow.rowId = "energy-system" 218 systemTraceRow.rowType = TraceRow.ROW_TYPE_SYSTEM_ENERGY 219 systemTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 220 systemTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 221 systemTraceRow.setAttribute("height", `80px`); 222 let element = systemTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement; 223 element!.style.height = `90px`; 224 systemTraceRow.style.width = `100%`; 225 systemTraceRow.setAttribute('children', ''); 226 systemTraceRow.name = "System"; 227 systemTraceRow.supplier = () => querySystemData().then(result => { 228 return this.getSystemData(result) 229 }) 230 systemTraceRow.onThreadHandler = (useCache) => { 231 procedurePool.submitWithName(`cpu1`, `energySystem`, { 232 list: systemTraceRow.must ? systemTraceRow.dataList : undefined, 233 offscreen: systemTraceRow.must ? systemTraceRow.offscreen[0] : undefined, 234 xs: TraceRow.range?.xs, 235 dpr: systemTraceRow.dpr, 236 isHover: systemTraceRow.isHover, 237 hoverX: systemTraceRow.hoverX, 238 hoverY: systemTraceRow.hoverY, 239 flagMoveInfo: this.trace.hoverFlag, 240 flagSelectedInfo: this.trace.selectFlag, 241 canvasWidth: systemTraceRow.canvasWidth, 242 canvasHeight: systemTraceRow.canvasHeight, 243 hoverEnergySystemStruct: EnergySystemStruct.hoverEnergySystemStruct, 244 selectEnergySystemStruct: EnergySystemStruct.selectEnergySystemStruct, 245 isRangeSelect: systemTraceRow.rangeSelect, 246 rangeSelectObject: TraceRow.rangeSelectObject, 247 useCache: useCache, 248 lineColor: systemTraceRow.getLineColor(), 249 startNS: TraceRow.range?.startNS || 0, 250 endNS: TraceRow.range?.endNS || 0, 251 totalNS: TraceRow.range?.totalNS || 0, 252 slicesTime: TraceRow.range?.slicesTime, 253 range: TraceRow.range, 254 frame: systemTraceRow.frame, 255 }, systemTraceRow.must && systemTraceRow.args.isOffScreen ? systemTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 256 systemTraceRow.must = false; 257 if (systemTraceRow.args.isOffScreen == true) { 258 if (systemTraceRow.isHover) { 259 EnergySystemStruct.hoverEnergySystemStruct = hover; 260 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_SYSTEM_ENERGY && it.name !== systemTraceRow.name).forEach(it => it.draw(true)); 261 } 262 return; 263 } 264 } 265 ) 266 } 267 this.trace.rowsEL?.appendChild(systemTraceRow) 268 let durTime = new Date().getTime() - time; 269 info('The time to load the Ability Memory is: ', durTime) 270 } 271 272 getSystemData(result: any): Promise<any> { 273 let systemDataList:any = new Array(); 274 let map = new Map(); 275 result.forEach((item: any) => { 276 if (item.eventName == "WORK_ADD") { 277 let systemData = this.getEnergySystemStruct(item.ts, 0); 278 map.set(item.eventName, systemData); 279 } 280 if (item.eventName == "WORK_STOP" || item.eventName == "WORK_REMOVE") { 281 let systemData = map.get("WORK_ADD"); 282 this.setEnergySystemStructDur(systemDataList, systemData, 0, item.ts); 283 if(item.eventName == "WORK_REMOVE"){ 284 map.delete("WORK_ADD") 285 } 286 } 287 if (item.eventName == "POWER_RUNNINGLOCK" && item.Value.endsWith("ADD")) { 288 let systemData = this.getEnergySystemStruct(item.ts, 1); 289 map.set(item.eventName, systemData); 290 } 291 if (item.eventName == "POWER_RUNNINGLOCK" && item.Value.endsWith("REMOVE")) { 292 let systemData = map.get("POWER_RUNNINGLOCK"); 293 this.setEnergySystemStructDur(systemDataList, systemData, 1, item.ts); 294 map.delete("POWER_RUNNINGLOCK"); 295 } 296 if (item.eventName == "GNSS_STATE" && item.Value.startsWith("start")) { 297 let systemData = this.getEnergySystemStruct(item.ts, 2); 298 map.set(item.eventName, systemData); 299 } 300 if (item.eventName == "GNSS_STATE" && item.Value.endsWith("stop")) { 301 let systemData = map.get("GNSS_STATE"); 302 this.setEnergySystemStructDur(systemDataList, systemData, 2, item.ts); 303 map.delete("GNSS_STATE"); 304 } 305 }) 306 if (map.size > 0) { 307 for (let item of map.values()) { 308 systemDataList.push(item); 309 } 310 map.clear(); 311 } 312 return systemDataList 313 } 314 315 private getEnergySystemStruct (startNs: number, type: number): EnergySystemStruct{ 316 let systemData = new EnergySystemStruct(); 317 systemData.startNs = startNs; 318 // @ts-ignore 319 systemData.dur = window.recordEndNS; 320 systemData.type = type; 321 return systemData; 322 } 323 324 private getEnergySystemStructDur (ts: number, type: number): EnergySystemStruct{ 325 let systemData = new EnergySystemStruct(); 326 systemData.startNs = 0; 327 systemData.dur = ts - 0; 328 systemData.type = type; 329 return systemData; 330 } 331 332 private setEnergySystemStructDur(systemDataList: any, systemData: EnergySystemStruct, type: number, ts: number){ 333 if (systemData) { 334 systemData.dur = ts - systemData.startNs!; 335 } else { 336 systemData = this.getEnergySystemStructDur(ts, type); 337 } 338 systemDataList.push(systemData); 339 } 340 341 private initPower = async () => { 342 let time = new Date().getTime(); 343 let powerTraceRow = new TraceRow<EnergyPowerStruct>({ 344 canvasNumber: 1, 345 alpha: true, 346 contextId: '2d', 347 isOffScreen: SpSystemTrace.isCanvasOffScreen 348 }); 349 powerTraceRow.rowParentId = `energy` 350 powerTraceRow.rowHidden = true 351 powerTraceRow.rowId = "energy-power" 352 powerTraceRow.rowType = TraceRow.ROW_TYPE_POWER_ENERGY 353 powerTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 354 powerTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 355 powerTraceRow.setAttribute("height", `200px`); 356 let element = powerTraceRow.shadowRoot?.querySelector(".root") as HTMLDivElement; 357 element!.style.height = `200px`; 358 powerTraceRow.style.width = `100%`; 359 powerTraceRow.setAttribute('children', ''); 360 powerTraceRow.name = "Power" 361 powerTraceRow.supplier = () => queryPowerData().then(items => { 362 return this.getPowerData(items) 363 }) 364 powerTraceRow.onThreadHandler = (useCache) => { 365 procedurePool.submitWithName(`cpu2`, `energyPower`, { 366 list: powerTraceRow.must ? powerTraceRow.dataList : undefined, 367 offscreen: powerTraceRow.must ? powerTraceRow.offscreen[0] : undefined, 368 xs: TraceRow.range?.xs, 369 dpr: powerTraceRow.dpr, 370 isHover: powerTraceRow.isHover, 371 hoverX: powerTraceRow.hoverX, 372 hoverY: powerTraceRow.hoverY, 373 flagMoveInfo: this.trace.hoverFlag, 374 flagSelectedInfo: this.trace.selectFlag, 375 canvasWidth: powerTraceRow.canvasWidth, 376 canvasHeight: powerTraceRow.canvasHeight, 377 hoverEnergyPowerStruct: EnergyPowerStruct.hoverEnergyPowerStruct, 378 selectEnergyPowerStruct: EnergyPowerStruct.selectEnergyPowerStruct, 379 isRangeSelect: powerTraceRow.rangeSelect, 380 rangeSelectObject: TraceRow.rangeSelectObject, 381 maxPowerName: SpHiSysEventChart.app_name, 382 useCache: useCache, 383 lineColor: powerTraceRow.getLineColor(), 384 startNS: TraceRow.range?.startNS || 0, 385 endNS: TraceRow.range?.endNS || 0, 386 totalNS: TraceRow.range?.totalNS || 0, 387 slicesTime: TraceRow.range?.slicesTime, 388 range: TraceRow.range, 389 frame: powerTraceRow.frame, 390 }, powerTraceRow.must && powerTraceRow.args.isOffScreen ? powerTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 391 powerTraceRow.must = false; 392 if (powerTraceRow.args.isOffScreen == true) { 393 if (powerTraceRow.isHover) { 394 EnergyPowerStruct.hoverEnergyPowerStruct = hover; 395 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_POWER_ENERGY && it.name !== powerTraceRow.name).forEach(it => it.draw(true)); 396 } 397 return; 398 } 399 } 400 ) 401 } 402 this.trace.rowsEL?.appendChild(powerTraceRow) 403 let durTime = new Date().getTime() - time; 404 info('The time to load the energy power is: ', durTime) 405 } 406 407 async getPowerData(items: any): Promise<any> { 408 let powerDataMap: any = {} 409 let appNameList: any = [] 410 items.forEach((item: any) => { 411 let dataItem = powerDataMap[item.startNS] 412 if (dataItem == undefined) { 413 if (item.appKey == "APPNAME") { 414 let appMap: any = {}; 415 let appNames = item.eventValue.split(",") 416 appNameList = appNames; 417 if (appNames.length > 0) { 418 for (let appNamesKey of appNames) { 419 appMap[appNamesKey] = new EnergyPowerStruct() 420 appMap[appNamesKey].name = appNamesKey 421 appMap[appNamesKey].ts = item.startNS 422 } 423 powerDataMap[item.startNS] = appMap; 424 } 425 } 426 } else { 427 if (item.appKey != "APPNAME") { 428 let values = item.eventValue.split(",") 429 for (let i = 0; i < values.length; i++) { 430 let appName = appNameList[i] 431 let obj = dataItem[appName] 432 if (obj != undefined) { 433 let eventName = item.eventName.split("_"); 434 let s = eventName[eventName.length - 1].toLocaleLowerCase(); 435 if (obj[s] == undefined) { 436 obj[s] = parseInt(values[i]) 437 } else { 438 obj[s] += parseInt(values[i]) 439 } 440 } 441 } 442 } else { 443 let dataMap = powerDataMap[item.startNS]; 444 let appNames = item.eventValue.split(",") 445 appNameList = appNames; 446 if (appNames.length > 0) { 447 for (let appNamesKey of appNames) { 448 dataMap[appNamesKey] = new EnergyPowerStruct() 449 dataMap[appNamesKey].name = appNamesKey 450 dataMap[appNamesKey].ts = item.startNS 451 } 452 } 453 } 454 } 455 }) 456 return Object.values(powerDataMap) 457 } 458 459 460 private initState = async () => { 461 let time = new Date().getTime(); 462 let stateList = ["Brightness nit", "Signal Level", "Wifi Event Received", "Audio Stream Change", 463 "Audio Volume Change", "Wifi State", "Bluetooth Br Switch State", "Location Switch State", "Sensor State"] 464 let stateName = ["BRIGHTNESS_NIT", "SIGNAL_LEVEL", "WIFI_EVENT_RECEIVED", "AUDIO_STREAM_CHANGE", 465 "AUDIO_VOLUME_CHANGE", "WIFI_STATE", "BLUETOOTH_BR_SWITCH_STATE", "LOCATION_SWITCH_STATE", "SENSOR_STATE"] 466 467 for (let index = 0; index < stateList.length; index++) { 468 let maxStateData = await queryMaxStateValue(stateName[index]) 469 if (!maxStateData[0]) { 470 continue; 471 } 472 let maxStateTotal = maxStateData[0].maxValue.toString() 473 if (maxStateData[0].type.toLocaleLowerCase().includes("state") || maxStateData[0].type.toLocaleLowerCase().includes("sensor")) { 474 if (maxStateData[0].maxValue == 0) { 475 maxStateTotal = "enable" 476 } else { 477 maxStateTotal = "disable" 478 } 479 } 480 let stateTraceRow = new TraceRow<EnergyStateStruct>({ 481 canvasNumber: 1, 482 alpha: false, 483 contextId: '2d', 484 isOffScreen: SpSystemTrace.isCanvasOffScreen 485 }); 486 stateTraceRow.rowParentId = `energy` 487 stateTraceRow.rowHidden = true 488 stateTraceRow.rowId = "energy-state" 489 stateTraceRow.rowType = TraceRow.ROW_TYPE_STATE_ENERGY 490 stateTraceRow.favoriteChangeHandler = this.trace.favoriteChangeHandler; 491 stateTraceRow.selectChangeHandler = this.trace.selectChangeHandler; 492 stateTraceRow.style.height = '40px' 493 stateTraceRow.style.width = `100%`; 494 stateTraceRow.setAttribute('children', ''); 495 stateTraceRow.name = `${stateList[index]}` 496 stateTraceRow.supplier = () => queryStateData(stateName[index]) 497 stateTraceRow.onThreadHandler = (useCache) => { 498 procedurePool.submitWithName(`cpu${stateList.length % (index + 1)}`, `energyState${index}`, { 499 list: stateTraceRow.must ? stateTraceRow.dataList : undefined, 500 offscreen: stateTraceRow.must ? stateTraceRow.offscreen[0] : undefined, 501 xs: TraceRow.range?.xs, 502 dpr: stateTraceRow.dpr, 503 isHover: stateTraceRow.isHover, 504 hoverX: stateTraceRow.hoverX, 505 hoverY: stateTraceRow.hoverY, 506 flagMoveInfo: this.trace.hoverFlag, 507 flagSelectedInfo: this.trace.selectFlag, 508 canvasWidth: stateTraceRow.canvasWidth, 509 canvasHeight: stateTraceRow.canvasHeight, 510 hoverEnergyStateStruct: EnergyStateStruct.hoverEnergyStateStruct, 511 selectEnergyStateStruct: EnergyStateStruct.selectEnergyStateStruct, 512 isRangeSelect: stateTraceRow.rangeSelect, 513 rangeSelectObject: TraceRow.rangeSelectObject, 514 maxState: maxStateData[0].maxValue, 515 maxStateName: maxStateTotal.toString(), 516 useCache: useCache, 517 lineColor: stateTraceRow.getLineColor(), 518 startNS: TraceRow.range?.startNS || 0, 519 endNS: TraceRow.range?.endNS || 0, 520 totalNS: TraceRow.range?.totalNS || 0, 521 slicesTime: TraceRow.range?.slicesTime, 522 range: TraceRow.range, 523 frame: stateTraceRow.frame, 524 }, stateTraceRow.must && stateTraceRow.args.isOffScreen ? stateTraceRow.offscreen[0] : undefined, (res: any, hover: any) => { 525 stateTraceRow.must = false; 526 if (stateTraceRow.args.isOffScreen == true) { 527 if (stateTraceRow.isHover) { 528 EnergyStateStruct.hoverEnergyStateStruct = hover; 529 this.trace.visibleRows.filter(it => it.rowType === TraceRow.ROW_TYPE_STATE_ENERGY && it.name !== stateTraceRow.name).forEach(it => it.draw(true)); 530 } 531 return; 532 } 533 } 534 ) 535 } 536 this.trace.rowsEL?.appendChild(stateTraceRow) 537 let durTime = new Date().getTime() - time; 538 info('The time to load the Ability Memory is: ', durTime) 539 } 540 } 541 542}