鸿蒙PC上的ArkUI跨平台开发实战:在鸿蒙PC电脑上构建渲染填充预算透视台 STRATA
鸿蒙PC上的ArkUI跨平台开发实战:在鸿蒙PC电脑上构建渲染填充预算透视台 STRATA
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言
这篇文章记录的是在鸿蒙PC电脑上、用 ArkUI 跨平台框架技术开发一个鸿蒙PC 应用的完整过程:STRATA(叠层),一个渲染填充预算透视台。
它要回答的问题很具体:一屏界面里的像素平均被重复绘制了几次,这些重复绘制在 60Hz、90Hz、120Hz 的桌面窗口里各吃掉多少毫秒,以及在十几层玻璃、光晕、卡片、遮罩叠起来的场景里,究竟该动哪一层。
大多数性能讨论停在"卡不卡"的观感层面,而桌面窗口的填充成本是可以先算清楚的:把界面结构抽象成图层数组,把每层的面积、模糊半径、投影扩散、不透明度折成片元量,再把片元量折成毫秒,你就得到一张逐层的账单。有了账单,"哪一层更贵、改哪一层更值"就从感觉变成了可复核的算术。
整个工程用 ArkTS 编写 ArkUI 声明式界面:左侧是固定的模式导轨与场景切换,中间是 Canvas 2D 绘制的透视画布,右侧是随选中图层联动的指标面板。三个视口共用同一份图层模型——热力图看叠加层数,轴测图看 Z 序关系,处方页看降载收益。开发环境、构建工具、运行目标全部在同一台鸿蒙PC 上,本文里的每一个数值都来自该设备上真实运行的读数。
需要先把技术边界讲清楚:ArkUI 是鸿蒙生态的声明式 UI 框架,ArkTS 是它配套的开发语言;ArkUI-X 是 ArkUI 跨平台框架向其他操作系统延伸的工程体系。本文工程的形态是原生 ArkUI 应用(deviceTypes 显式指定为 2in1),不是 ArkUI-X 的多平台工程结构。因此它扎实证明的是"在鸿蒙PC 上以 ArkUI 跨平台框架技术栈构建鸿蒙PC 原生桌面应用",以及这套技术栈在多设备形态之间的复用能力;它不宣称同一份代码已经跑在 iOS 或 Windows 上。凡是涉及边界的地方,下文都会点明。
关键词:鸿蒙PC、ArkUI跨平台框架、ArkUI-X、ArkTS、填充率、过度绘制、120Hz帧预算、Canvas 2D、2in1、OpenHarmony PC

图1:鸿蒙PC 运行现场。系统任务栏、桌面与正在运行的 DevEco 开发环境同屏可见,应用窗口标题为「叠层」。画布是 120×74 采样栅格的过绘制热力图,右侧是逐层填充账单。
一、为什么填充预算这件事要在鸿蒙PC 上算
手机上的界面是竖屏、单列、信息密度受限的。鸿蒙PC 的 2in1 形态一次把三个变量同时放大。
第一是像素总量。工程按 1000×620 dp 的设计栅格建模,设备倍率 2.0×,也就是一次满屏绘制要覆盖约 248 万设备像素。任何一层铺满窗口的玻璃或遮罩,都是一次 248 万像素的填充;再叠一层,就是第二次。
第二是窗口结构。桌面应用习惯把信息并置:左侧导轨、中间画布、右侧指标,再压上提示条、浮层面板、弹出卡片。同一块区域被三到四层容器覆盖,在桌面上是常态而不是异常。
第三是刷新率分档。工程内置 60Hz / 90Hz / 120Hz 三档,帧预算分别是 16.67ms、11.11ms、8.33ms。同一个界面在 120Hz 窗口里的预算只有 60Hz 的六成,原本"看起来还行"的组合会直接超支。
这三个变量叠在一起,产生了一个必须用算术回答的判断:平均叠加层数 2.24× 这种数字,到底是宽裕还是危险?答案取决于画幅、取决于刷新率、取决于被叠加的那一层是不是带背景模糊。所以这个题目天然属于鸿蒙PC:不是把手机页面放大,而是桌面窗口的层结构和像素预算本来就更紧张。

