KMP/CMP 接入鸿蒙 DID:对账文件改了一个字节,原签名还能验过吗?

KMP/CMP 鸿蒙社区 · 鸿蒙跨端实战项目 · 文件签印源码与 README

前言

对账单归档以后,有人发现一笔金额对不上。两份文件的名字一样,长度也一样,打开后只有一个数字不同。文件系统能告诉我们读到了多少字节,却回答不了哪份内容和签名产生时一致。即使把文件的哈希另存为一列,如果这列数据和文件一起被改写,收件方仍然缺少一个能单独验证的依据。

这个例子把问题缩到一行:同一份签名、同一把公钥,一份对账文本原封不动,另一份把金额的第一个字符从 1 改成 9。两份文件都能正常打开,都可以被业务代码解析成金额。只有验签能判断它们是否和签名对应。这样设计,是因为一段失败提示不能证明篡改检测有用:输入文件不存在、签名格式不对、设备不支持接口,都可能导致失败。原件通过、只改一个字节的副本不通过,才是这里要观察的结果。

跨端页面使用 Compose Multiplatform。密钥创建和签名由鸿蒙 Online Authentication Kit 的 DID 服务完成,验签使用系统密码框架。Kotlin 模块保管执行记录和两份文件的结论,鸿蒙适配器保管文件字节、密钥绑定及系统接口调用。页面拿到的是结果和阶段,不接触私钥,也不接收用于标识用户的字段。

两份文件

在 MatePad Edge 上打开「文件签印」,点一次「签名并比对」。页面左侧的原件显示金额 120.00,改动件显示 920.00;右侧依次显示生成密钥、绑定、查询、签名和验签。判定标准是原件通过、改动件失败,并且两行使用同一份签名。在模拟器中也可以打开页面并发起请求,运行至设备拒绝阶段,两个验签位仍显示待验证。

真机全屏签验结果,蓝色文件对照区与签验记录同屏显示。

从点击到两行验签结果出现,可以同时看到哪些步骤已经完成。

MatePad Edge 真机录屏

点击「签名并比对」,原件通过、改动件失败。

改动件保留了原件的换行、币种和单号。这里的金额只是方便肉眼找到差异,用的是程序生成的演示文件。应用把原件和改动件分别写到自己的目录,再读回两份字节数组。签名使用读回的原件,验签各读一份。也就是说,画面里的对照不是把一个内存字符串换个颜色:两份文件都经过了同样的读写路径,差别只在那一字节。

运行中的「验签失败」有两种容易混淆的含义。改动件的红色结果意味着验签器已经正常工作并返回不通过,它是实验预期。若签名服务未启动、系统拒绝调用,或读取公钥时抛错,页面应当停在相应步骤,两行都保留「待验证」。把这两类情况分开以后,看到红色字样就知道是文件与签名不匹配,还是这轮压根没有得到可用证据。

API 26 模拟器的 801 分支,两份文件仍待验证。

这一轮怎么判定

原件和改动件的文件长度是相同的,签名长度则不参与判断。SM2 的签名以 ASN.1 结构返回,整数的编码长度并不固定;即使同一份内容重试,拿到的签名字节也不需要相同。日志中的签名长度只用于排查是否拿到了输出。更可靠的判定是:第一次使用公钥和原件验过,第二次用同一个公钥和同一份签名检查改动件,结果不通过。

检查项送入的数据判定依据
原件原件字节、同一公钥、同一签名验签接口返回通过
改动件等长副本,仅改金额首字节,沿用公钥和签名验签接口返回不通过
模拟器同一宿主、同一份示例数据返回 801;无签名结果,两行保持待验证

按阶段看日志时,先找到本次点击产生的起始行,再往后读。进入签名阶段只能说明查到了目标绑定;进入验签阶段才意味着收到了系统签名。最后一行同时记录两个布尔结果。把这三处信息连起来,就能排除一种常见误读:把系统接口返回了响应,当成整个文件校验已经完成。

真机和模拟器日志对照

这组对照没有测耗时,也没有从两次真假值推出安全级别。它回答的是同一份签名是否适用于当前两份文件。判断过程未比较不同机型,也未比较本地与服务端的速度。想复核时,两次验签所需的三个输入都能在代码里定位,不用依赖界面文案或人为标记。

还可以用反向试验帮助检查接线:让签名输入改成 920.00 的版本,仍用同一把公钥分别核对两份文件。此时应该轮到 920.00 通过,120.00 不通过。这是一个复查办法,本文记录的演示仍然只对原件签名。区分「做了哪个试验」与「还可以怎么查」很重要,尤其是把演示交给同事复现时,不能把未运行的验证步骤算进实测结果。另一个办法是在调试时记录两个文件的长度和首个不同的字节位置。这两个值足以核实是否改了一处,不必把真实对账单输出到终端。

从别名到签名

密钥别名出现在创建请求里,签名接口却收的是密钥 ID。这两个字段不能随手填成同一串字。示例先生成随机后缀,为本轮新建一个别名和一个示例 DID。生成密钥之后,通过导入接口绑定示例 DID、别名和签名时要用的 ID;再从系统查询绑定,用查回的结果调用签名。中间的查询多了一次接口往返,但能避免把应用以为已经写进去的记录,当成系统实际保存的结果。

这里用的是教学范围的示例标识。它只用于在应用内建立可查的密钥绑定,不表示某个用户的真实身份,也没有公开解析服务。拿到这样的标识,另一台设备不会凭空知道某个人是谁。要做跨系统的身份互认,还需要选定标识方法、处理解析和密钥轮换,以及按业务决定凭证由谁签发、由谁信任。本文只走鸿蒙设备上的生成、绑定、查询和签名路径,不把这条路径包装成一套身份认证系统。

生成请求只指定 SM2 和签名验签用途。示例创建的是应用专用测试密钥,按公开接口的约定不配置认证器,不触发用户认证。这个选择适用于验证签名与文件字节之间的关系,不意味着用户已经授权一笔对账业务。如果业务需要人在场、明确同意或验明身份,应按目标设备支持的认证方式重新设计并验收,不能拿这份演示替代。尤其是有人看见「DID」就默认有指纹确认,这是两件需要独立验证的事。

生命周期也从创建请求开始考虑。每轮使用新的别名和示例标识,避免和前一轮碰撞。只有导入成功才尝试删除本轮示例 DID,删除失败另外记日志;不为了清理而动应用里其他条目。生成成功但导入失败时,示例未取得一条成功绑定的记录,不能假定删除 DID 会把未绑定密钥一并移除。实际业务若长期运行,应根据业务场景管理密钥、设备侧条目上限和失败重试。反复生成密钥既不等于轮换策略,也不是定位失败的好办法。

读取系统返回的密钥绑定后再签名

接口和限制可对照鸿蒙 DID API和数字身份开发指南。示例使用公开接口,不调用凭证导入接口,也不申请凭证管理所需权限。

验签看的是字节

金额从 120.00 改到 920.00 的位置在一个只含 ASCII 的样本里。字符串里的位置就是 UTF-8 字节下标。如果换成含中文的发票备注,字符位置和编码后的字节偏移通常不相同,就应在已编码的字节数组上查找目标序列或单独组织示例输入。不能把 Unicode 字符下标直接当作文件偏移,否则验证的可能根本不是以为修改的那一处。

文件读取也避免经过「文本读出来、转成对象、再序列化」的过程。哪怕解析后的数据完全一样,编辑器重写换行、增加文件开头的标记、调整键的顺序或删除末尾空格,都可能改掉底层字节。假如业务想允许这些格式变化,就要先约定规范化规则,并让签名方和验证方遵循同一规则。直接签文件时,规则反而清楚:读到什么字节,就验证什么字节。用哈希可辅助找差异,但不要把另算的一次哈希默默替换成签名约定。

