react-native-update 10.50.0 → 10.51.1

package/harmony/pushy/src/main/ets/NativeCheckOrchestrator.ts

@@ -0,0 +1,500 @@
+import http from '@ohos.net.http';
+import deviceInfo from '@ohos.deviceInfo';
+import logger from './Logger';
+import NativePatchCore from './NativePatchCore';
+import type { UpdateContext } from './UpdateContext';
+import { isSafePathComponent } from './PathUtils';
+import { monotonicNowMs } from './MonotonicClock';
+
+// 原生冷启动检测(NATIVE_CHECKUPDATE_DESIGN §10):每进程一次,getBundleUrl
+// 后延迟数秒运行,完全不依赖 app bundle——坏热更把 JS 砸挂后,下次启动仍能
+// 拉到修复版。决策全部来自 cpp/update_flow_core(经 NativePatchCore 的
+// NAPI 面),本文件只是 IO 胶水。失败静默且有界:每次启动至多一轮,无重试
+// 风暴,不拉黑版本。
+// 鸿蒙的 debug 门控由触发点天然承担:dev 走 MetroJSBundleProvider,
+// PushyFileJSBundleProvider.getBundleUrl 不会被调用。
+const TAG = 'NativeCheck';
+export const KEY_CONFIG = 'nativeConfig';
+// 供 JS 侧复用的原始响应缓存(§10.3),同时记录请求与配置指纹以限定命中范围。
+export const KEY_RESP_CACHE = 'nativeCheckResp';
+const REQUEST_TIMEOUT_MS = 10000;
+const REQUEST_CALL_TIMEOUT_MS = 15000;
+const MAX_CHECK_HTTP_ATTEMPTS = 8;
+const START_DELAY_MS = 5000;
+const DOWNLOAD_PHASE_TIMEOUT_MS = 10 * 60 * 1000;
+const DOWNLOAD_TYPE_DIFF = 'diff';
+const DOWNLOAD_TYPE_PDIFF = 'pdiff';
+
+interface NativeConfig {
+  appKey?: string;
+  packageVersion?: string;
+  endpoints?: string[];
+  queryUrls?: string[];
+  afterDownload?: string;
+  rnu?: string;
+  rn?: string;
+  disabled?: boolean;
+}
+
+interface FlowIdentity {
+  packageVersion: string;
+  currentVersion?: string;
+  uuid: string;
+  rolledBackVersion?: string;
+}
+
+interface FlowCInfo {
+  rnu: string;
+  rn: string;
+  os: string;
+  uuid: string;
+}
+
+interface FlowCheckInput {
+  packageVersion: string;
+  currentVersion?: string;
+  buildTime: string;
+  cInfo: FlowCInfo;
+  supportedDiffVersion: number;
+  bundleHash: string;
+}
+
+interface DecisionAttempt {
+  type?: string;
+  urls?: string[];
+}
+
+interface DecisionInfo {
+  name?: string;
+  description?: string;
+  metaInfo?: string;
+}
+
+interface Decision {
+  action?: string;
+  reason?: string;
+  hash?: string;
+  attempts?: DecisionAttempt[];
+  activate?: boolean;
+  info?: DecisionInfo;
+}
+
+interface RespCacheEntry {
+  ts: number;
+  body: string;
+  request: string;
+  config: string;
+}
+
+let scheduled = false;
+
+export function scheduleNativeCheck(
+  context: UpdateContext,
+  launchRolledBackVersion: string,
+): void {
+  if (scheduled) {
+    return;
+  }
+  scheduled = true;
+  // 结果本来就是"下次启动生效",延迟几秒让开冷启动关键路径(§7 R5)。
+  setTimeout(() => {
+    runOnce(context, launchRolledBackVersion).catch((e: Object) => {
+      // 救援路径自身绝不能把应用拖垮。
+      logger.error(TAG, `native check failed: ${e}`);
+    });
+  }, START_DELAY_MS);
+}
+
+async function runOnce(
+  context: UpdateContext,
+  launchRolledBackVersion: string,
+): Promise<void> {
+  // 在任何 IO 之前采样:resetToPackagedBundle 会递增它,本轮运行期间发生的
+  // reset 必须赢过本轮的决策。
+  const resetGeneration = context.getResetGeneration();
+  const configJson = context.getKv(KEY_CONFIG);
+  if (!configJson) {
+    // 无落盘配置(老接入/首启):静默不跑——这就是灰度开关。
+    return;
+  }
+  let config: NativeConfig;
+  try {
+    config = JSON.parse(configJson) as NativeConfig;
+  } catch (e) {
+    return;
+  }
+  if (config.disabled) {
+    return;
+  }
+  const appKey = config.appKey ?? '';
+  if (!appKey) {
+    return;
+  }
+
+  const currentVersion = context.getCurrentVersion();
+  // getConstants consumes the persisted rollback marker during startup; use
+  // the launch-path snapshot captured before that happens.
+  const rolledBackVersion = launchRolledBackVersion;
+  const uuid = context.getKv('uuid') ?? '';
+  const packageVersion = config.packageVersion || context.getPackageVersion();
+
+  const identity: FlowIdentity = {
+    packageVersion,
+    currentVersion,
+    uuid,
+  };
+  if (rolledBackVersion) {
+    identity.rolledBackVersion = rolledBackVersion;
+  }
+
+  const cInfo: FlowCInfo = {
+    rnu: config.rnu ?? '',
+    rn: config.rn ?? '',
+    // RNOH's Platform.Version is osFullName; use the same value so JS can
+    // reuse the response cache produced by this native request.
+    os: `harmony ${deviceInfo.osFullName}`,
+    uuid,
+  };
+
+  const input: FlowCheckInput = {
+    packageVersion: identity.packageVersion,
+    currentVersion,
+    buildTime: context.getBuildTime(),
+    cInfo,
+    supportedDiffVersion: NativePatchCore.getSupportedDiffVersion(),
+    bundleHash: await context.getBundleHash(),
+  };
+  const body = NativePatchCore.buildCheckRequestBody(JSON.stringify(input));
+  if (!body) {
+    return;
+  }
+
+  const responseText = await runCheckRequest(config, appKey, body);
+  if (!responseText) {
+    logger.debug(TAG, 'no endpoint reachable, giving up until next launch');
+    return;
+  }
+  // Anchor cache freshness to response arrival, before download/patch work.
+  const responseAtSeconds = Math.floor(Date.now() / 1000);
+
+  const decisionJson = NativePatchCore.handleCheckResponse(
+    responseText,
+    JSON.stringify(identity),
+    config.afterDownload ?? '',
+  );
+  if (!decisionJson) {
+    return;
+  }
+  const decision = JSON.parse(decisionJson) as Decision;
+  if (decision.action !== 'download') {
+    context.commitNativeCheckResult(
+      resetGeneration,
+      '',
+      '',
+      false,
+      buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
+    );
+    logger.debug(TAG, `nothing to do (${decision.reason ?? ''})`);
+    return;
+  }
+  const hash = decision.hash ?? '';
+  if (!isSafePathComponent(hash)) {
+    return;
+  }
+
+  let downloaded = context.hasDownloadedVersion(hash);
+  if (!downloaded) {
+    downloaded = await performAttempts(
+      context,
+      decision.attempts ?? [],
+      hash,
+      currentVersion,
+    );
+  }
+  if (!downloaded) {
+    context.commitNativeCheckResult(
+      resetGeneration,
+      '',
+      '',
+      false,
+      buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
+    );
+    return;
+  }
+
+  // 与 JS 侧下载成功后的 setLocalHashInfo 对齐,持久化版本元信息。
+  const info = decision.info;
+  let hashInfoJson = '';
+  if (info) {
+    const hashInfo: DecisionInfo = {};
+    if (typeof info.name === 'string') {
+      hashInfo.name = info.name;
+    }
+    if (typeof info.description === 'string') {
+      hashInfo.description = info.description;
+    }
+    if (typeof info.metaInfo === 'string') {
+      hashInfo.metaInfo = info.metaInfo;
+    }
+    hashInfoJson = JSON.stringify(hashInfo);
+  }
+
+  // 版本元信息、激活与响应缓存一次性原子提交(见 commitNativeCheckResult);
+  // 缓存只在原生文件/状态工作结束后公开,避免 JS 观察到响应后并发下载。
+  // 静默策略、或服务端按版本标记的 forceBoot(远程覆盖,救砖指令)才激活。
+  const activate = decision.activate === true;
+  let committed = false;
+  try {
+    committed = context.commitNativeCheckResult(
+      resetGeneration,
+      hash,
+      hashInfoJson,
+      activate,
+      buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
+    );
+  } catch (e) {
+    logger.error(TAG, `commit failed: ${e}`);
+    return;
+  }
+  if (!committed) {
+    logger.debug(TAG, 'reset during round, dropping result');
+  } else if (activate) {
+    logger.debug(TAG, `downloaded ${hash} and set for next launch`);
+  } else {
+    logger.debug(TAG, `downloaded ${hash}, activation left to JS`);
+  }
+}
+
+function buildResponseCacheJson(
+  configJson: string,
+  requestBody: string,
+  responseText: string,
+  responseAtSeconds: number,
+): string {
+  const cacheEntry: RespCacheEntry = {
+    ts: responseAtSeconds,
+    body: responseText,
+    request: requestBody,
+    config: configJson,
+  };
+  return JSON.stringify(cacheEntry);
+}
+
+function isValidCheckResponse(responseText: string | undefined): boolean {
+  if (responseText === undefined) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(responseText) as Object | null;
+    return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed);
+  } catch (e) {
+    return false;
+  }
+}
+
+async function httpRequest(
+  url: string,
+  postBody?: string,
+): Promise<string | undefined> {
+  const client = http.createHttp();
+  let callTimer: number | null = null;
+  try {
+    const header: Record<string, string> = { Accept: 'application/json' };
+    if (postBody !== undefined) {
+      header['Content-Type'] = 'application/json';
+    }
+    const requestPromise = client.request(url, {
+      method: postBody !== undefined
+        ? http.RequestMethod.POST
+        : http.RequestMethod.GET,
+      header,
+      extraData: postBody,
+      connectTimeout: REQUEST_TIMEOUT_MS,
+      readTimeout: REQUEST_TIMEOUT_MS,
+      expectDataType: http.HttpDataType.STRING,
+    });
+    const timeoutPromise = new Promise<http.HttpResponse>((_, reject) => {
+      callTimer = setTimeout(() => {
+        reject(Error(`HTTP request exceeded ${REQUEST_CALL_TIMEOUT_MS}ms`));
+      }, REQUEST_CALL_TIMEOUT_MS);
+    });
+    const response = await Promise.race([requestPromise, timeoutPromise]);
+    if (
+      response.responseCode >= 200 &&
+      response.responseCode < 300 &&
+      typeof response.result === 'string'
+    ) {
+      return response.result;
+    }
+    return undefined;
+  } catch (e) {
+    return undefined;
+  } finally {
+    if (callTimer !== null) {
+      clearTimeout(callTimer);
+    }
+    client.destroy();
+  }
+}
+
+// 顺序回退(§5.1):按纯层给出的候选序逐个请求,单请求超时;整轮失败后经
+// queryUrls 发现远程候选(排除已试过的)再来一轮。刻意不做 hedged race——
+// 该路径对延迟不敏感。
+async function runCheckRequest(
+  config: NativeConfig,
+  appKey: string,
+  body: string,
+): Promise<string | undefined> {
+  const orderedJson = NativePatchCore.orderEndpointCandidates(
+    JSON.stringify(config.endpoints ?? []),
+    Math.random(),
+  );
+  if (!orderedJson) {
+    return undefined;
+  }
+  const ordered = JSON.parse(orderedJson) as string[];
+  const tried = new Set<string>();
+  let httpAttempts = 0;
+  for (const rawBase of ordered) {
+    const base = normalizeEndpointBase(rawBase);
+    if (!base || tried.has(base)) {
+      continue;
+    }
+    if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+      return undefined;
+    }
+    tried.add(base);
+    const response = await httpRequest(`${base}/checkUpdate/${appKey}`, body);
+    if (isValidCheckResponse(response)) {
+      return response;
+    }
+  }
+  for (const listUrl of config.queryUrls ?? []) {
+    if (!listUrl) {
+      continue;
+    }
+    if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+      return undefined;
+    }
+    const listText = await httpRequest(listUrl);
+    if (listText === undefined) {
+      continue;
+    }
+    let remote: string[];
+    try {
+      const parsed = JSON.parse(listText) as Object;
+      if (!Array.isArray(parsed)) {
+        continue;
+      }
+      remote = parsed as string[];
+    } catch (e) {
+      continue;
+    }
+    for (const rawBase of remote) {
+      if (typeof rawBase !== 'string') {
+        continue;
+      }
+      const base = normalizeEndpointBase(rawBase);
+      if (!base || tried.has(base)) {
+        continue;
+      }
+      if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+        return undefined;
+      }
+      tried.add(base);
+      const response = await httpRequest(`${base}/checkUpdate/${appKey}`, body);
+      if (isValidCheckResponse(response)) {
+        return response;
+      }
+    }
+    // 拉到一份可解析的远程列表就够了。
+    break;
+  }
+  return undefined;
+}
+
+function normalizeEndpointBase(base: string): string {
+  return base.replace(/\/+$/, '');
+}
+
+async function runWithinDeadline(
+  start: () => Promise<void>,
+  deadlineUptimeMs: number,
+): Promise<void> {
+  const remainingMs = deadlineUptimeMs - monotonicNowMs();
+  if (remainingMs <= 0) {
+    throw Error('Download phase deadline expired before start');
+  }
+  let deadlineTimer = 0;
+  const deadlinePromise = new Promise<void>((_, reject) => {
+    deadlineTimer = setTimeout(() => {
+      reject(Error('Download phase deadline exceeded'));
+    }, remainingMs);
+  });
+  try {
+    // This bounds queueing, HTTP, decompression and native hpatch work from
+    // the orchestrator's perspective. The serialized task may still finish
+    // later, but it can no longer prevent the response cache from settling.
+    await Promise.race([start(), deadlinePromise]);
+  } finally {
+    clearTimeout(deadlineTimer);
+  }
+}
+
+async function performAttempts(
+  context: UpdateContext,
+  attempts: DecisionAttempt[],
+  hash: string,
+  originHash: string,
+): Promise<boolean> {
+  const incrementalDeadline = monotonicNowMs() + DOWNLOAD_PHASE_TIMEOUT_MS;
+  let fullDeadline = 0;
+  for (const attempt of attempts) {
+    const type = attempt.type ?? '';
+    if (type === DOWNLOAD_TYPE_DIFF && !originHash) {
+      // diff 以当前运行版本为源;没有运行中的热更版本就跳过。
+      continue;
+    }
+    const isFullAttempt =
+      type !== DOWNLOAD_TYPE_DIFF && type !== DOWNLOAD_TYPE_PDIFF;
+    if (isFullAttempt && fullDeadline === 0) {
+      // Preserve a full 10min rescue budget even when diff/pdiff exhausted
+      // their own phase window.
+      fullDeadline = monotonicNowMs() + DOWNLOAD_PHASE_TIMEOUT_MS;
+    }
+    const deadline = isFullAttempt ? fullDeadline : incrementalDeadline;
+    for (const url of attempt.urls ?? []) {
+      if (!url) {
+        continue;
+      }
+      if (monotonicNowMs() >= deadline) {
+        if (isFullAttempt) {
+          return false;
+        }
+        break;
+      }
+      try {
+        if (type === DOWNLOAD_TYPE_DIFF) {
+          await runWithinDeadline(
+            () => context.downloadPatchFromPpk(url, hash, originHash, deadline),
+            deadline,
+          );
+        } else if (type === DOWNLOAD_TYPE_PDIFF) {
+          await runWithinDeadline(
+            () => context.downloadPatchFromPackage(url, hash, deadline),
+            deadline,
+          );
+        } else {
+          await runWithinDeadline(
+            () => context.downloadFullUpdate(url, hash, deadline),
+            deadline,
+          );
+        }
+        return true;
+      } catch (e) {
+        logger.debug(TAG, `${type} attempt failed: ${e}`);
+      }
+    }
+  }
+  return false;
+}

