鸿蒙PC 异常显影暗房:3969 次报错如何收敛成 3 条定影结论——ArkUI 声明式 UI 的三处减法,兼跨平台框架选型边界(ArkUI-X / Flutter 对照)
鸿蒙PC 异常显影暗房:3969 次报错如何收敛成 3 条定影结论——ArkUI 声明式 UI 的三处减法,兼跨平台框架选型边界(ArkUI-X / Flutter 对照)
欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper
前言:报错排查台是最容易做成「看起来很专业」的一类应用——四个指标卡、一张堆栈列表、几根柱状图,截个图就能唬人。但真正决定它有没有用的,是三件看不见的事:同一条报错能不能稳定聚成一组、派生统计值会不会在每一帧里重算一遍、治理规则是不是对自己也生效。本文用一个完整可运行的鸿蒙PC 桌面应用「烛室 · Lucida」(Lucida_ohos)做样本,把「错误签名归一化 → 去重窗口 → 置信度门槛 → 定影」这条排查链路写实,再把它自己的三处性能与生命周期缺陷逐个拆开、给出可直接编译的 ArkTS 修复稿;最后一章用一张决策矩阵讲清楚:在 2in1 桌面形态上,什么时候该用 ArkUI 原生 声明式 UI,什么时候才值得引入跨平台框架(ArkUI-X、Flutter、React Native 这一层)。
关键词:鸿蒙PC、鸿蒙 PC、开源鸿蒙PC、跨平台框架、ArkUI 原生、ArkTS、ArkUI 声明式 UI、错误签名归一化、崩溃聚类、性能优化、方案选型治理、派生值预计算、LazyForEach、定时器生命周期、2in1 桌面形态、AtomGit

图 1 鸿蒙PC 完整桌面:前景是「烛室 · Lucida」的底片墙,背后是 DevEco 里的 Lucida_ohos 工程树,桌面底部 Dock 与右上系统状态栏清晰可见,最下方终端还留着本次运行的 aa start -a EntryAbility -b com.lucida.errorlab 输出
一、先把这台「暗房」交代清楚
1.1 工程基线
Lucida_ohos 是一个 ArkUI 原生、纯 ArkTS 的鸿蒙PC 单页应用,全部界面只有 10 个 .ets 源文件。
| 项 | 值 |
|---|---|
| 应用名 | 烛室 · Lucida |
bundleName | com.lucida.errorlab |
versionCode / versionName | 1000000 / 1.0.0 |
deviceTypes | ["2in1"](只面向鸿蒙PC 形态,不铺手机/平板) |
| SDK | compatibleSdkVersion 与 targetSdkVersion 均 26.0.0 |
| 构建模型 | apiType: 'stageMode',modelVersion: 5.0.0 |
| 三方依赖 | 空(oh-package.json5 的 dependencies: {},零三方库) |
| 源码结构 | pages/Index.ets + 6 个组件(SideSpine / NegativesView / DevelopView / ClusterView / VerifyView / ReportView)+ common(Models / Theme)+ EntryAbility |
这套配置本身就是一条经验:桌面应用要从第一天就钉死 deviceTypes 与 SDK 版本。API 26 起 compatibleSdkVersion 必须写 "26.0.0" 这样的三段式,纯数字的 26 会直接让构建失败;deviceTypes: ["2in1"] 则决定了应用只会被投放到鸿蒙PC,不会在手机形态上被拉成一个细长的畸形布局。工程里没有一行 window 相关的窗口尺寸代码,EntryAbility.onWindowStageCreate 只有一句 loadContent('pages/Index')——这意味着窗口的初始尺寸、可调边界全部交给系统桌面去管,应用侧只负责「给多大画多大」。这正是桌面布局必须全用 layoutWeight(1) 与百分比、而不是写死像素的根本原因。
1.2 界面骨架:一条 88vp 的书脊 + 五个工作台
整个应用的结构非常好读:左侧一条固定 width(88) 的竖向书脊(SideSpine,暗房隐喻里叫「烛室」),右侧 layoutWeight(1) 装当前工作台。五个工作台靠 @State viewIndex: number 切换,分别是底片墙(错误清单)、显影(单条错误的堆栈与结论)、聚类(错误分组)、验证(修复复测炉)、档案(统计台账)。
书脊上那五个竖排的二字标题,源码里是这么写的:
// components/SideSpine.ets(现状)
Column() {
ForEach(label.split(''), (ch: string) => {
Text(ch)
.fontSize(17)
.fontWeight(this.activeIndex === idx ? FontWeight.Bold : FontWeight.Medium)
.fontColor(this.activeIndex === idx ? '#F3EEE4' : '#9A948A')
.margin({ bottom: 3 })
}, (ch: string) => ch + idx.toString())
}
每个汉字一个 Text,五个标题就是 10 个文本节点;而且 label.split('') 在每次渲染时都会新建一个数组,ForEach 的键又拼了 idx。这不是性能灾难(10 个节点对 ArkUI 不算什么),但它是一个模式问题:用一个字符数组去模拟竖排,等于放弃了文本自身的能力。第十章第 8 条会给替代写法——单个 Text 配固定行宽自动逐字换行,节点数从 10 降到 5,键也变稳定。
1.3 数字从哪来:一句必须说清楚的实话
界面上的「3969 次累计报错」「置信度 92%」「12 周柱状图」全部来自 common/Models.ets 里的构造数据:6 条 ErrorNegative、5 条 ClusterGroup、4 条 VerifyTrial、12 个趋势整数。没有任何一条是真实采集的崩溃上报,Models.ets 的字段名再像线上表结构,它也只是字面量。
但它和「随手糊的假数据」有个关键区别:每个数字都能复算。6 条底片的命中数分别是 2184、641、347、512、189、96,加起来正好 3969,与档案页的「累计报错 3969 次」严格对上;聚类页的 5 组占比 38 / 24 / 18 / 13 / 7 加起来正好 100。这种「可复算」是演示工程最该守住的底线——数据可以是编的,账必须是平的。
需要额外说明一处版本差异:档案页截图显示「待显影 2 张 / 显影中 0 张 / 已定影 3 张」,而源码初始值是 open:2 / developing:1 / fixed:2 / wontfix:1。差异来自一次真实的点击——在显影页对 NEG-0417 按下「判制定影」,它的 status 由 developing 变成 fixed,于是 developing 归零、fixed 变 3。截图是操作之后的现场,源码是初始态,两者不矛盾。
二、报错排查(一):把「一条报错」变成一个稳定的签名
2.1 聚合失败的真正原因
做过线上排查的人都知道,最烦的不是崩溃本身,而是同一条崩溃在后台显示成一万条。原因很朴素:错误消息里天生带着不稳定信息。
以本项目图 2 里那条 Cannot read property width of null in MasonryGrid 为例,真实上报时它通常长这样:
Cannot read property width of null in MasonryGrid at node 0x7f3a1c20 (item 1847, 32.4ms)
Cannot read property width of null in MasonryGrid at node 0x7f3a9920 (item 92, 18.1ms)
两条是同一个 bug,字符串却完全不同。如果直接拿 message 当聚合键,聚合率是 0;如果粗暴地只取前 30 个字符,又会把「同一句报错、不同根因」的错误吞成一条。归一化与区分度是需要同时满足的矛盾,解法是分层:消息归一化负责「抹掉噪声」,栈顶符号负责「保住区分度」。
2.2 归一化:三条规则,顺序不能反
// 新增文件:entry/src/main/ets/common/Triage.ets
export class RawError {
readonly id: string;
readonly module: string;
readonly message: string;
readonly topSymbol: string;
readonly at: number;
readonly deviceId: string;
constructor(id: string, module: string, message: string, topSymbol: string,
at: number, deviceId: string) {
this.id = id;
this.module = module;
this.message = message;
this.topSymbol = topSymbol;
this.at = at;
this.deviceId = deviceId;
}
}
const QUOTED: RegExp = /"[^"]*"/g;
const HEX: RegExp = /0x[0-9a-fA-F]+/g;
const NUM: RegExp = /\d+/g;
export function normalizeMessage(msg: string): string {
let s: string = msg.replace(QUOTED, '"*"'); // 1. 引号里的内容一律打码
s = s.replace(HEX, '0x#'); // 2. 先吃掉十六进制地址
s = s.replace(NUM, '#'); // 3. 再把剩下的纯数字抹平
return s.toLowerCase(); // 4. 大小写对齐
}
export function signatureOf(raw: RawError): string {
return raw.module + '|' + normalizeMessage(raw.message) + '|' + raw.topSymbol;
}
顺序很关键:先处理十六进制,再处理纯数字。如果反过来,0x7f3a1c20 会先被 \d+ 拆成「0x + 一串 #」,留下 0x######## 这种长度不稳定的残渣,不同位数的地址就聚不到一起。同理,引号内容必须在数字之前打码,否则 item "1847" 这类带引号的 ID 会先被数字规则吃掉、再被引号规则盖住,虽然结果相同但语义更脏。
2.3 为什么签名要带上栈顶符号
归一化之后,「同一句报错、不同根因」的问题就浮出来了。本项目里 MasonryGrid 有两处都可能抛空引用:
- 一处在
MeasureChildren(测量阶段读节点宽度),源码MasonryGrid.ets:142; - 一处在
LayoutFlow(布局阶段重排),源码MasonryGrid.ets:97。
这两处的消息文本可以完全一致,但修复方式完全不同:前者要在异步图片回调里判空,后者要在布局前重建脏节点表。如果只看消息,它们会被并成一条,你修完一处、另一处还在崩,然后你开始怀疑「这个 bug 怎么修不死」。把栈顶业务符号纳入签名,就一次分开了。
这也是本项目 ErrorNegative 模型要保留 frames: StackFrame[] 的原因——DevelopView 里那四帧不是给用户看的装饰,而是签名的组成部分。下图里 01、02 两帧被标成「可疑帧」(suspicious: true),恰好就是这两处业务帧。

