鸿蒙PC 衡鉴 Arbitra 实战:用 ArkUI 把技术选型做成可校准、可归档的加权评分台——兼谈跨平台框架(Flutter / ArkUI-X)选型口径、排行重算开销与 7 类静默缺陷

欢迎加入开源鸿蒙PC社区: https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目:https://atomgit.com/OpenHarmonyPCDeveloper


前言:技术选型最贵的不是"选错",而是"选完之后没人说得清当时为什么这么选"。一份 ADR(Architecture Decision Record)写完之后通常有三种下场:躺在 Wiki 里没人更新、被贴进周报然后归档、或者干脆只存在于某次评审会的口述里。等到半年后线上出问题要复议,团队只能从零再吵一遍,而且往往更久——因为连"上次评分多少、权重是谁定的、为什么放弃了第一名"都无人可问。

桌面端把这件事的代价放大了:鸿蒙PC 上的工具类应用动辄以年为单位迭代,一次数据层或渲染栈的选型失误,重写成本按季度计;而 2in1 形态下窗口可以任意拉伸、会话常驻数小时、系统能力(多窗、拖拽、文件外设)是主力而不是点缀,这些恰恰是"选型对不对"最直接暴露的地方。于是"选型"从一次技术判断,变成了一个需要载体、需要口径、需要留痕的治理流程。

本文的样本是一套真实的鸿蒙PC 工程:应用「衡鉴 · Arbitra」是一个纯 ArkTS + ArkUI 声明式 UI、只面向 2in1 形态的技术方案选型与 ADR 加权评审实验台,deviceTypes 只保留 ['2in1'],SDK 26.0.0,零三方依赖,六个手写 .ets 文件、约 900 行。它把一次选型拆成四个工作面——决策看板(状态泳道)、方案评审(五维权重滑杆 + 候选排行)、决策时间线(事件流水)、治理规则(R1–R4 与待办闭环)。

文章走三条线:方案选型治理(权重为什么是相对值、总分怎么复算、一条 ADR 归档时到底该存什么)、性能优化(排行每次渲染都重新过滤排序、滑杆拖动把整列 key 打穿、线性计数在渲染路径里重复执行)、报错排查(7 类"不崩溃但结果错"的静默缺陷,逐条给根因与修法)。

有两点必须提前钉死:本工程用的是 ArkUI,不是 ArkUI-X;文中出现的跨平台框架(Flutter、ArkUI-X、Compose Multiplatform)只作为"被评估的候选方案"出现在选型方法一节,工程里没有引入任何跨平台框架运行时。界面上的 5 条 ADR、12 个候选方案、6 条时间线事件、默认权重 7/5/5/6/4,全部来自 Models.ets 的本地演示常量,不连接任何后端;凡是能从源码数出来的数字,我都会给文件与行号;凡是估算,我都写明估算依据。

关键词:鸿蒙PC、鸿蒙 PC、开源鸿蒙PC、跨平台框架、ArkUI、ArkUI-X 对照、Flutter 对照、Compose Multiplatform 对照、ADR 架构决策记录、加权评分矩阵、技术选型治理、派生计算、ForEach key、报错排查、AtomGit。


鸿蒙PC 真机完整桌面:衡鉴 Arbitra「决策看板」,三列 ADR 卡片分别停在采纳、建议、建议三种状态

开篇图 鸿蒙PC 真机完整桌面:应用窗口停在「决策看板」页。底部是系统 Dock,右下角是系统托盘与"上午11:20 / 11月16日"时间,窗口标题栏的最小化、最大化、关闭三个系统按钮齐全,左侧还能看到 DevEco Studio 的工程树(Arbitra_ohos · 版本控制 · 此电脑 · entry)。窗口内顶部是"衡 衡鉴 · Arbitra / 技术方案选型治理实验台 · ADR 决策与加权评审 · 演示原型"与右上角"模拟新提案"按钮;下面一排页签是决策看板 / 方案评审 / 决策时间线 / 治理规则,右侧一行计数"提议 3 · 采纳 1 · 废弃 1";主体是三列卡片:ADR-014「列表页懒加载方案」盖着"采纳"圆章、ADR-015「本地缓存引擎选型」与 ADR-016「崩溃日志采集通道」盖着"建议"圆章;页脚写着"决策、评分与时间线均为本地演示数据"

这张图是全文的入口,也是问题的完整呈现。请注意三个细节。

第一,状态是盖在卡片上的章,不是卡片里的一个字段。三条 ADR 的右上角分别是"采纳"“建议”"建议"三种圆形印章,倾斜 −12°,由 SealBadge.ets 的 .rotate({ angle: -12 }) 画出来,一个 @Prop statusVal 同时决定文案与描边色。把状态做成"盖章"而不是一行灰色小字,是这个工具最值得抄的一处设计:评审会上一屋子人都盯着屏幕时,颜色和形状比文字更快传达"这条已经定过了"。

第二,同一个应用里,三条 ADR 处在三个完全不同的阶段。"列表页懒加载方案"已经采纳,"本地缓存引擎选型"还在比 KV 与关系型,“崩溃日志采集通道"在权衡自建网关与复用可观测服务。选型工具的第一价值不是"选出赢家”,而是让候选方案在同一屏、同一口径、同一时间点被比较。

第三,"提议 3 · 采纳 1 · 废弃 1"与卡片上的章是两个口径。前者是 statusCount() 现场算出来的计数,后者是每条 ADR 自己的 status 字段。计数用于看板,状态用于分工——这两个口径一旦混用,治理工具立刻开始骗人:把"提议 3"当成"3 个待办",你会排出错误的会;把"采纳 1"当成"只剩 1 件事",你会漏掉五个维度的权重还没校准。

一、先把事实边界钉死:截图、工程、修复稿各是什么

技术文章最容易失信的地方,是把"我截到的界面"当成"我测到的数据"。所以先分三层,后面每一条论断都挂在这三层上。

第一层,问题样本:四张鸿蒙PC 真机完整截图。 四张都是同一台鸿蒙PC 设备的完整桌面——底部系统 Dock、右下角托盘与时间、窗口三键标题栏、左侧 DevEco Studio 工程树,一个不少;不是手机截图、不是应用内裁剪图、不是设计稿。四张分别停在四个工作面:决策看板、方案评审、决策时间线、治理规则。但要提醒一句:它们不是一次连续会话。 图 1 的评分矩阵显示"提议 3 · 采纳 1 · 废弃 1",与开篇图一致;图 2 的统计卡写着"6 时间线事件",而图 3 的决策时间线只渲染出 2 条。这不是截图裁剪,是两次运行——把它们当成"一条状态推进链"去读,会推出错误结论(我一开始就差点这么写)。读者如果自己要复现,请以"能看到的四块界面"为准,不要以"四张图连起来的故事"为准。

