鸿蒙PC 打印扫描控制台性能优化实战:把六类无效重组压回 16.7 ms 帧预算 —— 兼谈 ArkUI 与跨平台框架在 2in1 桌面上的性能分工
鸿蒙PC 打印扫描控制台性能优化实战:把六类无效重组压回 16.7 ms 帧预算 —— 兼谈 ArkUI 与跨平台框架在 2in1 桌面上的性能分工
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言:打印与扫描这类「后台设备管理」界面,看起来最不像性能敏感型应用:没有视频、没有动画长列表、没有高频手势,只有几块状态卡和一批任务行。但把它放到鸿蒙PC 的 2in1 桌面形态上,成本结构就变了——窗口可以被用户随手拖成任意宽度,鼠标指针会在整排按钮上高速划过,应用一旦打开就常驻数小时,用户还会在「设备港 / 任务队列 / 扫描台 / 耗材维护」四个视图之间反复切换。任何一个在手机上「反正看不出来」的写法,在鸿蒙PC 上都会被放大成三类可见症状:拖窗口时整页闪烁、鼠标划过时按钮反复重绘、扫描进度条每走一格就把整页重建一次。本文拿一套真实的鸿蒙PC 打印扫描控制台工程当样本,用静态可复算的方式把「无效重组」拆成六类,再给出六项可直接落地的 ArkUI 改造;同时说明为什么在 2in1 桌面上,ArkUI 原生声明式开发范式与跨平台框架之间的分工必须划清楚——本文不写 ArkUI-X,也不使用任何跨平台框架运行时,工程是纯 ArkTS + ArkUI。文中所有截图来自鸿蒙PC 真机,所有性能数字都不冒充实测,可复测的口径会连同复现清单一起交给读者。
关键词:鸿蒙PC、鸿蒙 PC、开源鸿蒙PC、性能优化、帧预算、P95 帧耗时、无效重组、ArkUI、跨平台框架、2in1 桌面、LazyForEach、ForEach key、状态管理、命中测试、AtomGit。
一、先把事实边界说清楚:截图、工程、补充代码各是什么
写性能文章最容易踩的坑,是把界面上的数字当成自己的实测结论。本文的材料分三层,先钉死,后面所有论断才有意义。
第一层是问题样本——四张鸿蒙PC 真机完整桌面截图。 它们拍的是同一台鸿蒙PC 设备的完整桌面:底部有系统 Dock(文件、浏览器、邮件、应用市场、云空间等一整套系统图标),右上角有系统状态栏、电池、音量、输入法与「下午9:36 / 11月15日」时间,前台是一个米白色纸感风格的应用窗口。窗口标题栏里的最小化、最大化、关闭三个系统按钮清晰可见,说明它不是手机截图,也不是应用内裁剪图。四张图分别停在「任务队列」「设备港」「扫描台」「耗材维护」四个页签,是同一个应用的四次完整截图。
第二层是配套工程——项目源码/Permissa_ohos。 这是一个纯 ArkTS / ArkUI 声明式 UI、Stage 模型的 2in1 工程,应用名「拓印 PRINTFOLD」,包名 com.permissa.vaultconsole,deviceTypes 只保留 ['2in1'],SDK 版本 26.0.0,工程级与模块级依赖全为空。它没有调用任何打印机、扫描仪的系统 Kit,界面上的墨量、纸张、任务进度、耗材百分比全部来自 Models.ets 里的 seedDevices() / seedJobs() / seedScans() / seedSupplies() 四个种子函数。也就是说:截图回答「要优化什么形态的界面」,工程回答「代码落在哪里」,但界面上的 78%、34%、46% 这些数字都不是性能数据,而是演示数据。
第三层是本文的补充实现。 第五至第十一章给出的 6 个 .ets 片段是新增的、可独立编译的纯 ArkTS 代码,用来把「帧预算怎么算、派生值怎么缓存、列表怎么懒加载、图标节点怎么收敛、桌面事件怎么节流」变成可复算的实现。它们尚未合并进截图里那个工程;读者按第十三章的复现清单放进去、编译、安装到同一台鸿蒙PC 设备上,才能得到属于自己设备的数字。
三层材料互不冒充,是本文所有结论可信的前提。接下来凡是「实测」,都会明确标出是谁在什么条件下测的;凡是「静态可见」,都会给出文件与行号,读者可以自己数一遍。
二、四张鸿蒙PC 真机完整截图:先看界面,再谈性能

图 1 鸿蒙PC 真机完整桌面:「任务队列」页。顶部是品牌区与四个页签,右上角是设备数、队列数与「队列畅通」状态胶囊;主体左侧是 6 条打印任务行(时间、彩色 CMYK 四点徽标、双面标签、进度条、状态词、暂停/取消/上移三个操作),右侧是队列统计与队列规则卡;底部状态条写着「本地演示数据 · 不连接真实打印设备」
图 1 是本文的主战场。请注意三件事:第一,每一条任务行右侧最多挂着三个圆形按钮,每个按钮里又嵌着一个矢量图标;第二,行内进度条是「按百分比设宽度」的实时属性,不是静态装饰;第三,整个页面被包在 Scroll 里,桌面鼠标滚轮可以滚动它。这三件事叠加起来,决定了「一次状态更新」在鸿蒙PC 上到底要付多少代价——它不只是改一个数字,而是要重新构建一整棵视图描述,再重新测量、重新绘制。