图 2 显影页:NEG-0417 标着「崩溃 · 致命 · 置信度 92%」,右侧是「判制定影」;中部四步证据链(回调 onComplete → 节点已回收 → MeasureChildren 判空缺失 → 进程崩溃),下部四帧堆栈中第 01、02 帧被标为「可疑帧」
三、报错排查(二):去重窗口、聚类与「够不够格定影」
3.1 命中数不等于发生次数
一条错误在崩溃的瞬间可能连报十几次(进程重启后立刻复现),也可能一台设备反复触发。排查台如果只显示「命中 2184 次」,你会误判成「2184 个用户受影响」。所以要做两级计数:hits(原始条数)和 episodes(按时间窗切分后的「发作轮次」)。
// 追加到 Triage.ets
export class Cluster {
readonly key: string;
readonly signature: string;
readonly sample: string;
readonly hits: number;
readonly episodes: number;
readonly devices: number;
readonly firstAt: number;
readonly lastAt: number;
constructor(key: string, signature: string, sample: string, hits: number,
episodes: number, devices: number, firstAt: number, lastAt: number) {
this.key = key;
this.signature = signature;
this.sample = sample;
this.hits = hits;
this.episodes = episodes;
this.devices = devices;
this.firstAt = firstAt;
this.lastAt = lastAt;
}
}
function shortHash(input: string): string {
let h: number = 5381;
for (let i = 0; i < input.length; i++) {
h = (h * 33 + input.charCodeAt(i)) % 4294967296;
}
return h.toString(16).padStart(8, '0');
}
export function aggregate(raw: RawError[], windowMs: number): Cluster[] {
const buckets: Map<string, RawError[]> = new Map<string, RawError[]>();
for (let i = 0; i < raw.length; i++) {
const sig: string = signatureOf(raw[i]);
const list: RawError[] | undefined = buckets.get(sig);
if (list === undefined) {
buckets.set(sig, [raw[i]]);
} else {
list.push(raw[i]);
}
}
const out: Cluster[] = [];
buckets.forEach((items: RawError[], sig: string) => {
items.sort((a: RawError, b: RawError): number => a.at - b.at);
const devices: Set<string> = new Set<string>();
let episodes: number = 0;
let lastAt: number = -1;
for (let i = 0; i < items.length; i++) {
if (items[i].at - lastAt > windowMs) {
episodes++; // 超过窗口间隔,记一次新的发作
}
lastAt = items[i].at;
devices.add(items[i].deviceId);
}
out.push(new Cluster(shortHash(sig), sig, items[0].message, items.length,
episodes, devices.size, items[0].at, items[items.length - 1].at));
});
out.sort((a: Cluster, b: Cluster): number => {
if (b.hits !== a.hits) {
return b.hits - a.hits;
}
return a.key < b.key ? -1 : 1; // 同分用 key 兜底,保证排序确定
});
return out;
}
windowMs 取 10 分钟是一个可用的起点:同一条签名在 10 分钟内连续上报,视作同一次发作。这个值必须可配、且必须写进报表口径,否则「2184 次 / 96 轮」和「2184 次 / 12 轮」会得出完全相反的优先级结论。
排序那里多写了一个兜底:命中数相同时按 key 升序。这不是洁癖——如果只按 hits 排,同分组的先后顺序就取决于 Map 的插入顺序,而插入顺序取决于上报到达顺序,同一批数据重放两次会得到两种顺序。一旦顺序不稳定,你在 AtomGit 上归档的结论、写进报表的「本期 Top1」就都会飘。
shortHash 用 djb2 而不是 Math.random 或时间戳:签名必须幂等。同样的输入必须永远得到同样的 key,否则前端列表的键会漂移、排序会跳、结论和 issue 对不上号。
3.2 置信度不是装饰,是准入门槛
图 2 里那条错误标着「置信度 92%」,档案页 6 条分别是 92 / 88 / 95 / 86 / 90 / 81。这些数字在源码里是 ErrorNegative.confidence 字面量,但如果要让「判制定影」这个动作有依据,它应该由证据算出,而不是手填。
// 追加到 Triage.ets
export class Evidence {
readonly stack: boolean; // 栈里命中了可疑业务帧
readonly log: boolean; // 日志里有同时间窗的上下文
readonly perf: boolean; // 性能采样出现同指纹(掉帧/卡顿/ANR)
constructor(stack: boolean, log: boolean, perf: boolean) {
this.stack = stack;
this.log = log;
this.perf = perf;
}
}
export const FIX_THRESHOLD: number = 90;
export function confidenceOf(e: Evidence): number {
let s: number = 0;
if (e.stack) { s += 0.5; }
if (e.log) { s += 0.3; }
if (e.perf) { s += 0.2; }
return Math.round(s * 100);
}
export function canFix(c: Cluster, e: Evidence): boolean {
return confidenceOf(e) >= FIX_THRESHOLD && c.episodes >= 3;
}
权重 0.5 / 0.3 / 0.2 的理由是证据强度递减:栈直接指向代码位置,是强证据;日志能补上下文,是中等证据;性能采样只能证明「当时确实卡了」,不能证明「是这个函数卡的」。三者齐备才是 100。
按这条门槛回看那 6 条:只有 92、95、90 三条够格「定影」,81、86、88 三条应该继续取证。这就是治理的含义——不是所有报错都该立刻动手,得有一条写死的准入线。 我在 canFix 里额外要求 episodes >= 3,是为了挡掉「偶发一次就被当成必现 bug 修」的浪费:一次发作的样本量,连复现都谈不上。