第二层,配套工程:项目源码/Arbitra_ohos。 一个纯 ArkTS / ArkUI 声明式 UI、Stage 模型的 2in1 工程,包名 com.arbitra.decision,deviceTypes 只有 ['2in1'],compatibleSdkVersion 与 targetSdkVersion 均为 26.0.0,工程级 dependencies 为空。它没有接数据库、没有接 HTTP、也没有接任何分布式能力——界面上的 5 条 ADR、12 个候选方案、5 个评审维度、6 条时间线事件,全部来自 Models.ets 的静态数据集;decide()、discard()、simulateProposal() 改的只是内存里的数组。也就是说:截图回答"这个工作面长什么样",工程回答"代码落在哪一行",而界面上的 7.4、6.7、220ms 是演示数据,不是采集数据。

第三层,本文的修复稿。 第六节给出的 .ets 片段是针对工程里静态可见缺陷的修改建议,全部用 ArkUI 原生能力写、可独立编译,文中逐条标明改哪个文件、改哪几行、改完能看到什么变化。它们不冒充实测性能报告,只承诺一件事:改前改后的差异可以用眼睛复现。

工程基线表(每一项都能在源码里查到,不是估值):

项实际值证据
应用 / 包名「衡鉴 · Arbitra」/ com.arbitra.decisionAppScope/app.json5:3-8
版本versionCode 1000000、versionName 1.0.0AppScope/app.json5:5-6
设备形态仅 ['2in1'],无 phone / tabletentry/src/main/module.json5:7
SDKcompatibleSdkVersion / targetSdkVersion 均 26.0.0build-profile.json5:7-8
构建模型hvigor + ohpm,Stage 模型,strictMode.useNormalizedOHMUrl: truebuild-profile.json5:11-13
三方依赖工程级 dependencies: {},模块级同oh-package.json5:9
页面入口windowStage.loadContent('pages/Index'),单页应用EntryAbility.ets:12
源码规模6 个手写 .ets,约 900 行(Index.ets 640 行)entry/src/main/ets/
状态中心7 个 @State、16 个 @Builder,全部集中在 Indexpages/Index.ets:9-15
数据层Models.ets 141 行:5 ADR / 12 候选 / 5 维度 / 6 事件common/Models.ets:95-141
主题硬编码色板 15 色 + 字号 5 级,纸感配色common/Theme.ets:1-25

这张表说明两件事。其一,这是一个零三方依赖的鸿蒙PC 原生 2in1 工程:进程启动后直接加载单页,没有框架运行时抢主线程,所以任何卡顿都更容易归因到业务代码本身;代价是所有聚合、求值、落盘都得自己写。其二,桌面形态适配只做了一半:看板是 Grid + columnsTemplate('1fr 1fr 1fr') 写死的三列,评审页的权重行是固定 150px 标签 + 弹性滑杆,都没有跟随窗口宽度做断点收敛。

也必须坦白它的另一面:这个工程目前是方法论原型,不是可用的治理平台。三处证据:Models.ets 的候选评分是写死的常量,没有"谁打的分、什么时候打的";Index.ets 的时间线事件只存在内存里,应用退出即清空;ADR 编号在"模拟新提案"时直接复用种子数据里的 ADR-019/020/021,点两次就会出现两个 ADR-019。换句话说,它验证的是流程形状,不是数据可靠性——而这两件事恰好是第五节要逐条拆开的问题。

二、评分口径:权重是相对值,总分是可以手算的

2.1 五个维度、一根滑杆、一个必须能复算的数字

鸿蒙PC 真机完整桌面:方案评审页,ADR-015 的五维权重滑杆与候选方案排行

图 1 鸿蒙PC 真机完整桌面:「方案评审」页。顶部一排议题 chip(ADR-014 / 015 / 016 / 017 / 018,当前选中 ADR-015),右侧"废弃议题"按钮;中间是五根权重滑杆——性能开销 7、实现成本 5、运维风险 5、长期维护 6、生态成熟 4,每根都在 0–10 之间;下面是"候选方案排行":第 1 名「KV 数据库」7.4 分带"荐"字与"加权最高"描边标、第 2 名「关系型数据库」6.7 分,两条都带"定标"按钮;页脚是"决策、评分与时间线均为本地演示数据"

这张图是整个工具的技术核心,因为它是唯一一块"输入会立刻改变输出"的面板。请注意三个细节。

第一,滑杆的刻度是 0–10,不是百分比。 五个维度默认值 7、5、5、6、4,合计 27。这个 27 很关键:它说明权重是相对值,不是"加起来必须等于 100"的百分比。所以界面从不显示"权重 26%",而是显示读数本身。好处是定权重时不用凑整(凑整的过程一定伴随妥协),坏处是任何把总分当百分制解释的文案都会变成谎话。

第二,总分是加权均值,落在 0–10 之间,保留一位小数。 计算在 Index.ets:30-44:

// pages/Index.ets:30-44
private totalW(): number {
  let s: number = 0;
  for (const w of this.weights) {
    s += w;
  }
  return Math.max(1, s);
}

private weighted(c: Candidate): number {
  let s: number = 0;
  for (let i = 0; i < c.scores.length && i < this.weights.length; i++) {
    s += c.scores[i] * this.weights[i];
  }
  return Math.round(s / this.totalW() * 10) / 10;
}

Math.max(1, s) 是防零除的护栏,Math.round(x * 10) / 10 是保留一位小数。这两行决定了界面上所有数字的量纲。

第三,这些数字是可以手算复核的。 拿图 1 的 KV 数据库,评分 [8, 8, 7, 7, 7](性能、成本、风险、维护、生态),权重 [7, 5, 5, 6, 4]:

8×7 + 8×5 + 7×5 + 7×6 + 7×4 = 56 + 40 + 35 + 42 + 28 = 201
201 / 27 = 7.444… → 7.4

关系型数据库 [6, 5, 6, 8, 9]:

6×7 + 5×5 + 6×5 + 8×6 + 9×4 = 42 + 25 + 30 + 48 + 36 = 181
181 / 27 = 6.703… → 6.7

两个数与截图上的 7.4、6.7 完全一致。这条"能手算"的性质看起来平淡,其实是治理工具的生命线:如果一线工程师无法在会议现场用计算器复算榜首,那么榜首就只是界面的装饰,迟早会有人怀疑工具在偷偷加权。我把这条写成硬约束:总分必须能被任何一个看过公式的人独立重算,误差为 0。

2.2 权重一改,冠军换人:这是特性,不是缺陷

同一条 ADR-014 下面有三个候选:按需分页加载 [8,6,7,7,8]、预取缓存优先 [7,5,6,6,7]、混合分级加载 [9,4,6,5,6]。在默认权重下:

候选加权和总分名次
按需分页加载56+30+35+42+32 = 195195/27 = 7.21
预取缓存优先49+25+30+36+28 = 168168/27 = 6.22
混合分级加载63+20+30+30+24 = 167167/27 = 6.23

现在只动权重,把它改成 [10, 1, 1, 1, 1](“这版只认启动性能,其余都是次要”),总权重从 27 掉到 14:

候选加权和总分名次
混合分级加载90+4+6+5+6 = 111111/14 = 7.91(反超)
按需分页加载80+6+7+7+8 = 108108/14 = 7.72
预取缓存优先70+5+6+6+7 = 9494/14 = 6.73

冠军换人了。 这条演示值千金:它证明"哪个方案更好"从来不是方案的属性,而是方案 × 权重的属性。所以治理规则 R1 要求"评审前必须校准维度权重"——不是因为流程好看,而是因为不校权重就等于默认用了模板里那套价值判断,而模板的作者可能根本不在这个项目里。

同时也要看到第二个细节:默认权重下第 2 名和第 3 名都是 6.2。界面上一个显示"2"、一个显示"3",读者会本能地以为它们有差别;实际上 168 与 167 的加权和只差 1,归一化后都收敛到 6.2。一位小数在这个量级上不足以支撑名次,这是 2.4 节要提的第一条改进:并列时该显示"2(并列)",或者把小数位放到两位。

2.3 治理规则 R1–R4 与代码的对应关系

鸿蒙PC 真机完整桌面:治理规则页,四张统计卡、三条待办与 R1–R4 规则清单

图 2 鸿蒙PC 真机完整桌面:「治理规则」页。顶部四张统计卡(提议中 3 / 已采纳 1 / 已废弃 1 / 时间线事件 6);下面三条待办卡片,每条右侧一个动作按钮——“3 个提议超出评审时限 / 催办全部”、“存在未复盘的废弃决策 / 完成复盘”、“评审权重沿用默认模板 / 去校准权重”;最下面是一块浅色"治理规则(本地演示)"面板,列出 R1 评审前必须校准维度权重、R2 提议 3 个工作日内必须有结论、R3 定标后自动归档权重与评分、R4 废弃决策需完成复盘

这一页是整个应用里最"像治理"的一屏,也是最容易写出假东西的一屏。规则文案在 Index.ets:566-573,四条如下:

规则文案代码里是否真的实现
R1评审前必须校准维度权重,避免口径漂移部分:滑杆可以改,但权重是全局一份 @State,切议题不重置、不隔离,"这条议题用的是哪套权重"无记录
R2提议 3 个工作日内必须有结论:采纳或废弃只做了催办:applyCheck('urge') 给所有 status === 0 的 ADR 各推一条事件,没有任何时间字段参与判断
R3定标后自动归档权重与评分,写入决策时间线没有实现:decide() 只把状态改成 1,再推一条文案"评审权重与评分已归档",归档物本身不存在
R4废弃决策需完成复盘,沉淀为反面案例只做了"完成复盘"按钮,推一条事件,没有复盘结构

这张表是我写这篇文章最想贴的东西。它把"规则文案"与"代码事实"并排放着,读者可以自己判断哪一条是承诺、哪一条是装饰。 R3 是最刺眼的一条:文案说"自动归档权重与评分",而 decide() 里存的只有一句字符串:

// pages/Index.ets:67-71
private decide(adrId: string, candName: string): void {
  this.adrs = this.adrs.map((a: AdrItem) => a.id === adrId ? a.withStatus(1) : a);
  this.pushEvent(this.adrById(adrId).code, '已采纳「' + candName + '」,评审权重与评分已归档。', 1);
  this.toast(this.adrById(adrId).code + ' 已定标:' + candName);
}

“已归档"三个字在这里是一个字符串常量,不是一次数据写入。半年后有人问"当时五个维度的权重是多少、总分多少、第二名差多少”,答案不在数据库里,而在两件事上:this.weights 的当前值(可能已经被后面的评审改掉了),和这条文案(它只说"已归档")。这是治理工具最常见的失效模式:流程有形状,但证据链在最后一米断掉。

2.4 权重必须是"议题级"的,否则 R1 无法被证明

Index.ets:12 里只有一份权重:

// pages/Index.ets:12
@State weights: number[] = [7, 5, 5, 6, 4];

它的生命周期是整个应用,不是单条议题。于是一个真实的评审场景会这样坏掉:你先评 ADR-015(存储),把性能权重从 7 调到 9;接着切到 ADR-016(崩溃日志通道),滑杆还停在 9,但你没有察觉——因为界面上没有任何东西告诉你"这不是默认模板"。等两条都定标,R1 声称的"评审前校准过权重"在数据上无法被证实,也无法被证伪。

这不是 UI 问题,是建模问题。修法是把权重从"全局一份"改成"每条议题一份",并且在切议题时显式带上"是否已校准"的标记(见第六节代码)。同样的思路适用于任何"多实体共享一份可调参数"的界面:只要参数是全局的,它迟早会被上一个上下文污染。

三、把跨平台框架放进同一张评分表:口径比结论重要

前两节讲的是"怎么算分",这一节讲"比什么"。因为这套工具在鸿蒙PC 上最常被拿来问的问题只有一个:这个应用到底要不要引入一个跨平台框架? 而它恰好可以用自己的五维模型回答。

先把术语钉准,避免最常见的三种混淆:

  • ArkUI:鸿蒙的声明式 UI 框架,ArkTS 语言 + 声明式语法 + 2in1 系统能力一等公民。本工程用的就是 ArkUI,没有 ArkUI-X,也没有任何跨平台框架运行时。
  • ArkUI-X:以 ArkUI 为基座的跨平台框架,目标是把 ArkTS 页面复用到其他平台。它是一个独立工程形态,不是"鸿蒙上的 ArkUI"。
  • Flutter / Compose Multiplatform:另外两条主流的跨平台框架路线,前者全自绘(Skia/Impeller)并依赖社区 ohos 适配层,后者是 Kotlin 声明式 UI + Skiko 渲染,需要 Kotlin/Native 工具链与 cinterop。

把这三条候选塞进衡鉴的五维模型里,会得到一张这样的对照(下面的分数是方法演示,不是任何基准测试结果;每一格都可以在界面里改,这正是工具存在的意义):

维度(默认权重)ArkUI 原生ArkUI-X 跨平台框架Flutter 跨平台框架Compose Multiplatform
性能开销(7)8:无运行时包装6:桥接层有开销5:自绘 + 引擎常驻5:Skiko + 运行时初始化
实现成本(5)4:无历史资产可复用7:ArkTS 一套多端6:Dart 生态成熟5:Kotlin 复用但工具链重
运维风险(5)8:系统能力直连6:目标平台差异需兜底5:适配层版本漂移5:cinterop 与 ABI 约束
长期维护(6)7:跟随系统演进6:双份适配成本6:社区活跃6:社区活跃
生态成熟(4)6:2in1 能力完整6:逐版补齐9:组件最丰富7:Android 生态可借力