适配器在调用异步系统接口前复制两份输入,以免调用方在等待期间继续改写数组。到了验签环节,原件、改动件分别新建一个验签器。两个验签器使用同一把公钥、同一份签名,只更新各自的内容。如果复用一份没有重新初始化的摘要状态,第二次计算可能把前一次输入算进去;这时得到的失败结果并不能说明单字节改动被检测到了。

公钥从 DID 密钥创建结果取得,经系统密码框架解析成可用于验签的公钥。这里不从文件名、签名长度或 DID 文本推测算法。SM2 和 SM3 的组合由示例配置明确给出,可对照华为的SM2 签名与验签指南。这次验签确实使用生成密钥时得到的公钥;生产环境里,验证方还必须独立确认那把公钥可信。攻击者若能同时替换文件、签名和公钥,单靠数学验签不会判断替换后的公钥来自谁。

DID 的签名入口对输入有字节数上限。示例把最大值写在库里,在进入系统服务前拒绝空数据、超过 4500 字节、长度不同或内容相同的对照输入。长度相同是本实验为了控制变量,不是验签算法对所有业务文件的要求。大文件如果采用摘要签名,应另外定义并记录摘要算法、输入格式、版本和验证约定,不能把这里只接受短输入的接口当作一个任意文件签名器。

跨端边界

应用宿主是最靠近设备的一层。它负责读写两份小文件,取得当前 Ability 的上下文,然后调用库里的鸿蒙适配器。没有把签名步骤散在按钮回调中:按钮只启动一轮任务,后面五个阶段由同一个适配器串起来。换一个 CMP 页面接入时,仍可用原来的适配器和共享状态;页面不用重新拼 DID 请求,也不需要知道 ASN.1 的编码细节。

桥上传的是本轮编号、阶段和结果。它不传输文件内容、密钥或任何用于识别用户的字段;连签名也只传长度。界面既然只要回答「原件和改动件分别如何」,就没有必要把签名字节和设备公钥跨层传一遍。如果以后需要导出签名包,应当另加一个明确的导出接口,在平台侧审查允许暴露的字段,并区分公开公钥与设备证明材料。

共享模块用一个递增编号串起开始、推进、完成和失败。新一轮把两行恢复成未验证;旧轮次的回调不允许写入本轮。阶段也必须向前走,不能在「生成密钥」直接把页面设成验签完成。宿主运行时禁用按钮,避免连续点击并发执行两次。两道约束各有用途:按钮控制用户交互,状态机管接收结果的顺序。即使未来入口换成自动重试,结果仍然要带上原轮次编号才能进入页面。

Kotlin 只接受属于本轮且按顺序返回的状态

宽窗把文件对照和调用顺序放在同一排;窄窗则先读结果,再向下看步骤。两种布局的判定数据来自同一个状态对象。切换窗口宽度不应重新生成密钥,回到界面也不能把尚未开始的结果自动标成失败。这些约束比某个控件的配色更关键:页面在窄窗里即使只露出前两行,也不能让读者把空白或颜色当成判定结果。

真机悬浮窄窗,结果区按窗口宽度重排。

在项目中,didSeal 包含共享状态和鸿蒙适配器,composeApp 负责 CMP 页面和 Kotlin 入口,example/ohos 是宿主示例。Gradle 把 ARM64 和 x86_64 的 Kotlin 原生库与头文件同步给宿主,并复制同一份鸿蒙适配器。读源码时从库目录进去比只看宿主里生成的副本清楚;改代码也应从源文件改起,下一次构建会重新同步。

从 801 查起

API 级别和设备能力是两道检查。工程的最低兼容、编译和目标均设为 API 26,因为这里直接调用从 API 26 开始的 DID 接口。系统能力查询可用于提前判断,但是返回支持不代表每个运行环境都能生成密钥。此处的 API 26 模拟器能启动页面,实际调用生成密钥时返回 801;真机上的相同请求可以继续到验签。把两者都只写成「API 26」会丢掉关键条件。

如果看到 801,先核实正在运行的目标设备,再确认是生成密钥、查询还是别的接口报错。这个错误还没走到原件与改动件的验签,改金额、换文件编码、改变验签算法,都无法使本轮产生签名。模拟器仍适合检查页面、错误分支和桥接状态。拿 JVM 的本地密钥做辅助测试也可以,但那只能验证共享逻辑或一般密码运算,不能算鸿蒙 DID 系统调用通过。

如果生成后报绑定错误,核对所填别名是不是本次应用生成的那一个,密钥用途是否是签名与验签,以及当前条目是否已经绑定其他标识。查询不到记录时,看看导入的标识和查询参数是否一致,是否要求返回密钥列表。查询只拿到标识并不等于取回了绑定,必须核对列表中的实际别名和 ID。绑定成功才开始排查签名输入和公钥导入,不要把几个阶段的报错归结为同一类问题。

若同一轮原件也验不过,先确认签名所用的输入确实是刚从磁盘读回来的原件,再确认公钥来自本轮生成结果。把文件重新编码、换用别轮生成的公钥或对 ASN.1 签名自行做未约定的格式转换,都会破坏对照。如果两份文件都验过,则先核对改动件确实与原件不同,验签函数没有重复拿到同一个输入。结果组合比单独看到某个 true 或 false 更能定位错误。

最后是对外展示的问题。样例把报错码保留下来,没有把失败包装成可用的结果;也不会在终端上打印文件内容、设备证明材料和完整标识。需要向维护方说明问题时,报告运行设备、系统版本、API 和失败阶段,外加最小的错误码就够开始复现。具体错误码可对照官方 DID 错误码。

还有一种容易被遗漏的情况:即使副本真的被改过,如果重新读取的是同一个文件,两条验签路径也可能都通过。读写测试因此要从两个不同的路径取得结果,而不是先把原件读进来,再把两条界面的文件名改成不同文字。示例在文件接口处检查写入和读取的字节数,碰到短读或写入失败就结束这一轮。把短读补零后继续送签,也许仍能获得合法签名,但签的是程序补出的内容,已经不是磁盘里要审查的那份文件了。

构建与复测

工程使用 DevEco Studio 6.1.1.300 的环境,构建由独立安装的 HarmonyOS API 26 命令行 SDK 完成。Kotlin/Native 鸿蒙版为 2.2.21-1.2.0,Compose Multiplatform 鸿蒙版与宿主包均为 1.9.2-1.2.0,Skiko 为 0.9.22.2-1.2.0。宿主的兼容、目标和编译版本均为 26,Gradle 构建同时生成平板和模拟器的原生库。

真机使用华为 MatePad Edge(QXS-W00),HarmonyOS 7.0.0,软件版本 7.0.0.111(SP16C00E111R6P5),API 26。真机在宽窗和悬浮窄窗中均完成签验对照。模拟器为 DevEco Emulator 26.0.0.402 的 Mate X7 配置(PHEMU-FD01,x86_64),HarmonyOS 7.0.0,镜像软件版本 7.0.0.107(SP8DEVC00E999R4P11),API 26。模拟器请求返回 801,两份文件仍显示待验证。

MatePad Edge 关于本机,保留系统栏,序列号已遮盖。

模拟器设备配置与系统版本

工程 API 配置

安装时先按 README 完成 Gradle 同步与 OHPM 依赖安装,再用 Hvigor 构建 HAP。真机应使用授权到当前设备且与包名匹配的调试签名。打开页面后点「签名并比对」,在真机检查两行相反的结论,并核对日志中的签名和验签阶段。在模拟器上,复核错误码分支、两份文件仍是待验证、没有输出伪造签名。两类结果应分开记录。

想更换对照数据时,先保留当前样本做一轮回归,然后改写宿主中的文本和改动位置。不要在同一轮既换文件内容,又换密钥算法、输入编码和签名格式。改一处时失败原因通常很好追;一起改了四处,看到原件验不过也无法立刻知道是哪一处引入的。最后在界面与日志各看一次结果,确认显示的标签确实对应这轮的两个值。