图 3 聚类页:五组「药水槽」(空引用判空缺失 38%、主线程阻塞 24%、渲染重绘风暴 18%、边界越界 13%、资源泄漏 7%)各带人数、周环比与占比条;右侧 12 周柱图最后三周(W10–W12)用亮红标出近期抬头
四、热路径盘点:一帧之内被重复算了三遍的地方
4.1 先数一遍「每一帧都在算什么」
性能优化最难的部分不是写优化代码,而是承认哪几行是纯重复劳动。ArkUI 的 build() 是热路径。任何一次状态变化都会让受影响的组件重新执行 build(),而 build() 里调用的每个函数都会被重新执行一遍。这台暗房里有三处在 build 路径上做全量扫描:
第一处,Index.mainBody() 直接调用 this.filtered():
// pages/Index.ets(现状)
private filtered(): ErrorNegative[] {
let out: ErrorNegative[] = [];
for (let i = 0; i < this.negatives.length; i++) {
const n = this.negatives[i];
if (this.filterKind !== 'all' && n.kind !== this.filterKind) {
continue;
}
out.push(n);
}
return out;
}
@Builder
mainBody() {
if (this.viewIndex === 0) {
NegativesView({ negatives: this.filtered(), /* ... */ })
}
}
两个后果。其一,每次渲染都新建一个数组,子组件的入参引用每次都变,NegativesView 必然整棵重建;其二,this.current() 在显影页同理,用线性查找在数组里找 selectedId,每次渲染扫一遍。
第二处,ReportView 的四个指标卡:
// components/ReportView.ets(现状)
private countOf(status: string): number {
let n: number = 0;
for (let i = 0; i < this.negatives.length; i++) {
if (this.negatives[i].status === status) { n++; }
}
return n;
}
this.metricCard('累计报错', this.totalHits().toString() + ' 次', '#E45B3F')
this.metricCard('待显影', this.countOf('open').toString() + ' 张', '#D98E32')
this.metricCard('显影中', this.countOf('developing').toString() + ' 张', '#D98E32')
this.metricCard('已定影', this.countOf('fixed').toString() + ' 张', '#5E8A6E')
totalHits() 一次全扫,countOf() 四次全扫,一次渲染就是 5n 次比较。n = 6 时是 30 次,测不出来;n = 2000 时是 1 万次,而且这 1 万次是「纯重复劳动」——数据一条没变,只是窗口挪了一下。
第三处,聚类页的柱状图归一化:
// components/ClusterView.ets(现状)
Row({ space: 6 }) {
ForEach(this.trend, (v: number, idx: number) => {
Column()
.height(Math.max(8, Math.round(v / this.maxTrend() * 150)))
// ...
}, (v: number, idx: number) => 'w' + idx.toString())
}
this.maxTrend() 写在 ForEach 的 item 构造里,意味着每根柱子都要重扫一遍 12 个数据求最大值:12 × 12 = 144 次比较,而正确答案只有一个,且整张图共用。
把三处加起来,n = 2000 时的每帧开销是 5n + 144 + n(current())≈ 1.2 万次比较。16.7 ms 的帧预算不会因为这 1.2 万次比较就崩,但它会稳定吃掉一部分 headroom——而桌面窗口拖动、缩放时,build() 是会被高频触发的。