图 2 鸿蒙PC 真机完整桌面:「设备港」页。左侧四张设备卡(青岚 M476 / 素纸 S200 / 风阅 F9 / 墨台 E30),每张卡包含状态点、墨量条、纸张条、连接详情与「上电/下电」「设为默认」两个按钮;右侧是端口速览、在线设备数、默认设备墨量与连接建议
图 2 暴露的是桌面形态特有的问题:右侧那张「端口速览」卡固定 320 vp 宽,左侧设备卡用 layoutWeight(1) 吃掉剩余宽度。当用户把窗口从 1400 vp 拖到 1000 vp 时,右侧栏不会变窄,而是左侧压缩——压缩到一定程度,设备名、连接详情、两个按钮就会挤在一起。这不是「好看不好看」的问题,而是每一次拖拽都会触发一次完整测量,如果不同时做断点收敛,拖拽过程中的重排次数会按事件频率线性增长。

图 3 鸿蒙PC 真机完整桌面:「扫描台」页。左侧是 196 vp 高的扫描预览台(内含一条随进度下行的扫描线)、四个扫描模式胶囊、开始扫描按钮;右侧是文稿库(3 份文稿,带已保存/未保存胶囊与删除按钮)与模式说明表
图 3 是全文最值得看的一页。点一次「开始扫描」,工程里的实现是 setTimeout 每 420 ms 写一次 scanProgress,共 5 次写满 100%。每一次写入都发生在 Index 这个状态中心里,而 Index 的 build() 里挂着四个视图的 if / else 分支、顶部导航、底部状态条——也就是说,一次扫描会让整页视图描述重建 5 次,只为让两根进度条各前进 20%。这就是本文要解决的第一类浪费。

