鸿蒙PC上的ArkUI跨平台实战:用ArkTS写一台布局测量与重排代价剖面台
鸿蒙PC上的ArkUI跨平台实战:用ArkTS写一台布局测量与重排代价剖面台
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言
这是一次完整的记录:在鸿蒙PC电脑上,使用 ArkUI 框架技术开发一个面向鸿蒙PC的桌面应用。项目名 Metrika(中文名「量廊」),定位是一台「ArkUI 布局测量与重排代价剖面台」。它不渲染真实业务界面,而是把一个典型 PC 三栏工作台的节点树搬进一个可解释的盒模型求解器:按一次按钮,你就能看到这一帧里有多少个节点被测量、多少次文本整形被触发、多少个干净子树直接命中跨帧缓存、脏路径有多长,以及最终折算出的布局耗时落在 1.0 ms 预算的哪个位置。
做这件事的动机很朴素。手机上的页面通常只有一屏、一种宽度、一种朝向,布局问题往往被「页面够简单」掩盖;而鸿蒙PC应用天生要被拖动改变窗口大小、被并排摆放、被自由拉宽拉窄。约束一变,布局就要重算,重算路径的长短直接决定这一帧还剩多少时间留给渲染。很多人能背出「减少重排」这句话,却说不清自己那一屏到底重算了几次、走了多少节点。这把尺子的价值,就是把这些数字从黑箱里拽出来。
需要提前明确两个边界,避免误读。第一,文中所有微秒数值来自引擎内部按固定口径累计的代价模型(单节点测量 5.2 μs、文本整形 9.0 μs 起、定位 2.2 μs),它衡量的是重排路径的长短,不是 DevEco Profiler 采样的真实 CPU 时间,也不代表某台鸿蒙PC 的绝对性能。第二,本文所说的「ArkUI 跨平台」,指 ArkUI 这套声明式 UI 技术体系以及建立在它之上的 ArkUI-X 跨平台框架的同源能力;本项目聚焦鸿蒙PC 原生侧,没有提供 iOS、Android 或 Windows 的构建产物,也不声称一份代码零改动即可运行于任意桌面系统。
关键词:鸿蒙PC、ArkUI、ArkUI-X跨平台框架、ArkTS、OpenHarmony PC、2in1桌面应用、布局测量、重排代价、Canvas剖面、AtomGit

