鸿蒙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 真机完整截图:先看界面,再谈性能

鸿蒙PC 真机完整桌面:任务队列页

图 1 鸿蒙PC 真机完整桌面:「任务队列」页。顶部是品牌区与四个页签,右上角是设备数、队列数与「队列畅通」状态胶囊;主体左侧是 6 条打印任务行(时间、彩色 CMYK 四点徽标、双面标签、进度条、状态词、暂停/取消/上移三个操作),右侧是队列统计与队列规则卡;底部状态条写着「本地演示数据 · 不连接真实打印设备」

图 1 是本文的主战场。请注意三件事:第一,每一条任务行右侧最多挂着三个圆形按钮,每个按钮里又嵌着一个矢量图标;第二,行内进度条是「按百分比设宽度」的实时属性,不是静态装饰;第三,整个页面被包在 Scroll 里,桌面鼠标滚轮可以滚动它。这三件事叠加起来,决定了「一次状态更新」在鸿蒙PC 上到底要付多少代价——它不只是改一个数字,而是要重新构建一整棵视图描述,再重新测量、重新绘制。

鸿蒙PC 真机完整桌面:设备港页

图 2 鸿蒙PC 真机完整桌面:「设备港」页。左侧四张设备卡(青岚 M476 / 素纸 S200 / 风阅 F9 / 墨台 E30),每张卡包含状态点、墨量条、纸张条、连接详情与「上电/下电」「设为默认」两个按钮;右侧是端口速览、在线设备数、默认设备墨量与连接建议

图 2 暴露的是桌面形态特有的问题:右侧那张「端口速览」卡固定 320 vp 宽,左侧设备卡用 layoutWeight(1) 吃掉剩余宽度。当用户把窗口从 1400 vp 拖到 1000 vp 时,右侧栏不会变窄,而是左侧压缩——压缩到一定程度,设备名、连接详情、两个按钮就会挤在一起。这不是「好看不好看」的问题,而是每一次拖拽都会触发一次完整测量,如果不同时做断点收敛,拖拽过程中的重排次数会按事件频率线性增长。

鸿蒙PC 真机完整桌面:扫描台页

图 3 鸿蒙PC 真机完整桌面:「扫描台」页。左侧是 196 vp 高的扫描预览台(内含一条随进度下行的扫描线)、四个扫描模式胶囊、开始扫描按钮;右侧是文稿库(3 份文稿,带已保存/未保存胶囊与删除按钮)与模式说明表

图 3 是全文最值得看的一页。点一次「开始扫描」,工程里的实现是 setTimeout 每 420 ms 写一次 scanProgress,共 5 次写满 100%。每一次写入都发生在 Index 这个状态中心里,而 Index 的 build() 里挂着四个视图的 if / else 分支、顶部导航、底部状态条——也就是说,一次扫描会让整页视图描述重建 5 次,只为让两根进度条各前进 20%。这就是本文要解决的第一类浪费。

鸿蒙PC 真机完整桌面:耗材维护页

图 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.vaultconsoleAppScope/app.json5
版本versionCode 1000000、versionName 1.0.0AppScope/app.json5
设备形态仅 ['2in1'],无 phone / tabletentry/src/main/module.json5
SDKcompatibleSdkVersion / targetSdkVersion 均 26.0.0,runtimeOS: HarmonyOSbuild-profile.json5
构建模型hvigor + ohpm,Stage 模型,strictMode.useNormalizedOHMUrl: truebuild-profile.json5
三方依赖工程级、模块级、hvigor 三处 dependencies 全为空oh-package.json5、hvigor/hvigor-config.json5
页面入口windowStage.loadContent('pages/Index'),单页应用entryability/EntryAbility.ets
源码规模18 个手写 .ets,其中 11 个被引用、7 个未被任何文件 importentry/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 以上的跳变。

六、六类无效重组:从「感觉卡」到「能指出行号」

有了量表,接下来做的是归因。归因最有趣的地方在于:很多浪费不需要跑起来就能看见,静态读代码就能数出来。下图是本文的归因总表,六类浪费一一对应一项改造,全部能在源码里指到行。

鸿蒙PC 打印扫描控制台性能归因示意:六类无效重组与对应改造

图 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 掉帧」的假安心,因为窗口期的帧数太少。

十三、复现清单与踩坑记录

想把上面的结论复现出来,按这个顺序做,成本最低:

  1. 用 DevEco Studio 打开 项目源码/Permissa_ohos,确认 deviceTypes 只有 2in1、SDK 为 26.0.0,签名后用 hdc install 装到鸿蒙PC 设备上,直接看到图 1~图 4 的界面;
  2. 把第五章的 PerfProbe.ets 与 displaySync 接线加进 Index,先不加任何改造,跑一轮基线,记录 P50 / P95 / jankRate;
  3. 按第七至第十一章逐项改造,每改一项就重跑同一操作序列,把三件套抄进表格;
  4. 最后再做一次「全开」,对比「全关」与「全开」的差值,差值才是这套改造的真实价值。

过程中有几个坑,我按踩到的顺序列出来:

  • 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 去承担它擅长的窗口、事件与渲染,两边的性能账才都算得清。

Logo

作为“人工智能6S店”的官方数字引擎,为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