把这个例子带进自己的应用时,也别直接把演示的单次签验流程接到所有文件上。服务端收件、离线传输和端侧归档,各自面对的信任条件不同。以端侧归档为例,应先说明签名和公钥各存在哪里、读者如何取得可信公钥,以及以后更换密钥时旧签名如何继续验。样例省去了这些业务规则,正好能把 DID 签名这一层单独跑明白;准备长期保存记录时,再把它们补齐。

总结

这次可复用的部分是一条很短的链路:用系统 DID 服务生成应用密钥,绑定并回读,签原件,再用同一个公钥和签名检查两份字节。原件通过,等长改动件失败,说明签名绑定到内容;模拟器上的 801 则说明 API 级别达标后仍需查设备能力。前者是验签结论,后者是环境结论,不能用其中一个替代另一个。

如果在自己的业务里加文件校验,建议先约定签的究竟是文件字节、规范化数据还是摘要,再确定公钥的信任来源及密钥如何管理。跨端界面只接收它要呈现的状态,系统专用接口留在平台适配器中。这样从一张对账文本换成别的短文件时,最先要改的是样本和签名约定,不必把界面、原生桥和鸿蒙适配层一起拆开重写。

完整代码

以下是库、宿主示例和原生桥的关键完整文件。构建顺序见上节;其余工程配置包括资源、模块清单、Gradle 包装器及依赖版本表。

鸿蒙签验适配器

didSeal/src/ohosMain/arkts/DidSealAdapter.ets

import { common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { did } from '@kit.OnlineAuthenticationKit';

export enum SealStep {
  Key = 1, Bind = 2, Query = 3, Sign = 4, Verify = 5
}

export const MAX_SIGN_BYTES: number = 4500;

export class SealError extends Error {
  readonly code: number;

  constructor(code: number, message: string) {
    super(message);
    this.code = code;
  }
}

export interface SealResult {
  original: boolean;
  modified: boolean;
  signatureBytes: number;
}

export class DidSealAdapter {
  static available(): boolean {
    return canIUse('SystemCapability.Security.DID');
  }

  private static async verify(key: cryptoFramework.PubKey, bytes: Uint8Array,
    signature: Uint8Array): Promise<boolean> {
    // 每份内容分别初始化验签器,避免两份数据进入同一个摘要状态。
    const verifier = cryptoFramework.createVerify('SM2_256|SM3');
    await verifier.init(key);
    await verifier.update({ data: bytes });
    return verifier.verify(null, { data: signature });
  }

  async compare(context: common.UIAbilityContext, original: Uint8Array, modified: Uint8Array,
    onStep: (step: SealStep) => void, onCleanupError: (code: number) => void): Promise<SealResult> {
    if (!DidSealAdapter.available()) {
      throw new SealError(801, 'DID is unavailable');
    }
    if (original.length === 0 || original.length > MAX_SIGN_BYTES || modified.length > MAX_SIGN_BYTES ||
      original.length !== modified.length || original.every((byte: number, i: number) => byte === modified[i])) {
      throw new SealError(-10, 'Provide different non-empty inputs of the same length, at most 4500 bytes');
    }
    // 对异步调用的输入拍快照,防止调用方在等待期间继续写入数组。
    const signedInput = original.slice();
    const changedInput = modified.slice();
    const random = cryptoFramework.createRandom().generateRandomSync(12).data;
    const nonce = Array.from(random).map((b: number) => b.toString(16).padStart(2, '0')).join('');
    const alias = 'file_seal_' + nonce;
    const subject = 'did:example:fileseal' + nonce;
    const keyId = subject + '#file-signing';
    let bound = false;
    try {
      // 仅为演示文件创建应用专用密钥,不开启用户身份认证。
      const key = await did.generateKey(context, {
        keyAlias: alias,
        keyConfig: { algorithm: did.KeyAlgo.SM2, purposeList: [did.KeyPurpose.SIGN, did.KeyPurpose.VERIFY] },
        extension: '{"systemPrompt":"none"}'
      });
      onStep(SealStep.Bind);
      await did.importDid(context, { did: subject, didKeyList: [{ keyAlias: alias, keyId: keyId }] });
      bound = true;
      onStep(SealStep.Query);
      const record = await did.queryDid(context, { did: subject, queryDidConfig: { requireDidKey: true } });
      const stored = record.didKeyList?.find((item: did.DidKey): boolean => item.keyAlias === alias);
      if (!stored || stored.keyId !== keyId) {
        throw new SealError(-11, 'DID key binding did not match');
      }
      onStep(SealStep.Sign);
      const proof = await did.sign(context, { keyId: stored.keyId, inData: signedInput });
      onStep(SealStep.Verify);
      const keys = await cryptoFramework.createAsyKeyGenerator('SM2_256').convertKey({ data: key.publicKey }, null);
      return {
        original: await DidSealAdapter.verify(keys.pubKey, signedInput, proof.outData),
        modified: await DidSealAdapter.verify(keys.pubKey, changedInput, proof.outData),
        signatureBytes: proof.outData.length
      };
    } finally {
      // 只清理本轮成功导入的示例 DID。清理错误单独上报,保留主结果。
      if (bound) {
        try {
          await did.deleteDid(context, subject);
        } catch (error) {
          onCleanupError((error as BusinessError).code ?? -1);
        }
      }
    }
  }
}

KMP 状态

didSeal/src/commonMain/kotlin/dev/didseal/core/SealRun.kt

package dev.didseal.core

enum class SealStage(val wire: Int) {
    Ready(0), Key(1), Bind(2), Query(3), Sign(4), Verify(5), Complete(6), Failed(7);

    companion object {
        fun decode(wire: Int): SealStage? = entries.firstOrNull { it.wire == wire }
    }
}

data class SealReport(
    val ticket: Int = 0,
    val api: Int = 0,
    val size: Int = 0,
    val stage: SealStage = SealStage.Ready,
    val original: Boolean? = null,
    val modified: Boolean? = null,
    val signatureBytes: Int = 0,
    val failedAt: SealStage? = null,
    val code: Int? = null
)

/** 只记录界面需要的结果,DID 标识、密钥和文件内容均留在平台层。 */
class SealRun {
    private var nextTicket = 0
    var report = SealReport()
        private set

    fun reset() { report = SealReport() }

    fun begin(api: Int, size: Int): SealReport {
        report = SealReport(++nextTicket, api, size, SealStage.Key)
        return report
    }

    fun advance(ticket: Int, wire: Int): SealReport? {
        val stage = SealStage.decode(wire) ?: return null
        if (ticket != report.ticket || stage.wire != report.stage.wire + 1 ||
            stage.wire > SealStage.Verify.wire) return null
        report = report.copy(stage = stage)
        return report
    }

    fun finish(ticket: Int, original: Boolean, modified: Boolean, bytes: Int): SealReport? {
        if (ticket != report.ticket || report.stage != SealStage.Verify || bytes <= 0) return null
        report = report.copy(stage = SealStage.Complete, original = original, modified = modified, signatureBytes = bytes)
        return report
    }

    fun fail(ticket: Int, code: Int): SealReport? {
        if (ticket != report.ticket || report.stage.wire !in SealStage.Key.wire..SealStage.Verify.wire) return null
        report = report.copy(stage = SealStage.Failed, failedAt = report.stage, code = code)
        return report
    }
}

示例页面

composeApp/src/commonMain/kotlin/dev/didseal/sample/SealBoard.kt

package dev.didseal.sample

import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.verticalScroll
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
import dev.didseal.core.SealReport
import dev.didseal.core.SealStage

private val Workspace = Color(0xFFEAF0F5)
private val Rail = Color(0xFF15263B)
private val Ink = Color(0xFF17263A)
private val Muted = Color(0xFF53667D)
private val Rule = Color(0xFFD6DFE8)
private val Blue = Color(0xFF225AC1)
private val Green = Color(0xFF10654D)
private val Red = Color(0xFF9F2D42)
private val Sheet = RoundedCornerShape(12.dp)
private val phases = listOf("生成应用密钥", "绑定示例 DID", "读取密钥绑定", "签署原件", "对照验签")

@Composable
fun SealBoard(report: SealReport) {
    BoxWithConstraints(Modifier.fillMaxSize().background(Workspace), contentAlignment = Alignment.TopCenter) {
        val wide = maxWidth >= 760.dp
        Column(
            Modifier.widthIn(max = 1180.dp).fillMaxWidth().verticalScroll(rememberScrollState())
                .padding(horizontal = if (wide) 32.dp else 14.dp, vertical = 18.dp),
            verticalArrangement = Arrangement.spacedBy(14.dp)
        ) {
            Text("文件对照", color = Ink, fontSize = 24.sp, fontWeight = FontWeight.Bold)
            VerificationSummary(report)
            if (wide) {
                Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
                    DocumentComparison(report, Modifier.weight(2f))
                    AuditTrail(report, Modifier.weight(1f))
                }
            } else {
                DocumentComparison(report, Modifier.fillMaxWidth())
                AuditTrail(report, Modifier.fillMaxWidth())
            }
        }
    }
}