图2:同一个场景的第二种看法。图层沿 Z 轴按 18dp 步距拆开,能一眼看出右侧抽屉玻璃压在四张列表卡之上;右侧下方同步给出遮挡关系——顶部工具条被搜索胶囊压住 63% 的面积。
二、工程骨架:把设备目标钉在 2in1,把窗口交给桌面系统
鸿蒙PC 应用的第一个工程事实是设备目标。entry/src/main/module.json5 里显式声明 deviceTypes 为 2in1,让"面向二合一 / PC 形态"成为构建期就成立的约束,而不是从界面宽度倒推出来的猜测(下为节选,图标与文案等资源引用已省略):
{
module: {
name: 'entry',
type: 'entry',
mainElement: 'EntryAbility',
deviceTypes: ['2in1'],
deliveryWithInstall: true,
pages: '$profile:main_pages',
abilities: [
{
name: 'EntryAbility',
srcEntry: './ets/entryability/EntryAbility.ets',
exported: true,
skills: [
{ entities: ['entity.system.home'], actions: ['action.system.home'] }
]
}
]
}
}
入口 Ability 保持极简,只做一件事:把页面挂上窗口,并把加载结果写进日志:
import { AbilityConstant, UIAbility, Want } from '@kit.AbilityKit';
import { window } from '@kit.ArkUI';
import { hilog } from '@kit.PerformanceAnalysisKit';
const DOMAIN = 0x0000;
export default class EntryAbility extends UIAbility {
onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
hilog.info(DOMAIN, 'Strata', 'Ability onCreate');
}
onWindowStageCreate(windowStage: window.WindowStage): void {
windowStage.loadContent('pages/Index', (err) => {
if (err.code) {
hilog.error(DOMAIN, 'Strata', 'Failed to load content: %{public}s', JSON.stringify(err));
return;
}
hilog.info(DOMAIN, 'Strata', 'Content loaded');
});
}
}
这里有一个刻意的取舍:没有硬编码窗口尺寸,也没有写死最小宽高。桌面窗口是用户可以随意拖拽的对象,与其在 Ability 里限死一个尺寸,不如让界面本身在任意尺寸下都成立。具体做法是"固定宽度的侧栏 + 弹性主区":左侧模式导轨固定 96vp,右侧检视面板固定 386vp,中间画布用 layoutWeight(1) 吃掉剩余宽度;处方页的右侧对照栏固定 478vp,左侧处方列表弹性伸展。
Row() {
this.modeRail()
if (this.mode === 'scan') {
this.scanView()
} else if (this.mode === 'stack') {
this.stackView()
} else {
this.rxView()
}
}
.width('100%')
.layoutWeight(1)
.alignItems(VerticalAlign.Top)
固定侧栏加弹性主区,比"所有区域按比例缩放"更容易在宽屏上保持信息密度。按比例缩放在 2in1 的宽窗口里会把画布拉成一条过宽的横带,指标数字的字号跟着漂移;固定侧栏能让 27px 的主指标数字在任何窗口宽度下都稳定,只有画布在增减。
三、设计坐标系:1000×620 与 2.0× 的解耦
ArkUI 跨平台框架实践里最容易被跳过的一步,是把"设计坐标"和"设备像素"分开。工程的全部几何量——图层位置、尺寸、圆角、探测点——都写在 1000×620 的设计坐标系里;只有在折算帧成本时,才引入设备倍率与填充率:
export const DESIGN_W: number = 1000;
export const DESIGN_H: number = 620;
export const GRID_W: number = 120;
export const GRID_H: number = 74;
export const DEVICE_SCALE: number = 2.0;
export const FILL_RATE: number = 960000; // 设备像素 / 毫秒(基线设备填充能力)
这样解耦有三个直接好处。图层模型可以脱离任何具体屏幕存在,测试与复算都不需要真机;同一份场景在不同倍率的设备上只是 DEVICE_SCALE 换个数字,界面结构一行不用改;画布的视口变换只需要处理"设计坐标 → 画布坐标",与设备分辨率完全无关。
FILL_RATE = 960000 是基线设备的填充能力:每毫秒能填 96 万个设备像素。它不是从这台机器上测出来的绝对上限,而是一个可校准的刻度。换成别的设备,只改这一个常量,所有账单按同一比例平移,场景之间的相对关系不变——这一点很重要,因为工具的价值在于比较,而不在于给某个 GPU 打分。
四、填充账单:从图层到毫秒
图层模型的字段不多,但每一个都对应真实的渲染代价:
export class Layer {
id: number;
name: string;
kind: string; // base | glow | glass | card | chrome | scrim | text
x: number;
y: number;
w: number;
h: number;
radius: number;
alpha: number;
blur: number; // 背景模糊半径,0 表示无
shadow: number; // 投影扩散半径,0 表示无
visible: boolean;
}
面积不能简单按 w × h 算。圆角切掉的四个角是真实的空白,每个角被切掉 r² - πr²/4,四角合计 (4 - π) r²:
function clampRadius(l: Layer): number {
let r = l.radius;
const half = Math.min(l.w, l.h) / 2;
if (r > half) {
r = half;
}
if (r < 0) {
r = 0;
}
return r;
}
export function layerArea(l: Layer): number {
const r = clampRadius(l);
const corner = (4 - Math.PI) * r * r;
const a = l.w * l.h - corner;
return a > 0 ? a : 0;
}
权重是模型的核心。背景模糊按半径线性计价——模糊半径越大,采样窗口越宽,每像素要读的邻居越多;半透明意味着要做混合,而混合比直接覆盖贵:
function layerWeight(l: Layer): number {
let w = 1;
if (l.blur > 0) {
w += l.blur / 14;
}
if (l.alpha < 0.99) {
w += 0.12;
}
return w;
}
function shadowBand(l: Layer): number {
if (l.shadow <= 0) {
return 0;
}
const s = l.shadow;
const outer = (l.w + s * 2) * (l.h + s * 2);
return Math.max(0, outer - l.w * l.h);
}
投影只按外扩环带的 35% 计价,因为高斯衰减下环带外缘的实际写入远小于几何面积。最后把三部分加起来,乘设备倍率的平方,除以填充率,得到这一层的毫秒数:
export function measure(layers: Layer[], refresh: number): Metrics {
const m = new Metrics();
let frag = 0;
let vis = 0;
const s2 = DEVICE_SCALE * DEVICE_SCALE;
for (let i = 0; i < layers.length; i++) {
const l = layers[i];
if (!l.visible) {
continue;
}
vis++;
frag += (layerArea(l) * layerWeight(l) + shadowBand(l) * 0.35) * s2;
}
m.fragments = frag;
m.fillMs = frag / FILL_RATE;
m.layers = vis;
m.budgetMs = 1000 / refresh;
m.share = m.budgetMs > 0 ? m.fillMs / m.budgetMs * 100 : 0;
return m;
}
measure() 只算总账,不做栅格统计,因为它每次切换处方都要被调用十几遍(单条收益、累积瀑布各算一轮),必须足够便宜。真正带栅格的是 scan()。
五、手算一层玻璃:先验证模型,再相信结论
一个成本模型最容易犯的错,是算得很像那么回事,但没人能复核。所以先用"指挥舱"场景里最贵的那一层做手算校验——主控玻璃面板,560×404,圆角 30,不透明度 0.14,背景模糊 28,投影 26。
面积:560 × 404 = 226240,圆角扣除 (4 - π) × 30² ≈ 772,得 225468。
权重:1 + 28/14 + 0.12 = 3.12。
主体片元:225468 × 3.12 ≈ 703460。
投影环带:(560 + 52) × (404 + 52) - 226240 = 52832,按 35% 计 18491。
合计:703460 + 18491 = 721951,乘 4(2.0× 的平方)得 2887804 设备像素,除以 960000 得 3.008ms。
设备上读到的这一层正是 3.01 ms。再看底板:1000 × 620 × 4 ÷ 960000 = 2.583ms,界面上是 2.58 ms。环境光左:400 × 400 - (4 - π) × 200² ≈ 125654,权重 1 + 0.12 = 1.12,乘 4 除以 960000 得 0.586ms,界面上是 0.59 ms。
三层手算全部落在读数上。这说明公式链路是自洽的:几何 → 片元 → 毫秒,每一步都能被纸笔追平。模型的边界也清楚——它不区分 GPU 的早期深度测试与硬件合批,同色系半透明叠加一律按层计费。所以界面底部那行字不是客套:相对成本模型,结论仍需真机复核。工具负责回答"哪一层更贵、改哪一层更值",DevEco Studio 的 Frame Profiler 与 hitrace 负责回答"这台机器上到底省了多少"。
六、120×74 采样栅格与过绘制比
总账之外的第二个问题:重复绘制发生在哪一块屏幕区域。scan() 把设计画布切成 120×74 共 8880 个格子,逐格统计叠加层数:
export function scan(layers: Layer[], refresh: number): ScanResult {
const res = new ScanResult();
res.metrics = measure(layers, refresh);
const total = GRID_W * GRID_H;
const cells = zeros(total);
const masks: Uint8Array[] = [];
const layerPx: number[] = zeros(layers.length);
const layerCells: number[] = zeros(layers.length);
const s2 = DEVICE_SCALE * DEVICE_SCALE;
const cw = DESIGN_W / GRID_W;
const ch = DESIGN_H / GRID_H;
for (let i = 0; i < layers.length; i++) {
const mask = new Uint8Array(total);
masks.push(mask);
const l = layers[i];
if (!l.visible) {
continue;
}
layerPx[i] = (layerArea(l) * layerWeight(l) + shadowBand(l) * 0.35) * s2 / FILL_RATE;
const gx0 = Math.max(0, Math.floor(l.x / cw));
const gx1 = Math.min(GRID_W - 1, Math.ceil((l.x + l.w) / cw) - 1);
const gy0 = Math.max(0, Math.floor(l.y / ch));
const gy1 = Math.min(GRID_H - 1, Math.ceil((l.y + l.h) / ch) - 1);
let count = 0;
for (let gy = gy0; gy <= gy1; gy++) {
const py = (gy + 0.5) * ch;
for (let gx = gx0; gx <= gx1; gx++) {
const px = (gx + 0.5) * cw;
if (insideLayer(l, px, py)) {
const idx = gy * GRID_W + gx;
cells[idx] += 1;
mask[idx] = 1;
count++;
}
}
}
layerCells[i] = count;
}
// ……统计覆盖、过绘制比、峰值层数
}
两个细节值得说。
其一是圆角命中。格子中心点是否落在圆角矩形内,不能只判外接矩形,否则四个角会被多算一层。insideLayer() 把点先钳到"内缩矩形"里,再算到该点的距离是否超过圆角半径:
export function insideLayer(l: Layer, px: number, py: number): boolean {
if (px < l.x || px > l.x + l.w || py < l.y || py > l.y + l.h) {
return false;
}
const r = clampRadius(l);
if (r <= 0.01) {
return true;
}
const cx = Math.min(Math.max(px, l.x + r), l.x + l.w - r);
const cy = Math.min(Math.max(py, l.y + r), l.y + l.h - r);
const dx = px - cx;
const dy = py - cy;
return dx * dx + dy * dy <= r * r;
}
其二是掩码复用。每层扫描时顺手把命中的格子写进 Uint8Array 掩码,后面算遮挡关系时就是两次掩码按位与,不用重复做几何判断。8880 格 × 13 层的两两比较放在掩码上是 13×12/2 次线性扫描,桌面 CPU 上是一次可以忽略的瞬时计算,但把它写在切换处方的同步路径里仍然要克制——所以遮挡对只在 scan() 里算一次,随处方复算一起刷新。
统计口径是:覆盖占比只统计 c > 0 的格子;过绘制比只统计 c ≥ 2 的格子占已覆盖格子的比例;峰值层数取全图最大值,并记录峰值坐标用于画布上的靶心标记。指挥舱场景的读数是平均 2.24×、过绘制 72%、峰值 4 层——平均不到 2.5 层,听起来温和,但峰值 4 层意味着存在一小片区域被填了四遍,那里才是真正该动刀的位置。
七、轴测爆炸视图:把 Z 序摊平,还要能点中
热力图解决了"贵在哪一片",但没解决"谁压在谁上面"。第二个视口把十几个图层沿 Z 轴按步距拆开,用一次斜投影画出爆炸图。投影是一个手写的仿射变换:x 方向按 0.42 的斜切量收敛纵深,y 方向按 0.34 压缩,再减去该层的 Z 偏移:
private quad(p: Proj, l: Layer, z: number): Quad {
const q = new Quad();
const ax = l.x;
const bx = l.x + l.w;
const ay = l.y;
const by = l.y + l.h;
q.x0 = p.ox + (ax - 0.42 * ay) * p.k;
q.y0 = p.oy + 0.34 * ay * p.k - z;
q.x1 = p.ox + (bx - 0.42 * ay) * p.k;
q.y1 = p.oy + 0.34 * ay * p.k - z;
q.x2 = p.ox + (bx - 0.42 * by) * p.k;
q.y2 = p.oy + 0.34 * by * p.k - z;
q.x3 = p.ox + (ax - 0.42 * by) * p.k;
q.y3 = p.oy + 0.34 * by * p.k - z;
return q;
}
投影的缩放系数 k 不是常数,而是按画布实际尺寸反算出来的,同时保证整组薄片不出画布:
private proj(): Proj {
const W = this.ctx.width;
const H = this.ctx.height;
const p = new Proj();
const spanX = 1260;
const spanY = 240 + this.layers.length * this.gap;
p.k = Math.min((W - 96) / spanX, (H - 80) / spanY);
if (p.k < 0.2) {
p.k = 0.2;
}
p.ox = W / 2 - 370 * p.k;
const zMax = (this.layers.length - 1) * this.gap * this.zScale(p.k);
const ySpan = 0.34 * DESIGN_H * p.k;
let oy = H * 0.52 - (ySpan - zMax) / 2;
if (oy - zMax < 34) {
oy = 34 + zMax;
}
p.oy = oy;
return p;
}
p.k 有 0.2 的下限,p.oy 有一次"顶部越界回推"。窗口被拖窄时整组薄片会缩小,拖到很窄时至少还看得见轮廓,而不会突然消失——这类保底逻辑在桌面窗口场景里是必需的,因为用户真的会把窗口拖成一条竖缝。
画布上的点击必须能命中薄片。这里不能复用圆角矩形的判断,因为投影后每层都是一个任意四边形。用的是同侧叉积法:点相对四条边的叉积符号必须一致,才判定在四边形内:
private insideQuad(q: Quad, x: number, y: number): boolean {
let sign = 0;
const xs: number[] = [q.x0, q.x1, q.x2, q.x3];
const ys: number[] = [q.y0, q.y1, q.y2, q.y3];
for (let i = 0; i < 4; i++) {
const j = (i + 1) % 4;
const cross = (xs[j] - xs[i]) * (y - ys[i]) - (ys[j] - ys[i]) * (x - xs[i]);
if (Math.abs(cross) < 0.001) {
continue;
}
const s = cross > 0 ? 1 : -1;
if (sign === 0) {
sign = s;
} else if (s !== sign) {
return false;
}
}
return true;
}
拾取顺序是从上往下遍历(i 从后往前),第一个命中的就是视觉上最上层的那张薄片,符合直觉。选中后,右侧面板会展开该层的名称、类型、不透明度、模糊、投影、几何尺寸、覆盖格占比和填充账单——从"看见"到"读到一个数字",路径不超过一次点击。