package/harmony/pushy/src/main/ets/NativePatchCore.ts

@@ -86,6 +86,20 @@ interface NativePatchCoreBindings {
   crc32(data: Uint8Array | ArrayBuffer): number;
   /** 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道) */
   getSupportedDiffVersion(): number;
+
+  // 更新流程决策层(cpp/update_flow_core,NATIVE_CHECKUPDATE_DESIGN §10):
+  // JSON 字符串进出,与决策层自身的边界一致。返回 undefined = 输入未通过
+  // 解析,编排器跳过本轮检测。
+  buildCheckRequestBody(inputJson: string): string | undefined;
+  orderEndpointCandidates(
+    endpointsJson: string,
+    randomSample: number,
+  ): string | undefined;
+  handleCheckResponse(
+    responseText: string,
+    identityJson: string,
+    afterDownload: string,
+  ): string | undefined;
 }
 
 export default NativeUpdateCore as unknown as NativePatchCoreBindings;

package/harmony/pushy/src/main/ets/PathUtils.ts

@@ -0,0 +1,21 @@
+// Server-controlled identifiers are used as children of the update root. Keep
+// validation in a dependency-free module so startup orchestration and storage
+// code can share it without creating an import cycle.
+export function isSafePathComponent(name: string): boolean {
+  return (
+    typeof name === 'string' &&
+    name.length > 0 &&
+    name !== '.' &&
+    name !== '..' &&
+    !name.includes('/') &&
+    !name.includes('\\') &&
+    !name.includes('\0')
+  );
+}
+
+export function assertSafePathComponent(name: string): string {
+  if (!isSafePathComponent(name)) {
+    throw Error(`Invalid path component: ${name}`);
+  }
+  return name;
+}