按默认权重算:ArkUI 原生 (8×7 + 4×5 + 8×5 + 7×6 + 6×4) / 27 = 182 / 27 = 6.7;ArkUI-X (6×7+7×5+6×5+6×6+6×4)/27 = 167/27 = 6.2;Flutter (5×7+6×5+5×5+6×6+9×4)/27 = 162/27 = 6.0;Compose Multiplatform (5×7+5×5+5×5+6×6+7×4)/27 = 149/27 = 5.5。

这组数字的用途不是宣布"原生赢",而是把"为什么赢"拆到项:原生对 Flutter 的领先来自性能 +21、运维 +15、维护 +6,但 Flutter 在实现成本上 +10、生态上 +12 又追回 22 分,净差只有 20 分(均分 0.7)。看单项你会以为"原生碾压",看净差你才知道这是一场 20 分的比赛。 而 20 分在一个 cost 能从 6 拉到 10 的模型里,随时会被抹平:

Flutter(把 cost 从 6 调到 10):(5×7 + 10×5 + 5×5 + 6×6 + 9×4) / 27 = 182 / 27 = 6.7
ArkUI(cost 保持 4)           :182 / 27 = 6.7

差距从 0.7 收敛到 0——并列了。这不是巧合,而是一次诚实的推演:“如果这个团队已经有大量 Flutter 资产,那么复用带来的成本优势恰好抵消掉性能与运维的劣势,此时决策不应该由技术偏好决定,而应该由’鸿蒙PC 端要不要用上多窗、拖拽、文件外设这些系统能力’决定。” 把这句话写进 ADR 的"破例理由"字段,比写"我们更熟悉 Flutter"体面得多,也更能扛住半年后的复议。

这就是选型治理的价值:它不产出"正确答案",它产出一组可复核的数字,并且允许任何人在会上当场把某个权重拉一下,看结论会不会翻。 结论会翻,说明这个决策本来就依赖前提,那就把前提写清楚;结论不翻,说明这个决策是稳的。两种情况都比"我觉得 XX 更熟"有用。

顺带说清一件事:本文所有界面、所有代码都是 ArkUI 写的。 上面那张表里出现的跨平台框架,在本工程里只是 Library.candidates 之外的一组演示数字——工具可以评它们,但工程没有引入它们。这个区分很重要,因为把"用 ArkUI-X 写"和"用 ArkUI 写、但评估过 ArkUI-X"混为一谈,是鸿蒙PC 选题里最常见的表述事故。

四、性能:把 build() 当热路径读,五处静默浪费

ArkUI 是声明式 UI:状态变了,框架重新执行 build() 生成新的视图描述,与旧树做差分,只把差异提交渲染管线。差分的成本取决于树的规模与差异的粒度,而这两者都由 build() 里的表达式决定。 衡鉴的状态全部压在一个 struct 里(Index.ets:9-15):

@State tabIdx: number = 0;
@State adrs: AdrItem[] = Library.adrs;
@State events: TimelineEvent[] = Library.events;
@State weights: number[] = [7, 5, 5, 6, 4];
@State selAdrId: string = 'a2';
@State fixedChecks: string[] = [];
@State seedIdx: number = 0;

七个 @State,任何一个变化都会让 Index.build() 完整跑一次。而"拖一根滑杆"这件事,会同时改 weights、触发 ReviewTab 的整棵子树重算。下面五处是我按源码静态数出来的浪费,共同点是:都不影响正确性,只影响"拖一下要多久才看到数字变"。

4.1 候选排行每次渲染都重新过滤 + 排序 + 求值

// pages/Index.ets:46-50
private sortedCandidates(adrId: string): Candidate[] {
  const list: Candidate[] = Library.candidates.filter((c: Candidate) => c.adrId === adrId);
  list.sort((a: Candidate, b: Candidate) => this.weighted(b) - this.weighted(a));
  return list;
}

这一行的成本有三份:filter 每次返回新数组(12 条候选全扫一遍)、sort 每次重新比较、比较器里每次比较都重新调用两次 weighted()。而 weighted() 内部还要再求一次 totalW()(遍历 5 个权重)。以 ADR-015 的 3 个候选计,排序最多 3 次比较,最坏 6 次 weighted();以全库 12 个候选计,12·log₂12 ≈ 43 次比较、最多 86 次 weighted(),而每次 weighted() 是 5 次乘加 + 5 次累加 + 1 次除法**——也就是说,一次 render 光排序就做掉了大约 900 次浮点运算**。

单次 900 次运算在桌面上不值一提(微秒级)。真正的问题是它每帧都在做,而且做的是同一件事:只要 weights 没变、selAdrId 没变,候选的分数就是常量。这就是典型的"派生值没有缓存"——ArkUI 没有 useMemo,派生状态必须自己维护,缓存必须挂在成员上,挂在 build() 的局部作用域里等于没做(build() 里也不允许声明局部变量)。

4.2 ForEach 的 key 里塞了加权分,滑杆每动一格就重建整列

// pages/Index.ets:447-450
ForEach(this.sortedCandidates(this.selAdrId), (c: Candidate, rank: number) => {
  this.CandidateLine(c, rank + 1, this.adrById(this.selAdrId))
}, (c: Candidate, rank: number) => c.name + '-' + rank.toString() + '-' + this.weighted(c).toString())

key 是 名称-名次-加权分。滑杆 step: 1,一次拖动从 7 拖到 9 会连发多次 onChange,每一格都会让所有候选的 key 全部变化,框架只能按"删旧建新"处理——于是你拖动滑杆时,下面整列排行(含进度条、按钮、描边)在重建,而不是在更新。

这是一个必须显式记账的取舍:key 里放"渲染依赖的可变值",等于把"数据更新"降级成"组件重建"。 这里其实不需要:名次和分数都可以作为 @Builder 参数传进去,内容会跟着刷新;key 只放 c.name 就足够唯一(同一议题下候选名不重复),框架会把列表当成"元素换位置"来处理,组件实例保留、只更新属性,拖动手感立刻就对了。代价是:如果以后要给"名次跃迁"做动画,得自己用 animateTo 补,不能指望重建。

4.3 线性计数在渲染路径里被反复调用

// pages/Index.ets:52-60
private statusCount(status: number): number {
  let n: number = 0;
  for (const a of this.adrs) {
    if (a.status === status) {
      n++;
    }
  }
  return n;
}