图3:第三个场景把问题推到极端。整屏遮罩压在背景卡片之上,填充 11.06 ms,占 120Hz 帧预算的 133%,过绘制比 100%,12 层全部参与填充。
八、六条处方:克隆、施用、同模型复算
工具的价值不在报数字,而在给出可执行的动作。工程内置六条处方,每条都是对图层数组的纯变换:
export const FIX_LIST: FixDef[] = [
new FixDef(0, 'F1', '合并环境光层',
'同类光晕只保留最外一层,其余烘焙进底色;大面积柔光没必要叠三层。', '合并同类光晕', '#7CF7C4'),
new FixDef(1, 'F2', '玻璃背板去模糊',
'把 backdropBlur 换成半透明实底并提高不透明度,观感接近,采样量骤降。', '权重 -64%', '#58D6FF'),
new FixDef(2, 'F3', '投影半径收窄',
'投影按 30% 半径重算,或改为 1px 描边 + 极浅投影,减少边缘填充带。', '投影带 -70%', '#FFC46B'),
new FixDef(3, 'F4', '全屏遮罩压实',
'遮罩不透明度提到 92%,为下一步「遮挡剔除」创造条件。', '可剔除底层', '#FF6E5A'),
new FixDef(4, 'F5', '遮挡剔除',
'被 92% 以上不透明层完全盖住的图层,直接从渲染树摘除。', '按遮挡剔除', '#B49BFF'),
new FixDef(5, 'F6', '静态饰条合并',
'顶部栏、搜索框、状态胶囊等静态底板合并成一张预渲染层。', '静态层归一', '#C6F06B')
];
处方不是打勾式的省钱技巧,每一条都对应模型里的一个可计算项。F1 摘掉同类光晕的多余层——只保留最外一层,其余烘焙进底色,因为大面积柔光叠三层在视觉上几乎无法分辨。F2 把背景模糊换成半透明实底并补偿不透明度:模糊归零,权重从 1 + 28/14 + 0.12 掉到 1.12,这一条在玻璃密集的桌面上收益最大。F3 把投影半径收敛到三成,投影带按平方关系缩小。F4 把遮罩不透明度提到 92%。F5 依赖 F4 的结果:只有 92% 以上的不透明层才被认为完全遮住了下层。F6 把静态饰条合并成一张预渲染层。
关键实现是"先克隆再改",不能让处方污染原始场景:
export function applyFixes(base: Layer[], on: boolean[]): Layer[] {
const layers: Layer[] = [];
for (let i = 0; i < base.length; i++) {
layers.push(base[i].clone());
}
if (on[1]) {
for (let i = 0; i < layers.length; i++) {
const l = layers[i];
if (l.blur > 0) {
l.blur = 0;
l.alpha = Math.min(0.96, l.alpha + 0.14);
}
}
}
// ……F1 / F3 / F4 / F5 / F6
return layers;
}
F5 的剔除判据是完全覆盖,边框比较留 0.5 的容差:
function covers(up: Layer, low: Layer): boolean {
const eps = 0.5;
return up.x <= low.x + eps && up.y <= low.y + eps &&
up.x + up.w >= low.x + low.w - eps && up.y + up.h >= low.y + low.h - eps;
}
有了纯函数,全部数字都来自"同一套公式再跑一遍",不做任何估算插值。页面里三组读数各司其职:
单条收益 是只施放一条处方、单独复算的结果,用 measure() 快速算,用于回答"这条值不值得开"。
顺序全开 是 F1 到 F6 依次累积施放的结果,每加一条重算一次,形成一条瀑布,用于回答"一起开能到多少"。
复算对照 是当前勾选状态的真实账单,用于回答"现在这一屏是多少"。
三条读数在同一台鸿蒙PC 上的表现是:抽屉工作台场景原始 8.96ms,F1 不动(该场景没有多层光晕),F2 落到 6.01ms,F3 到 5.80ms,F4、F5 不动,F6 到 5.63ms,累计降幅 37%。F1 在这里"不动"不是 bug,而是模型的诚实之处:场景里没有可合并的光晕层,处方自然没有收益,界面会直接标成"无适用层"并降低整行透明度。
F4 与 F5 的关系则暴露了一个更真实的工程问题:处方之间有前置依赖。模态聚焦场景里,F5 单独施放的收益是 0.00ms,因为遮罩此时还是不透明度 0.62,达不到 92% 的完全遮挡门槛,一条都剔不掉;只有先开 F4 把遮罩压实,F5 才有 4 层可剔。界面把这件事写在了 F5 的说明里——“为下一步遮挡剔除创造条件”。工具如果只报单条收益,用户就会误判 F5 无用;把累积瀑布摆在旁边,依赖关系自然显形。