图 4 档案页:累计报错 3969 次、待显影 2 张、显影中 0 张、已定影 3 张——这四条数字就是 totalHits() 与三次 countOf() 每次渲染都重算一遍的结果;下方「本期关键判断」6 行结论各带置信度(92 / 88 / 95 / 86 / 90 / 81);对照源码初始态,developing 归零、fixed 变 3,正是点过一次「判制定影」的结果
4.2 修复:写穿式索引,一次构建、多次读
正确姿势是把派生值改造成「写入时重算」的缓存,而不是「读取时现算」。ArkUI 的 V1 状态管理没有 computed 语义,所以缓存要自己管,但只需要管一处:数据变更的那个入口。
// 新增文件:entry/src/main/ets/common/NegativeIndex.ets
import { ErrorNegative } from './Models';
export class ReportStats {
readonly totalHits: number;
readonly open: number;
readonly developing: number;
readonly fixed: number;
readonly parked: number;
constructor(totalHits: number, open: number, developing: number,
fixed: number, parked: number) {
this.totalHits = totalHits;
this.open = open;
this.developing = developing;
this.fixed = fixed;
this.parked = parked;
}
}
export function statsOf(list: ErrorNegative[]): ReportStats {
let total: number = 0;
let open: number = 0;
let developing: number = 0;
let fixed: number = 0;
let parked: number = 0;
for (let i = 0; i < list.length; i++) {
const n: ErrorNegative = list[i];
total += n.count;
if (n.status === 'open') {
open++;
} else if (n.status === 'developing') {
developing++;
} else if (n.status === 'fixed') {
fixed++;
} else {
parked++; // wontfix 也要算进账,否则台账不闭合
}
}
return new ReportStats(total, open, developing, fixed, parked);
}
export class NegativeIndex {
private all: ErrorNegative[] = [];
private byId: Map<string, ErrorNegative> = new Map<string, ErrorNegative>();
private byKind: Map<string, ErrorNegative[]> = new Map<string, ErrorNegative[]>();
private stats: ReportStats = new ReportStats(0, 0, 0, 0, 0);
private trendMax: number = 0;
rebuild(list: ErrorNegative[], trend: number[]): void {
this.all = list;
this.byId.clear();
this.byKind.clear();
this.stats = statsOf(list);
let max: number = 0;
for (let i = 0; i < trend.length; i++) {
if (trend[i] > max) { max = trend[i]; }
}
this.trendMax = max;
for (let i = 0; i < list.length; i++) {
const n: ErrorNegative = list[i];
this.byId.set(n.id, n);
const bucket: ErrorNegative[] | undefined = this.byKind.get(n.kind);
if (bucket === undefined) {
this.byKind.set(n.kind, [n]);
} else {
bucket.push(n);
}
}
}
get(id: string): ErrorNegative | undefined { return this.byId.get(id); }
kinds(): Map<string, ErrorNegative[]> { return this.byKind; }
list(kind: string): ErrorNegative[] {
if (kind === 'all') { return this.all; }
const bucket: ErrorNegative[] | undefined = this.byKind.get(kind);
return bucket === undefined ? [] : bucket;
}
report(): ReportStats { return this.stats; }
max(): number { return this.trendMax; }
}
改造后的调用侧只有两行成本:
// pages/Index.ets(修复后)
import { buildTrend } from '../common/Models';
import { NegativeIndex } from '../common/NegativeIndex';
private index: NegativeIndex = new NegativeIndex();
private trend: number[] = buildTrend(); // 由 Index 持有,再传给 ClusterView
aboutToAppear(): void {
this.index.rebuild(this.negatives, this.trend);
}
private commit(id: string, status: string): void {
const target: ErrorNegative | undefined = this.index.get(id);
if (target === undefined) { return; }
target.status = status;
this.negatives = this.negatives.slice(); // 通知视图层:引用变了
this.index.rebuild(this.negatives, this.trend); // 写穿:改完立刻重算
}
这样 build() 里只剩 this.index.report().totalHits 与 this.index.list(this.filterKind) 两次 O(1) 读取,指标卡的 5n 次扫描和柱状图的 144 次比较全部归零。代价是每次状态变更多一次 O(n) 重建——而这正好是我们想要的形状:写少、读多,就可以把成本压到写路径上。
顺带一个必须提醒的坑:target.status = status 之后必须 this.negatives = this.negatives.slice()。ArkUI 对 @State 数组元素的深层属性变更感知并不总是可靠,直接改元素属性可能不触发重渲染;换一个新数组引用是最稳的「通知」。改完引用再重建索引,顺序不能反,否则索引里握着的还是旧数组。
五、列表的三处隐性开销:死状态、会自我失效的键、一次性建完的 ListItem
5.1 最贵的状态,是那个「什么都不影响」的状态
性能优化做到列表这一层,重点往往已经不是算法,而是「谁在无谓地重渲染」。本章的三处开销,没有一处会出现在代码审查的告警里。
底片墙右上角有个检索框。源码这么写:
// components/NegativesView.ets(现状)
@State query: string = '';
TextInput({ text: this.query, placeholder: '检索错误…' })
.onChange((v: string) => {
this.query = v;
})
看起来没问题,直到你去追过滤逻辑——它在父组件的 filtered() 里,而那里只判断 this.filterKind:
if (this.filterKind !== 'all' && n.kind !== this.filterKind) {
continue;
}
query 没有参与任何计算。于是每敲一个字符:@State query 变化 → NegativesView 整组件重渲染 → 内部 List 的所有 ListItem 重新走一遍 build → 过滤结果一个字节都没变。这是最典型的「负收益状态」:它不产出任何功能,只产出渲染开销。
这里有个取舍要想清楚。方案 A 是干脆不给输入框绑状态(非受控):
// 方案 A:输入框不回写状态,只在回车时取一次值
private pending: string = ''; // 普通字段,不是 @State,改它不触发渲染
TextInput({ placeholder: '检索错误…' })
.onChange((v: string) => {
this.pending = v;
})
.onSubmit((enterKey: EnterKeyType) => {
this.onQuery(this.pending);
})
代价是「清空/程序化重置输入框」做不到。方案 B 是真过滤 + 防抖,保留状态但把重渲染压到停手之后:
// 方案 B(推荐):120ms 防抖后才落状态
private debounce: number = -1;
TextInput({ placeholder: '检索错误…' })
.onChange((v: string) => {
if (this.debounce >= 0) { clearTimeout(this.debounce); }
this.debounce = setTimeout(() => {
this.debounce = -1;
this.onQuery(v); // 只把结果推给父组件,自己不改状态
}, 120);
})
方案 B 的关键不在防抖,而在**「输入框自己不改状态」**:TextInput 不绑 text,就不会因为状态变化把自己刷一遍;过滤结果由父组件的 filterKind 换成 query 之后统一走 NegativeIndex,链路只剩一次。这两个方案都比现状好,区别只是「要不要程序化控制输入框」。
5.2 用可变字段拼 key,等于每次改状态都换一个列表项
底片墙的 ForEach 键是:
}, (item: ErrorNegative) => item.id + item.status + item.count.toString())
意图大概是「状态变了就刷新这张卡」,但 ArkUI 的键语义是身份,不是版本。键一变,框架认为「这是一条新数据」,于是销毁旧 ListItem、新建一个。后果在桌面端特别明显:滚动位置丢、hover 态丢、选中态的过渡动画被截断,点「判制定影」的一瞬间整行闪一下。
正确做法是键只写身份,可变字段交给 build 内部读取:
}, (item: ErrorNegative) => item.id)
因为 status 是组件内被读取的属性,状态变化本来就会触发这张卡重渲染,不需要靠换键来「强制刷新」。换键强制刷新是 React 里 key={Math.random()} 的同款反模式,在 ArkUI 里同样成立。
5.3 台账上千条时,ForEach 必须换成 LazyForEach
只有 6 条数据时,List + ForEach 完全够用。但排查台一旦接上真实上报,条数会到几百上千,此时 List 会一次性把所有 ListItem 建出来——构建成本、内存占用、首屏时间三项同时恶化。LazyForEach 配 IDataSource 才是正解:
// 追加到 common/NegativeIndex.ets
export class NegativeSource implements IDataSource {
private items: ErrorNegative[] = [];
private listeners: DataChangeListener[] = [];
totalCount(): number { return this.items.length; }
getData(index: number): ErrorNegative { return this.items[index]; }
registerDataChangeListener(listener: DataChangeListener): void {
if (this.listeners.indexOf(listener) < 0) {
this.listeners.push(listener);
}
}
unregisterDataChangeListener(listener: DataChangeListener): void {
const i: number = this.listeners.indexOf(listener);
if (i >= 0) { this.listeners.splice(i, 1); }
}
reload(list: ErrorNegative[]): void {
this.items = list;
for (let i = 0; i < this.listeners.length; i++) {
this.listeners[i].onDataReloaded();
}
}
}
// components/NegativesView.ets(修复后)
List({ space: 12 }) {
LazyForEach(this.source, (item: ErrorNegative) => {
ListItem() {
this.negativeCard(item)
}
}, (item: ErrorNegative) => item.id)
}
.cachedCount(6) // 视口外多留 6 条,滚动回拉时不闪白
.scrollBar(BarState.Off)
.edgeEffect(EdgeEffect.Spring)
cachedCount(6) 是桌面端的经验值:鸿蒙PC 窗口高度比手机大得多,一屏能放 6–8 张卡片,预取太少会在高速滚动时露白。onDataReloaded() 是「全量重载」语义,简单但会重建可见项;数据量再上一个量级时应该切到 onDataAdd / onDataChange 的增量通知——这也是我在 NegativeSource 里保留 listeners 数组、而不是直接绑一个 @State 数组的原因:增量通知需要一个可枚举的观察者列表。
六、一致性审计:诊断台犯了自己写进结论的病
6.1 先替源码说句公道话
本章的两处问题,一处偏性能(定时器不随视图收敛),一处偏正确性(没有句柄,链条可能静默空转);但它们来自同一个源头:这段代码只被验证过「点下去有用」,没被验证过「离开时会收尾」。
验证炉页有个「点火复现」按钮,点了之后进度条要一格格涨。源码是递归 setTimeout:
// pages/Index.ets(现状)
private advanceTrial(id: string, p: number): void {
setTimeout(() => {
for (let i = 0; i < this.trials.length; i++) {
const t = this.trials[i];
if (t.id !== id) { continue; }
const next = p + 18 + Math.round(Math.random() * 10);
if (next >= 100) {
this.trials[i] = new VerifyTrial(t.id, t.name, t.condition,
t.before, t.after, 'done', 100);
} else {
this.trials[i] = new VerifyTrial(t.id, t.name, t.condition,
t.before, t.after, 'running', next);
this.advanceTrial(id, next);
}
}
}, 420);
}
很多文章会到这里就说「重复点击会起两条链,进度条会跳」。这个工程其实挡住了:VerifyView 的按钮写了 .enabled(t.state !== 'running'),running 期间按钮是灰的,点不动。这一点得替源码说清楚,否则就是扣帽子。
真正的问题在另外两处,而且都是真的:
- 没有句柄。
setTimeout的返回值从来没被保存,全工程没有任何一处clearTimeout针对这条链。这意味着一旦时序出岔子(比如trials数组被整体替换、id不再存在),这条链会静默空转:每次回调扫一遍数组、找不到目标、什么也不做、也不停。 - 不随视图生命周期收敛。
viewIndex从「验证炉」切到「聚类」或「档案」,VerifyView被销毁,但定时器挂在Index上,继续每 420 ms 跑一次。用户看着聚类页,后台有个看不见的进度条在推进——纯耗电、纯耗 CPU,而且如果用户切回来,看到的进度与他离开时的预期不一致。
6.2 修复:句柄表 + 幂等 + 离开就停
// pages/Index.ets(修复后)
private timers: Map<string, number> = new Map<string, number>();
private startTrial(id: string): void {
if (this.timers.has(id)) {
return; // 幂等:正在烧就不再点火
}
const t: VerifyTrial | undefined = this.trialOf(id);
if (t === undefined || t.state === 'done') {
return;
}
this.commitTrial(id, 8, 'running');
this.schedule(id, 8);
}
private schedule(id: string, p: number): void {
const handle: number = setTimeout(() => {
this.timers.delete(id); // 先摘句柄,再决定是否续烧
const next: number = p + 18 + Math.round(Math.random() * 10);
if (next >= 100) {
this.commitTrial(id, 100, 'done');
this.showToast(id + ' 复测完成');
return;
}
this.commitTrial(id, next, 'running');
this.schedule(id, next);
}, 420);
this.timers.set(id, handle);
}
private stopAll(): void {
this.timers.forEach((handle: number) => clearTimeout(handle));
this.timers.clear();
}
private switchView(idx: number): void {
if (idx !== 2) { // 离开验证炉就停火
this.stopAll();
}
this.viewIndex = idx;
}
aboutToDisappear(): void {
this.stopAll(); // 窗口关闭/Ability 退出,一个都不留
}
(trialOf 与 commitTrial 是按 id 查找、按 id 写回的两个小助手,实现略。)
三处细节值得单独说:
timers.delete(id)必须放在回调第一行。如果放在schedule里,续烧时新旧句柄会短暂共存,stopAll就有机会漏掉一个;has(id)做幂等,而不是靠按钮 disabled。按钮的enabled是 UI 层约束,任何绕过 UI 的调用路径(比如将来的「批量复测」)都不受它保护,句柄表才是唯一的真约束;aboutToDisappear是兜底,不是主逻辑。主逻辑是「切视图就停」,兜底是「组件销毁就停」。两层都要有,因为Index作为根页面在整个应用生命周期里都不会销毁——只写aboutToDisappear等于什么都没写,这也是很多人误以为「我加了清理」的假象。
顺带说一个耐人寻味的细节:同一个文件里的 toast 定时器,写得完全正确——if (this.toastTimer >= 0) { clearTimeout(this.toastTimer); },还顺手把句柄重置为 -1。也就是说,作者知道该怎么做,只是没把这个模式复制到复现链上。这类「同文件内不一致」的缺陷,比「完全不懂」更难靠 review 发现,因为它会被旁边那段正确代码掩护过去。
6.3 这条 bug 最讽刺的地方
翻一下 Models.ets 里第 6 条底片 NEG-0344 的结论:
连接轮换时旧心跳定时器未销毁即注册新定时器,产生双倍心跳频率,无崩溃但浪费能耗。
诊断台自己犯的,正是它写进结论文档里的病。 这是本文最想强调的一句:治理规则如果不是先对自己生效,它就只是给别人看的 PPT。所以修复稿的验收线里,我把「每个 trial 同时最多一个定时器」写成了硬指标——不是靠 review 眼力,而是靠 timers.size <= trials.filter(running).length 这条断言。
七、选型取舍之一:24 个节点,还是 12 根画笔
聚类页那张 12 周柱图,是用 12 个 Column 拼出来的,不是 Canvas。这是方案选型治理里最容易被审美绑架的一题——「图表」两个字很容易让人条件反射地画 Canvas。
先看它长什么样:
// components/ClusterView.ets(现状)
Column()
.width(16)
.height(Math.max(8, Math.round(v / this.maxTrend() * 150)))
.borderRadius(4)
.backgroundColor(idx >= this.trend.length - 3 ? '#E45B3F' : '#7A2B20')
12 根柱 = 12 个 Column + 12 个 Text(周标签)= 24 个节点。这个量级用 Canvas 是亏的:Canvas 要自己算坐标、自己画圆角、自己处理 vp2px 的高分屏换算、自己管重绘时机;而组件树交给 ArkUI 的布局引擎,圆角、颜色、动效、无障碍全部免费。图元少、变化低频、需要交互语义时,组件树赢。
反过来,什么时候必须上 Canvas?我给一张可以照着签字的判定表:
| 判据 | 组件树 | Canvas |
|---|---|---|
| 静态图元数量 | < 100 | > 200 |
| 是否需要逐帧重绘(每帧数据都变) | 否 | 是 |
| 是否需要单点命中测试 / 焦点 / 无障碍 | 是 | 否(要自己实现) |
| 是否需要裁剪、混合、渐变叠加 | 简单场景 | 复杂场景 |
| 滚动容器内数量 | 受 LazyForEach 约束 | 一块画布即可 |
用这张表回看本项目:12 根柱、数据变化频率是「一周一次」、需要 hover 提示 → 组件树正确。而同一个暗房如果要加一条「近 60 秒报错速率实时折线」,那就是每帧 60 个点、每秒重绘,必须换 Canvas 并且做脏矩形。
这条规则的实用价值在于:它把「我觉得 Canvas 更专业」这种审美判断,换成了可核对的三行数字。选型的本质是给后来者留下可复用的判断依据,而不是留下一个已经做完的决定。
八、选型取舍之二:跨平台框架的三张门票
8.1 先把说法摆正
必须说清楚一件事:本文这套界面全部由 ArkUI 原生声明式 UI 写成,用的是 ArkTS + 系统组件(Column / Row / List / Stack / Text / TextInput),跑的是鸿蒙PC 的 2in1 形态。工程里没有 ArkUI-X 的转译产物,也没有 Flutter、React Native 这类跨端运行时。
前面反复提到的跨平台框架是个更大的概念,指的是「一套 UI 代码在多端复用的那类框架」,包括 ArkUI-X、Flutter、React Native 等。它们的价值与代价完全不同,不能混为一谈。写这篇文章时我最怕的就是把「我用 ArkUI 写了个鸿蒙PC 应用」说成「我用跨平台框架写了个鸿蒙PC 应用」——前者是事实,后者是错的。
8.2 三张门票
我把「要不要引入跨平台框架」拆成三个必须同时答「是」的问题,任一答「否」,原生就是更优解:
- 复用票据:同一套界面是否真的要在 ≥ 2 个端上发布?注意是「发布」,不是「以后可能会」;
- 能力票据:目标场景是否避开系统能力的深水区?窗口模型、多窗口编排、剪贴板、文件选择器这类东西,跨平台框架的桌面适配通常最薄,桥接成本最高;
- 预算票据:性能预算是否有余量去吸收那层转换?重列表、逐帧动画、大图滚动这三类负载最吃亏。
三张票全齐,才轮到比较框架本身;缺一张,讨论就应该停在「先写原生」。这台暗房三张票都不齐:单端发布、重度依赖桌面窗口形态、列表与图表都在性能敏感区。
8.3 决策矩阵
| 约束 | ArkUI 原生 | 跨平台框架(ArkUI-X / Flutter / React Native) |
|---|---|---|
| UI 代码多端复用 | 无,需按端重写 | 强项,一套代码多端 |
| 渲染路径层数 | 少一层,直接进 ArkUI 渲染管线 | 多一层(转译 / 自绘 / 桥接) |
| 系统能力调用(窗口、文件、剪贴板、分布式) | 直接、类型完整 | 需桥接或插件,桌面端尤其薄 |
| 桌面窗口特性(多窗口、可调尺寸、Dock) | 原生支持 | 取决于框架的桌面适配成熟度 |
| 团队栈 | 需会 ArkTS | 复用既有前端/移动端经验 |
| 性能上限 | 高(无跨层开销) | 受跨层开销约束,重列表/动画差距最明显 |
| 迭代速度(多端同发) | 慢(分端开发) | 快 |
一句话结论:跨平台框架卖的是「复用」,不是「性能」。16.7 ms 的帧预算不会因为你换了框架而变宽,只会因为你多了一层转换而变窄。这台暗房做的是重度文本排版 + 列表 + 柱状图 + 大量系统级窗口交互,且只面向鸿蒙PC 单端——没有任何复用需求来摊薄跨层成本,所以选 ArkUI 原生。反过来,如果同一个排查台还要出 Web 版和内嵌 H5 版,那跨平台框架的账才算得过来。
8.4 迁移成本要提前算清楚
如果将来真要把这个暗房搬上跨平台框架,成本集中在三处,都不在 UI 层:
- 状态管理。ArkUI 的
@State/@Observed/@Track是框架私有的观察机制,换成 Flutter 的InheritedWidget/Riverpod 或 React 的 hooks,等于把Index.ets里所有状态逻辑重写一遍; - 布局语义。
layoutWeight(1)、Blank()、constraintSize这些在 ArkUI 里很自然的东西,在其他框架里没有一一对应物,宽屏桌面的「书脊 + 内容」两栏布局要重新做断点; - 系统能力。这篇文章里的东西其实没用多少系统能力(零三方依赖、无权限申请、无文件读写),所以迁移阻力小;一旦加上「导出报告到本地」这类真实能力,桥接层就成了主要工作量。
所以我的治理结论是:先按「单端 + 系统能力密集 + 性能敏感」把原生写对,再用一张显式的表记录「什么时候该换」的触发条件——而不是一开始就为了「将来可能的多端」付出跨层成本。这个「什么时候」应当写进仓库文档,和代码一起托管在 AtomGit 上,跟着版本走。
九、治理三件套:令牌、台账、量纲
前八章讲的是「让程序变快」「让结论可信」。这一章讲的是让这两件事长期不退化。我在这个工程里找到三处真实的治理缺口,都不是会崩的 bug,但都会让排查台慢慢变成「看着专业、用起来不放心」的东西。
9.1 设计令牌 100% 失守
common/Theme.ets 里老老实实定义了整套令牌:
export class LucColors {
static readonly charcoal: string = '#191714';
static readonly panel: string = '#211E18';
static readonly card: string = '#2A2620';
static readonly cardHi: string = '#332E25';
static readonly line: string = '#3C362C';
static readonly devRed: string = '#C8402E';
static readonly paper: string = '#F3EEE4';
static readonly silver: string = '#9A948A';
// ...
}
然后我去数了 components/ 与 pages/ 下的实际引用:LucColors. 出现 0 次,而硬编码的六位色值出现 145 次。其中 '#F3EEE4' 26 次、'#9A948A' 17 次、'#3C362C' 17 次、'#2A2620' 7 次。同一栋楼里,LucMetrics(含 spineWidth: 88)也是 0 引用——SideSpine 里写的是字面量 .width(88);只有 LucText 被用了 6 次,算是半个幸存者。令牌和实现彻底脱钩——改一次主题色要全文件搜索替换,换深色/浅色主题更是无从谈起。
这不是审美问题,是可维护性问题:颜色是最容易被复制粘贴污染的一类常量,一旦散落在 145 处,任何主题改动都会漏。
治理动作很小:组件一律 import { LucColors } from '../common/Theme' 并用 LucColors.card。为了让这条规则不靠自觉,把它写进 CI 的静态检查:对 src/main/ets 下除 Theme.ets 以外的文件,禁止出现 #[0-9A-Fa-f]{6} 字面量。一条正则,永久生效。
9.2 台账不闭合:5 个状态,4 张卡
图 4 上四条口径卡是「累计报错 / 待显影 / 显影中 / 已定影」,加起来是 2 + 0 + 3 = 5,但底片墙上一共有 6 条底片。差的那一条是 NEG-0344,状态 wontfix(界面文案「搁置」),它没有对应的卡片。
这是排查台最危险的一类缺陷:不报错。用户扫一眼指标卡,会以为「5 条就是全部」,从而漏掉那条被主动搁置的问题。而 NEG-0344 恰好是那条「定时器未销毁」——也就是第六章里诊断台自己犯的病。
修法有两种,选简单的:把 ReportStats 的 parked 也铺一张卡(第 4.2 节的 statsOf 已经统计了),并在断言里加一条台账闭合检查:
// pages/Index.ets:台账闭合检查(hilog 来自 @kit.PerformanceAnalysisKit)
import { hilog } from '@kit.PerformanceAnalysisKit';
const s: ReportStats = this.index.report();
const sum: number = s.open + s.developing + s.fixed + s.parked;
if (sum !== this.negatives.length) {
hilog.error(0x0000, 'Lucida', 'ledger unbalanced: %{public}d vs %{public}d',
sum, this.negatives.length);
}
statsOf 里的 else { parked++; } 用的是兜底分支而不是 === 'wontfix',这是故意的:将来新增任何状态,都会自动落进「搁置」桶,台账绝不漏数。统计函数对未知枚举值应该保守收敛,而不是静默丢弃。
9.3 单位口径:让 UI 猜单位,等于制造歧义
验证炉的「修复前 / 修复后」两列是这么渲染的:
Text(t.before >= 1 ? t.before.toFixed(1) + ' 次/千轮'
: (t.before * 100).toFixed(0) + '% 崩溃率')
用 >= 1 猜单位。于是同一屏里出现了两种量纲:T2 是 6.8 次/千轮,T1 是 42% 崩溃率,T3 是 840.0 次/千轮。数值本身没错,但读者无法跨行比较——42% 和 6.8 次/千轮谁更好?没人能一眼判断。
根因在数据模型:VerifyTrial 没有单位字段,UI 只好替它猜。修法是补一个字段,把单位变成数据的一部分:
// common/Models.ets(修复后)
export class VerifyTrial {
id: string;
name: string;
condition: string;
unit: string; // 'per1k' | 'ratio'
before: number;
after: number;
state: string;
progress: number;
// ... constructor 同步增加 unit 参数
}
// 渲染侧只做格式化,不做判断
private fmt(v: number, unit: string): string {
return unit === 'ratio' ? (v * 100).toFixed(0) + '%' : v.toFixed(1) + ' 次/千轮';
}
这条经验可以推广成一句治理原则:单位属于数据,不属于渲染。 任何「根据数值大小推断含义」的渲染逻辑,都会在数据跨界时变成歧义源。
同一类错误在这个工程里还出现在「宽度」上。聚类页的占比条写的是:
.width(Math.round(c.share * 0.9)) // share = 38,得到 34
share 是百分比,width() 的单位却是 vp。于是在一条几百 vp 宽的卡片里,38% 只画出了 34vp —— 这正是图 3 里那五根占比条看起来都短短一截的原因。验证炉的进度条同样如此:.width(Math.round(t.progress)),满进度只有 100vp。
正确写法是把百分比交给 width('38%'),或者用 layoutWeight 分配:
.width(c.share.toFixed(1) + '%') // 让布局引擎去乘父容器宽度
vp 是绝对长度,% 是相对比例,两者不能互相当。 这和「单位靠猜」是同一个根因:把一个带有语义的量,交给了一个只会读数值的 API。
十、验收线、复现清单与踩坑
10.1 三条可核对的验收线
优化和治理如果没有验收线,等于没做。这台暗房我定了三条,每条都能用「打开应用点几下」验证,不需要埋点:
| 编号 | 验收线 | 怎么验 | 通过标准 |
|---|---|---|---|
| L1 | 签名幂等 | 把同一批 RawError 打乱顺序跑两次 aggregate | 分组数、每组 hits、排序结果完全一致 |
| L2 | 派生值不随渲染增长 | 反复切换五个工作台 20 次 | 指标卡数值不变;build 路径内无 for 循环扫描 |
| L3 | 定时器有界 | 点火 2 条 trial,切到聚类页 | timers.size 归零;切回验证炉进度停在离开时的值 |
L2 是这三条里最容易自欺的。因为「数值不变」在 n=6 时恒成立(哪怕你每帧扫 5 遍)。真正可核对的版本是代码层:用 grep 确认 build() 及其 @Builder 里没有循环和 sort。这条规则比任何性能分析器都好用,因为它不需要跑起来。
10.2 复现清单
# 1. 依赖(工程零三方库,这一步只生成 oh_modules 骨架)
ohpm install
# 2. 构建 debug HAP
hvigorw assembleHap --mode module -p product=default -p buildMode=debug --no-daemon
# 3. 产物位置
# entry/build/default/outputs/default/entry-default-signed.hap
# 4. 装到鸿蒙PC 设备(2in1 形态)
hdc install -r entry/build/default/outputs/default/entry-default-signed.hap
# 5. 启动
hdc shell aa start -a EntryAbility -b com.lucida.errorlab
图 1 里那行终端输出就是第 4、5 步的实际结果:install ... entry-default-signed.hap in 431 ms,紧接着 aa start -a EntryAbility -b com.lucida.errorlab,Launch com.lucida.errorlab success in 687 ms。排查类文章最好保留这一步的原始输出,因为它同时证明了「包名正确」「签名有效」「设备是鸿蒙PC」。
10.3 八条踩坑
compatibleSdkVersion必须写"26.0.0"。API 26 起三段式是硬要求,写26会构建失败。deviceTypes只写["2in1"]是刻意的。它决定了布局按桌面尺寸设计,也决定了不会在手机形态上被拉成畸形。- 桌面布局不要写死像素。书脊
88vp是唯一的定值,其余全靠layoutWeight(1),窗口拖多宽都能自适应。 EntryAbility里没有窗口尺寸代码。初始窗口大小由系统桌面决定,别在 Ability 里抢着设置,PC 上会与用户预期冲突。@State数组元素的属性变更不总是触发重渲染。改完属性补一句this.arr = this.arr.slice(),最稳。ForEach的键是「身份」不是「版本」。用可变字段拼键会让列表项销毁重建,滚动位置和动效一起丢。setTimeout在 ArkTS 里返回number,可以直接放进Map<string, number>。顺手存句柄,成本是两行代码,收益是不会有幽灵定时器。- 中文竖排别用「一字符一个
Text」。单个Text给固定宽度(如width(20)+textAlign(TextAlign.Center))就会自动逐字换行,节点数和键稳定性都更好。
十一、小结:一台排查台该有的三层自律
把这篇的结论压成三句话:
第一层,数据层要可复算。 错误签名 = 模块 + 归一化消息 + 栈顶符号,归一化按「引号 → 十六进制 → 纯数字」顺序做;命中数 hits 与发作轮次 episodes 分开统计;置信度由三源证据加权算出,且必须有准入线。这一层的所有函数都应该是纯函数,可单测、可重放——分组结果和输入顺序无关,才叫幂等。
第二层,渲染层要可解释。 build() 只做「取值 + 拼装」,不做扫描、排序、过滤;派生值靠写穿式索引,一次构建多次读;@State 只留给真正影响输出的东西,那个「什么都不影响」的状态是纯负债;列表的键只用身份,可变字段交给组件内部;数据上千条就换 LazyForEach。
第三层,治理层要对自己生效。 令牌不是写着好看的,145 处硬编码色值说明它没生效;台账不是四张卡片的和,要能对上总条数;单位不是渲染时猜出来的,是数据自带的字段;定时器不是「点了才开始」的,是「离开就停」的。这一层最容易被当成「工程规范」跳过,但它决定了前两层三个月后还在不在。
回到标题里的两个词。鸿蒙PC 给这台暗房带来的不只是更大的画布——书脊 + 内容的两栏结构、88vp 定宽 + layoutWeight(1) 的弹性、cachedCount(6) 这样的桌面端预取值,都是 2in1 形态独有的设计约束;如果哪天要移植到别的端,这些数字全部要重算。而跨平台框架能帮你复用的恰恰是「结构」而不是「约束」,所以我在第八章把决策矩阵写得很直白:跨平台框架卖复用,不卖性能,16.7 ms 不会因为换了框架而变宽。
最后一句留给 NEG-0344。那条被标成「搁置」、连卡片都没有的错误,结论是「旧定时器未销毁即注册新定时器」。写这篇文章的过程中,我在 Index.advanceTrial 里找到了同一句话。排查台最有价值的功能,不是它诊断出了多少别人的 bug,而是它敢不敢把自己的 bug 也挂上墙。 工程代码已按本文的修复稿整理,可以直接托管到 AtomGit 上按 L1–L3 三条验收线跑一遍——这也是我给这类「治理型应用」定的最低标准。
本文所有截图均在鸿蒙PC 设备上截取,为完整桌面画面;工程源码 Lucida_ohos 为纯 ArkUI 原生 ArkTS 实现,零三方依赖,界面数据为构造样例但账目可复算。
更多推荐



所有评论(0)