TabRow() 里调 3 次(提议/采纳/废弃),GovernanceTab() 里调 4 次(三张统计卡 + 条件判断),待办卡片的标题里又各调 1 次。一次 build() 合计至少 9 次全表扫描,5 条 ADR 就是 45 次比较。数量小,但性质差:这是 O(n) 的计算被放进了每帧都跑的路径,而它本可以是"一次遍历出三个数"。

同样的形状还出现在 adrById()(Index.ets:21-28):评审页里 header 两次、条件判断一次、每条候选一次,一次 build 里被调用 6 次以上,每次都是 O(n) 的 for。这类函数单看无害,乘法一乘就出来了。

4.4 时间线没有滚动容器

TimelineTab() 是 Column 直接 ForEach,外面没有 Scroll:

// pages/Index.ets:469-486
TimelineTab() {
  Column({ space: 0 }) {
    ForEach(this.events, (ev: TimelineEvent) => { TimelineRow({ ... }) }, (ev: TimelineEvent) => ev.id)
    Text('').height(10)
  }
  .width('100%')
  .layoutWeight(1)
  .padding({ left: 40, right: 40, top: 14, bottom: 6 })
}

事件只会追加、不会消失("催办全部"一次就能加 N 条)。内容超出高度后没有滚动,直接压到页脚的"决策、评分与时间线均为本地演示数据"上——图 3 里最下面那条事件文案与页脚文字已经重叠,就是这个问题的现场照片。同时它也是一个键盘可达性问题:鸿蒙PC 用户会习惯用滚轮,而这个页面根本不响应滚轮。

4.5 三列网格写死,窗口一窄就挤

看板是 Grid + columnsTemplate('1fr 1fr 1fr')(Index.ets:250)。在截图里 1080×720 的窗口下三列正好,但 2in1 的窗口宽度是用户手里的变量:拉到 700px 宽,每列只剩 220px,maxLines(1) 的标题会被截成四个字,SealBadge 的 40×40 圆章会把正文挤成两行。桌面端的布局问题有一半不在 CPU 上,而在"最窄那个断点谁让位"上——手机端宽度是常量,桌面端宽度是输入。

五、报错排查:7 类"不崩溃但结果错"的静默缺陷(附 3 条编译错)

这一章收录的每一条都是界面看起来正常、行为不对的类型。真正抛异常闪退的错误反而不难查,难查的是"结果错了但没人报错"。按"症状 → 根因 → 一行修法"组织,症状描述尽量对齐你在鸿蒙PC 真机上会看到的东西。

5.1 点了"催办全部",时间线只多出一条(或顺序错乱)

症状:治理规则页点"催办全部",toast 提示"已向 5 个提议发出催办",但切到决策时间线只看到 1 条新事件;或者事件顺序莫名调换、个别行重复出现。

根因:事件 id 用毫秒时间戳当唯一键,而催办是循环里连续 push:

// pages/Index.ets:62-65
private pushEvent(code: string, text: string, kind: number): void {
  const ev: TimelineEvent = new TimelineEvent('en' + Date.now().toString(), '11-15', code, text, kind);
  this.events = [ev].concat(this.events);
}

applyCheck('urge') 在 for 循环里对每个待议 ADR 调一次 pushEvent,五次调用全部落在同一毫秒内——Date.now() 返回值相同,于是五个事件拿到同一个 id。ForEach 的 key 正是 ev.id(Index.ets:479),key 重复的后果是框架无法区分这几项,表现就是丢行、错序、或者点一下闪一下。

修法:唯一键必须来自单调递增的序列号,而不是时钟:

private seq: number = 0;

private pushEvent(code: string, text: string, kind: number): void {
  this.seq = this.seq + 1;
  const ev: TimelineEvent = new TimelineEvent('en-' + this.seq.toString(), '11-15', code, text, kind);
  this.events = [ev].concat(this.events);
}

这条坑的通用版本是:凡是用 Date.now() / Math.random() 当列表 key 的地方,在"一次操作产生多个元素"的场景下都会塌。 时间戳不是唯一性保证,只是"通常够用"。

鸿蒙PC 真机完整桌面:决策时间线页,两条事件,最下面一条的文字已经压到页脚

图 3 鸿蒙PC 真机完整桌面:「决策时间线」页。左侧一条竖线串起事件点:第一枚是红色实心点(kind=1,采纳类)配 11-08 ADR-014 已采纳「按需分页加载」,归档评审记录。;第二枚是绿色点(kind=0,验证类)配 11-09 ADR-014 完成启动耗时回归验证,P95 提前 220ms。。注意第二行文字已经与页脚的"决策、评分与时间线均为本地演示数据"重叠——这就是 4.4 节说的"没有滚动容器",事件再多就会直接压在页脚上

5.2 评审页标题是 A,候选排行却是空的

症状:从看板点进某条 ADR,标题显示 ADR-014,但"候选方案排行"区一片空白;换一条又正常。极端情况下整页白屏并抛 Cannot read property 'code' of undefined。

根因:adrById() 找不到时静默兜底到第一条:

// pages/Index.ets:21-28
private adrById(id: string): AdrItem {
  for (const a of this.adrs) {
    if (a.id === id) {
      return a;
    }
  }
  return this.adrs[0];
}

selAdrId 是独立于 adrs 的外键。一旦某条 ADR 从数组里消失(给看板加"删除"、或按标签过滤后重建列表),selAdrId 就悬空:adrById 返回 this.adrs[0](于是标题"看起来正常"),而 sortedCandidates(selAdrId) 仍然用旧 id 去 filter,得到空数组。一个兜底把"找不到"翻译成了"第一条",把可诊断的错误变成了不可诊断的错配。 如果 adrs 真的被清空,this.adrs[0] 是 undefined,下一行 .code 立刻炸。

顺带说清一处容易被误判的地方:ADR-017「动态化包体加载策略」的候选排行本来就是空的——Models.ets:112-125 的 12 个候选里没有任何一条挂在 a4 上,因为这条议题在 11-05 已被废弃。于是"空排行"在界面上有两种完全不同的成因(这条真的没有候选 / 外键悬空),而当前 UI 对两者给的是同一片留白。空态必须能自证原因,否则排查的第一步就卡在"这是数据问题还是渲染问题"。

修法:让返回值类型诚实地允许"没有",并在 UI 层显式给空态:

private adrById(id: string): AdrItem | undefined {
  for (const a of this.adrs) {
    if (a.id === id) {
      return a;
    }
  }
  return undefined;
}

调用处写 const adr = this.adrById(this.selAdrId); if (adr === undefined) { /* 空态:请选择议题 */ }。"兜底"这两个字在治理类工具里往往是有害的:它掩盖的是"数据不一致",而数据不一致正是这个工具本该发现的东西。

5.3 点"去校准权重",卡片永远不消失