图4:处方页的完整读数。左侧六条处方逐条标出影响层数与单条收益,右侧上半是原始 / 处方后的复算对照,下半是 F1→F6 的顺序全开瀑布,8.96 → 5.63 ms 就是顺序全开后的累计结果。
九、Canvas 的工程细节:视口变换、独立光束、窗口缩放
ArkUI 的 Canvas 组件在桌面窗口里会频繁面对尺寸变化,这是手机端不太会遇到的问题。工程里三个画布组件统一用同一套重绘契约:onReady 首绘,onAreaChange 兜住尺寸变化:
Canvas(this.ctx)
.width('100%')
.height('100%')
.onReady(() => {
this.redraw();
})
.onAreaChange((oldValue: Area, newValue: Area) => {
this.redraw();
})
.onClick((e: ClickEvent) => {
const vp = this.vp();
const px = (e.x - vp.ox) / vp.s;
const py = (e.y - vp.oy) / vp.s;
if (px >= 0 && px <= DESIGN_W && py >= 0 && py <= DESIGN_H) {
this.onPick(px, py);
}
})
vp() 根据当前画布尺寸算出一个等比缩放系数,让 1000×620 的设计画布始终完整落在可视区内:
private vp(): Vp {
const v = new Vp();
const W = this.ctx.width;
const H = this.ctx.height;
const s = Math.min(W / DESIGN_W, H / DESIGN_H) * 0.94;
v.s = s > 0 ? s : 0.5;
v.ox = (W - DESIGN_W * v.s) / 2;
v.oy = (H - DESIGN_H * v.s) / 2;
return v;
}
于是绘制时用一次 translate + scale 把设计坐标整体搬进画布,线宽则反向除以 vp.s 保持视觉粗细稳定:
ctx.save();
ctx.translate(vp.ox, vp.oy);
ctx.scale(vp.s, vp.s);
// ……按 1000×620 设计坐标绘制
ctx.restore();
这里有个容易踩的坑:缩放之后 lineWidth = 1 会被放大成 vp.s 像素,画出来是粗线;所以工程里所有描边都写成 1 / vp.s,只有选中态的高亮线才刻意给到 2.4 / vp.s 和 2.6 / vp.s。
点击反算也必须走同一条变换链:e.x 是画布内坐标,减去偏移再除以缩放,才回到设计坐标。少除一次 vp.s,热力图上的点就会整体偏到左上方,而且窗口越宽偏得越离谱。
第三个细节是扫描光束独立成层。热力图上压着一条持续移动的渐变光带,如果它跟着热力图一起重绘,等于每 45ms 重算 8880 个格子加 13 层轮廓。所以光带被拆成单独的 BeamOverlay 组件,自己持有一块 Canvas,只画一条 createLinearGradient 光带:
aboutToAppear(): void {
this.start();
}
aboutToDisappear(): void {
this.stop();
}
private start(): void {
if (this.timer !== -1) {
return;
}
this.timer = setInterval(() => {
if (!this.active) {
return;
}
this.pos += 0.011;
if (this.pos > 1.02) {
this.pos = -0.02;
}
this.paint();
}, 45);
}
build() {
Canvas(this.ctx)
.width('100%')
.height('100%')
.hitTestBehavior(HitTestMode.None)
}
hitTestBehavior(HitTestMode.None) 是关键的一行:光带铺满整个画布,如果它参与命中测试,下层热力图的点击会被它全部吃掉,读点功能直接失效。声明为不参与命中测试后,点击穿透到 ScanBoard,而光带照常绘制。此外 aboutToDisappear 里必须清掉定时器——桌面应用会在窗口切换、页面返回时反复创建销毁组件,漏一个 clearInterval 就是一条持续跑着的循环。
十、状态管线:@State 切片,@Prop 加 @Watch 驱动重绘
ArkUI 的声明式更新管的是组件树,管不了命令式的 Canvas 上下文。画布内容要变,必须由状态变化显式触发一次 redraw()。工程的解法是用 @Prop + @Watch 把"数据变了"翻译成"重画":
@Component
export struct StackCanvas {
@Prop @Watch('redraw') layers: Layer[] = [];
@Prop @Watch('redraw') selected: number = -1;
@Prop @Watch('redraw') gap: number = 18;
onPick: (id: number) => void = () => {};
// ……
}
三个属性分别是图层数组、选中索引和拆分层距,任何一个变化都会回调 redraw(),不需要在父组件里手写"改了 gap 记得让画布重画"。这是把副作用收敛到一处,比在每次 onChange 里手动调用更不容易漏。
父组件的状态切片直接决定了重绘粒度:
@State mode: string = 'scan';
@State layers: Layer[] = [];
@State cells: number[] = [];
@State row: number[] = [];
@State metrics: Metrics = new Metrics();
@State selected: number = -1;
@State refresh: number = 120;
@State fixes: boolean[] = [false, false, false, false, false, false];
@State waterfall: WaterStep[] = [];
这里有一条 ArkTS 的硬约束值得强调:数组与对象的状态更新必须换新引用。原地 push 一个元素,ArkUI 观察不到变化,界面不会刷新。所以改可见性时要显式切片:
private toggleLayer(i: number): void {
if (this.baseLayers[i].kind === 'base') {
this.say('底板不可摘除,它是填充账单的锚点');
return;
}
this.baseLayers[i].visible = !this.baseLayers[i].visible;
this.baseLayers = this.baseLayers.slice();
this.baseMetrics = measure(this.baseLayers, this.refresh);
this.probeOpen = false;
this.rebuild();
}
slice() 造出的新数组让 @State 感知到变化,随后 rebuild() 把整条计算链重跑一遍:重算基线账单、施用处方、扫描栅格、重算单条收益与累积瀑布。整个链路是同步的,一次点击走完,界面随后统一刷新——这是桌面交互能接受的时延,因为 8880 格的统计在这个量级上是一次很轻的计算。
模式切换用的是同一种"数据驱动分支"写法,三个视口在 build() 里按 mode 互斥出现,切换时不做任何手动清理:
if (this.mode === 'scan') {
this.scanView()
} else if (this.mode === 'stack') {
this.stackView()
} else {
this.rxView()
}
真正会被反复重建的只有画布组件本身,所以它们的 onReady 必须承担首绘,aboutToAppear 必须自己启动定时器,aboutToDisappear 必须清干净——这三个生命周期在桌面端切换视图时会被高频触发,任何一个漏掉都会留下隐形开销。
十一、鸿蒙PC 上的实测读数
四个场景、三种刷新率、六条处方的组合,全部在这台鸿蒙PC 上跑出来。120Hz 下的原始读数如下:
| 场景 | 图层 | 填充耗时 | 帧预算占用 | 平均叠加 | 过绘制比 |
|---|---|---|---|---|---|
| 01 指挥舱(毛玻璃主控) | 13 | 9.34 ms | 112% | 2.24× | 72% |
| 02 抽屉工作台(侧栏+抽屉) | 11 | 8.96 ms | 107% | — | — |
| 03 模态聚焦(全屏遮罩) | 12 | 11.06 ms | 133% | — | 100% |
| 04 光晕首屏(视差光球) | 11 | 8.04 ms | 97% | — | — |
后两列只在 X 光视图的指标带里常驻显示,其余场景切到 X 光视图后同样可读,上表只记录切到该视图时读到的完整口径。
120Hz 的帧预算是 8.33ms。四个场景里三个超支,只有一个勉强落在预算内。这里最容易误判的是指挥舱:平均叠加只有 2.24×,看起来离"惨不忍睹"很远,但填充耗时 9.34ms 已经超出预算 1.00ms,占掉 112%。
把预算从 120Hz 切到 60Hz,同一份场景的占用率立刻掉到 56%,界面从"超出帧预算"变成"预算内"——同一界面、同一台机器、同一份代码,只因为窗口刷新率不同,结论完全相反。这就是为什么工具把刷新率做成顶部常驻的三段开关,而不是藏在设置里:预算口径必须和读数摆在一起。
模态聚焦是四个场景里最值得看的。12 层、10.82 Mpx 片元、填充 11.06ms、预算占用 133%、过绘制比 100%——意味着所有已覆盖像素都至少被填了两遍。原因很直接:一整块不透明度 0.62 的全屏遮罩压在背景三张卡片上,遮罩本身要填满一屏,被它盖住的卡片还要各自填一遍,然后才轮到遮罩做混合。逐层账单里,遮罩与卡片合计吃掉了绝大部分预算。
对这个场景按顺序开处方,读数变化是:只开 F2(玻璃去模糊)单条收益 -1.67ms,只开 F3(投影收窄)-0.15ms,只开 F6(静态饰条合并)-0.08ms;F1、F4、F5 的单条收益都是 0.00ms。而把 F4 打开之后 F5 才具备 4 层的可剔除量。这三档数字放在一起,才是完整的判断依据。

