库里那条 208 px 的进度弧,这一版不许用 SVG、不许用 Canvas、不加原生模块,只能用 View 的 borderRadius 和 overflow 裁出来。弧怎么拼、roundfit.plan/v1 的槽位存活表怎么写、28 KB 预算为什么最后只留主值和一行标签,都在这条渲染路径里。

仓库地址:https://atomgit.com/lqjmac/roundfit-rn
版本地址:https://atomgit.com/oh-react-native/ohos_react_native/tree/0.84-main
三方库框架:https://atomgit.com/oh-react-native

0. 环境与实测设备

项版本/型号
React Native0.84.1(peer 依赖,与 RNOH 0.84.3 配套)
RNOH@rnoh/react-native-openharmony 0.84.3 + Hermes;module.json5 声明 "deviceTypes": ["wearable"]
Node / 构建24.12.0 / npm 11.12.1;TypeScript + Babel 双格式(CJS / ESM / types)
roundfit-rn1.0.0(本仓库,npm 包;运行时只依赖 react / react-native,无原生代码)
测试Vitest 50 项(几何 20 + Plan 30),npm run verify = typecheck + example typecheck + vitest + build
Plan 校验node scripts/export-plan.mjs 生成 preview/plan.json,六框架共用 validate_plan.mjs 校验
实测设备Huawei_Wearable 模拟器,HarmonyOS 7.0.0.105 / API 26,466×466 物理像素,density 2.0(233×233 逻辑 dp)
实测形态RNOH wearable HAP:Metro bundle + ohpm + hvigor assembleHap 产出,unsigned 直装模拟器

1. 一条不许用 SVG 的弧

库里的 208 px 进度弧是这一版最先动手的部件。react-native-svg 是最顺手的答案,量一下依赖就放弃了:它带一整棵原生依赖树,RNOH 上还要额外适配,和"运行时只有 react / react-native"冲突。Canvas 是浏览器的方案,RN 里没有。剩下唯一的路是拿 View 拼。

场景"消息一瞥"本身没有弧数据(arc: null),手表截图里看不到弧;ArcProgress 是库组件,留给需要弧的场景用,4.2 节拆代码。

圆的绘制可以切两半:正方形外层 View 用 borderRadius: size/2 加 overflow: 'hidden' 变成圆;左右各一个半宽 View 各裁一半,每个半圆里放一个只有上、右两段边框着色的"半环",旋转相应角度。0–180° 由右半圆负责,180–360° 由左半圆接手,端点是一枚三角函数定位的小圆点。

形态也不帮忙。手表没有横竖屏,useWindowDimensions 还在,但输入只有一个 466×466 的圆;固定宽度卡片、两列网格、右对齐数值这些矩形惯性在这里都会被圆边裁掉。每个有高度的盒子因此改用"区间最窄弦宽"约束,整圆再 overflow: 'hidden' 兜底。

预算这边最紧。"消息一瞥"这个固定场景只有 28 KB,目标档位 glance 是六框架里最苛刻的一档:20 KB 留给主值和一行标签,背景模糊 12 KB、缩略图 16 KB 加起来正好 28 KB,主值反而没地方放。

2. 四档在手表上长什么样

示例 WatchApp 跑在 Huawei_Wearable 模拟器(HarmonyOS 7.0.0.105 / API 26,466×466,density 2.0)的 RNOH HAP 里,1 设计像素 = 1 物理像素,四档取舍可以和 preview/plan.json 逐屏对照。这个 1:1 不是巧合:窗口是 233×233 dp,scale = 233 / 466 = 0.5,设计像素乘 0.5 得到 dp,再乘 density 2 正好是一个物理像素。换一块 density 1.5 的表,同一份 Plan 会整体缩小,但相对位置不变。

启动是 full 档,53/128 KB 的宽裕演示态:

full 档:眉标、主值与两行指标

深色底上单一主色 #FF7AA2:眉标 ROUND FIT · REACT NATIVE、标题、主值 3 与标签、两行指标、两个操作,全部落在半径 199 的安全圆内;底部是 53/128 KB · 全量 的胶囊。

点按一次切到 compact:第二行指标和「全部已读」消失,33/64 KB。再点,essential:眉标没了,只剩标题、主值、一行指标和一个操作,31/40 KB。再点,glance,28 KB 预算的正主:

glance 档:只剩主值和一行标签