@Composable
private fun VerificationSummary(report: SealReport) {
    val verified = report.stage == SealStage.Complete && report.original == true && report.modified == false
    val failed = report.stage == SealStage.Failed || (report.stage == SealStage.Complete && !verified)
    val tone = if (verified) Green else if (failed) Red else Blue
    val background = if (verified) Color(0xFFDDF5EA) else if (failed) Color(0xFFFBE5E8) else Color(0xFFE0EAFC)
    val message = when (report.stage) {
        SealStage.Ready -> "点击上方「签名并比对」开始。"
        SealStage.Complete -> if (verified) "验签结果符合预期 · ${report.size} 字节输入 · ${report.signatureBytes} 字节签名"
            else "验签组合不符合预期,请检查输入与签名。"
        SealStage.Failed -> if (report.code == 801) "当前设备环境不支持 DID 调用(801)。"
            else "系统或示例返回 ${report.code},本轮没有验签结论。"
        else -> "正在运行 · API ${report.api}"
    }
    Text(message, Modifier.fillMaxWidth().background(background, Sheet).padding(14.dp),
        color = tone, fontSize = 14.sp, fontWeight = FontWeight.SemiBold)
}

@Composable
private fun DocumentComparison(report: SealReport, modifier: Modifier) {
    BoxWithConstraints(modifier) {
        if (maxWidth >= 500.dp) {
            Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
                DocumentSheet("原件", "receipt.txt", "120.00", report.original, false, Modifier.weight(1f))
                DocumentSheet("改动件", "receipt-edited.txt", "920.00", report.modified, true, Modifier.weight(1f))
            }
        } else {
            Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
                DocumentSheet("原件", "receipt.txt", "120.00", report.original, false, Modifier.fillMaxWidth())
                DocumentSheet("改动件", "receipt-edited.txt", "920.00", report.modified, true, Modifier.fillMaxWidth())
            }
        }
    }
}