图 4 鸿蒙PC 真机完整桌面:「耗材维护」页。左上是 CMYK 四色墨粉卡与 A4 纸盒、成像鼓卡,右下是维护台(最需要更换、喷头清洗、色彩校准)与省墨模式说明
图 4 里有一个典型细节:右侧维护台要显示「最需要更换」的耗材名与颜色,而它是通过 lowest() 这个遍历函数算出来的。代码里这个函数在一次 build() 中被调用了 4 次(判断非空 2 次、取名字 1 次、判断阈值 1 次),每次都是 O(n) 遍历。演示数据只有 6 项,看不出问题;但这类「派生值在 build 里反复求值」的写法,一旦列表涨到几百项,就会变成每帧几十次无效遍历。
三、为什么「设备管理台」在鸿蒙PC 上也算性能问题
把性能问题归到设备管理界面,需要一条讲得通的因果链,而不是一句「优化总是好的」。在鸿蒙PC 的 2in1 桌面形态上,这条链至少经过四站。
第一站是视图描述重建。 ArkUI 是声明式 UI:状态变化后,框架重新执行 build() 生成新的视图描述,再与旧树做差分,只把差异提交给渲染管线。差分的成本取决于「树的规模」和「差异的粒度」。本文工程的所有状态都放在 Index 一个 struct 里,17 个 @State 中的任何一个变化,都会让 Index.build() 完整执行一次;四个视图又是 if / else 互斥分支,所以「当前视图有多大」直接等于「一次状态更新的描述成本」。打印扫描台的界面元素密度很高(一条任务行就有 20 个左右的节点),一次重建不是免费的。
第二站是测量与布局。 桌面窗口宽度可变,layoutWeight(1) 的列宽度依赖容器宽度,右侧固定宽度的卡片又会反过来压缩左侧。任何一次宽度变化都可能引发级联测量;而 Scroll 里的内容一旦高度变化(例如扫描完成往文稿库插一条),滚动容器的内容尺寸也要重算。桌面和手机的区别在于:手机上一屏基本固定,鸿蒙PC 上用户会主动、连续、高频地改变它。
第三站是绘制节点的数量。 本文工程的图标不是位图,而是用 Path 组件画的矢量图标:一个图标展开成 1~6 个 Path 子节点,每个 Path 都带 scale 变换与描边样式。按图 1 的种子数据静态展开,一屏「任务队列」页共有 30 个图标实例、85 个 Path 子节点(顶栏 9 个图标 24 个节点、队列主体 20 个图标 58 个节点、底栏 1 个图标 3 个节点)。桌面 DPI 高、窗口大、绘制面积大,节点数与描边宽度的组合直接决定 GPU 侧的栅格化压力。
第四站是事件与常驻。 鸿蒙PC 上有两件手机没有的事:一是鼠标 hover,指针会以每秒上百次的频率在按钮之间移动;二是窗口拖拽,onAreaChange 的回调频率跟随鼠标事件。两者都是「高频、小信息量」的输入,天然容易触发过量状态写入。再加上桌面应用常驻数小时、窗口可同时开多个,任何「每帧都多做一点」的习惯都会累积成用户能察觉的迟滞。
这条链条给出一个很重要的优化顺序:先把「一次重建的粒度」做小(派生值缓存、key 稳定、状态下沉),再把「重建的次数」做少(懒加载、事件节流),最后才是「节点本身更轻」(图标资源化)。 反过来先抠图标,收益会被重建掩盖掉。
四、工程基线盘点:把目标态钉死在文件里
在动手之前,先把配套工程的真实配置核一遍。下表的每一项都能在源码里查到,不是估计值。
| 项 | 实际值 | 证据 |
|---|---|---|
| 应用 / 包名 | 「拓印 PRINTFOLD」 / com.permissa.vaultconsole | AppScope/app.json5 |
| 版本 | versionCode 1000000、versionName 1.0.0 | AppScope/app.json5 |
| 设备形态 | 仅 ['2in1'],无 phone / tablet | entry/src/main/module.json5 |
| SDK | compatibleSdkVersion / targetSdkVersion 均 26.0.0,runtimeOS: HarmonyOS | build-profile.json5 |
| 构建模型 | hvigor + ohpm,Stage 模型,strictMode.useNormalizedOHMUrl: true | build-profile.json5 |
| 三方依赖 | 工程级、模块级、hvigor 三处 dependencies 全为空 | oh-package.json5、hvigor/hvigor-config.json5 |
| 页面入口 | windowStage.loadContent('pages/Index'),单页应用 | entryability/EntryAbility.ets |
| 源码规模 | 18 个手写 .ets,其中 11 个被引用、7 个未被任何文件 import | entry/src/main/ets/ |
| 主页面 | Index.ets 299 行,17 个 @State,四个视图用 if / else 切换 | pages/Index.ets:17-33 |
| 图标体系 | PressIcon 38 个具名分支 + 1 个 default,全部用 Path 绘制 | components/PressIcon.ets:8-89 |
| 桌面适配 | 各视图侧栏固定宽 300 / 320 / 330 vp,无窗口宽度断点 | QueueView.ets:216、DevicesView.ets:227、ScanView.ets:216 |
这张表说明两件事。其一,这是一个零三方依赖的鸿蒙PC 原生 2in1 工程,进程起来后直接加载单页,没有框架运行时抢主线程,所以测到的耗时更容易归因到业务代码;代价是所有采样、统计、导出都得自己写。其二,桌面形态适配只做了一半:宽度用的是固定值,没有跟随窗口;hover 只做了按钮级着色,没有做事件合并。
接下来必须坦白它的另一面。这个工程目前是一个交互原型,界面上的性能观感来自三处,没有一处是采集来的:
Models.ets:120-157:四台设备的墨量/纸张、六条任务的页数/份数、六项耗材的百分比,都是写死的常量;QueueView.ets:25-36:任务进度不是真实打印进度,而是按状态映射的常量(打印中 46%、已暂停 28%、排队中 6%、已完成 100%);Index.ets:39-55:扫描进度用setTimeout每 420 ms 递增 20%,与任何真实设备无关。
这不是要批评工程,恰恰相反:一个界面数据全是演示值的原型,正是讲性能的好样本——因为它把「性能问题」和「业务复杂度」彻底分开了。你看到的每一次卡顿嫌疑,都只可能来自 UI 写法本身。
五、把「快不快」变成可复算的帧预算
性能优化如果不先定义判据,最后一定会变成玄学。鸿蒙PC 常见屏幕刷新率是 60 Hz,一帧 16.7 ms;高刷屏会到 90 / 120 Hz,帧预算相应缩到 11.1 / 8.3 ms。工程里没有做任何帧采样,所以第一步不是改代码,而是装一个「量表」。
采集侧用系统提供的 displaySync 帧回调:每来一次垂直同步,就回调一次并带一个纳秒级时间戳。把相邻时间戳相减,就是这一帧的实际间隔;间隔超过预算,就是一次掉帧(jank)。
import { displaySync } from '@kit.ArkGraphics2D';
@Entry
@Component
struct Index {
// 帧探针:256 帧环形缓冲,预算按 60 Hz 的 16.7 ms
private probe: PerfProbe = new PerfProbe(256, 16.7);
private sync: displaySync.DisplaySync | undefined = undefined;
aboutToAppear(): void {
this.startProbe();
}
aboutToDisappear(): void {
if (this.sync !== undefined) {
this.sync.stop();
this.sync = undefined;
}
}
private startProbe(): void {
try {
const sync: displaySync.DisplaySync = displaySync.create();
sync.setExpectedFrameRateRange({ expected: 60, min: 30, max: 120 });
sync.on('frame', (info: displaySync.IntervalInfo) => {
// 回调里只做数组写入,绝不写 @State,否则观测本身就会制造掉帧
this.probe.feed(info.timestamp);
});
sync.start();
this.sync = sync;
} catch (err) {
console.warn('displaySync unavailable on this device');
this.sync = undefined;
}
}
}
聚合侧是纯计算类,不依赖任何 UI,可以单独拷进任意工程:
// entry/src/main/ets/common/PerfProbe.ets
export interface FrameReport {
frames: number;
p50: number;
p95: number;
worst: number;
jank: number;
jankRate: number;
budgetMs: number;
}
export class PerfProbe {
private static readonly NS_PER_MS: number = 1e6;
private ring: number[];
private cursor: number = 0;
private filled: number = 0;
private lastNs: number = 0;
private budgetMs: number;
constructor(capacity: number = 256, budgetMs: number = 16.7) {
this.ring = new Array<number>(capacity).fill(0);
this.budgetMs = budgetMs;
}
feed(timestampNs: number): void {
if (this.lastNs > 0) {
const gap: number = (timestampNs - this.lastNs) / PerfProbe.NS_PER_MS;
this.ring[this.cursor] = gap;
this.cursor = (this.cursor + 1) % this.ring.length;
if (this.filled < this.ring.length) {
this.filled += 1;
}
}
this.lastNs = timestampNs;
}
report(): FrameReport {
const n: number = this.filled;
if (n === 0) {
return { frames: 0, p50: 0, p95: 0, worst: 0, jank: 0, jankRate: 0, budgetMs: this.budgetMs };
}
const sorted: number[] = this.ring.slice(0, n);
sorted.sort((a: number, b: number) => a - b);
let jank: number = 0;
for (let i = 0; i < n; i++) {
if (sorted[i] > this.budgetMs) {
jank += 1;
}
}
return {
frames: n,
p50: sorted[Math.floor((n - 1) * 0.5)],
p95: sorted[Math.floor((n - 1) * 0.95)],
worst: sorted[n - 1],
jank: jank,
jankRate: jank / n,
budgetMs: this.budgetMs
};
}
reset(): void {
this.cursor = 0;
this.filled = 0;
this.lastNs = 0;
}
}
这段代码有两个刻意的设计,值得单独说:其一,回调里不写状态。 帧回调在每帧都会触发,一旦在里面写 @State,就等于让观测器自己成为主要的 UI 负载源;正确做法是把数字塞进普通数组,用户点「取一次报告」或一个低频定时器再读出来。其二,单位是纳秒。 IntervalInfo.timestamp 是纳秒,忘记除以 1e6 会得到 16 700 000 这种荒谬的「毫秒」值,这个坑我在前一个工程里踩过一次。
判据统一成三件套:P50(中位帧间隔,代表常态)、P95(尾部,代表用户能感知的卡顿风险)、jankRate(超过预算的帧占比)。只报一个平均 FPS 是没有意义的——均值会被大量「刚好及格」的帧拉平,恰好在鸿蒙PC 上,用户感知最强烈的就是那几次 30 ms 以上的跳变。
六、六类无效重组:从「感觉卡」到「能指出行号」
有了量表,接下来做的是归因。归因最有趣的地方在于:很多浪费不需要跑起来就能看见,静态读代码就能数出来。下图是本文的归因总表,六类浪费一一对应一项改造,全部能在源码里指到行。