只剩主值 3 和一行标签。没有眉标、没有指标行、没有弧、没有操作。估算 14 + 6 = 20 KB,塞进 28 KB 还剩 8 KB。这个"丢"不是渲染器临时判断的:Plan 生成时就写好了 glance 的槽位存活表(eyebrowY=null、titleY=null、rowsY=[]、actionsY=null、arcRadius=null),丢什么、为什么丢,JSON 里可查。

操作位在契约里直接归零,glance 不留操作:TIER_ACTION_COUNT.glance = 0,SLOT_MAX_RANK.actions = 2,glance 的 rank 是 3,超过 2 就判死。原因不复杂:单个操作 2 KB 看着便宜,可它还需要足够的命中区、一句对比度够的文案和一块底色;在 20 KB 的账里,这等于把主值从 82 px 压回 58 px。而 glance 的使用场景是抬腕看一眼就放下,本来不该有第二个决定要做。

那用户怎么退出?示例 WatchApp 把整个屏幕做成一个 Pressable:点一下循环到下一档,任何一次点击都能回到 full。真实手表上更常见的是系统返回手势或表冠。组件只画 Plan,不接管导航,也不和系统抢手势。

再点回 full。长按 450 ms 切省电,requestedTier 再降一档,验证单向棘轮。

实验室页:档位、预算与决策列表

档位/内存胶囊实时显示当前档与 KB 占用,顶部还有时间、刻度线和一片低透明度光斑。点「查看」只弹提示,档位不变。

3. 槽位存活表与 20 KB 的账

链路是"内容模型 + 约束 → 档位 → 槽位存活 → Plan":

直径 466 / 内容安全圆半径 199 ──► chordWidth(dy) ──► 每行宽度上限 ──► 文本截断
        │
        ├─ 内容模型(眉标、标题、主值、说明、指标行、弧、操作)
        ├─ 约束(budgetKB=28、textScale、contentHeight、requestedTier)
        └─► tier = max(memoryCap, textScaleCap, heightCap, requestedTier)
                  │
                  └─► 槽位存活表 → roundfit.plan/v1
                         (保留槽位 + dropped 文案 + memory.decisions)

几何与内存公式和前五个框架一致:

常量值含义
SAFE_RADIUS199内容安全半径(233 − 34)
ARC_RADIUS208进度弧半径
ROW_GUTTER24行宽弦宽余量
textWidthΣ (isCJK ? 1.0 : 0.56) × fontSize六框架共享度量
内存:base 14 + 眉标 2 + 主值 9(glance 为 6)+ 每行指标 6
      + 弧 7 + 每操作 2 + 模糊 12(仅 full)+ 图片 16(仅 full)

full      = 14 + 2 + 9 + 12 + 4 + 12(blur) = 53 KB
compact   = 14 + 2 + 9 + 6 + 2             = 33 KB
essential = 14 + 9 + 6 + 2                 = 31 KB
messages·glance = 14 + 6                   = 20 KB ≤ 28 KB ✓

把 20 KB 拆开:底座 14 KB 是固定的(容器、主题、Composition 与文本节点),主值 9 KB、glance 降到 6 KB,每行指标 6 KB,弧 7 KB,每个操作 2 KB,模糊 12 KB,缩略图 16 KB。最容易超的是模糊:12 KB 占 28 KB 预算的 43%,加底座 14 KB 已经 26 KB,只剩 2 KB 给主值,连 glance 的 20 KB 都放不下。缩略图更狠,glance 加上它要 36 KB,直接越过 28 KB 预算。

指标行和操作才是要精打细算的地方,每行 6 KB、每个 2 KB。模糊和缩略图直接绑在档位上,只有 full 允许。契约把 MAX_ROWS 写死为 2,不只为了省钱:固定布局表 full 只有 [272, 318] 两个 y,再加一行也没有位置可放,硬加就得改整张表和六框架的对账。

底座那 14 KB 也降不下去。它是删不掉的固定开销:整个圆屏的容器树、主题和文本排版上下文都在里面,能砍的是它上面的内容,主值与底座在 20 KB 里大致三比七。

RN 的差异化职责在渲染路径:

框架弧形进度路径RN 的选择
FlutterCustomPainter—
KMPCompose Canvas—
Cordova / ElectronDOM / Canvas / SVG—
Qt / QMLQML 场景图—
React Native—View + borderRadius 半圆裁剪,零 SVG