@Composable
private fun DocumentSheet(label: String, filename: String, amount: String, passed: Boolean?, changed: Boolean,
                          modifier: Modifier) {
    val tone = when (passed) { true -> Green; false -> Red; null -> Muted }
    val verdict = when (passed) { true -> "验签通过"; false -> "验签失败"; null -> "待验证" }
    Column(modifier.background(Color.White, Sheet).border(1.dp, Rule, Sheet).padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(11.dp)) {
        Text(label, color = Ink, fontSize = 17.sp, fontWeight = FontWeight.Bold)
        Text(filename, color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
        Column(Modifier.fillMaxWidth().background(Color(0xFFF4F7FA), RoundedCornerShape(6.dp)).padding(12.dp)) {
            Text("receipt=DEMO-01", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
            Row {
                Text("amount=", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 13.sp)
                Text(amount.take(1), color = if (changed) Red else Ink, fontFamily = FontFamily.Monospace,
                    fontSize = 13.sp, modifier = Modifier.background(if (changed) Color(0xFFFFE6A8) else Color.Transparent))
                Text(amount.drop(1), color = Ink, fontFamily = FontFamily.Monospace, fontSize = 13.sp)
            }
            Text("currency=CNY", color = Muted, fontFamily = FontFamily.Monospace, fontSize = 12.sp)
        }
        Text(verdict, color = tone, fontSize = 14.sp, fontWeight = FontWeight.Bold)
    }
}

@Composable
private fun AuditTrail(report: SealReport, modifier: Modifier) {
    Column(modifier.background(Rail, Sheet).padding(16.dp),
        verticalArrangement = Arrangement.spacedBy(12.dp)) {
        Text("签验记录", color = Color.White, fontSize = 17.sp, fontWeight = FontWeight.Bold)
        phases.forEachIndexed { index, label ->
            val phase = index + 1
            val reached = (report.failedAt ?: report.stage).wire
            val status = when {
                report.stage == SealStage.Failed && reached == phase -> "失败"
                reached > phase -> "完成"
                reached == phase -> "执行中"
                else -> "待处理"
            }
            val tone = when (status) {
                "失败" -> Color(0xFFFFA7B6)
                "完成" -> Color(0xFF80DFB8)
                "执行中" -> Color(0xFF91BEFF)
                else -> Color(0xFFABC0D6)
            }
            Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically,
                horizontalArrangement = Arrangement.spacedBy(8.dp)) {
                Text(phase.toString().padStart(2, '0'), color = tone, fontFamily = FontFamily.Monospace, fontSize = 11.sp)
                Text(label, Modifier.weight(1f), color = Color.White, fontSize = 13.sp)
                Text(status, color = tone, fontSize = 11.sp)
            }
        }
    }
}

Kotlin 原生入口

composeApp/src/ohosMain/kotlin/dev/didseal/sample/Platform.kt

package dev.didseal.sample

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.compose.ui.window.ComposeArkUIViewController
import dev.didseal.core.SealReport
import dev.didseal.core.SealRun
import kotlinx.cinterop.ExperimentalForeignApi
import kotlinx.coroutines.initMainHandler
import kotlin.experimental.ExperimentalNativeApi
import platform.ArkTS.ArkTS_Napi_NativeModule.napi_env
import platform.ArkTS.ArkTS_Napi_NativeModule.napi_value

private val run = SealRun()
private var report by mutableStateOf(SealReport())

@OptIn(ExperimentalNativeApi::class, ExperimentalForeignApi::class)
@CName("MainArkUIViewController")
fun MainArkUIViewController(env: napi_env): napi_value {
    initMainHandler(env)
    run.reset()
    report = run.report
    return ComposeArkUIViewController(env) { SealBoard(report) }
}

@OptIn(ExperimentalNativeApi::class)
@CName("SealBegin")
fun sealBegin(api: Int, size: Int): Int {
    report = run.begin(api, size)
    return report.ticket
}

@OptIn(ExperimentalNativeApi::class)
@CName("SealStepUpdate")
fun sealStep(ticket: Int, step: Int) {
    run.advance(ticket, step)?.let { report = it }
}

@OptIn(ExperimentalNativeApi::class)
@CName("SealFinish")
fun sealFinish(ticket: Int, original: Int, modified: Int, bytes: Int) {
    run.finish(ticket, original == 1, modified == 1, bytes)?.let { report = it }
}

@OptIn(ExperimentalNativeApi::class)
@CName("SealErrorUpdate")
fun sealError(ticket: Int, code: Int) {
    run.fail(ticket, code)?.let { report = it }
}

ArkTS 宿主与文件读写

example/ohos/entry/src/main/ets/pages/Index.ets

import { common } from '@kit.AbilityKit';
import { util } from '@kit.ArkTS';
import { LengthMetrics } from '@kit.ArkUI';
import { BusinessError, deviceInfo } from '@kit.BasicServicesKit';
import { fileIo } from '@kit.CoreFileKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { ArkUIViewController, Compose } from '@cpf-kmp-cmp/compose';
import nativeApi from 'libentry.so';
import { DidSealAdapter, SealError } from '../didseal/DidSealAdapter';

const DOMAIN = 0x012A;
const TAG = 'DidSeal';
const SAMPLE = 'receipt=DEMO-01\namount=120.00\ncurrency=CNY\n';

@Entry
@Component
struct Index {
  private controller: ArkUIViewController | undefined = undefined;
  private adapter: DidSealAdapter = new DidSealAdapter();
  @State private busy: boolean = false;

  aboutToAppear(): void {
    this.controller = nativeApi.createController();
  }

  private writeThenRead(path: string, value: Uint8Array): Uint8Array {
    const file = fileIo.openSync(path, fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE | fileIo.OpenMode.TRUNC);
    try {
      const bytes = new ArrayBuffer(value.length);
      new Uint8Array(bytes).set(value);
      if (fileIo.writeSync(file.fd, bytes) !== value.length) {
        throw new SealError(-20, 'Could not write the whole fixture');
      }
      const data = new ArrayBuffer(value.length);
      if (fileIo.readSync(file.fd, data, { offset: 0 }) !== value.length) {
        throw new SealError(-21, 'Could not read the whole fixture');
      }
      return new Uint8Array(data);
    } finally {
      fileIo.closeSync(file);
    }
  }

  private async run(): Promise<void> {
    if (this.busy) {
      return;
    }
    this.busy = true;
    const context = this.getUIContext().getHostContext() as common.UIAbilityContext;
    const input = new util.TextEncoder().encodeInto(SAMPLE);
    const ticket = nativeApi.begin(deviceInfo.sdkApiVersion, input.length);
    hilog.info(DOMAIN, TAG, 'begin api=%{public}d bytes=%{public}d', deviceInfo.sdkApiVersion, input.length);
    try {
      const change = input.slice();
      const offset = SAMPLE.indexOf('120.00');
      change[offset] = 0x39;
      const original = this.writeThenRead(context.filesDir + '/receipt.txt', input);
      const modified = this.writeThenRead(context.filesDir + '/receipt-edited.txt', change);
      const result = await this.adapter.compare(context, original, modified, (step) => {
        nativeApi.step(ticket, step);
        hilog.info(DOMAIN, TAG, 'step=%{public}d', step);
      }, (code) => {
        hilog.warn(DOMAIN, TAG, 'cleanup_error=%{public}d', code);
      });
      nativeApi.finish(ticket, result.original ? 1 : 0, result.modified ? 1 : 0, result.signatureBytes);
      hilog.info(DOMAIN, TAG, 'verify original=%{public}d changed=%{public}d signature_bytes=%{public}d',
        result.original ? 1 : 0, result.modified ? 1 : 0, result.signatureBytes);
    } catch (error) {
      const code = (error as BusinessError).code ?? -1;
      nativeApi.fail(ticket, code);
      hilog.warn(DOMAIN, TAG, 'error=%{public}d', code);
    } finally {
      this.busy = false;
    }
  }

  build() {
    Column() {
      Flex({ wrap: FlexWrap.Wrap, space: { main: LengthMetrics.vp(16), cross: LengthMetrics.vp(14) },
        alignItems: ItemAlign.Center, justifyContent: FlexAlign.SpaceBetween }) {
        Row({ space: 12 }) {
          Text('签').fontSize(18).fontWeight(FontWeight.Bold).fontColor('#FFFFFF')
            .width(40).height(40).textAlign(TextAlign.Center).borderRadius(9).backgroundColor('#225AC1')
          Column({ space: 3 }) {
            Text('文件签印').fontSize(23).fontWeight(FontWeight.Bold).fontColor('#17263A')
            Text('用同一份签名检查原件与改动件').fontSize(12).fontColor('#53667D')
          }.alignItems(HorizontalAlign.Start)
        }
        Button(this.busy ? '验证中' : '签名并比对', { type: ButtonType.Normal })
          .id('seal-run')
          .enabled(!this.busy)
          .borderRadius(10)
          .backgroundColor('#225AC1')
          .fontColor('#FFFFFF')
          .fontWeight(FontWeight.Bold)
          .height(44)
          .padding({ left: 20, right: 20 })
          .onClick(() => { this.run(); })
      }
      .width('100%')
      .constraintSize({ maxWidth: 1180 })
      .padding({ left: 16, right: 16, top: 10, bottom: 10 })
      if (this.controller) {
        Compose({ controller: this.controller, libraryName: 'entry' }).width('100%').layoutWeight(1)
      }
    }.height('100%').width('100%').backgroundColor('#FFFFFF')
  }
}

N-API 桥

example/ohos/entry/src/main/cpp/napi_init.cpp

#include "libkn_api.h"
#include "napi/native_api.h"

#include <array>
#include <cstdint>

namespace {
template <size_t N>
bool ReadArgs(napi_env env, napi_callback_info info, std::array<int32_t, N>& values)
{
    std::array<napi_value, N + 1> args;
    size_t count = args.size();
    if (napi_get_cb_info(env, info, &count, args.data(), nullptr, nullptr) == napi_ok && count == N) {
        for (size_t index = 0; index < N; ++index) {
            if (napi_get_value_int32(env, args[index], &values[index]) != napi_ok) break;
            if (index + 1 == N) return true;
        }
    }
    napi_throw_type_error(env, nullptr, "Expected numeric probe data");
    return false;
}

napi_value CreateController(napi_env env, napi_callback_info)
{
    return reinterpret_cast<napi_value>(MainArkUIViewController(env));
}

napi_value Begin(napi_env env, napi_callback_info info)
{
    std::array<int32_t, 2> args;
    if (!ReadArgs(env, info, args)) return nullptr;
    napi_value result;
    napi_create_int32(env, SealBegin(args[0], args[1]), &result);
    return result;
}

napi_value Finish(napi_env env, napi_callback_info info)
{
    std::array<int32_t, 4> args;
    if (!ReadArgs(env, info, args)) return nullptr;
    SealFinish(args[0], args[1], args[2], args[3]);
    napi_value result;
    napi_get_undefined(env, &result);
    return result;
}

napi_value Step(napi_env env, napi_callback_info info)
{
    std::array<int32_t, 2> args;
    if (!ReadArgs(env, info, args)) return nullptr;
    SealStepUpdate(args[0], args[1]);
    napi_value result;
    napi_get_undefined(env, &result);
    return result;
}

napi_value Error(napi_env env, napi_callback_info info)
{
    std::array<int32_t, 2> args;
    if (!ReadArgs(env, info, args)) return nullptr;
    SealErrorUpdate(args[0], args[1]);
    napi_value result;
    napi_get_undefined(env, &result);
    return result;
}
napi_value Init(napi_env env, napi_value exports)
{
    androidx_compose_ui_arkui_init(env, exports);
    napi_property_descriptor methods[] = {
        {"createController", nullptr, CreateController, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"begin", nullptr, Begin, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"finish", nullptr, Finish, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"step", nullptr, Step, nullptr, nullptr, nullptr, napi_default, nullptr},
        {"fail", nullptr, Error, nullptr, nullptr, nullptr, napi_default, nullptr},
    };
    napi_define_properties(env, exports, sizeof(methods) / sizeof(methods[0]), methods);
    return exports;
}
}

static napi_module module = {1, 0, nullptr, Init, "entry", nullptr, {0}};
extern "C" __attribute__((constructor)) void RegisterEntryModule()
{
    napi_module_register(&module);
}

桥接声明

example/ohos/entry/src/main/cpp/types/libentry/Index.d.ts

import type { ArkUIViewController } from '@cpf-kmp-cmp/compose/src/main/cpp/types/libcompose_arkui_utils';
export const createController: () => ArkUIViewController;
export const begin: (api: number, size: number) => number;
export const step: (ticket: number, stage: number) => void;
export const finish: (ticket: number, original: number, modified: number, signatureBytes: number) => void;
export const fail: (ticket: number, code: number) => void;

库构建

didSeal/build.gradle.kts

plugins {
    alias(libs.plugins.kotlinMultiplatform)
}

kotlin {
    ohosArm64()
    ohosX64()
}

示例构建与产物同步

composeApp/build.gradle.kts

import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)
}