症状:治理规则页的三条待办里,"评审权重沿用默认模板"那张卡的按钮点了会跳到方案评审页,但回来之后卡片还在;反复点,永远在。

根因:applyCheck() 里 weights 分支提前 return,跳过了"标记已完成"那一行:

// pages/Index.ets:99-103
} else if (id === 'weights') {
  this.tabIdx = 1;
  return;                       // ← 这一行让 fixedChecks 永远不追加
}
this.fixedChecks = this.fixedChecks.concat([id]);

修法:治理项闭环要由事实驱动,而不是由点击驱动。把判断条件从"点过按钮"改成"权重已偏离默认模板",再用 @Watch 或直接在 weights 变更时复位:

private isDefaultWeights(): boolean {
  const base: number[] = [7, 5, 5, 6, 4];
  if (this.weights.length !== base.length) {
    return false;
  }
  for (let i = 0; i < base.length; i++) {
    if (this.weights[i] !== base[i]) {
      return false;
    }
  }
  return true;
}

然后卡片显示条件从 fixedChecks.indexOf('weights') < 0 改成 this.isDefaultWeights()。这样它变成一个自查项:改了权重就自动消失,改回去又会出现——比"点过就算做完"诚实得多。

5.4 点两次"模拟新提案",出现两个 ADR-019

症状:连点"模拟新提案",看板上出现两条 ADR-019,时间线里也有两条 code 相同、内容不同的事件。

根因:simulateProposal() 拿种子数据循环取用,code 原样复制:

// pages/Index.ets:79-87
const seed: AdrItem = Library.incoming[this.seedIdx % Library.incoming.length];
this.seedIdx++;
const fresh: AdrItem = new AdrItem(seed.id + '-' + this.seedIdx.toString(), seed.code, ...);

id 加了序号所以 ForEach 不会冲突,但 code 是 ADR 的业务主键,它重复意味着"两条不同的决策记录共享同一个编号"。看板上分不清,时间线上引用的 ADR-019 指向不明——这在真实治理里是致命的,因为复议时你要靠编号定位唯一一条记录。

修法:编号分配必须是应用级的单调计数器,与种子数据解耦;种子只负责"标题与摘要模板":

@State nextAdrNo: number = 19;

private newCode(): string {
  const no: string = this.nextAdrNo.toString().padStart(3, '0');
  this.nextAdrNo = this.nextAdrNo + 1;
  return 'ADR-' + no;
}

更严谨的做法是把"已用编号"落盘并在启动时取最大值 +1,否则应用重启后计数器归位,编号又会撞。编号唯一性是治理数据的第一约束,比字段完整性更靠前。

5.5 可以定标第 2 名,但归档里查不到"为什么不是第 1 名"

症状:这不是崩溃,是评审后半年才发作的病——ADR 里写着"已采纳「关系型数据库」“,可它是 6.7 分,而 7.4 分的 KV 数据库被跳过了;再问"当时为什么破例”,没人答得上来。

根因:CandidateLine() 给每一行都渲染了"定标"按钮(Index.ets:346-356),只看 adr.status === 0,不看名次:

if (adr.status === 0) {
  Text('定标') /* ... */ .onClick(() => { this.decide(adr.id, c.name); })
} else {
  Text(adr.status === 1 ? '已采纳' : '已废弃') /* ... */
}

“允许破例"本身是对的——评分是决策的输入,不是决策本身。问题在于破例这件事没有留下任何理由字段。ADR 制度的精髓就藏在"能解释偏离"里:如果第 2 名被选中,记录里必须有一句"为什么”。

修法:给决策加一条结构化记录(见第六节 DecisionRecord),并让"非第 1 名定标"强制走一个输入理由的流程(bindSheet 里一个 TextInput 即可);理由是空串时按钮直接禁用。这条是全文唯一一条"不是 bug 但比 bug 更贵"的缺陷:它不影响任何一次点击,只影响三年内所有复议。

5.6 五根滑杆全拖到 0,整列变成 0.0 且毫无提示

症状:极端操作下(或误操作把五根都拉到最左),候选排行所有分数都变成 0.0,名次按原顺序平铺,看不出异常。

根因:totalW() 用 Math.max(1, s) 兜住零除,于是 0/1 得到 0,而不是 NaN 或异常。护栏挡住了崩溃,也挡住了"发现错误"的机会。

修法:护栏要保留,但必须同时给出可观测信号:当 totalW() === 0 时,在权重区渲染一行提示"权重全为 0,评分无意义",并把"定标"按钮置灰。兜底值不是错误处理,只是延迟暴露——桌面端尤其明显,因为这类错误不会被用户上报,只会被用户默默关掉。

5.7 装不上、连不上:包名冲突与形态约束

症状一:hdc install 报 9568263 … downgrade,或 DevEco 点运行弹"安装失败"。

根因:本工程 versionCode 1000000(AppScope/app.json5:5),而同一台鸿蒙PC 上常常并行装着多个共用调试签名的演示工程;设备上已有同包名且版本号更高的包时,安装会被拒。

修法:hdc uninstall com.arbitra.decision 后再装,或把新工程的 versionCode 调高。做系列演示工程时,建议每个工程的 versionCode 直接按日期编码(例如 1116001),从根上避免降级判定。

症状二:应用在手机上装不上/不显示。

根因:module.json5:7 只声明 deviceTypes: ['2in1']。这是有意为之——看板三列、评审双区、时间线长流水,都是给桌面大屏设计的,装到手机形态上即使能装也没有意义。

修法:不要为了"能装上"而加 phone。正确做法是承认形态约束并在 UI 上做宽窄断点(4.5 节);如果确实要多端,那是两条产品线,不是"一个 module 加两个 deviceTypes"。

定位手段:真机上没有控制台时,hilog 是最便宜的探针。本工程在 EntryAbility 里埋了两条,tag 是 ArbitraAbility:

// entryability/EntryAbility.ets:13-18
windowStage.loadContent('pages/Index', (err: BusinessError) => {
  if (err.code) {
    hilog.error(0x0000, 'ArbitraAbility', 'loadContent failed: %{public}s', JSON.stringify(err));
    return;
  }
  hilog.info(0x0000, 'ArbitraAbility', 'loadContent ok');
});

用 hdc shell hilog -T ArbitraAbility 按 tag 过滤即可。两个细节值得抄:loadContent 的失败分支一定要打日志,否则"白屏"时你连是页面路径写错还是渲染抛异常都不知道;%{public}s 不能省,不标 public 的字符串在日志里会被打码成 <private>,排查时只能看到一串星号。

5.8 附:三条 ArkTS 严格模式下的高频编译错

严格模式(strictMode.useNormalizedOHMUrl: true)下,.ets 文件"第一次写就红"的常客是这三个:

报错关键字触发写法修法
arkts-no-untyped-obj-literals把对象字面量赋给无类型标注的变量定义 class/interface 并标注;本工程的 AdrItem、Candidate、TimelineEvent 都是为此存在
arkts-no-any-unknown用 any 接 JSON.parse 的结果定义接口后 as 断言,或用 Record<string, number[]> 收窄
Property has no initializerclass 字段只声明不赋值构造器全字段赋值(Models.ets 的四个类都是这个写法)

本工程一个 interface 都没用、全用 class + 构造器,原因就在这里:class 在 ArkTS 里可以做 withStatus() 这种不可变更新方法(返回新实例),而 interface 没有方法,只能在外面手写字段拷贝——手写拷贝在加字段时一定会漏(这条在 5.5 的结构化记录里会再遇到一次)。

六、修复稿:四处改动,把"形状"补成"证据"

下面四段代码是针对上面静态可见缺陷的修改稿,全部用 ArkUI 原生写、可独立编译进本工程。它们不追求"完整重构",只解决一件事:让每一次决策都能被复算,让每一次点击都不制造新问题。

6.1 先算分再排序,并把分数传到渲染层

// common/Models.ets 追加:带分数的候选视图对象
export class RankedCandidate {
  candidate: Candidate;
  score: number;

  constructor(candidate: Candidate, score: number) {
    this.candidate = candidate;
    this.score = score;
  }
}
// pages/Index.ets:替换 sortedCandidates,一次求值、排序器里不再重算
private ranked(adrId: string): RankedCandidate[] {
  const list: RankedCandidate[] = [];
  for (const c of Library.candidates) {
    if (c.adrId === adrId) {
      list.push(new RankedCandidate(c, this.weighted(c)));
    }
  }
  list.sort((a: RankedCandidate, b: RankedCandidate) => b.score - a.score);
  return list;
}
// pages/Index.ets:key 只留候选名,分数与名次作为参数传入
ForEach(this.ranked(this.selAdrId), (r: RankedCandidate, rank: number) => {
  this.CandidateLine(r.candidate, rank + 1, this.adrById(this.selAdrId), r.score)
}, (r: RankedCandidate) => r.candidate.name)

改动收益可以数出来:排序器从"每次比较 2 次 weighted()“降到 0 次,weighted() 调用次数从"排序期最坏 86 次"降到"候选数 n 次”;拖动滑杆时 key 不再变,整列从"重建"变成"更新"。代价是放弃"名次跃迁"的隐式重建动画,需要动画就用 animateTo 显式补。

6.2 一条真正被归档的决策记录

// common/Models.ets 追加:决策归档物
export class DecisionRecord {
  code: string;
  picked: string;
  score: number;
  weights: number[];
  firstPlace: string;
  overrideReason: string;
  at: string;

  constructor(code: string, picked: string, score: number, weights: number[],
    firstPlace: string, overrideReason: string, at: string) {
    this.code = code;
    this.picked = picked;
    this.score = score;
    this.weights = weights;
    this.firstPlace = firstPlace;
    this.overrideReason = overrideReason;
    this.at = at;
  }

  needsReason(): boolean {
    return this.picked !== this.firstPlace && this.overrideReason.length === 0;
  }
}
// pages/Index.ets:定标时写入结构化归档,而不是只写一句文案
@State decisions: DecisionRecord[] = [];

private decide(adrId: string, c: Candidate, reason: string = ''): void {
  const adr: AdrItem | undefined = this.adrById(adrId);
  if (adr === undefined) {
    this.toast('议题已不存在,请刷新');
    return;
  }
  const board: RankedCandidate[] = this.ranked(adrId);
  const top: string = board.length > 0 ? board[0].candidate.name : c.name;
  // reason 由"破例说明"弹层回填;首选方案时保持空串
  const rec: DecisionRecord = new DecisionRecord(adr.code, c.name, this.weighted(c),
    this.weightsOf(adrId).slice(0), top, reason, '11-16');
  if (rec.needsReason()) {
    this.toast('非首选方案必须填写破例理由');
    return;
  }
  this.decisions = [rec].concat(this.decisions);
  this.adrs = this.adrs.map((a: AdrItem) => a.id === adrId ? a.withStatus(1) : a);
  this.pushEvent(adr.code, '已采纳「' + c.name + '」,加权 ' + rec.score.toFixed(1)
    + ',权重 ' + rec.weights.join('/') + ' 已归档。', 1);
  this.toast(adr.code + ' 已定标:' + c.name);
}

这段代码假定 6.3 的议题级权重已经落地(weighted() 内部改成按 adrId 取权重);"非首选方案"的 reason 由点击第 2/3 名的"定标"时弹出的 bindSheet 回填,首选方案点击直接走通。注意 this.weightsOf(adrId).slice(0) 这一句:必须拷贝,不能存引用,否则后面再拖滑杆,会把历史归档里的权重一起改掉——这是"归档"与"状态"混用同一份数组时最阴险的一种数据污染。

6.3 权重按议题分账

// common/Models.ets 追加
export class WeightSet {
  adrId: string;
  values: number[];

  constructor(adrId: string, values: number[]) {
    this.adrId = adrId;
    this.values = values;
  }
}
// pages/Index.ets:切议题即换口径,未校准时显式提示
@State weightSets: WeightSet[] = [];

private weightsOf(adrId: string): number[] {
  for (const w of this.weightSets) {
    if (w.adrId === adrId) {
      return w.values;
    }
  }
  return [7, 5, 5, 6, 4];
}

private setWeight(adrId: string, idx: number, v: number): void {
  const base: number[] = this.weightsOf(adrId).slice(0);
  base[idx] = Math.round(v);
  let hit: boolean = false;
  const next: WeightSet[] = this.weightSets.map((w: WeightSet): WeightSet => {
    if (w.adrId === adrId) {
      hit = true;
      return new WeightSet(adrId, base);
    }
    return w;
  });
  this.weightSets = hit ? next : next.concat([new WeightSet(adrId, base)]);
}

这三十行带来两个收益:其一,R1 从"点了按钮"变成"每条议题有自己的权重快照",可被证明;其二,评审页顶部 chip 可以给"未校准"的议题加一个小圆点,把口径漂移变成可见状态。

6.4 时间线加滚动与空态

// pages/Index.ets:给时间线一个 Scroll,并给空列表一个交代
@Builder
TimelineTab() {
  Scroll() {
    Column({ space: 0 }) {
      if (this.events.length === 0) {
        Text('暂无决策事件')
          .fontSize(F.body)
          .fontColor(Pal.inkFaint)
          .padding({ top: 40 })
      }
      ForEach(this.events, (ev: TimelineEvent) => {
        TimelineRow({ date: ev.date, code: ev.code, text: ev.text, kind: ev.kind })
      }, (ev: TimelineEvent) => ev.id)
      Text('').height(10)
    }
    .width('100%')
  }
  .layoutWeight(1)
  .scrollBar(BarState.Auto)
  .align(Alignment.Top)
  .padding({ left: 40, right: 40, top: 14, bottom: 6 })
}