跨框架对照靠 preview/plan.json,各组件的像素实现不参与:同一块表上能逐屏比较哪些内容被放弃。Plan 由 scripts/export-plan.mjs 调库代码生成,六框架用同一个 validate_plan.mjs 校验。

4. 从 Plan 到半圆:分层与四个实现

4.1 六个文件,三层

src 前六个文件是纯函数,其余是组件与 hook:

roundfit-rn/
├─ src/
│  ├─ geometry.ts / tier.ts / memory.ts
│  ├─ plan.ts                  # 内容模型 + roundfit.plan/v1 生成器
│  ├─ theme.ts / types.ts
│  ├─ RoundScreen.tsx          # 圆屏渲染器(466 设计圆装入窗口)
│  ├─ ArcProgress.tsx          # 半圆裁剪进度环(无 SVG)
│  ├─ GlanceCard.tsx / TierBadge.tsx
│  ├─ useRoundLayout.ts        # useWindowDimensions 布局 hook
│  └─ index.ts
├─ __tests__/                  # 50 项:几何 20 + Plan 30
├─ example/
│  ├─ App.tsx                  # 466×466 参考屏 + 桌面调参面板
│  ├─ WatchApp.tsx             # 手表入口:点按切档 / 长按省电
│  ├─ watch.js                 # AppRegistry 入口(RoundFitRNExample)
│  └─ harmony/                 # RNOH wearable HAP(entry/AppScope/cpp)
├─ scripts/
│  ├─ export-plan.mjs          # 生成 preview/plan.json
│  ├─ build-watch-hap.sh       # Metro bundle + ohpm + hvigor assembleHap
│  └─ run-watch.sh             # hdc install + aa start
└─ preview/plan.json           # 生成产物(勿手改)

工程结构:库、示例与 preview

分层的边界很窄:运行时零依赖,peer 只有 react / react-native,无原生代码、无 autolinking;npm run verify 不碰设备,typecheck + example typecheck + vitest + build 全部离线;HAP 不签名入库,调试 profile 绑定 bundle 名和设备列表,模拟器接受 unsigned 包直装。

宿主侧拿到 Plan,直接交给 RoundScreen:

import { RoundScreen, buildRoundPlan } from 'roundfit-rn';

const plan = buildRoundPlan({
  constraints: { budgetKB: 28, textScale: 1, contentHeight: 466 },
});

<RoundScreen
  plan={plan}
  maxSize={466}
  onActionPress={(action) => console.log(action.label)}
/>

4.2 ArcProgress:两个半圆裁出一条弧

组件不大,但每一段都对应一个几何约束,所以把整个文件放上来,后面再拆:

// src/ArcProgress.tsx
import { useEffect, useRef } from 'react';
import { Animated, StyleSheet, Text, View } from 'react-native';
import { ROUND_THEME } from './theme';
import type { ArcProgressProps } from './types';