kotlin {
    // 共享界面分别生成平板 ARM64 与模拟器 X64 动态库。
    listOf(ohosArm64(), ohosX64()).forEach { target ->
        target.binaries.sharedLib {
            baseName = "kn"
            if (buildType == NativeBuildType.RELEASE) {
                optimized = false
            }
            export(libs.compose.multiplatform.export)
            linkerOpts("-lz")
            val backend = rootProject.findProperty("rendererBackend")?.toString() ?: "skia"
            if (backend == "fusion-renderer") {
                linkerOpts(
                    "-lnative_drawing", "-limage_source", "-lpixelmap", "-lpixelmap_ndk.z",
                    "-lnative_window", "-lace_napi.z", "-lhilog_ndk.z", "-lhitrace_ndk.z",
                    "-luv", "-lunwind", "-licu"
                )
            }
        }
        target.compilations.getByName("main") {
            val resource by cinterops.creating {
                defFile(file("src/ohosMain/cinterop/resource.def"))
                includeDirs(file("src/ohosMain/cinterop/include"))
            }
        }
    }

    sourceSets {
        commonMain.dependencies {
            implementation(projects.didSeal)
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material)
            implementation(compose.material3)
            implementation(compose.ui)
            implementation(compose.components.resources)
            implementation(compose.components.uiToolingPreview)
            implementation(libs.kotlinx.coroutines.core)
            implementation(libs.atomicFu)
        }
        val ohosMain by creating {
            dependsOn(commonMain.get())
            dependencies {
                api(libs.compose.multiplatform.export)
            }
        }
        getByName("ohosArm64Main").dependsOn(ohosMain)
        getByName("ohosX64Main").dependsOn(ohosMain)
    }
}

// 成套复制动态库与头文件,鸿蒙宿主不依赖 Android 或 iOS SDK。
arrayOf("debug", "release").forEach { type ->
    val capitalized = type.replaceFirstChar { it.uppercase() }
    tasks.register<Copy>("publish${capitalized}BinariesToHarmonyApp") {
        group = "harmony"
        dependsOn("link${capitalized}SharedOhosArm64", "link${capitalized}SharedOhosX64")
        duplicatesStrategy = DuplicatesStrategy.INCLUDE
        into(rootProject.file("example/ohos"))
        from("build/bin/ohosArm64/${type}Shared/libkn_api.h") {
            into("entry/src/main/cpp/include/arm64-v8a/")
        }
        from("build/bin/ohosArm64/${type}Shared/libkn.so") {
            into("entry/libs/arm64-v8a/")
        }
        from("build/bin/ohosX64/${type}Shared/libkn_api.h") {
            into("entry/src/main/cpp/include/x86_64/")
        }
        from("build/bin/ohosX64/${type}Shared/libkn.so") {
            into("entry/libs/x86_64/")
        }
        val resourcePackage = "${rootProject.name}.${project.name.lowercase()}.generated.resources"
        from("src/commonMain/composeResources") {
            into("entry/src/main/resources/rawfile/composeResources/$resourcePackage/")
        }
        from(rootProject.file("didSeal/src/ohosMain/arkts/DidSealAdapter.ets")) {
            into("entry/src/main/ets/didseal/")
        }
    }
}

HarmonyOS 工程 API 配置

example/ohos/build-profile.json5

{
  "app": {
    "signingConfigs": [],
    "products": [
      {
        "name": "default",
        "compatibleSdkVersion": "26.0.0",
        "targetSdkVersion": "26.0.0",
        "compileSdkVersion": "26.0.0",
        "runtimeOS": "HarmonyOS",
        "buildOption": {
          "nativeCompiler": "BiSheng",
          "strictMode": {
            "caseSensitiveCheck": true,
            "useNormalizedOHMUrl": true
          }
        }
      }
    ],
    "buildModeSet": [
      {
        "name": "debug",
      },
      {
        "name": "release"
      }
    ]
  },
  "modules": [
    {
      "name": "entry",
      "srcPath": "./entry",
      "targets": [
        {
          "name": "default",
          "applyToProducts": [
            "default"
          ]
        }
      ]
    }
  ]
}

相关推荐

直播预告|码道能力全景 :工具、模式与智能体如何协同

同样是用 AI 写代码,为什么有人效率翻倍,有人却在反复返工?11月 17 日 19:00-20:30 ,本期直播围绕「码道能力全景 :工具、模式与智能体如何协同」展开,将从三个角度拆这个问题。能力、实战、规范三块拼齐,帮你判断什么场景该用、怎么用得更稳!

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 5

KMP/CMP 接入鸿蒙圆屏穿戴:表盘信息降级与 60 KB 内存账

本文介绍基于KMP/CMP架构的圆屏布局与内存降级库roundfit-kmp,通过纯Kotlin Multiplatform实现圆屏弦宽计算、内存预算与档位决策,统一ArkTS与原生端逻辑。在466px圆屏上,四档(glance/essential/compact/full)动态调整内容可见性,确保界面与内存估算一致。核心机制包括:逐高度计算可用宽度、跨N-API同步计划数据、固定坐标系下的弹性取舍。实验验证了预算、字号、档位对渲染结果的影响,实现“同一份计算,多端一致”的高效表盘适配。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 12

React Native 鸿蒙圆屏穿戴实战:20 KB 预算下的消息一瞥

本文详解在 React Native OpenHarmony 环境下,以零 SVG/Canvas、无原生模块限制,仅用 View 的 borderRadius 与 overflow 实现 208px 进度弧的渲染方案。通过半圆裁剪与三角函数定位拼接弧形,结合四档适配(full → glance),严格控制 28KB 内存预算,基于槽位存活表动态隐藏非关键元素,实现手表端高效、可验证的渐进式界面降级。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 12

Flutter 鸿蒙圆屏穿戴实战:让信息学会自己降级

在466px圆屏上,round_fit库通过弦宽公式动态计算每行可用宽度,结合几何约束、档位降级与内存预算(20KB起),实现手表端响应式布局。52项测试全通过,四页App在模拟器中完整运行,支持从full到glance四档降级,确保内容始终在安全圆内,且内存与显示效果精准可控。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 9

Qt 鸿蒙平板适配实战:一份源码,两条构建链,一个布局契约

Qt for OpenHarmony 5.12.12 与桌面 Qt 6.11 共用同一份 QML 和 C++ 源码,通过包装层差异实现跨平台兼容:鸿蒙端使用 qmlRegisterType() 手动注册类型,桌面端依赖 qt_add_qml_module() 自动注册;旋转逻辑封装为静态纯函数,确保几何计算一致。布局基于窗口尺寸动态解析,支持横竖屏、多栏、侧轨/底栏切换,实测于华为 MOR-M1 真机运行稳定,测试通过率 100%。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 12

Qt 鸿蒙端侧 OCR 实战:当系统 API 只给了 ArkTS 入口