package/harmony/pushy/src/main/ets/PushyTurboModule.ts

@@ -8,6 +8,10 @@ import logger from './Logger';
 import NativePatchCore from './NativePatchCore';
 import { UpdateContext } from './UpdateContext';
 import { EventHub } from './EventHub';
+import {
+  KEY_CONFIG,
+  KEY_RESP_CACHE,
+} from './NativeCheckOrchestrator';
 
 const TAG = 'PushyTurboModule';
 
@@ -186,6 +190,24 @@ export class PushyTurboModule extends UITurboModule {
     this.context.setKv('uuid', uuid);
   }
 
+  // Provisioning for the native cold-start update check
+  // (NATIVE_CHECKUPDATE_DESIGN §10.1): the raw JSON persists as-is, parsed on
+  // read by the orchestrator; absent config = check disabled. Validated at
+  // write time — a corrupt config would otherwise silently disable the
+  // native check forever with no signal.
+  async syncNativeConfig(config: string): Promise<void> {
+    logger.debug(TAG, ',call syncNativeConfig');
+    JSON.parse(config);
+    this.context.setKv(KEY_CONFIG, config);
+  }
+
+  // 原生冷启动检测落盘的原始响应缓存,JS 侧新鲜期内直接复用免二次请求
+  // (NATIVE_CHECKUPDATE_DESIGN §10.3)。缺省空串,永不 reject。
+  async getNativeCheckCache(): Promise<string> {
+    logger.debug(TAG, ',call getNativeCheckCache');
+    return this.context.getKv(KEY_RESP_CACHE) ?? '';
+  }
+
   async reloadUpdate(options: { hash: string }): Promise<void> {
     logger.debug(TAG, ',call reloadUpdate');
     const hash = this.requireHash(options.hash, 'reloadUpdate');