export function ArcProgress({
  progress,
  size,
  thickness = 6,
  color = ROUND_THEME.accent,
  trackColor = ROUND_THEME.track,
  reduceMotion = false,
  cap,
  label,
  style,
  testID,
}: ArcProgressProps) {
  const fade = useRef(new Animated.Value(reduceMotion ? 1 : 0)).current;

  useEffect(() => {
    if (reduceMotion) {
      fade.stopAnimation();
      fade.setValue(1);
      return;
    }
    fade.setValue(0);
    const animation = Animated.timing(fade, {
      toValue: 1,
      duration: 320,
      useNativeDriver: true,
    });
    animation.start();
    return () => animation.stop();
  }, [fade, reduceMotion]);

  const safeSize = Number.isFinite(size) ? Math.max(0, size) : 0;
  const safeThickness = Math.min(
    Math.max(1, Number.isFinite(thickness) ? thickness : 1),
    Math.max(1, safeSize / 2),
  );
  const sweep = Number.isFinite(progress) ? Math.min(1, Math.max(0, progress)) : 0;

  if (safeSize <= 0) {
    return <View style={style} testID={testID} />;
  }

  const rotation = sweep * 360 - 135;
  const ringBase = {
    position: 'absolute' as const,
    width: safeSize,
    height: safeSize,
    borderRadius: safeSize / 2,
    borderWidth: safeThickness,
    borderColor: 'transparent',
    borderTopColor: color,
    borderRightColor: color,
  };
  const dotRadius = Math.max(2, safeThickness * 0.9);
  const dotSize = dotRadius * 2;
  const dotDistance = safeSize / 2 - safeThickness / 2;
  const dotAngle = sweep * 2 * Math.PI - Math.PI / 2;
  const dotLeft = safeSize / 2 + Math.cos(dotAngle) * dotDistance - dotRadius;
  const dotTop = safeSize / 2 + Math.sin(dotAngle) * dotDistance - dotRadius;
  const capSize = Math.max(9, safeThickness * 1.7);

  return (
    <Animated.View
      testID={testID}
      accessible
      accessibilityRole="progressbar"
      accessibilityLabel={label ?? '圆形进度'}
      accessibilityValue={{ min: 0, max: 100, now: Math.round(sweep * 100) }}
      style={[styles.root, { width: safeSize, height: safeSize, opacity: fade }, style]}
    >
      <View
        style={{
          position: 'absolute',
          width: safeSize,
          height: safeSize,
          borderRadius: safeSize / 2,
          borderWidth: safeThickness,
          borderColor: trackColor,
        }}
      />

      <View style={[styles.half, { left: safeSize / 2 }]}>
        {sweep > 0.5 ? (
          <View
            style={[
              ringBase,
              { left: -safeSize / 2, transform: [{ rotate: '45deg' }] },
            ]}
          />
        ) : null}
        <View
          style={[
            ringBase,
            { left: -safeSize / 2, transform: [{ rotate: `${rotation}deg` }] },
          ]}
        />
      </View>

      <View style={[styles.half, { left: 0 }]}>
        <View style={[ringBase, { left: 0, transform: [{ rotate: `${rotation}deg` }] }]} />
      </View>

      {sweep > 0 ? (
        <View
          style={{
            position: 'absolute',
            width: dotSize,
            height: dotSize,
            borderRadius: dotRadius,
            backgroundColor: color,
            left: dotLeft,
            top: dotTop,
          }}
        />
      ) : null}

      {cap !== undefined && cap.length > 0 ? (
        <Text
          allowFontScaling={false}
          numberOfLines={1}
          style={{
            position: 'absolute',
            left: 0,
            right: 0,
            top: Math.max(0, safeThickness + 2),
            textAlign: 'center',
            fontSize: capSize,
            fontWeight: '600',
            color,
          }}
        >
          {cap}
        </Text>
      ) : null}
    </Animated.View>
  );
}

const styles = StyleSheet.create({
  root: {
    position: 'relative',
  },
  half: {
    position: 'absolute',
    top: 0,
    width: '50%',
    height: '100%',
    overflow: 'hidden',
  },
});

styles.half 只有五个属性:position: 'absolute'; top: 0; width: '50%'; height: '100%'; overflow: 'hidden'。整条弧里没有 path 节点,压在最底下的是整圆轨道,左右各一个半圆容器负责裁剪,半圆里放两段着色边框,端点由三角函数落位。没有 JS 逐帧循环,淡入走 Animated.timing + useNativeDriver: true。轨道不进裁剪逻辑,borderColor: trackColor 一行就够。cap 文案与 label 无障碍属性挂在同一个组件上,accessibilityValue 给 0–100 的整数,读屏软件不需要理解半圆。

把几何摊开:外层容器边长 safeSize,按 208 的弧半径算就是 416,borderRadius: safeSize / 2 让它成为正圆,overflow: 'hidden' 把子节点裁在圆内。两个半圆容器宽度都是 safeSize / 2,一个从 left: 0 起,一个从 left: safeSize / 2 起,各自再 overflow: 'hidden',于是左容器只显示左半边,右容器只显示右半边。这两个容器不画东西,只负责裁剪,开销是布局节点。不直接用整圆,是因为 RN 没有 clip-path:单个 View 只能整块显示或隐藏,切成左右两半,才能分别控制露出的弧段。

ringBase 是同样大小的正方 View,borderRadius: safeSize / 2,borderWidth: safeThickness,只给 borderTopColor 与 borderRightColor 上色。圆角把上、右两边各压成 90°,拼起来是右上半个环。旋转角是 sweep × 360 − 135:进度 0 是 −135°,50% 到 45°,100% 到 225°,每 1% 转 3.6°。它和 dotAngle = sweep × 2π − π/2 是两套独立的角度:前者转半环,后者定位端点,端点从 12 点起算。

