react-native-update 10.58.1 → 10.59.1

package/harmony/pushy/src/main/ets/{NativeCheckOrchestrator.ts → SyncCoordinator.ts}

@@ -3,13 +3,14 @@ import deviceInfo from '@ohos.deviceInfo';
 import logger from './Logger';
 import NativePatchCore from './NativePatchCore';
 import type { UpdateContext } from './UpdateContext';
-import { NativeUpdateRound, nativeUpdateResult } from './NativeUpdateResult';
-import type { NativeUpdateResult } from './NativeUpdateResult';
+import { BundlePreparationRound, bundlePreparationResult } from './BundlePreparationResult';
+import type { BundlePreparationResult } from './BundlePreparationResult';
 import { isSafePathComponent } from './PathUtils';
+import { QUERY_PATH, STATUS_NONE } from './Texts';
 import { monotonicNowMs } from './MonotonicClock';
 import {
   ERROR_DOWNLOAD_FAILED,
-  createUpdateError,
+  createPushyError,
   getErrorMessage,
 } from './ErrorCodes';
 
@@ -20,7 +21,7 @@ import {
 // 风暴,不拉黑版本。
 // 鸿蒙的 debug 门控由触发点天然承担:dev 走 MetroJSBundleProvider,
 // PushyFileJSBundleProvider.getBundleUrl 不会被调用。
-const TAG = 'NativeCheck';
+const TAG = 'NativeSync';
 export const KEY_CONFIG = 'nativeConfig';
 // 供 JS 侧复用的原始响应缓存(§10.3),同时记录请求与配置指纹以限定命中范围。
 export const KEY_RESP_CACHE = 'nativeCheckResp';
@@ -31,7 +32,7 @@ export const KEY_RESP_CACHE = 'nativeCheckResp';
 export const KEY_ROUND_INCOMPLETE = 'nativeCheckIncomplete';
 const REQUEST_TIMEOUT_MS = 10000;
 const REQUEST_CALL_TIMEOUT_MS = 15000;
-const MAX_CHECK_HTTP_ATTEMPTS = 8;
+const MAX_QUERY_HTTP_ATTEMPTS = 8;
 const START_DELAY_MS = 5000;
 const DOWNLOAD_PHASE_TIMEOUT_MS = 10 * 60 * 1000;
 const DOWNLOAD_TYPE_DIFF = 'diff';
@@ -62,7 +63,7 @@ interface FlowCInfo {
   uuid: string;
 }
 
-interface FlowCheckInput {
+interface FlowInput {
   packageVersion: string;
   currentVersion?: string;
   buildTime: string;
@@ -109,18 +110,18 @@ interface RespCacheEntry {
 
 let scheduled = false;
 // The host and delayed check use one promise, including its settled result.
-const hostRound = new NativeUpdateRound();
+const hostRound = new BundlePreparationRound();
 let scheduledContext: UpdateContext | undefined;
 let scheduledRollback = '';
 let roundGeneration = -1;
 let roundConfigGeneration = -1;
 let roundConfigJson: string | undefined;
-let roundResult = nativeUpdateResult('failed', 'check_failed');
+let roundResult = bundlePreparationResult('failed', 'check_failed');
 
 function startNativeRound(
   context: UpdateContext,
   launchRolledBackVersion: string,
-): Promise<NativeUpdateResult> {
+): Promise<BundlePreparationResult> {
   const preflight = configurationError(context);
   if (preflight !== undefined) {
     return Promise.resolve(preflight);
@@ -129,8 +130,8 @@ function startNativeRound(
     try {
       await runOnce(context, launchRolledBackVersion);
     } catch (e) {
-      logger.error(TAG, `native check failed: ${getErrorMessage(e)}`);
-      roundResult = nativeUpdateResult('failed', 'internal_error');
+      logger.error(TAG, `native sync failed: ${getErrorMessage(e)}`);
+      roundResult = bundlePreparationResult('failed', 'internal_error');
     }
     return roundResult;
   });
@@ -138,82 +139,82 @@ function startNativeRound(
 
 // A preflight skip must not consume the process's only round: configuration
 // may arrive after the delayed startup timer on a first-ever launch.
-function configurationError(context: UpdateContext): NativeUpdateResult | undefined {
+function configurationError(context: UpdateContext): BundlePreparationResult | undefined {
   const json = context.getKv(KEY_CONFIG);
   if (!json) {
-    return nativeUpdateResult('skipped', 'not_configured');
+    return bundlePreparationResult('skipped', 'not_configured');
   }
   try {
     const config = JSON.parse(json) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
     if (config.disabled) {
-      return nativeUpdateResult('skipped', 'disabled');
+      return bundlePreparationResult('skipped', 'disabled');
     }
     if (typeof config.appKey !== 'string' || config.appKey.trim().length === 0) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
   } catch (e) {
-    return nativeUpdateResult('failed', 'invalid_config');
+    return bundlePreparationResult('failed', 'invalid_config');
   }
   return undefined;
 }
 
-export async function checkAndUpdateNative(
+export async function prepareBundleNative(
   context: UpdateContext,
-): Promise<NativeUpdateResult> {
+): Promise<BundlePreparationResult> {
   if (scheduledContext !== context) {
-    return nativeUpdateResult('skipped', 'not_initialized');
+    return bundlePreparationResult('skipped', 'not_initialized');
   }
   const configJson = context.getKv(KEY_CONFIG);
   if (!configJson) {
-    return nativeUpdateResult('skipped', 'not_configured');
+    return bundlePreparationResult('skipped', 'not_configured');
   }
   try {
     const config = JSON.parse(configJson) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
     if (config.disabled) {
-      return nativeUpdateResult('skipped', 'disabled');
+      return bundlePreparationResult('skipped', 'disabled');
     }
     if (typeof config.appKey !== 'string' || !config.appKey) {
-      return nativeUpdateResult('failed', 'invalid_config');
+      return bundlePreparationResult('failed', 'invalid_config');
     }
   } catch (e) {
-    return nativeUpdateResult('failed', 'invalid_config');
+    return bundlePreparationResult('failed', 'invalid_config');
   }
   const result = await startNativeRound(context, scheduledRollback);
   if (roundConfigGeneration !== context.getNativeConfigGeneration()
       || configJson !== roundConfigJson || configJson !== context.getKv(KEY_CONFIG)) {
-    return nativeUpdateResult('cancelled', 'config_changed');
+    return bundlePreparationResult('cancelled', 'config_changed');
   }
   if (roundGeneration !== context.getResetGeneration()) {
-    return nativeUpdateResult('cancelled', 'reset');
+    return bundlePreparationResult('cancelled', 'reset');
   }
   // Do not let a caller mutate the cached result observed by later callers.
-  return nativeUpdateResult(result.status, result.reason, result.hash, result.activated);
+  return bundlePreparationResult(result.status, result.reason, result.hash, result.activated);
 }
 
 // JS 在本进程内已拿到有效检查响应时对应的配置 JSON(markJsCheckCompleted)。
 // 进程级:下次启动无信号,冷启动轮次照常运行。
 let jsCompletedConfig: string | undefined;
 
-export function markJsCheckCompleted(config: string): void {
+export function recordJsRound(config: string): void {
   jsCompletedConfig = config;
 }
 
 // JS 已用与原生完全相同的配置拿到有效响应(§10.3):延迟轮次就是一次重复请求。
 // 只有计划内的轮次会问这个问题——JS 没起来、启动即崩、检查失败时都不会有信号。
-function isJsCheckCompleted(context: UpdateContext): boolean {
+function hasJsRound(context: UpdateContext): boolean {
   return (
     jsCompletedConfig !== undefined &&
     jsCompletedConfig === context.getKv(KEY_CONFIG)
   );
 }
 
-export function scheduleNativeCheck(
+export function scheduleNativeSync(
   context: UpdateContext,
   launchRolledBackVersion: string,
 ): void {
@@ -227,16 +228,16 @@ export function scheduleNativeCheck(
   // 除非上个进程死于轮中(残留标记),那时每一秒启动时间都要用来续传。
   const delayMs = context.getKv(KEY_ROUND_INCOMPLETE) ? 0 : START_DELAY_MS;
   setTimeout(() => {
-    if (isJsCheckCompleted(context)) {
+    if (hasJsRound(context)) {
       logger.info(
         TAG,
-        'native check skipped: JS check completed in this process',
+        'native sync skipped: JS already queried in this process',
       );
       return;
     }
     startNativeRound(context, launchRolledBackVersion).catch((e: Object) => {
       // 救援路径自身绝不能把应用拖垮。
-      logger.error(TAG, `native check failed: ${getErrorMessage(e)}`);
+      logger.error(TAG, `native sync failed: ${getErrorMessage(e)}`);
     });
   }, delayMs);
 }
@@ -250,32 +251,32 @@ async function runOnce(
   const resetGeneration = context.getResetGeneration();
   roundGeneration = resetGeneration;
   roundConfigGeneration = context.getNativeConfigGeneration();
-  roundResult = nativeUpdateResult('failed', 'check_failed');
+  roundResult = bundlePreparationResult('failed', 'check_failed');
   const configJson = context.getKv(KEY_CONFIG);
   roundConfigJson = configJson;
   if (!configJson) {
     // No persisted configuration: report the rollout gate to native callers.
-    roundResult = nativeUpdateResult('skipped', 'not_configured');
+    roundResult = bundlePreparationResult('skipped', 'not_configured');
     return;
   }
   let config: NativeConfig;
   try {
     config = JSON.parse(configJson) as NativeConfig;
     if (!config || typeof config !== 'object' || Array.isArray(config)) {
-      roundResult = nativeUpdateResult('failed', 'invalid_config');
+      roundResult = bundlePreparationResult('failed', 'invalid_config');
       return;
     }
   } catch (e) {
-    roundResult = nativeUpdateResult('failed', 'invalid_config');
+    roundResult = bundlePreparationResult('failed', 'invalid_config');
     return;
   }
   if (config.disabled) {
-    roundResult = nativeUpdateResult('skipped', 'disabled');
+    roundResult = bundlePreparationResult('skipped', 'disabled');
     return;
   }
   const appKey = config.appKey ?? '';
   if (!appKey) {
-    roundResult = nativeUpdateResult('failed', 'invalid_config');
+    roundResult = bundlePreparationResult('failed', 'invalid_config');
     return;
   }
   // 从这里起本轮开始做真实工作:留下面包屑,死于轮中时下次启动零延迟续传。
@@ -361,7 +362,7 @@ async function runConfiguredRound(
     uuid,
   };
 
-  const input: FlowCheckInput = {
+  const input: FlowInput = {
     packageVersion: identity.packageVersion,
     currentVersion,
     buildTime: context.getBuildTime(),
@@ -369,14 +370,14 @@ async function runConfiguredRound(
     supportedDiffVersion: NativePatchCore.getSupportedDiffVersion(),
     bundleHash: await context.getBundleHash(),
   };
-  const body = NativePatchCore.buildCheckRequestBody(JSON.stringify(input));
+  const body = NativePatchCore.buildRequestBody(JSON.stringify(input));
   if (!body) {
-    roundResult = nativeUpdateResult('failed', 'invalid_request');
+    roundResult = bundlePreparationResult('failed', 'invalid_request');
     return;
   }
 
   const httpsOnly = isHttpsOnly(config);
-  const responseText = await runCheckRequest(config, appKey, body, httpsOnly);
+  const responseText = await runQueryRequest(config, appKey, body, httpsOnly);
   if (!responseText) {
     logger.warn(TAG, 'no endpoint reachable, giving up until next launch');
     return;
@@ -384,18 +385,18 @@ async function runConfiguredRound(
   // Anchor cache freshness to response arrival, before download/patch work.
   const responseAtSeconds = Math.floor(Date.now() / 1000);
 
-  const decisionJson = NativePatchCore.handleCheckResponse(
+  const decisionJson = NativePatchCore.handleResponse(
     responseText,
     JSON.stringify(identity),
     config.afterDownload ?? '',
   );
   if (!decisionJson) {
-    roundResult = nativeUpdateResult('failed', 'invalid_response');
+    roundResult = bundlePreparationResult('failed', 'invalid_response');
     return;
   }
   const decision = JSON.parse(decisionJson) as Decision;
   if (decision.action !== 'download') {
-    const committed = await context.commitNativeCheckResult(
+    const committed = await context.commitSyncResult(
       resetGeneration,
       '',
       '',
@@ -403,15 +404,15 @@ async function runConfiguredRound(
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
     roundResult = committed
-      ? nativeUpdateResult('noUpdate', decision.reason ?? '')
-      : nativeUpdateResult('cancelled', 'reset');
+      ? bundlePreparationResult(STATUS_NONE, decision.reason ?? '')
+      : bundlePreparationResult('cancelled', 'reset');
     logger.info(TAG, `nothing to do (${decision.reason ?? ''})`);
     return;
   }
   const hash = decision.hash ?? '';
   if (!isSafePathComponent(hash)) {
     logger.warn(TAG, 'decision carries an unsafe hash, ignoring');
-    roundResult = nativeUpdateResult('failed', 'invalid_response');
+    roundResult = bundlePreparationResult('failed', 'invalid_response');
     return;
   }
 
@@ -430,7 +431,7 @@ async function runConfiguredRound(
   }
   if (!downloaded) {
     logger.warn(TAG, `all download attempts for ${hash} failed`);
-    const committed = await context.commitNativeCheckResult(
+    const committed = await context.commitSyncResult(
       resetGeneration,
       '',
       '',
@@ -438,8 +439,8 @@ async function runConfiguredRound(
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
     roundResult = committed
-      ? nativeUpdateResult('failed', 'download_failed')
-      : nativeUpdateResult('cancelled', 'reset');
+      ? bundlePreparationResult('failed', 'download_failed')
+      : bundlePreparationResult('cancelled', 'reset');
     return;
   }
 
@@ -466,13 +467,13 @@ async function runConfiguredRound(
     hashInfoJson = JSON.stringify(hashInfo);
   }
 
-  // 版本元信息、激活与响应缓存一次性原子提交(见 commitNativeCheckResult);
+  // 版本元信息、激活与响应缓存一次性原子提交(见 commitSyncResult);
   // 缓存只在原生文件/状态工作结束后公开,避免 JS 观察到响应后并发下载。
   // 静默策略、或服务端按版本标记的 forceBoot(远程覆盖,救砖指令)才激活。
   const activate = decision.activate === true;
   let committed = false;
   try {
-    committed = await context.commitNativeCheckResult(
+    committed = await context.commitSyncResult(
       resetGeneration,
       hash,
       hashInfoJson,
@@ -481,7 +482,7 @@ async function runConfiguredRound(
     );
   } catch (e) {
     logger.error(TAG, `commit failed: ${getErrorMessage(e)}`);
-    roundResult = nativeUpdateResult('failed', 'commit_failed');
+    roundResult = bundlePreparationResult('failed', 'commit_failed');
     return;
   }
   if (!committed) {
@@ -492,8 +493,8 @@ async function runConfiguredRound(
     logger.info(TAG, `downloaded ${hash}, activation left to JS`);
   }
   roundResult = committed
-    ? nativeUpdateResult('downloaded', '', hash, activate)
-    : nativeUpdateResult('cancelled', 'reset');
+    ? bundlePreparationResult('downloaded', '', hash, activate)
+    : bundlePreparationResult('cancelled', 'reset');
 }
 
 function buildResponseCacheJson(
@@ -511,12 +512,12 @@ function buildResponseCacheJson(
   return JSON.stringify(cacheEntry);
 }
 
-function isValidCheckResponse(responseText: string | undefined): boolean {
+function isValidResponse(responseText: string | undefined): boolean {
   if (responseText === undefined) {
     return false;
   }
   try {
-    return NativePatchCore.isValidCheckResponse(responseText);
+    return NativePatchCore.isValidResponse(responseText);
   } catch (e) {
     return false;
   }
@@ -570,7 +571,7 @@ async function httpRequest(
 // 顺序回退(§5.1):按纯层给出的候选序逐个请求,单请求超时;整轮失败后经
 // queryUrls 发现远程候选(排除已试过的)再来一轮。刻意不做 hedged race——
 // 该路径对延迟不敏感。
-async function runCheckRequest(
+async function runQueryRequest(
   config: NativeConfig,
   appKey: string,
   body: string,
@@ -591,12 +592,12 @@ async function runCheckRequest(
     if (!base || tried.has(base)) {
       continue;
     }
-    if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+    if (httpAttempts++ >= MAX_QUERY_HTTP_ATTEMPTS) {
       return undefined;
     }
     tried.add(base);
-    const response = await httpRequest(`${base}/checkUpdate/${appKey}`, body);
-    if (isValidCheckResponse(response)) {
+    const response = await httpRequest(`${base}${QUERY_PATH}${appKey}`, body);
+    if (isValidResponse(response)) {
       return response;
     }
   }
@@ -604,7 +605,7 @@ async function runCheckRequest(
     if (!listUrl) {
       continue;
     }
-    if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+    if (httpAttempts++ >= MAX_QUERY_HTTP_ATTEMPTS) {
       return undefined;
     }
     const listText = await httpRequest(listUrl);
@@ -634,12 +635,12 @@ async function runCheckRequest(
         logger.warn(TAG, `ignoring non-https remote endpoint ${base}`);
         continue;
       }
-      if (httpAttempts++ >= MAX_CHECK_HTTP_ATTEMPTS) {
+      if (httpAttempts++ >= MAX_QUERY_HTTP_ATTEMPTS) {
         return undefined;
       }
       tried.add(base);
-      const response = await httpRequest(`${base}/checkUpdate/${appKey}`, body);
-      if (isValidCheckResponse(response)) {
+      const response = await httpRequest(`${base}${QUERY_PATH}${appKey}`, body);
+      if (isValidResponse(response)) {
         return response;
       }
     }
@@ -659,7 +660,7 @@ async function runWithinDeadline(
 ): Promise<void> {
   const remainingMs = deadlineUptimeMs - monotonicNowMs();
   if (remainingMs <= 0) {
-    throw createUpdateError(
+    throw createPushyError(
       ERROR_DOWNLOAD_FAILED,
       'Download phase deadline expired before start',
     );
@@ -668,7 +669,7 @@ async function runWithinDeadline(
   const deadlinePromise = new Promise<void>((_, reject) => {
     deadlineTimer = setTimeout(() => {
       reject(
-        createUpdateError(
+        createPushyError(
           ERROR_DOWNLOAD_FAILED,
           'Download phase deadline exceeded',
         ),

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

@@ -0,0 +1,28 @@
+// Encoded text shared by the Harmony module. No imports, so any file can use it
+// without forming an import cycle.
+
+// Decodes text produced by scripts/encode-native-text.ts (byte i XORed with
+// (0x5A + 0x1D * i) & 0xFF), keeping service addresses and paths out of static
+// string scans of the package. Not a secret.
+export function revealText(hex: string): string {
+  let text = '';
+  for (let i = 0; i < hex.length / 2; i++) {
+    const byte = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    text += String.fromCharCode(byte ^ ((0x5a + 0x1d * i) & 0xff));
+  }
+  return text;
+}
+
+// Request path appended to an endpoint base.
+export const QUERY_PATH: string = revealText('7514fcd4ad805d55263e08fc99');
+
+// Protocol values, version-info flags and storage names, stored encoded.
+export const STATUS_NONE: string = revealText('3418c1c1aa8a7c40');
+export const POLICY_NEXT_LAUNCH: string = revealText('2912e0ffab8e6c70323b1dedd3');
+export const STORAGE_DIR_NAME: string = revealText('0502e4d5af9f6d');
+export const PREFERENCES_NAME: string = revealText('2f07f0d0ba8e');
+export const PPK_DELTA_SUFFIX: string = revealText('7407e4dae09b69512137');
+export const APP_DELTA_SUFFIX: string = revealText('7416e4c1e09b69512137');
+export const BUNDLE_DELTA_ENTRY: string = revealText('3802fad5a28e264d232d11f6d8aade67596914e0ead8b0');
+export const DEVTOOLS_RESTART_EVENT: string = revealText('0832d8fe8faf');
+export const DEVTOOLS_RESTART_REASON: string = revealText('1218e0e3ab876744266d');