本文介绍基于 Qt 与 OpenHarmony 的 OCR 桥接方案,解决 C++ 无法直接调用 textRecognition 的问题。通过在同进程内监听 127.0.0.1:52141,使用 HTTP/1.1 传输图片字节,由 ArkTS 侧执行识别并返回结果。项目实现轻量级桥接,支持长图分块处理,实测 3120×2080 图片识别耗时 443ms,验证了跨语言通信可行性。方案依赖系统权限与回环网络,未来可适配 NDK 接口开放。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 21

KMP/CMP 接入鸿蒙平板适配:响应式工作台与窗口旋转实战

本文介绍鸿蒙PC端ArkUI与Compose Desktop跨平台布局适配方案,通过Kotlin/Native实现统一断点逻辑(resolveTabletLayout),避免双端规则漂移。布局决策基于窗口尺寸变化,不依赖设备型号或方向,由Kotlin侧唯一计算并以JSON形式传递至ArkUI。工程上采用多平台Gradle构建,共享代码库支持桌面、移动端及OHOS,原生桥接通过N-API与版本脚本控制符号导出,确保跨语言调用稳定。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 2

Flutter 鸿蒙平板适配实战:约束是唯一的事实来源

该库基于纯 Dart 实现鸿蒙端自适应布局,核心为 TabletLayoutBuilder,仅依赖父级约束,通过 resolveTabletLayout 纯函数动态计算布局。支持多断点响应式设计,方向由宽高比推导,不依赖 MediaQuery.orientation,确保折叠屏、分屏等场景下状态保留。工作台双 Pane 常驻树上,仅切换可见性,实现零丢失预览与黄金对比测试。适配 1280×800/800×1280 预览及真实窗口(1100×643),兼容横竖屏、侧轨/底部导航切换,可发布为三方包

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 4

Electron 鸿蒙平板适配实战:把旋转变成一次纯函数计算

tablet-adaptive-electron 通过纯函数 planContentResize 实现跨平台窗口旋转,核心在于以内容区中心为锚点、结合工作区约束动态调整窗口大小与位置,避免因 setBounds 锚点偏差导致漂移。主进程与 renderer 共用断点契约,鸿蒙侧通过 ArkTS HAR 对齐适配,实现横竖屏无缝切换。验证覆盖断点、布局、IPC 等 70 项,支持 Electron 与 HarmonyOS PC 多端统一体验。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 4

KMP/CMP 鸿蒙分屏拖拽:把网页文字拖进摘录卡

“纸边摘录”是基于鸿蒙跨端框架(KMP/CMP)实现的分屏笔记工具,通过系统级拖拽事件接收浏览器选中文字,经由UDMF数据传递与ArkTS/Kotlin桥接,将纯文本转为可备注的卡片。设计上区分拖入预览、落点判断与数据写入三阶段,确保仅在有效落点导入,并避免重复或空内容。核心亮点在于严格按纯文本类型接收、UTF-8字节安全桥接、卡片状态稳定绑定,实现高效、无干扰的阅读辅助体验。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 3

KMP/CMP 鸿蒙平板适配:软键盘弹出后,怎么让备注框和提交按钮都能用

本文通过鸿蒙跨端示例,演示了在平板全屏与悬浮窗下,会议预约表单如何应对软键盘弹出导致的布局遮挡问题。采用KeyboardAvoidMode.RESIZE模式,由鸿蒙宿主动态压缩视口,Compose根据新约束重新布局,确保输入框获焦后自动滚入可见区域,确认按钮始终位于底部可触位置。关键在于:焦点变化与布局重测双触发滚动请求,避免因时序差导致内容被遮;将确认按钮置于滚动区外,保障提交操作连续性;同时验证全屏与悬浮窗两种形态下的可用性,确保用户在任意窗口尺寸下均可流畅完成填写与提交。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 3

Electron 鸿蒙端侧 OCR 实战:把鸿蒙设备的眼睛借给桌面应用

该库通过 hdc 工具将图片传至鸿蒙设备,利用 Core Vision Kit 实现离线中文票据识别,成功绕过 Electron 无法调用 HarmonyOS 系统 OCR 的限制。识别结果以 JSON 形式回传,失败时自动降级至本地 Tesseract.js。核心机制基于 job id 管理文件传输与并发任务,确保安全隔离。实测显示设备端识别仅需 414ms,且支持模拟器与真实设备,具备高可靠性与可扩展性。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 2

Cordova 鸿蒙平板适配实战:旋转屏幕,但不旋转页面状态

本文介绍 cordova-plugin-tablet-adaptive 插件在 ArkWeb 环境下的布局适配实现:基于纯 JS 与 ResizeObserver 动态测量容器尺寸,将布局逻辑封装为纯函数,通过方向锁探测与降级处理实现跨屏自适应。实测于 HarmonyOS PC(3120×2080),验证了窗口缩放下布局字段、状态与焦点的稳定迁移,确保无重载切换。插件无原生代码,仅依赖 DOM 测量,核心在于“以视口为准”的响应式设计,成功落地于 46 项测试

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 3

《机器人有点东西》启元机器人开发者直播季 第二期来啦!

带你揭秘机器人运动控制背后的技术原理,从第一条指令到第一个动作,聊聊运控开发的关键技术与实践经验!📅 直播时间:11 月 16 日 20:00-21:00。机器人运动控制的核心原理。从零开始的运控开发思路。运动调试与技术进阶经验。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 7

开源鸿蒙社区月度优秀评选|9 月批次获奖名单公示

开源鸿蒙社区月度优秀评选由,面向高校学生开发者,秉持小任务、快认定、强反馈、持续贡献原则,搭建高校常态化贡献评优体系,沉淀开源鸿蒙优质生态成果。2026 年 6 月—12 月6-8 月开展统一评选,合并批次获奖名额为三个月名额总和。9 月、10 月、11 月、12 月每月独立评选。目前,9 月批次优秀评选名单已正式产生,现予以公示。以下名单。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 8

全国第一课!启元T1 Pro走进北邮研究生课堂

北京邮电大学研究生课程《机器人认知计算》迎来一位特殊的“助教”——上纬启元旗下的启元T1 Pro机器人。在启元“具身智能产教融合创新实践平台”的支持下,方斌老师以启元T1 Pro为示范,为60余名研究生讲授“基于VLM的具身智能技术”。这是启元T1 Pro在全国高校课堂上的第一课,也标志着启元具身智能产教融合平台在高校教学中正式落地。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 8

KMP 鸿蒙电脑快捷键实战:用 Kotlin 状态机接管 Ctrl+S 与右键菜单

本文介绍Kotlin Multiplatform鸿蒙社区推出的kmp-ohos-pc-shortcut库,解决鸿蒙电脑端快捷键实现难题。基于KMP共享层构建状态机,精准处理修饰键、焦点切换、输入法干扰等复杂场景,支持Ctrl+S、Ctrl+Shift+S等多组合键,并在2in1模拟器中实现自由窗口右键菜单自动适配。全链路由Kotlin决策,ArkTS仅订阅事件,确保跨端一致性与可靠性。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 11

Flutter 修复 flutter_tts 鸿蒙分段等待与 WAV 导出:折叠屏双栏讲义朗读

针对折叠屏双栏有声讲义场景,修复了 oh-flutter/flutter_tts_ohos 在首次朗读引擎未初始化、播放等待早退及离线 WAV 导出缺失的问题。通过串行化引擎重建与播放完成等待逻辑,并按分片序号拼接带标准文件头的 WAV 文件,实现三段朗读逐段等待(模拟器18,658ms)、单次导出246ms生成173,204B有效WAV。修复后在真机上稳定运行,捕获并重排跨进程乱序分片,完整代码已开源于 atomgit.com/oh-flutter/flutter_tts_ohos

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 10

Flutter 修复 device_calendar 鸿蒙重复规则与服务链接:让周期会议日程准确展开并保留入会入口