两半容器各裁一半,旋转角一变,各自露出的弧段长度就变,合起来就是当前进度。进度过半时,右容器里再叠一个固定 45° 的环,把另一侧补齐,这段是纯几何补偿,不需要额外状态。端点圆点用 cos/sin 定角度,半径取 safeSize / 2 − safeThickness / 2,落在环的中线上。

4.3 useRoundLayout:设计坐标到屏幕

// src/useRoundLayout.ts
/** Pure constructor shared by the hook and unit tests that avoid RN. */
export function createRoundLayoutResult(
  viewport: RoundViewport,
  options: ComputeRoundLayoutOptions = {},
): RoundLayoutResult {
  const layout = computeRoundLayout(viewport, options);
  return {
    ...layout,
    viewport,
    mapX: (designX: number) => designXToScreen(layout, designX),
    mapY: (designY: number) => designYToScreen(layout, designY),
    scaleLength: (designLength: number) => designLengthToScreen(layout, designLength),
    widthAt: (designY: number, height: number) =>
      Math.min(layout.side, bandWidth(designY, height) * layout.scale),
  };
}

/**
 * Fits the fixed 466×466 Plan circle into the current window.
 */
export function useRoundLayout(input: RoundLayoutInput = {}): RoundLayoutResult {
  const window = useWindowDimensions();
  const viewport = input.viewport ?? { width: window.width, height: window.height };

  return useMemo(
    () =>
      createRoundLayoutResult(viewport, {
        maxSize: input.maxSize,
        diameter: input.diameter,
        safeRadius: input.safeRadius,
      }),
    [
      viewport.width,
      viewport.height,
      input.maxSize,
      input.diameter,
      input.safeRadius,
    ],
  );
}

side 是圆的渲染边长,等于 466 × scale;窗口两边不等时圆居中,多出来的部分是留白,不会被拉伸。

映射全在 computeRoundLayout 里:scale = min(w, h, maxSize) / 466,side = 466 × scale,Plan 的 y 是设计坐标里的垂直中心,落到屏幕是 top = (y − 233) × scale + side/2 − height/2。widthAt(y, height) 用 bandWidth() 取上下弦里更窄的那条;这和 Flutter 版 chordWidthForBand 踩的是同一个坑:行有高度,只按中心 y 取宽会把盒子顶出安全圆。

hook 和纯函数分开放,是为了让测试不碰 RN:createRoundLayoutResult({ width: 466, height: 466 }) 在 Node 里就能断言映射结果。

4.4 tier.ts:槽位存活表与单向棘轮

// src/tier.ts
export const SLOT_MAX_RANK: Readonly<Record<SlotId, TierRank>> = Object.freeze({
  hero: 3,
  'hero.label': 3,
  title: 2,
  'row[0]': 2,
  actions: 2,
  eyebrow: 1,
  'row[1]': 1,
  arc: 1,
  'hero.detail': 0,
  blur: 0,
  image: 0,
});

/** Budget mapping from SPEC §3. */
export function memoryCapForBudget(budgetKB: number): Tier {
  if (!Number.isFinite(budgetKB)) {
    return 'glance';
  }
  if (budgetKB >= 96) {
    return 'full';
  }
  if (budgetKB >= 56) {
    return 'compact';
  }
  if (budgetKB >= 32) {
    return 'essential';
  }
  return 'glance';
}

/**
 * Final tier: the deepest cap among memory, font scale, content height and the
 * caller's request. `requestedTier` can only ask for a deeper tier.
 */
export function resolveTier(constraints: Partial<RoundConstraints> = {}): TierResolution {
  const memoryCap = memoryCapForBudget(constraints.budgetKB ?? 128);
  const textScaleCap = textScaleCapFor(constraints.textScale ?? 1);
  const contentHeightCap = contentHeightCapFor(constraints.contentHeight ?? 466);
  const requestedTier = constraints.requestedTier ?? 'full';
  const tier = deepestTier(memoryCap, textScaleCap, contentHeightCap, requestedTier);

  return {
    tier,
    tierRank: TIER_RANK[tier],
    memoryCap,
    textScaleCap,
    contentHeightCap,
    requestedTier,
  };
}

/** True when a slot is still present at `tier`. */
export function slotSurvives(tier: Tier, slot: SlotId): boolean {
  return TIER_RANK[tier] <= SLOT_MAX_RANK[slot];
}