图1:截图来自鸿蒙PC 真机运行现场。画面里能同时看到系统桌面底部任务栏、DevEco Studio 的工程树,以及 Metrika 以独立窗口形式运行的三栏界面——左侧是变更注入与重排账本,中间是结构剖面与测量瀑布,右侧是选中节点、布局耗时与图例。这正是鸿蒙PC 作为桌面形态应有的应用呈现方式:窗口化、可并排、鼠标可交互。
一、鸿蒙PC上的布局代价,为什么要单独做一把尺子
先说清楚要度量什么。ArkUI 的一次界面更新,在布局阶段大致要经历三件事:父容器带着可用尺寸去测量子节点(measure),根据测量结果分配每个子节点的实际宽高,最后把子节点定位到具体坐标(layout)。文本节点还要额外做一次整形才能知道行数和高度,这是整个链路上最贵的一环。
在鸿蒙PC 上,这三件事被放大得很明显。用户把窗口从 1080 拖到 940,根约束就变了,宽度需要沿着树一路向下重新传播;网格从两列变三列,每个卡片分到的宽度变了,文本的换行位置跟着变,行数变了,卡片高度又得反过来影响父容器——一次看似简单的交互,实际上是整条约束链的连锁反应。
工程里内置了四种「变更注入」,正好对应四类常见写法:
- 视口收窄:根约束变化,考察约束沿树传播的路径长度。
- 改写文本:只改一行文案,考察脏标记是否只沿父链向上扩散,兄弟子树是否能整棵跳过。
- 改列数:网格列宽重分配,考察「测量—分配」是否互锁,是否引发返工。
- 抖动注入:同一帧内连续请求三次布局,模拟「读完尺寸立刻写样式」的反模式,考察缓存被打断后的代价放大。
在这台尺子上,判据被固定成两个刻度:单次求解 1.0 ms 为布局预算上限,整帧 16.7 ms 为硬上限。左侧账本记录每一次变更的来龙去脉,底部「帧预算尺」保留最近 40 次求解的柱状历史。这样一来,哪一种写法在鸿蒙PC 的宽屏窗口下更贵,不再靠感觉争论。
二、工程骨架:把 deviceTypes 钉在 2in1
很多所谓的「PC 版」应用,只是把手机页面拉宽。Metrika 从工程配置的第一个字段起就不含糊:它明确声明自己只面向 2in1 形态,也就是二合一与桌面形态的鸿蒙PC 设备。
{
module: {
name: 'entry',
type: 'entry',
mainElement: 'EntryAbility',
deviceTypes: ['2in1'],
pages: '$profile:main_pages',
abilities: [
{
name: 'EntryAbility',
srcEntry: './ets/entryability/EntryAbility.ets',
exported: true,
skills: [
{
entities: ['entity.system.home'],
actions: ['action.system.home']
}
]
}
]
}
}
deviceTypes 只写 2in1,意味着应用不会以手机形态被安装到平板上,也不会因为「看起来能拉伸」就冒充桌面应用。skills 里的 entity.system.home 与 action.system.home 让它具备桌面入口能力,双击图标即在鸿蒙PC 的窗口系统中以独立窗口启动。
构建配置采用 API 26 的写法,SDK 版本必须带完整三段号:
{
"app": {
"products": [
{
"name": "default",
"compatibleSdkVersion": "26.0.0",
"targetSdkVersion": "26.0.0",
"runtimeOS": "HarmonyOS",
"signingConfig": "default"
}
]
}
}
整个工程零第三方依赖,oh-package.json5 的 dependencies 是空对象。这一点很关键:本文想证明的是 ArkUI 本身的能力边界,而不是某个图表库、布局库的能力。整个工程只有六个 ArkTS 文件——pages/Index.ets 负责页面,engine/BoxEngine.ets 是求解器,engine/Scene.ets 构造场景树,components/ProfileCanvas.ets 负责绘制,common/Theme.ets 收敛色板,entryability/EntryAbility.ets 是唯一的系统入口。
页面结构采用「顶栏 + 三栏 + 底尺」的桌面骨架,用 layoutWeight 把中间画布撑开,左右两栏给定固定宽度并用 Scroll 兜住溢出:
build() {
Column() {
this.TopBar()
Row({ space: 14 }) {
Scroll() {
Column({ space: 12 }) {
this.InjectCard()
this.LedgerCard()
}
}
.width(300)
Column({ space: 12 }) {
Column() {
ProfileCanvas({
stamp: this.stamp,
sweep: this.sweep,
selected: this.selected,
engine: this.engine,
onPick: (id: string) => {
this.selected = id;
}
})
}
.layoutWeight(1)
this.StatStrip()
}
.layoutWeight(1)
Scroll() {
Column({ space: 12 }) {
this.InspectorCard()
this.BudgetCard()
this.LegendCard()
}
}
.width(272)
}
.layoutWeight(1)
this.FrameRuler()
}
.width('100%')
.height('100%')
.backgroundColor(Ink.bg)
}
这种写法在鸿蒙PC 上很自然:左右栏是工具面板,中间是主视觉区,窗口变宽时收益全部给中间画布,而不是把按钮拉成一排巨型方块。顺带提一个桌面细节——注入项的行组件实现了 onHover,鼠标悬停时描边点亮并换底色:
.onHover((isHover: boolean) => {
this.hovered = isHover;
})
.onClick(() => this.onTap())
触屏时代很多人会忘掉这一点,但在鸿蒙PC 上,指针悬停反馈是「这是桌面应用」最基础的礼貌。
三、纯 ArkTS 的盒模型求解器
整个项目最有料的部分不在 UI,而在 BoxEngine.ets。它是一个不渲染任何像素的纯逻辑求解器,只负责遍历节点树、累计代价、记录每个节点的访问次数与自耗时。
节点模型把布局需要的字段和诊断需要的字段放在一起:
export class LayoutNode {
id: string;
label: string;
kind: string; // row | col | grid | text | chip | box
text: string = '';
fontSize: number = 16;
fixedW: number = -1;
fixedH: number = -1;
flex: number = 0;
pad: number = 0;
gap: number = 0;
cols: number = 2;
children: LayoutNode[] = [];
parent: LayoutNode | null = null;
depth: number = 0;
x: number = 0;
y: number = 0;
w: number = 0;
h: number = 0;
allocW: number = 0;
lines: number = 1;
selfUs: number = 0;
visits: number = 0;
reused: boolean = false;
dirty: boolean = false;
cacheW: number = -1;
cacheH: number = -1;
}
注意最后四个字段。reused 与 dirty 是画布上两种颜色的来源:命中缓存画青色,本帧脏区画珊瑚色。cacheW / cacheH 是跨帧缓存的键——缓存键必须包含约束,这一点是很多手写布局优化翻车的根源:只记尺寸不记约束,父容器一换宽度,子节点还拿着旧尺寸自我感觉良好。
代价累计集中在一个 charge 方法里,口径完全透明:
private charge(n: LayoutNode): void {
let c = this.costNode; // 5.2 μs 基础测量
if (n.kind === 'text') {
this.stats.textShapes++; // 文本整形单独计数
c += this.costTextBase + n.text.length * this.costChar;
}
this.stats.measures++;
this.stats.costUs += c;
n.selfUs += c;
n.visits++;
}
文本的代价随字数线性增长(每字 0.2 μs),这符合直觉:越长的段落,整形越贵,换行计算也越多。visits 记录本帧该节点被访问了几次——当同一个节点在一次求解里被访问三次,你基本就能判断这里发生了返工。
真正的重排发生在 measure,它的入口先做一次缓存判定:
private measure(n: LayoutNode, availW: number, availH: number): void {
// exact 策略下跨帧复用:约束未变、自身不脏且子树干净,直接沿用上一帧尺寸
if (this.strategy === 'exact' && n.cacheW === availW && n.cacheH === availH && !this.hasDirty(n)) {
n.reused = true;
this.stats.cacheHits++;
return;
}
this.charge(n);
const innerW = Math.max(24, availW - n.pad * 2);
const innerH = Math.max(18, availH - n.pad * 2);
if (n.kind === 'text') {
const raw = LayoutEngine.textWidth(n.text, n.fontSize);
const lineH = LayoutEngine.lineHeight(n.fontSize);
const usable = Math.max(1, innerW);
n.lines = Math.max(1, Math.ceil(raw / usable));
n.w = n.flex > 0 ? availW : Math.min(raw + n.pad * 2, availW);
n.h = n.lines * lineH + n.pad * 2;
n.allocW = n.w;
n.cacheW = availW;
n.cacheH = availH;
return;
}
if (n.kind === 'row') {
this.measureRow(n, innerW, innerH);
} else if (n.kind === 'col') {
this.measureCol(n, innerW, innerH);
} else if (n.kind === 'grid') {
this.measureGrid(n, innerW, innerH);
} else {
n.w = n.fixedW > 0 ? n.fixedW : innerW;
n.h = n.fixedH > 0 ? n.fixedH : 36;
n.allocW = n.w;
}
if (n.fixedW > 0) {
n.w = n.fixedW;
}
if (n.fixedH > 0) {
n.h = n.fixedH;
}
n.cacheW = availW;
n.cacheH = availH;
}
Math.max(24, ...) 与 Math.max(18, ...) 是两道防御:窗口被拖得极窄时,可用宽高可能算成负数或零,若不钳制,文本行宽会出现除以零式的荒谬结果。这类「窗口自由缩放才暴露」的边界,恰恰是鸿蒙PC 应用必须提前考虑、而手机应用很难遇到的。
场景树本身也照抄了真实 ArkUI 的嵌套关系:根是纵向 Column,头部是 Row 包着品牌、标题与三个 Chip,主体 Row 里左边窄导航(固定 196)、右边主舞台(弹性),舞台里再嵌工具栏、两列卡片网格、页脚。这棵树共 34 个节点,既不至于太浅看不出传播代价,也不至于太深让截图读不过来。
四、三种求解策略:一遍到位、整树双趟、先量后分
求解入口把三种策略分派得很清楚,同时把「布局趟数」作为诊断字段写进统计:
solve(): SolveStats {
this.stats = new SolveStats();
this.stats.nodes = this.count(this.root);
this.stats.dirty = this.countDirty(this.root);
this.stats.layoutPass = this.strategy === 'exact' ? 1 : (this.strategy === 'double' ? 2 : 3);
this.resetVisits(this.root);
if (this.strategy === 'naive') {
for (let i = 0; i < this.root.children.length; i++) {
this.probe(this.root.children[i]);
}
this.measure(this.root, this.viewW, this.viewH);
this.measure(this.root, this.viewW, this.viewH);
} else if (this.strategy === 'double') {
this.measure(this.root, this.viewW, this.viewH);
this.measure(this.root, this.viewW, this.viewH);
} else {
this.measure(this.root, this.viewW, this.viewH);
}
this.arrange(this.root, 0, 0);
this.clearDirty(this.root);
this.history.push(this.stats.costUs);
if (this.history.length > 40) {
this.history.splice(0, this.history.length - 40);
}
return this.stats;
}
exact 是理想写法:父级先按固定宽与弹性权重算出每个子节点的精确可用宽度,把约束正确下传,一趟走完。double 是常见的保守写法:不信任下传的约束,先把整棵树量一遍拿内在尺寸,再量第二遍做最终分配,两趟之间没有任何复用。naive 更糟,它在两趟之前还做了一次「探测式测量」——为了拿内在尺寸先遍历一遍子树,拿到的结果随后丢弃:
// 探测式测量:只为拿内在尺寸而遍历,结果随后丢弃,代价真实发生
private probe(n: LayoutNode): void {
this.stats.measures++;
n.visits++;
let c = this.costNode;
if (n.kind === 'text') {
this.stats.textShapes++;
c += this.costTextBase + n.text.length * this.costChar;
}
this.stats.costUs += c;
n.selfUs += c * 0.5;
for (let i = 0; i < n.children.length; i++) {
this.probe(n.children[i]);
}
}
这段代码在真实项目里长得不一定是这个样子,但它精确描述了那种直觉式优化:「我先调一下 getMeasuredWidth 看看多大,再决定怎么排」。在 ArkUI 里这对应的是在布局阶段读取尺寸再写样式,读取本身会打断测量缓存。数字上非常直观:切到「先量后分」后,测量次数从 34 次涨到 101 次,文本整形从 12 次涨到 36 次,布局耗时从 417 μs 抬到 1.10 ms,直接越过 1.0 ms 预算线,占掉一帧的 6.6%。