本文修复了鸿蒙版 device_calendar 插件在周期日程同步与会议链接读取中的关键问题,包括重复频率映射错误、链接转换缺失及周期实例查询异常。通过对比模拟器与真机测试,验证了修复后可正确返回每日/每周重复日程(如7天晨会、4周研讨),并完整回读会议链接。完整代码已开源至 oh-flutter/device_calendar,支持鸿蒙系统Flutter开发,欢迎提交Issue或参与社区交流。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 11

Flutter 修复 screen_retriever 鸿蒙电脑屏幕工作区检索:让桌面贴边窗口精准避让系统 Dock 栏

基于 oh-flutter/screen_retriever 0.4.0 单包分支,修复鸿蒙端缺失实现及 Dart 3.11.5 兼容问题,恢复标准 MethodChannel 桥接,补全逻辑像素折算、系统可用工作区读取、监听注销闭环与窗口内光标采样。解决贴边窗口越界、底部按钮被遮挡等问题,实现工具窗精准贴靠桌面右下角,代码已开源至 oh-flutter/screen_retriever。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 12

Flutter 适配 wearable_rotary 鸿蒙穿戴旋转表冠:圆屏长列表单手平滑浏览

为解决鸿蒙圆屏模拟器上Flutter应用表冠滚动失效问题,作者在wearable_rotary基础上新增鸿蒙原生支持,通过onDigitalCrown接收旋转事件,实现焦点容器绑定、角度换算与整数幅度解析,使列表可双向滚动。适配后支持表冠浏览与触屏标记协同操作,代码已开源至oh-flutter/plugins,欢迎参与共建。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 22

读徐直军《走进华为的创新之旅》:让创新成为可持续的能力

华为轮值董事长徐直军在美国《时代》杂志发表署名文章《走进华为的创新之旅:看见、亲历、引领》,回顾三十余年来亲历和推动华为创新发展的历程,分享关于人才投入、研发体系建设与基础研究的思考。对于服务开发者的 AtomGit 而言,这些实践经验也带来了启发:我们应该如何支持人的创造力,如何帮助协作形成合力,又如何让今天的积累成为未来创新的基础?以下分享这篇文章,与广大开发者共同学习,并结合平台实践展开思考。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 33

启元机器人 Developer Playground 深圳开发者见面会圆满落幕

当「整活」的开发者遇上具身智能,代码不再只停留在屏幕之内,而是驱动实体机器人听懂指令、跑通一套新 Skill。11 月 14 日,启元机器人 Developer Playground 开发者见面会暨启元机器人深圳旗舰店开业仪式,在深圳卓悦中心正式启幕,来自 AI 应用、企业研发、机器人与嵌入式及高校技术团队的开发者们齐聚现场,围绕T1 变形机器人、Q1 人形机器人完成技术分享与 Robot Challenge 双赛道实操。为活动致辞。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 29

AtomGit 10月:“建设人工智能开源社区 AtomGit,释放开源活力。”

10 月 19 日,国务院新闻办公室新闻发布会上,工业和信息化部科技司司长魏巍在介绍“人工智能+制造”专项行动成效时明确提及:“建设人工智能开源社区 AtomGit,释放开源活力。未来,AtomGit 将持续携手开发者与生态伙伴,汇聚开源创新力量,共同推动人工智能技术创新与应用。AtomGit 企业版正式上线;开源实践中心上线,同步推出城市坐标计划 · 活动日历、开源人物志与五阶段开源成长路径;OpenAPI 文档全新改版;模型硬件匹配能力、企业版、热门专题页上线。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 123

诚邀报名 | 相约南京!2026 开源鸿蒙技术大会即将启幕,共探操作系统与 AI 共生演进新方向

随着人工智能技术加速发展,操作系统正迎来新一轮变革。面对、具身智能等前沿技术带来的新需求,操作系统将如何与深度融合、协同演进?二者的融合创新又将为软件开发与产业发展带来哪些新机遇?大会信息时间2026 年 11 月 28 日地点南京扬子江国际会议中心主办开源鸿蒙项目群技术指导委员会(TSC)看点主论坛 · 二十场技术分论坛 · 创新成果展区。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 94

开源鸿蒙跨平台直播|AI 时代,用 cj-tauri 开发鸿蒙 PC 应用

AI 已经把写代码这一段压平了,可改完到看见结果之间还隔着编译、重启和打包:一次全量编译要等 11 分 09 秒,一天能试几轮?要把桌面应用交付到开源鸿蒙 PC,又不想为这一端单独维护一套代码和一层桥接,路径该怎么选?开源鸿蒙跨平台系列直播第 24 期将结合 cj-tauri 的实践,分享「仓颉后端 + 系统 WebView 前端」这套组合。内容覆盖仓颉在开源鸿蒙生态里的位置、宿主与 IPC 双向桥的分工、能力白名单的最小权限模型,以及前端热更新给迭代节奏带来的变化;

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 60

报名开启|11 月 21 日北京,CANN 油气 & 化工行业 AI Meetup,共探 AI 落地路径

AI 加速走进油气化工行业,前沿技术如何落地业务、解决真实痛点,成为行业开发者共同关注的话题。为推动 AI 技术与行业场景深度融合,分享一线场景实践经验,围绕生态共建研讨,CANN 开源社区「油气 & 化工行业 AI Meetup」!本次活动聚焦三维全波形反演、AI 储层建模、油气 CV 应用、算子优化、图机器学习适配、化工智能体与分子筛选等方向,与行业伙伴、技术专家面对面交流,共探 AI 落地路径。活动时间:2026 年 11 月 21 日(周六)13:30–17:10。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 55

本期精选 G-Star 开源项目推荐|DSH 插件生态

从桌面状态反馈、界面设计和团队协作,到视觉理解、图像创作与应用操作,这些项目展示了 DSH 生态不同的扩展方向。有的解决具体体验问题,有的为 Agent 增加一类能力,也有项目把通用工具带进 DSH 工作区。欢迎前往仓库阅读 README、体验项目,并通过Star、Issue 或 PR支持作者。也欢迎更多开源项目申请加入 G-Star 计划,让你的项目被更多开发者看到。素材使用提示:本文介绍的是开源项目的技术能力。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 57

报名开启|11 月 21 日北京,CANNBot × MegaKernel Meetup,共探智能算子新方向

大模型落地浪潮下,算子开发、性能调优成为模型部署的核心难点。CANN 持续开源开放,依托 Agent 技术探索算子自动生成新范式。为促进算子开发者深度交流、共建 CANN 开源生态,11 月 21 日 CANN 开源社区在北京发起「CANNBot × MegaKernel Meetup」,现已开放报名!🙌。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 135

Flutter 修复 no_screenshot 鸿蒙窗口隐私模式切换:让一次性恢复口令页离开后恢复正常截屏

本文记录了在鸿蒙系统上使用 no_screenshot 插件实现页面截屏保护时,遇到的二次切换失效、恢复接口返回值错误及异步状态不同步问题。通过分析原生实现,修复了状态切换逻辑错误、返回值混淆及监听取消时的竞态问题,确保窗口隐私状态正确同步。修复后,模拟器与真机(畅享 100 Pro Max)均能正常实现进入/退出受保护页面后的截屏恢复,完整代码已开源于 oh-flutter/no_screenshot。

白天写代码,晚上追AI大模型,偶尔搞点八卦 开源动态|技术干货|实习机会|生态活动 我负责分享,你负责变强 94
上一篇: Electron 鸿蒙端侧 OCR 实战:把鸿蒙设备的眼睛借给桌面应用
下一篇: KMP/CMP 鸿蒙平板适配:软键盘弹出后,怎么让备注框和提交按钮都能用
AtomGit 代码君
AtomGit 代码君 企业官方账号 企业官方账号
博客等级 码龄6年 2万+粉丝 895原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值