SLOT_MAX_RANK 是这张表最值钱的部分:每个槽位能活到哪一档,写成一个数。hero 和 hero.label 是 3,任何档都活;title、row[0]、actions 到 2;eyebrow、row[1]、arc 到 1;hero.detail、blur、image 只活在 0。渲染器不写 if 链,Plan 生成阶段也查同一张表,所以"界面里没有"和"Plan 里 dropped"永远是同一个答案。

resolveTier() 除了最终档,还带出三路 cap 判定:预算、字号、高度各有一个结论,memory.decisions 靠它写清档位是被谁压下去的。预算 28 KB 时 memoryCap 是 glance,另外两路是 full,最终取 glance;requestedTier 也在同一个 max 里,只能加码。

4.5 plan.ts:固定 y 表

// src/plan.ts
export interface FixedTierLayout {
  eyebrowY: number | null;
  titleY: number | null;
  heroY: number;
  rowsY: readonly number[];
  actionsY: number | null;
  memoryY: number;
  arcRadius: number | null;
}

export const FIXED_LAYOUTS: Readonly<Record<Tier, FixedTierLayout>> = Object.freeze({
  full: Object.freeze({
    eyebrowY: 84,
    titleY: 116,
    heroY: 214,
    rowsY: Object.freeze([272, 318]),
    actionsY: 364,
    memoryY: 412,
    arcRadius: 208,
  }),
  compact: Object.freeze({
    eyebrowY: 86,
    titleY: 122,
    heroY: 222,
    rowsY: Object.freeze([286]),
    actionsY: 368,
    memoryY: 412,
    arcRadius: 208,
  }),
  essential: Object.freeze({
    eyebrowY: null,
    titleY: 140,
    heroY: 208,
    rowsY: Object.freeze([276]),
    actionsY: 356,
    memoryY: 408,
    arcRadius: null,
  }),
  glance: Object.freeze({
    eyebrowY: null,
    titleY: null,
    heroY: 218,
    rowsY: Object.freeze([]),
    actionsY: null,
    memoryY: 412,
    arcRadius: null,
  }),
});

这张表和 Flutter 版的 RoundFitLayout 逐项一致,Object.freeze 套到内层,防止某个渲染器顺手改 y、让六框架对账找不到原因。eyebrowY: null 表示这个槽位在该档不存在,不是缺值。Plan 生成时只有眉标真的保留才写进 JSON,所以 preview/plan.json 里 glance 的 eyebrowY/titleY/actionsY/arcRadius 全是 null,rowsY 是空数组。

messages 场景没有弧数据(arc: null),所以 full 的 arcRadius: 208 在 Plan 里不会出现弧节点;layout 保留这个字段只是让六框架的固定布局保持同构。生成一份 Plan 走的是固定顺序:buildRoundPlan() 先把预算收敛到 8–1024 KB,resolveTier() 算出档位,FIXED_LAYOUTS[tier] 取出 y 表,再按档位裁行、裁操作,最后 estimateMemory() 算账并断言不超预算。droppedSlotsFor() 用槽位表和档位行数产出 dropped 文案,buildDecisions() 写五项决策。整条链路不 import React Native,scripts/export-plan.mjs 用 esbuild 打包后能在 Node 里直接跑。compact 实测 33 KB 而非 40 KB,也是因为消息场景没有那 7 KB 的弧。

buildPlanRow() 里还有一个容易混淆的字段:rows[].width 记的是估算文本宽度,不是行盒宽度;它先被 rowContainerWidth(y) 夹到 300 与弦宽以内,再由 truncateText() 截断。渲染器那边另外用 widthAt(y, height) 取上下弦宽里更窄的那条,两边受同一个上限约束,不会一份写 300、一份写 366。

5. 返工记录:弧、预算与打包

弦宽按中心 y 取,是这里最早踩的坑。中心 y 合法不代表整块合法,行有高度,圆在行的上下两端更窄,靠近圆边的行仍会被裁。修法是每个文本框按自身高度取上下弦宽的较小值,再用整圆的 overflow: 'hidden' 兜底。

画弧的选型也返工过一次。react-native-svg 是最顺手的答案,可为一个进度环引入整棵原生依赖树、还要在 RNOH 上适配,不划算;最后落在左右两个半圆 View 加 borderRadius 裁剪上。手表预算下,依赖本身也占内存。