Scroll 的 align(Alignment.Top) 别漏——默认居中,事件少的时候整条时间线会飘到屏幕中间,看起来像加载失败。这是鸿蒙PC 上写滚动容器最常忘的一行。

七、诚实边界:哪些数字能用,哪些不能用

写到这里必须把话说完整,否则这篇文章的结论会被误用。

第一,界面上的分数全是演示数据,但计算过程是真的。 7.4、6.7、7.2、6.2 这些数字来自 Models.ets 里写死的 scores 常量乘以滑杆上的权重,你可以用计算器逐条复核(2.1 与 2.2 已经复核过四条)。它们的意义是验证评分公式与展示链路正确,不是"这个方案就是 7.4 分"。

第二,"P95 提前 220ms"是演示文案,不是我测出来的。 它写在 Models.ets:129 的 TimelineEvent 种子里,用来展示"一条验证类事件该长什么样"。真要写这个数字,需要给出机型、构建类型、样本量、冷热启动区分和至少三轮取值——缺任何一项都不是性能数据,是故事。

第三,第四节五处性能问题都是"静态可推断"级别的改动,没有做压测对照。 86 次 weighted()、9 次全表扫描、900 次浮点运算,都是从源码数出来的工作量,不是 profiling 出来的耗时。它们的正确表述是"减少了多少重复计算",而不是"快了 XX 毫秒"。我刻意不写毫秒数,是因为这个工程里没有任何帧采样代码(没有 withFrameNanos,没有 FrameMeter)——没有测量就没有毫秒,这是写性能文章最起码的自律。

第四,这个工程目前不能当生产工具用。 时间线只在内存、ADR 编号会撞、权重不分账、归档是文案——每一条都在正文里指到了具体行号。下一步按优先级排三件事:其一,落盘——把 decisions、events、weightSets 序列化到 filesDir 的 JSON 并在启动时读回(EntryAbility 里已经能拿到 this.context.filesDir);其二,闭环——R1 到 R4 四条规则全部改成"事实驱动"而非"点击驱动";其三,断点——看板 columnsTemplate 按窗口宽度在 3 列 / 2 列 / 1 列之间切换,让 2in1 的窗口缩放不再是布局炸弹。

八、总结:三条线的落点

方案选型治理的落点不是"选出方案",而是让候选在同一屏、同一口径、同一时间点被比较,并把结论固化成有编号、有状态、可被取代的证据。衡鉴把三样东西写进了代码:权重是常量数组(可改、可复算)、总分是纯函数(能手算复核)、状态是三态字段(可回退)。但 R3 那条"自动归档"提醒我们:只要归档物没被写进数据结构,一切"已归档"都只是文案。 治理工具最容易在最后一米失效,而这一米恰恰是唯一重要的那一米。

性能优化的落点是把 build() 当热路径:派生计算别每帧重算、ForEach 的 key 里别塞加权分、线性计数别在渲染路径里重复跑、滚动容器别忘了 align(Alignment.Top)、三列网格别忘了桌面窗口是变量。这五条没有一条需要新框架,也没有一条需要 profiler 才能发现——读代码就能数出来。

报错排查的落点在于分清"崩溃"与"结果错"。崩溃有堆栈好查;结果错只能靠四条清单去扫:唯一键是不是真的唯一(Date.now() 不是)、兜底是不是在掩盖不一致(返回 adrs[0] 是)、闭环是不是由事实驱动(return 跳过标记就不是)、编号是不是业务主键(复用种子 code 就不是)。 再配一个 hilog 的 %{public}s 和 loadContent 失败分支,能省掉整个下午。

最后回到鸿蒙PC 这个前提。同一套 ArkUI 代码跑在手机上和在 2in1 上,遇到的问题不是同一个集合:窗口宽度是变量、会话是小时级、系统能力是主力而不是点缀。这决定了鸿蒙PC 上的技术决策必须留档——因为每一次决策的代价都要在用户桌面上摊好几年。至于要不要引入跨平台框架、要不要让 ArkUI-X 或 Flutter 承担一部分页面,答案不在任何一篇对比文章里,而在你自己那张五维评分表上:先把权重写下来,再把它算出来,最后把理由存下来。

九、复现步骤

  1. 用 DevEco Studio 打开 项目源码/Arbitra_ohos(Stage 模型,compatibleSdkVersion 26.0.0)。
  2. 在 build-profile.json5 的 signingConfigs 里填入你自己的调试签名(工程默认是空数组,直接编译会报签名失败)。
  3. 目标设备选 2in1(鸿蒙PC 真机或 PC 形态模拟器),运行后 windowStage.loadContent('pages/Index') 直接进入决策看板。
  4. 复现 2.1 的口径:点开 ADR-015「本地缓存引擎选型」,把五根滑杆停在 7/5/5/6/4,核对 KV 数据库是否为 7.4、关系型是否为 6.7;手算 201/27 与 181/27。
  5. 复现 2.2 的冠军换人:切到 ADR-014,把权重拖成 10/1/1/1/1,「混合分级加载」应从第 3 名升到第 1 名(7.9),「按需分页加载」退到第 2(7.7)。
  6. 复现 5.1 的重复 key:治理规则页点"催办全部",然后切到决策时间线,看新事件条数是否与 toast 提示的条数一致(当前实现通常不一致)。
  7. 复现 4.1 与 4.2 的成本:在评审页来回拖动任意一根滑杆,观察下方排行整列的重建闪烁;把 key 改成 c.name 后同样拖动,闪烁应消失。
  8. 复现 5.3 的不闭环:点"去校准权重"跳到评审页,随便改一根滑杆再回治理页,卡片仍在——因为 fixedChecks 从未被追加。

工程源码托管在 AtomGit(PC 社区平台:https://atomgit.com/OpenHarmonyPCDeveloper)。本文全部界面与代码使用 ArkUI(ArkTS 声明式 UI)实现,未引入 ArkUI-X、Flutter 或 Compose Multiplatform 运行时;文中提到的这些跨平台框架仅作为选型对照的候选方案,出现位置集中在第三节与第八节。文中"鸿蒙PC"指搭载 HarmonyOS 的 2in1 桌面设备形态,与手机 / 平板形态在窗口模型上有本质差异。如果你要把这套流程搬进自己的团队,最小可用版本只需要三样东西:一份带权重且按议题分账的评分常量、一条能被计算器复核的总分公式、一张只追加不修改的决策记录表。

Logo

讨论HarmonyOS开发技术,专注于API与组件、DevEco Studio、测试、元服务和应用上架分发等。

更多推荐