图2:同一台鸿蒙PC、同一个场景,只把顶栏策略从「约束优先」切到「先量后分」。右上角的状态文字从绿色的「预算内运行」变成珊瑚色的「超出布局预算」,右下角帧预算尺的历史柱状图也跟着变矮——瓶颈不在设备,在写法。
「整树双趟」介于两者之间:不做探测,但也不复用,测量 68 次、文本整形 24 次、耗时 759.2 μs,占一帧 4.5%,勉强没超预算,却把预算的七成花在了重复劳动上。

图3:双趟策略的读数。三张截图连起来看,就是一条完整的因果链:趟数增加 → 测量与整形次数成倍增长 → 布局耗时线性抬升 → 帧预算被挤占。
把三种策略的账算细一点会更清楚。以约束优先为例:34 次测量 × 5.2 μs ≈ 176.8 μs,34 次定位 × 2.2 μs ≈ 74.8 μs,剩下的约 165 μs 全部来自那 12 个文本节点——文本整形一项就吃掉近四成的布局时间。这也解释了一个经验判断:在鸿蒙PC 的宽屏界面上,段落型文本比容器嵌套更容易成为布局阶段的成本中心,尤其是当文本宽度随窗口变化而频繁重排时。
五、脏标记与跨帧缓存:只改一行文本,为什么要花 125 μs
三种策略对比的是「一趟走多干净」,而真实交互里更关键的是「这次到底需不需要全量重算」。Metrika 的实现是教科书式的两段式:向上标脏,向下剪枝。
markDirty(id: string): number {
const target = this.find(this.root, id);
if (!target) {
return 0;
}
let cur: LayoutNode | null = target;
let marked = 0;
while (cur) {
if (!cur.dirty) {
cur.dirty = true;
marked++;
}
cur = cur.parent;
}
return marked;
}
private hasDirty(n: LayoutNode): boolean {
if (n.dirty) {
return true;
}
for (let i = 0; i < n.children.length; i++) {
if (this.hasDirty(n.children[i])) {
return true;
}
}
return false;
}
markDirty 只用一条父链循环,不做子树递归——改一个叶子节点,脏标记只需要从它自己一路标到根,兄弟子树完全不动。hasDirty 则负责回答「这棵子树里到底有没有脏东西」,它是缓存能不能复用的唯一开关:约束相同、自身不脏、子树干净,三条同时成立才允许整棵跳过。
页面上「改写文本」按钮做的事,实质只有「改内容 + 标脏 + 重解」三步,其余都是选中校验:
private retext(): void {
const node = this.engine.find(this.engine.root, this.selected);
const fallback = this.engine.find(this.engine.root, 'cardBody1');
let target: LayoutNode | null = node;
if (target === null || target.kind !== 'text') {
target = fallback;
}
if (target === null) {
return;
}
const t: LayoutNode = target;
t.text = t.text.length > 44
? t.text.substring(0, 40) + '。'
: t.text + '追加一句以确认行宽与换行位置。';
this.engine.markDirty(t.id);
this.selected = t.id;
this.run('改写文本「' + t.id + '」 · 只沿父链标记脏区,兄弟子树应命中缓存');
}
实测读数和预期完全对得上:节点总数仍是 34,但测量次数降到 6 次,文本整形只剩 1 次,缓存命中 8 次,布局耗时 125.6 μs,占一帧 0.8%。6 次测量正好是从根到被改文本的那条链路——根、主体、舞台、网格、卡片、正文,一个不多一个不少;8 次缓存命中意味着 8 个干净子树整棵被跳过,包括头部栏、左侧导航、工具栏、其余三张卡片和页脚。

