鸿蒙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

STRATA 在鸿蒙PC上运行:指挥舱场景的 X 光视图,平均叠加 2.24×,过绘制 72%,填充 9.34ms

图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:不是把手机页面放大,而是桌面窗口的层结构和像素预算本来就更紧张。

抽屉工作台场景的轴测爆炸视图,11 层沿 Z 轴拆开

图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 指挥舱(毛玻璃主控)139.34 ms112%2.24×72%
02 抽屉工作台(侧栏+抽屉)118.96 ms107%——
03 模态聚焦(全屏遮罩)1211.06 ms133%—100%
04 光晕首屏(视差光球)118.04 ms97%——

后两列只在 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 能力足够支撑这类工程化的分析工具,而模型本身的口径与边界,仍然需要由写代码的人负责说清楚。

Logo

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

更多推荐