npm run verify 里曾经掺了设备步骤,早期把 HAP 构建也放进去,模拟器没起就红;现在 verify 全离线,手表运行拆成独立脚本。Plan 也手写过一版,改了槽位表忘同步,手抄 JSON 改一处漏五处,六框架对账直接崩;现在 export-plan.mjs 调库代码生成 preview/plan.json。预算上也反复过一次:28 KB 下想保留模糊,12 KB 模糊加 16 KB 图片恰好把预算吃光,主值没地方放。后来模糊与图片只计入 full 档,glance 回到 14 + 6 = 20 KB。

requestedTier 差点做成双向。应用请求档位如果还能升级,预算上限就形同虚设。现在它只能让应用再降一档,最终档取 deepestTier(memoryCap, textScaleCap, contentHeightCap, requestedTier),单向棘轮写进契约,测试断言。

设备上还遇到两处。install -r 会杀掉正在运行的实例,run-watch.sh 紧接着 aa start 时,未完成的 force-stop 会把新进程 SIGKILL——实测遇到一次,表现是回到表盘,脚本现在等 1 秒。另一个是 rawfile 必须以 Stored 写进 HAP:手工重打包成 Deflate,Hermes 会在 1:1 报 Invalid UTF-8 continuation byte。两处都改在脚本和打包参数上,src/ 一行没动。构建脚本还特意去 DevEco 目录里找 hvigor 6.26.4,免得 PATH 里那个 6.21.2 抢先,把 API 26 的工程判成缺组件。DevEco 的 Run 不会打包 JavaScript:改完 JS 必须重跑 scripts/build-watch-hap.sh,否则 rawfile 里还是旧 bundle,界面上看不出变化。

6. 安装、导出与手表脚本

roundfit-rn 1.0.0,Apache-2.0。装上就能用,不需要 link 或 autolinking:

npm install roundfit-rn

桌面调试与手表运行:

npm install
npm run verify                  # typecheck + example typecheck + 50 项 vitest + build
node scripts/export-plan.mjs    # 生成 preview/plan.json
node ../tools/validate_plan.mjs preview/plan.json

# 手表 HAP(可选路径)
bash scripts/build-watch-hap.sh # Metro bundle + ohpm install + hvigor assembleHap
bash scripts/run-watch.sh       # hdc install + aa start(默认 127.0.0.1:5555)

npm run verify 的 vitest 段记录为 Test Files 2 passed (2)、50 项(另一次完整回归里是 49 passed + 1 skipped),typecheck 双工程无错误,构建产出 CJS / ESM / types 三份。Plan 导出:

✓ preview/plan.json
  tier=glance (rank 3)  hero=3  memory=20/28 KB  rows=0  actions=0  dropped=6
  decisions=5  layout.heroY=218

dropped 六项是「眉标、标题、主值说明、指标行 2 行、弧形进度、次操作 2 个」;decisions 的五项是预算判定、槽位优先级、弦宽约束(351 px)、模糊关闭、图片关闭。node ../tools/validate_plan.mjs 输出 ✓ React Native 消息 glance 20/28 KB。六份 Plan 的字段顺序、颜色格式、决策条数都归它管,字段一改就会在校验阶段报出来。

手表 HAP 38 MB,其中 bundle.harmony.js 1.16 MB(Stored);首次原生编译产生约 1.5 GB 的 entry/.cxx,复用后约一分钟。38 MB 的大头是 Hermes 与 RNOH 的原生库,JS bundle 只占 3% 上下,所以改一行业务代码,重新打进去的也只有这 1 MB 出头。

验证材料都放在仓库里。仓库说明是几何常量表、内存公式、API 全表和六框架对照;圆屏契约文档与验证记录收了契约定义和全部命令输出;示例宿主说明 写 wearable HAP 的构建与运行;__tests__/ 是那 50 项(几何 20 + Plan 30)。

当前版本在 Node 24.12.0 / RN 0.84.1 / RNOH 0.84.3 下验证:npm run verify 退出码 0,Plan 通过六框架共用校验器,Huawei_Wearable 模拟器装 RNOH wearable HAP 跑起来——启动 full(53/128 KB),点按循环四档即时重排,长按省电请求再降一档,glance 实测 20/28 KB 与 preview/plan.json 逐字一致。

没验证的部分:这是本机非官方 wearable 目标的实测结果,不代表官方承诺支持该形态;发布给他人要在 DevEco 配置签名;hilog 里 RNOH 会打印 Cannot read property getWindowName of undefined,标注 usually not a problem,本次渲染正常。

下一版最想补的是把六份 preview/plan.json 放进 CI 统一比对。

Logo

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。

更多推荐