图 5 归因示意(自绘):左列是静态代码就能看出的六类浪费,中列是可复算的证据,右列是对应改造。本图不含任何真机测量数值
第 1 类:派生值在 build 里反复求值。 QueueView.build() 里 visibleJobs() 出现 3 次(QueueView.ets:168,169,173),每次都会 filter 出一个新数组;队列统计的 4 个 StatRead 各自 filter 一次(QueueView.ets:188-191)。SuppliesView 更直接:lowest() 在 SuppliesView.ets:138-139 两行里被调了 4 次,每次 O(n) 遍历。演示数据小,看不出来;数据结构一涨,这就是「每次重建都白跑几十次循环」。
第 2 类:状态中心过大。 Index 一个 struct 里放了 17 个 @State(Index.ets:17-33),扫描进度、toast 文案、帮助面板开关全在一层。任何一个变化都让 Index.build() 完整跑一遍。扫描时 420 ms 一次、连写 5 次,等于 2.1 秒内整页重建 5 次。
第 3 类:ForEach 的 key 带状态。 QueueView.ets:175 的 key 是 job.id.toString() + job.state。看起来「更精确」,实际效果是:一暂停、一恢复,key 就变了,框架认为这是两个不同的节点,于是销毁旧行、重建新行。整行 20 多个节点、4 个图标全部重来一遍,只为了一个字符串变化。
第 4 类:列表没有懒加载。 四个视图都是 Scroll + Column + ForEach,一次性构建全部子节点。演示 6 条任务时无所谓,一旦接上真实打印队列(企业环境里几十到几百条很常见),首屏就要为屏幕外的行付出布局与绘制成本。
第 5 类:图标节点膨胀。 PressIcon 用 switch 返回路径数组,build() 里再 ForEach 出 Path。两个问题:一是每次 build 都新造一个数组,ForEach 拿到的永远是「新引用」;二是路径表缺项会静默落到 default——工程里 layers(任务队列页签、队列计数)和 filter(只看进行中按钮)都不在 switch 的分支里,实际渲染出来的是 default 那个盾牌轮廓。这是「性能问题顺手带出一个 UI bug」的典型例子。
第 6 类:桌面高频事件没有收敛。 窗口拖拽会连续触发 onAreaChange,而工程里没有断点判断,每来一次就重排一次;每个 PressBtn 自带 @State hovered(PressControls.ets:15),一整排 4 个按钮就是 4 个独立状态点,鼠标扫过去就是 4 次状态写入。
这六类浪费有一个共同点:它们都不会让应用崩溃,只会让每一次交互贵一点点。 而鸿蒙PC 用户的交互密度恰恰最高,于是「一点点」累积成可感知的迟滞。
七、改造一:把派生值收进带修订戳的快照
第一个改造最小、最安全,也最容易见效:给派生值加一层「修订戳缓存」。思路很简单——如果这一帧的输入(任务列表 + 过滤开关)和上一帧完全一样,就没必要再遍历一遍。
// entry/src/main/ets/common/QueueDerive.ets
import { JOB_DONE, JOB_PAUSED, JOB_PRINTING, JOB_WAITING, PrintJob } from './Models';
export interface QueueSnapshot {
printing: number;
waiting: number;
paused: number;
done: number;
visible: PrintJob[];
}
export class QueueDerive {
private stamp: string = '';
private cached: QueueSnapshot = { printing: 0, waiting: 0, paused: 0, done: 0, visible: [] };
// 用「id + 状态」拼出轻量修订戳,只有它变了才重算
private stampOf(jobs: PrintJob[], activeOnly: boolean): string {
let s: string = activeOnly ? 'A' : 'B';
for (let i = 0; i < jobs.length; i++) {
s += '|' + jobs[i].id.toString() + ':' + jobs[i].state;
}
return s;
}
snapshot(jobs: PrintJob[], activeOnly: boolean): QueueSnapshot {
const stamp: string = this.stampOf(jobs, activeOnly);
if (stamp === this.stamp) {
return this.cached;
}
let printing: number = 0;
let waiting: number = 0;
let paused: number = 0;
let done: number = 0;
const visible: PrintJob[] = [];
for (let i = 0; i < jobs.length; i++) {
const job: PrintJob = jobs[i];
if (job.state === JOB_PRINTING) {
printing += 1;
}
if (job.state === JOB_WAITING) {
waiting += 1;
}
if (job.state === JOB_PAUSED) {
paused += 1;
}
if (job.state === JOB_DONE) {
done += 1;
}
if (!activeOnly || job.state !== JOB_DONE) {
visible.push(job);
}
}
this.stamp = stamp;
this.cached = { printing: printing, waiting: waiting, paused: paused, done: done, visible: visible };
return this.cached;
}
}
在视图里只需要把 this.derive 挂成成员,然后把原来 7 处遍历都换成 this.derive.snapshot(this.jobs, this.showActiveOnly):
@Component
export struct QueueView {
@Prop jobs: PrintJob[] = [];
@Prop showActiveOnly: boolean = false;
private derive: QueueDerive = new QueueDerive();
build() {
Scroll() {
Column({ space: 18 }) {
// 一次 build 内后续所有调用都命中缓存,返回同一个对象引用
SectionHead({
index: '01',
title: '打印队列',
hint: this.derive.snapshot(this.jobs, this.showActiveOnly).visible.length.toString() + ' 个任务'
})
// ……其余统计、ForEach 数据源同样走 snapshot()
}
}
}
}
这里必须说清它的能力边界,否则就成了另一种玄学:修订戳本身还是 O(n) 的字符串拼接,它省掉的是「同一帧内重复遍历」和「数组重复分配」,而不是「跨帧重算」。更彻底的做法是把统计做成状态机——在暂停、取消、上移、清理已完成这几个变更点顺手增减计数器,build() 里只读字段。代价是每个变更点都要维护一致性,写错就是数据不同步。先用修订戳把成本和正确性同时拿住,等列表真的上千条再上状态机,这是推荐的落地顺序。
八、改造二:key 只留 id,列表交给 LazyForEach
第二个改造针对第 3、4 类浪费。先把 ForEach 的 key 改成只依赖 id:
// 改造前:状态一变,key 就变,节点被销毁重建
ForEach(this.visibleJobs(), (job: PrintJob, index: number) => {
this.jobRow(job, index)
}, (job: PrintJob) => job.id.toString() + job.state)
// 改造后:key 只认身份,状态变化另行通知
ForEach(this.visibleJobs(), (job: PrintJob, index: number) => {
this.jobRow(job, index)
}, (job: PrintJob) => job.id.toString())
收益和风险都要讲:收益是「暂停/恢复不再重建整行」;风险是「key 里没有状态,如果组件又没声明依赖,界面可能不刷新」。在本例中 jobRow(job, index) 的参数是同一个 PrintJob 引用,父级 @Prop jobs 整体替换后引用变了,行内读到的是新对象,所以能正确刷新。但如果改成「原地改 job.state」的写法,就必须配合 @Observed / @ObjectLink,否则框架看不见这层变化。key 稳定性和状态可见性是一枚硬币的两面,必须一起设计。
再往前走一步,把列表换成懒加载:
// entry/src/main/ets/common/JobDataSource.ets
import { PrintJob } from './Models';
export class JobDataSource implements IDataSource {
private jobs: PrintJob[] = [];
private listeners: DataChangeListener[] = [];
totalCount(): number {
return this.jobs.length;
}
getData(index: number): PrintJob {
return this.jobs[index];
}
registerDataChangeListener(listener: DataChangeListener): void {
if (this.listeners.indexOf(listener) < 0) {
this.listeners.push(listener);
}
}
unregisterDataChangeListener(listener: DataChangeListener): void {
const pos: number = this.listeners.indexOf(listener);
if (pos >= 0) {
this.listeners.splice(pos, 1);
}
}
reload(next: PrintJob[]): void {
this.jobs = next;
for (let i = 0; i < this.listeners.length; i++) {
this.listeners[i].onDataReloaded();
}
}
// 只通知某一行刷新,不重建整个列表
patchState(index: number, state: string): void {
this.jobs[index].state = state;
for (let i = 0; i < this.listeners.length; i++) {
this.listeners[i].onDataChange(index);
}
}
}
private source: JobDataSource = new JobDataSource();
List() {
LazyForEach(this.source, (job: PrintJob, index: number) => {
ListItem() {
this.jobRow(job, index)
}
}, (job: PrintJob) => job.id.toString())
}
.cachedCount(6) // 视口外缓存 6 行,滚动时复用
.divider({ strokeWidth: 1, color: PressColors.line })
.width('100%')
cachedCount 的选择是桌面形态的调优点:鸿蒙PC 窗口高、可见行多,缓存太少会在滚动时反复创建销毁,缓存太多又让「屏外节点」重新变成成本。经验值是「可见行数 × 0.5~1」,本例视口约 10 行,取 6 是个保守起点。另外要注意,List 自带滚动容器,原来套在外面的 Scroll 必须去掉,否则会出现「列表里再套滚动」的双层手感问题——这是从 Scroll + Column + ForEach 迁移到 List + LazyForEach 时最常见的翻车点。
九、改造三:图标路径表化,外加一个小 bug 修复
第三个改造针对第 5 类浪费。把 switch 换成模块级常量表,收益有三层:不再每次 build 新造数组、ForEach 拿到的永远是同一个引用、缺失的图标名可以被显式发现。
// entry/src/main/ets/common/IconPaths.ets
const TABLE: Map<string, string[]> = new Map<string, string[]>();
TABLE.set('printer', ['M6 4 H18 V8 H6 Z', 'M4 8 H20 V16 H17 V20 H7 V16 H4 Z', 'M8 12 H16']);
TABLE.set('layers', ['M12 3 L20 8 L12 13 L4 8 Z', 'M4 12 L12 16.5 L20 12']);
TABLE.set('scan', ['M4 8 V4 H8', 'M20 8 V4 H16', 'M4 16 V20 H8', 'M20 16 V20 H16', 'M3 12 H21', 'M6 8 H18']);
TABLE.set('ink', ['M12 3 C16 8 18 11 18 14 A6 6 0 0 1 6 14 C6 11 8 8 12 3 Z', 'M9.5 15 A2.5 2.5 0 0 0 14 15']);
TABLE.set('paper', ['M5 3 H16 L20 7 V21 H5 Z', 'M16 3 V7 H20', 'M8 11 L10 13 L14 9']);
TABLE.set('filter', ['M4 6 H20', 'M7 12 H17', 'M10 18 H14']);
const FALLBACK: string[] = ['M12 3 L20 6 V12 C20 17 16.5 20 12 21.5 C7.5 20 4 17 4 12 V6 Z'];
export function iconPaths(name: string): string[] {
const hit: string[] | undefined = TABLE.get(name);
return hit === undefined ? FALLBACK : hit;
}
import { iconPaths } from '../common/IconPaths';
@Component
export struct PressIcon {
@Prop name: string = 'shield';
@Prop iconColor: string = '#8295A1';
@Prop iconSize: number = 18;
@Prop stroke: number = 1.6;
build() {
Stack() {
ForEach(iconPaths(this.name), (command: string) => {
Path()
.commands(command)
.width(24)
.height(24)
.scale({ x: this.iconSize / 24, y: this.iconSize / 24 })
.fill(Color.Transparent)
.stroke(this.iconColor)
.strokeWidth(this.stroke)
.strokeLineCap(LineCapStyle.Round)
.strokeLineJoin(LineJoinStyle.Round)
}, (command: string) => command)
}
.width(this.iconSize)
.height(this.iconSize)
.hitTestBehavior(HitTestMode.None) // 图标本身不可点,退出命中测试
}
}
最后那行 hitTestBehavior(HitTestMode.None) 是桌面形态的专属优化:鸿蒙PC 上指针事件远比触摸密集,每个图标都参与命中测试,意味着每次鼠标移动都要多走几个节点。图标本身不带 onClick(点击都挂在父级 PressBtn 上),把它从命中测试里摘出去是纯收益。
但请务必注意:表化只解决了「数组分配」和「缺项静默失败」,没有减少节点数量,一屏 85 个 Path 还是 85 个。要把节点数真正压下来得换绘制方式:把这批 24×24 的图形导出成 .svg 放进 media/,用 Image($r('app.media.icon_printer')) 渲染,一个图标就是一个节点,且解码结果会按目标尺寸缓存。代价是失去 strokeWidth 随主题变化的灵活性——典型的「性能换灵活」,我在工程里会保留矢量版给强调态、位图版给列表行。
十、改造四:把扫描进度从状态中心里请出去
第四个改造针对第 2 类浪费,也是本文唯一一个「改结构」的改造。原来扫描进度住在 Index 里,ScanView 通过 @Prop progress 单向接收,于是每 420 ms 一次写入都会让 Index.build() 与 ScanView.build() 各跑一遍,而真正需要变化的只有两根进度条。改成:进度只在扫描台内部存在,整场扫描完成时向父级回调一次。
@Component
export struct ScanView {
@Prop docs: ScanDoc[] = [];
@Prop mode: string = '彩色 · 300 dpi';
@State private scanning: boolean = false;
@State private progress: number = 0;
onModeChange: (mode: string) => void = () => {};
onFinishScan: (mode: string) => void = () => {};
private step(): void {
if (!this.scanning) {
return;
}
if (this.progress >= 100) {
this.scanning = false;
this.onFinishScan(this.mode); // 整场扫描只向父级回调一次
return;
}
// 每一档用 400 ms 属性动画补间,进度条与扫描线连续推进
animateTo({ duration: 400, curve: Curve.Linear }, () => {
this.progress = Math.min(100, this.progress + 20);
});
setTimeout(() => this.step(), 420);
}
private toggleScan(): void {
if (this.scanning) {
this.scanning = false; // 中途停止,不再排下一档
return;
}
this.progress = 0;
this.scanning = true;
this.step();
}
}
这一改有三层收益。第一层是重建范围:状态从「整页中心」下沉到「扫描卡片」,一次写入只让卡片子树重算,顶栏、侧栏、底栏都不再参与。第二层是写入次数:原来是 5 次进度写入 + 1 次完成写入,现在仍是 5 档,但只有最后那次回调会碰到父级状态。第三层是观感:animateTo 让进度条与扫描线在 400 ms 内插值,动画由渲染管线按 vsync 驱动,不再出现「每 420 ms 跳一格」的台阶感。
如果还想把写入次数压到 1 次,可以把整场动画一次性交给框架:animateTo({ duration: 2100, curve: Curve.Linear, onFinish: () => this.onFinishScan(this.mode) }, () => { this.progress = 100; })。代价是百分比文本会从 0% 直接跳到 100%(文本内容不是可插值属性),除非再叠一个 @AnimatableExtend 或自绘。这就是性能与信息密度之间的取舍:我更倾向保留 5 档离散文本 + 连续动画,因为打印扫描台的用户确实会盯那个百分比。
十一、改造五:让桌面窗口和鼠标事件有「档位」
第五个改造针对第 6 类浪费,也是鸿蒙PC 与手机差异最大的地方。窗口宽度依赖不能直接用「像素级」值,而要收敛成档位:
@State private railWidth: number = 320;
private appliedRail: number = 320;
private applyWindowWidth(width: number): void {
const next: number = width >= 1180 ? 320 : (width >= 980 ? 260 : 0);
if (next === this.appliedRail) {
return; // 档位没变就什么都不做
}
this.appliedRail = next;
this.railWidth = next;
}
Column() {
Row({ space: 12 }) {
Column() { /* 主列:设备列表 / 任务列表 */ }.layoutWeight(1)
if (this.railWidth > 0) {
Column() { /* 侧栏:端口速览 / 统计 */ }.width(this.railWidth)
}
}
}
.onAreaChange((_old: Area, now: Area) => {
// 鸿蒙PC 拖拽窗口时回调频率跟随指针事件,必须先在方法内做档位判断
this.applyWindowWidth(Number(now.width));
})
if (this.railWidth > 0) 这一句还有个附带收益:窄窗口下侧栏整棵子树不进入组件树,既省布局也省绘制;而 railWidth 从 320 切到 260 时,只有一处宽度变化,不会牵动主列宽度重算两次。
鼠标 hover 的处理同理。改造前每个 PressBtn 各自持有 @State hovered,一行 4 个按钮就是 4 个状态点;改造后把 hover 收敛到「行」这一级:
// 行组件持有唯一 hover 状态
@State private hoverId: string = '';
Row() {
ForEach(['pause', 'close', 'move'], (action: string) => {
PressBtn({
icon: action,
btnSize: 34,
iconSize: 13,
active: this.hoverId === action, // 子组件只读,不写状态
action: () => this.onRowAction(action)
})
}, (action: string) => action)
}
.onHover((isHover: boolean) => {
this.hoverId = isHover ? 'row' : ''; // 进出整行各写一次,行内移动不再写
})
这样做的收益在鸿蒙PC 上比在手机上明显得多:指针在同一行内从按钮 A 移到按钮 B,onHover 不会重新触发,状态写入次数从「跨按钮次数」降到「跨行次数」。反过来说,如果确实需要按钮级的高亮反馈,就必须接受这部分写入——那就把按钮做小、把行做宽,用布局来减少「跨节点」的次数。
十二、A/B 验收:把对照实验写进流程
六项改造逐条落地之后,必须有办法判断「到底哪一项有用」。我的做法是固定一个可重复的操作序列,逐项开关对照:
| 改造项 | 观测指标 | 期望方向 | 复测条件 |
|---|---|---|---|
| 派生值快照缓存 | P50 帧间隔 | 持平或略降(省遍历,不减节点) | 同一窗口,反复切换「只看进行中」20 次 |
| key 去掉状态 + 局部刷新 | P95、单帧最大值 | 明显下降(不再整行重建) | 对同一条打印中任务连点暂停/继续 20 次 |
List + LazyForEach | 首帧耗时、滚动 P95 | 任务数 ≥ 200 时显著下降 | 注入 200 条任务,恒速滚轮滚动 10 秒 |
| 图标表化 + 关命中测试 | 指针移动 P95 | 小幅下降(少节点、少命中遍历) | 鼠标在任务行按钮区往返滑动 30 次 |
| 进度状态下沉 + 动画 | 扫描期间 jankRate | 明显下降 | 连点「开始扫描」5 轮,每轮 2.1 秒 |
| 窗口断点节流 | 拖拽期间最大帧间隔 | 明显下降 | 从 1400 vp 拖到 960 vp 再拖回,重复 10 次 |
表格里刻意不填数字。原因很直接:没有一个数字是本文测出来的,填上去就是编造。读者按这张表跑完,得到的才是自己设备的结论。需要强调的是,判据必须三件套一起看——只盯 P50 会漏掉卡顿,只盯 jankRate 会在低负载场景下得到「0 掉帧」的假安心,因为窗口期的帧数太少。
十三、复现清单与踩坑记录
想把上面的结论复现出来,按这个顺序做,成本最低:
- 用 DevEco Studio 打开
项目源码/Permissa_ohos,确认deviceTypes只有2in1、SDK 为26.0.0,签名后用hdc install装到鸿蒙PC 设备上,直接看到图 1~图 4 的界面; - 把第五章的
PerfProbe.ets与displaySync接线加进Index,先不加任何改造,跑一轮基线,记录 P50 / P95 / jankRate; - 按第七至第十一章逐项改造,每改一项就重跑同一操作序列,把三件套抄进表格;
- 最后再做一次「全开」,对比「全关」与「全开」的差值,差值才是这套改造的真实价值。
过程中有几个坑,我按踩到的顺序列出来:
displaySync的timestamp单位是纳秒。 直接当毫秒用会得到 1600 万级的数字,然后你会以为自己发现了史上最慢的 UI。- 帧回调里绝对不能写
@State。 观测器一旦成为负载源,后面所有数据都是自证的。 ForEach的 key 里塞状态等于主动触发销毁重建。 这不是「更精确」,是「更贵」。onAreaChange是逐事件回调,不是逐档位回调。 不做档位比较,拖窗口就会变成连续重排。PressIcon的路径表缺项会静默落到default。 工程里layers和filter就踩了这条;表化后建议在 debug 构建里对未命中项打一条console.warn,别让 UI bug 藏在性能优化里。Scroll套List会得到双重滚动。 迁移懒加载时先把外层Scroll摘掉,否则你会以为是LazyForEach有 bug。- 工程里还有 7 个未被任何文件 import 的
.ets(VaultView、VaultIcon、VaultControls、VaultTopRail、RadarView、MatrixView、SwitchesView)。不可达模块不会进运行时,但它们会拖慢构建扫描与代码评审,删之前先全局搜一遍引用,别把pages/Index的依赖误伤。 - 演示数据必须标明来源。 打印扫描类界面最容易让人误读:墨量 78%、进度 46% 看起来像真实读数,其实全是常量。写性能文章时,把这条写进截图说明,比事后解释有用得多。
十四、回到选型:ArkUI 与跨平台框架在 2in1 桌面上的分工
聊到这里,可以回答一个经常被问到的问题:这套东西为什么不干脆用跨平台框架写一份,顺带兼容别的桌面?
先把概念说准。本文工程的 UI 是 ArkUI,也就是鸿蒙原生的声明式 UI 框架,用 ArkTS 写 .ets,走 Stage 模型与 @State / @Prop / @Link 这一套状态管理,运行在系统的渲染管线之上。ArkUI-X 是另一套东西——是把 ArkUI 的开发能力延伸到其他平台上的跨平台框架;本文没有使用 ArkUI-X,也没有引入 Flutter、Compose Multiplatform、React Native 之类的跨平台框架运行时。这个区分必须写清楚,因为把 ArkUI 说成 ArkUI-X 是这类文章最常见的表述错误。
那么跨平台框架在这个场景里能做什么、不能做什么?
能做的部分是业务与状态层。 打印任务的状态机、耗材阈值的计算、队列排序与去重、与后端或设备的协议适配,这些逻辑与平台无关,用跨平台框架抽一层共享代码是合理的,也确实省人力。
不容易做的部分恰好是本文全部的性能战场。 第一,2in1 桌面的窗口语义:应用要跟着窗口宽度自适应、要有最小宽度策略、要响应最大化/还原,这些能力长在系统窗口与原生布局体系里,跨平台框架通常需要一层桥接,桥接越厚,测量与布局的可控性越差。第二,指针语义:鼠标 hover、右键菜单、滚轮惯性,跨平台框架一般要自己模拟或映射,onHover 这类「进出节点才触发」的语义未必能原样保留,而本文第十一章的优化正建立在这个语义上。第三,帧预算的归因:使用跨平台框架时,一次掉帧可能来自共享层逻辑、桥接层序列化、原生渲染多个环节,定位成本会显著上升;而纯 ArkUI 工程里,build() 与节点树就是唯一嫌疑人,本文第六章那种「指到行号」的归因才有可能。
所以我的建议是一个分层而不是二选一的判断:设备管理台这类「窗口形态强、交互密度高、常驻时间长」的鸿蒙PC 应用,界面层用 ArkUI 原生写,把性能预算花在能看见的地方;真正跨端复用的部分(协议、状态机、数据模型)抽成与 UI 无关的纯逻辑模块。这样既拿到 ArkUI 在 2in1 上的窗口与事件能力,也不放弃跨平台框架擅长的代码复用。本文的 PerfProbe 和 QueueDerive 都是零 UI 依赖的纯计算类,就是按这个思路写的——它们可以原样搬进任何框架的共享层。
顺带说一句工程习惯:这套示例工程的源码与后续改造都放在 AtomGit 上维护,仓库名与提交记录能对应到文章的每个章节,方便读者 diff。AtomGit 的目录结构按章节拆,比一次性丢一个大压缩包更容易复现。
十五、小结
回到最初那个反常识的判断:打印扫描控制台看起来不像性能敏感型应用,但在鸿蒙PC 的 2in1 形态上,它会同时踩中四站成本——视图描述重建、级联测量、绘制节点数量、高频桌面事件。而它的问题形态又极其典型:没有一处是「算法错了」,全是「每帧多做了一点点」。
本文给出的六项改造,本质上是六个「把成本放回它该在的位置」的动作:
- 派生值 → 收进带修订戳的快照,不再在
build()里反复遍历; - key → 只认身份,不认状态,避免无意义的销毁重建;
- 列表 → 交给
LazyForEach,让屏外行不进入布局; - 图标 → 路径表化、退出命中测试,必要时换成 SVG 资源;
- 进度 → 状态下沉到叶组件,用属性动画代替高频写状态;
- 桌面事件 → 收敛成档位,用布局减少跨节点次数。
最后再强调一次方法论:先有量表,再谈优化。 一个 256 帧的环形缓冲、三个统计量(P50 / P95 / jankRate)、一张固定操作序列的对照表,成本不到一小时,却能把「感觉卡」变成「哪一行贵」。性能优化最贵的从来不是改代码,而是改错地方——在鸿蒙PC 这种窗口形态自由、指针事件密集的平台上,这句话的含金量比在手机上更高。
至于 ArkUI 与跨平台框架的选择,我的结论也很朴素:界面贴着系统写,逻辑离开系统写。 让跨平台框架去承担它擅长的复用,让 ArkUI 去承担它擅长的窗口、事件与渲染,两边的性能账才都算得清。
更多推荐




所有评论(0)