图5:工具把"口径"做成一个常驻入口。片元量与权重、填充耗时、帧预算与过绘制、处方的施用方式、看数字之前该做什么,五条口径连同诚实边界一起写在面板里,任何人打开都能复算同一组数字。
十二、把"跨平台"说准确:ArkUI 与 ArkUI-X 的边界
文章开头已经划过一次边界,这里把它说透,因为这是最容易写错的地方。
ArkUI 是框架,ArkTS 是语言。 本文工程里所有界面都用 ArkUI 的声明式语法描述:Column / Row / Stack 组织布局,@Builder 抽出可复用的 UI 片段,@State / @Prop 管理状态,@Watch 驱动副作用。Canvas、Slider、Scroll、Button 都是 ArkUI 的内置组件。这是"用 ArkUI 开发",不是"用 ArkUI-X 开发"。
ArkUI-X 是 ArkUI 跨平台框架的延伸工程体系。 它让基于 ArkUI 写的界面有能力构建到其他操作系统上,工程结构、构建链、平台适配层都和单平台工程不同。本文工程是 deviceTypes: ['2in1'] 的原生鸿蒙PC 应用,没有引入 ArkUI-X 的工程结构,也没有多平台产物。
那为什么还把它算作"ArkUI 跨平台框架技术"的实践?因为在 ArkUI 的体系里,跨平台能力的第一层含义是跨设备形态:同一套声明式 UI 与同一套状态模型,在手机、折叠、平板、2in1 上成立。本文工程把设备目标钉在 2in1,所有几何都用设计坐标表达、按 vp 布局、按百分比与 layoutWeight 分配空间,窗口从 1200 宽拖到 2400 宽界面都成立;画布的缩放系数按可用尺寸反算,不依赖任何固定分辨率。这正是跨平台框架该有的写法——不假设屏幕。
所以准确的表述是:这是一个在鸿蒙PC 上、用 ArkUI 跨平台框架技术栈构建的鸿蒙PC 原生桌面应用;它验证了 ArkUI 在 2in1 形态上的布局能力、Canvas 绘制能力与状态驱动能力,并且这套写法在 ArkUI-X 面向其他系统的工程里可以直接复用。它不能被说成"一份代码跑遍全平台",那是另一件事。
工程源码托管在 AtomGit 平台,同批开源鸿蒙PC 工程可在 PC 社区平台的申请新建项目入口查看:https://atomgit.com/OpenHarmonyPCDeveloper。
十三、结语
这个工具最终沉淀下来的不是四个场景的漂亮读数,而是三件更硬的东西。
一是可复算的成本模型。几何 → 片元 → 毫秒,三步全部能用纸笔追平,手算的三层与界面读数分毫不差。一个能被人复核的模型,才配参与决策;一个只能给出结论的模型,本质上还是玄学。
二是同模型复算的处方机制。六条处方都是图层数组的纯变换,施用后走一遍同样的公式,不做插值、不做估算。这让"改哪一层更值"变成可对比的排序,也让处方之间的前置依赖显形——F4 不压实遮罩,F5 就无层可剔,这种关系只有把累积瀑布摆在旁边才看得出来。
三是桌面窗口的适配纪律。固定侧栏加弹性主区、视口按可用尺寸反算、onAreaChange 兜住缩放、定时器成对启停、命中测试显式穿透——这些都是在鸿蒙PC 的窗口环境里被反复触发、在手机上几乎不会遇到的路径。
把这三件事放在一起看,"在鸿蒙PC 上开发鸿蒙PC 应用"就不只是一句口号了:开发环境、构建链、运行目标、调试观测全部收在同一台设备上,从改一行 blur 到看见毫秒数变化,闭环不超过一次点击。ArkUI 跨平台框架提供的声明式布局与 Canvas 能力足够支撑这类工程化的分析工具,而模型本身的口径与边界,仍然需要由写代码的人负责说清楚。
更多推荐



所有评论(0)