图4:这是整篇文章最值得盯住的一张图。左侧账本记录了五次操作的历史,最上面一条是本次「改写文本 cardBody1,只沿父链标记脏区」;底部帧预算尺的柱子明显比前几张矮,耗时 125.6 μs,只有冷启动的三成。
但这里必须诚实指出一个尚未解决的问题:定位次数依然是 34 次。也就是说,测量阶段已经做到了按脏路径裁剪,定位阶段却仍在遍历整棵树。125.6 μs 里约 75 μs 花在定位上,占了六成。这个现象在小场景里不明显,一旦节点数上到几百,arrange 就会变成新的瓶颈。正确的补法是给定位阶段也加约束与位置缓存,或者把定位结果挂在相对坐标上做增量更新——这也是「布局优化」这件事最容易半途而废的地方:测量优化完了,定位没跟上,整体收益只有一半。
六、Canvas 双通道剖面与扫掠动画
读数是结论,画布才是过程。中间的主视觉是一个 ArkUI Canvas,把同一棵节点树画成左右两个通道:左侧是结构剖面,缩进即嵌套,条的长度按节点真实分配宽度取平方根映射;右侧是测量瀑布,每个节点一条自耗时横条。两个通道共用同一行基线,所以「谁占了宽度」和「谁花了时间」可以直接横向对照。
Canvas(this.ctx)
.width('100%')
.height('100%')
.onReady(() => {
this.cw = this.ctx.width;
this.ch = this.ctx.height;
this.repaint();
})
.onAreaChange((oldArea: Area, newArea: Area) => {
this.cw = Number(newArea.width);
this.ch = Number(newArea.height);
this.repaint();
})
.onClick((e: ClickEvent) => {
const idx = Math.floor((e.y - this.hitTop) / Math.max(1, this.hitRowH));
if (idx >= 0 && idx < this.hitNodes.length) {
this.onPick(this.hitNodes[idx].id);
}
})
onAreaChange 是这里的要害。鸿蒙PC 的窗口随时会被拖拽缩放,画布拿到的宽高不是常量,必须在区域变化时重算 cw / ch 并重绘;把 960×620 写死在 repaint 里,窗口一拉就全乱。行高也不是固定的,而是按节点数自适应:
const top = 46;
const bottom = H - 20;
const rowH = Math.min(26, Math.max(15, (bottom - top) / n));
const barH = Math.max(9, rowH - 8);
结构条的长度用平方根压缩,是因为根节点宽度往往是叶子的十几倍,线性映射会让所有子节点挤成一条线:
// 结构条:长度按真实分配宽度映射
const ratio = Math.max(0.14, Math.min(1, Math.sqrt(node.w / Math.max(1, this.engine.root.w))));
const bw = Math.max(24, ratio * (leftW - tx - 6));
ctx.fillStyle = this.alpha(tone, isSel ? '59' : '2B');
ctx.fillRect(tx, y + 3, bw, barH);
ctx.strokeStyle = this.alpha(tone, isSel ? 'FF' : '88');
ctx.lineWidth = isSel ? 2 : 1;
ctx.strokeRect(tx, y + 3, bw, barH);
颜色语义也编码在数据里,而不是靠人工配色:node.dirty 画珊瑚色,node.reused 画青色,其余按节点类型取色(Row 青、Column 酸青柠、Text 琥珀、Grid 紫)。于是「这一帧重算了什么」不需要看数字,扫一眼颜色分布就知道。
最后是扫掠动画。每次求解完成后,一条横向光带从上到下扫过画布,把「这一帧的波前」可视化出来。它不是装饰,而是把「一次布局的推进方向」变成可感知的运动:
private sweepAnim(): void {
this.sweep = 0;
try {
this.getUIContext().animateTo({ duration: 640, curve: Curve.EaseOut }, () => {
this.sweep = 1;
});
} catch (e) {
this.sweep = 1;
}
}
getUIContext().animateTo 驱动一个 @Prop @Watch('repaint') 的数值属性,属性每变一帧就触发一次 Canvas 重绘,扫掠线因此平滑下移。这里用 try / catch 兜住,是为了应对组件尚未挂载到 UI 上下文时调用动画的边界情况——宁可让扫掠线直接落到终点,也不要因为一个纯装饰动画抛异常而中断求解流程。
七、鸿蒙PC上的真实读数与口径说明
四张截图对应四次求解,把读数整理成一张表,因果链就一目了然:
| 场景 | 策略 | 测量 | 文本整形 | 缓存命中 | 布局耗时 | 占一帧 | 判定 |
|---|---|---|---|---|---|---|---|
| 冷启动初始布局 | 约束优先 | 34 | 12 | 0 | 417.0 μs | 2.5% | 预算内 |
| 切到先量后分 | 先量后分 | 101 | 36 | 0 | 1.10 ms | 6.6% | 超预算 |
| 切到整树双趟 | 整树双趟 | 68 | 24 | 0 | 759.2 μs | 4.5% | 预算内 |
| 改写一行文本 | 约束优先 | 6 | 1 | 8 | 125.6 μs | 0.8% | 预算内 |
三条结论值得带走:
第一,趟数是最贵的变量。 从一遍到三遍,测量次数涨了约三倍(34 → 101),耗时涨了约 2.6 倍(417 μs → 1.10 ms)。增长不是严格线性的,因为文本整形只随遍历次数翻倍而增加,不随探测再翻一次;但只要趟数上去,成本必然跟着上去,没有例外。
第二,缓存命中是量级差异,不是百分比优化。 改写一行文本时,测量次数从 34 降到 6,降幅 82%;耗时从 417 μs 降到 125.6 μs,降幅 70%。这不是「优化了 10%」的故事,而是「大部分工作本来就不该做」的故事。脏标记做对了,剪枝是天然的。
第三,剩下的瓶颈会换位置。 当测量被剪到 6 次之后,定位的 34 次反而成了大头。优化从来不是一次收工,它只是把瓶颈从一个阶段推到下一个阶段。
口径方面再说清楚一次:表中耗时是求解器内部按固定单价累计的代价模型输出,单价写在代码常量里(costNode = 5.2、costTextBase = 9.0、costChar = 0.2、costLayout = 2.2),任何人在任何设备上跑同一操作,得到的数字都相同。这既是缺点也是优点:它不能告诉你某台鸿蒙PC 的绝对性能,但它能稳定地告诉你「写法 A 比写法 B 多做了一倍的活」,这种可比性在技术选型讨论中比绝对数字更有用。若要验证真实耗时,应把同一套操作序列放到 DevEco Studio 的 Profiler 里采样,对照 ArkUI 布局阶段的帧耗时曲线,而不是拿本文的微秒数当性能基准。
八、ArkUI 跨平台框架的准确边界与工程建议
有必要把「ArkUI」与「ArkUI-X」的关系讲准确,否则很容易写成营销话术。ArkUI 是鸿蒙生态的声明式 UI 框架,用 ArkTS 描述界面,@Component / @State / @Builder 这一套语法就是它的表达能力;ArkUI-X 是架在 ArkUI 之上的跨平台框架,把同一套声明式 UI 能力延伸到更多操作系统。二者是同源关系:UI 层的写法一致,差别在平台适配层与系统能力调用。
Metrika 的定位因此可以说得十分清楚——它是在鸿蒙PC 上、用 ArkUI 开发的鸿蒙PC 原生应用;它的 UI 层是纯声明式组件加一个 Canvas,没有一行业务逻辑依赖桌面专属 API,工程里唯一与系统耦合的地方是 EntryAbility 里加载首页的那几行:
onWindowStageCreate(windowStage: window.WindowStage): void {
windowStage.loadContent('pages/Index', (err) => {
if (err.code) {
hilog.error(DOMAIN, 'Metrika', 'Failed to load content: %{public}s', JSON.stringify(err));
return;
}
hilog.info(DOMAIN, 'Metrika', 'Content loaded');
});
}
这种「UI 与能力分离」的组织方式,正是 ArkUI-X 跨平台框架迁移成本最低的形态:页面、组件、求解器都可以原样带走,需要替换的只有加载入口与少量平台能力。本文不宣称已经完成移植,但把可移植性做在结构里,比写在 PPT 里可靠。
结合这次在鸿蒙PC 上的实践,给几条能落地的建议:
- 别用固定像素假设窗口。 工程里的视口宽度是一个可切换的
@State(1080 ↔ 940),画布尺寸来自onAreaChange。这两处都在提醒:约束是输入,不是常量。凡是从外部读一次宽度就写死的代码,在可缩放的鸿蒙PC 窗口里都是定时炸弹。 - 缓存键必须带约束。
cacheW/cacheH记的是「在什么可用尺寸下量出来的」,不是「量出来多大」。只记结果不记前提,是手写布局缓存最常见的错误。 - 脏标记向上,剪枝向下。 标脏用父链循环,判断复用用子树递归,两者方向相反、职责分明。混在一起写,就会出现「明明只改了一个字,整页都重算」。
- 同帧内不要读写交替。 「抖动注入」按钮就是在演示这个反模式:同帧连续三次请求布局,缓存被反复打断,代价直接翻三倍。ArkUI 里对应的写法是在布局回调里再去改尺寸,能避则避。
- 桌面交互细节要补。 悬停高亮、指针形状、点击热区、键盘焦点,这些在触屏上可以糊弄,在鸿蒙PC 上用户一眼就能察觉缺失。本项目至少给注入项补了
onHover反馈,其余仍待完善。
工程代码托管在 AtomGit,按纯 ArkUI 单模块组织,没有引入任何第三方依赖,便于逐文件对照本文阅读。
九、总结
Metrika(量廊)是一个跑在鸿蒙PC 上的 ArkUI 布局代价剖面台。它把盒模型求解从框架内部搬到台面上:34 个节点的三栏工作台场景,三种求解策略,四种变更注入,一套透明的代价口径,加上一个能一眼看出「谁脏了、谁被复用了」的双通道 Canvas 画布。
四张鸿蒙PC 真机截图串起来的是一个很朴素的结论:布局优化的收益主要来自「少做」,而不是「做快」。 从三趟降到一趟,耗时从 1.10 ms 降到 417 μs;再叠上脏标记与跨帧缓存,改一行文本只要 125.6 μs。反过来说,任何声称「优化了布局性能」的改动,如果拿不出测量次数、整形次数、缓存命中数和耗时这四个数字,就很难判断它到底优化了哪一段路径。
更重要的是,这些经验在鸿蒙PC 这种窗口可自由缩放的桌面形态下会被反复放大:约束随时在变,缓存随时可能失效,文本随时要重排换行。用 ArkUI 开发鸿蒙PC 应用,写起来是声明式的、很舒服;但要让它在大窗口、多窗口、频繁缩放的环境里依然跟手,就必须知道框架在背后替你做了多少趟活。这台尺子的意义,就是让那部分「看不见的工作」变得可读、可数、可对比。
后续可以继续往下做的方向也很明确:给定位阶段补增量缓存(当前 34 次定位仍占六成耗时)、把节点树规模扩到数百级观察曲线拐点、以及把代价模型输出与真实 Profiler 采样做一次同场景对齐。等这三件事做完,这台剖面台就不只是教学演示,而是一个能参与真实鸿蒙PC 项目评审的度量工具。
更多推荐




所有评论(0)