react-native-update 10.56.0 → 10.57.0

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

@@ -3,6 +3,8 @@ 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 { isSafePathComponent } from './PathUtils';
 import { monotonicNowMs } from './MonotonicClock';
 import {
@@ -106,6 +108,94 @@ interface RespCacheEntry {
 }
 
 let scheduled = false;
+// The host and delayed check use one promise, including its settled result.
+const hostRound = new NativeUpdateRound();
+let scheduledContext: UpdateContext | undefined;
+let scheduledRollback = '';
+let roundGeneration = -1;
+let roundConfigGeneration = -1;
+let roundConfigJson: string | undefined;
+let roundResult = nativeUpdateResult('failed', 'check_failed');
+
+function startNativeRound(
+  context: UpdateContext,
+  launchRolledBackVersion: string,
+): Promise<NativeUpdateResult> {
+  const preflight = configurationError(context);
+  if (preflight !== undefined) {
+    return Promise.resolve(preflight);
+  }
+  return hostRound.run(async () => {
+    try {
+      await runOnce(context, launchRolledBackVersion);
+    } catch (e) {
+      logger.error(TAG, `native check failed: ${getErrorMessage(e)}`);
+      roundResult = nativeUpdateResult('failed', 'internal_error');
+    }
+    return roundResult;
+  });
+}
+
+// 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 {
+  const json = context.getKv(KEY_CONFIG);
+  if (!json) {
+    return nativeUpdateResult('skipped', 'not_configured');
+  }
+  try {
+    const config = JSON.parse(json) as NativeConfig;
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      return nativeUpdateResult('failed', 'invalid_config');
+    }
+    if (config.disabled) {
+      return nativeUpdateResult('skipped', 'disabled');
+    }
+    if (typeof config.appKey !== 'string' || config.appKey.trim().length === 0) {
+      return nativeUpdateResult('failed', 'invalid_config');
+    }
+  } catch (e) {
+    return nativeUpdateResult('failed', 'invalid_config');
+  }
+  return undefined;
+}
+
+export async function checkAndUpdateNative(
+  context: UpdateContext,
+): Promise<NativeUpdateResult> {
+  if (scheduledContext !== context) {
+    return nativeUpdateResult('skipped', 'not_initialized');
+  }
+  const configJson = context.getKv(KEY_CONFIG);
+  if (!configJson) {
+    return nativeUpdateResult('skipped', 'not_configured');
+  }
+  try {
+    const config = JSON.parse(configJson) as NativeConfig;
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      return nativeUpdateResult('failed', 'invalid_config');
+    }
+    if (config.disabled) {
+      return nativeUpdateResult('skipped', 'disabled');
+    }
+    if (typeof config.appKey !== 'string' || !config.appKey) {
+      return nativeUpdateResult('failed', 'invalid_config');
+    }
+  } catch (e) {
+    return nativeUpdateResult('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');
+  }
+  if (roundGeneration !== context.getResetGeneration()) {
+    return nativeUpdateResult('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);
+}
+
 // JS 在本进程内已拿到有效检查响应时对应的配置 JSON(markJsCheckCompleted)。
 // 进程级:下次启动无信号,冷启动轮次照常运行。
 let jsCompletedConfig: string | undefined;
@@ -131,6 +221,8 @@ export function scheduleNativeCheck(
     return;
   }
   scheduled = true;
+  scheduledContext = context;
+  scheduledRollback = launchRolledBackVersion;
   // 结果本来就是"下次启动生效",延迟几秒让开冷启动关键路径(§7 R5)——
   // 除非上个进程死于轮中(残留标记),那时每一秒启动时间都要用来续传。
   const delayMs = context.getKv(KEY_ROUND_INCOMPLETE) ? 0 : START_DELAY_MS;
@@ -142,7 +234,7 @@ export function scheduleNativeCheck(
       );
       return;
     }
-    runOnce(context, launchRolledBackVersion).catch((e: Object) => {
+    startNativeRound(context, launchRolledBackVersion).catch((e: Object) => {
       // 救援路径自身绝不能把应用拖垮。
       logger.error(TAG, `native check failed: ${getErrorMessage(e)}`);
     });
@@ -156,22 +248,34 @@ async function runOnce(
   // 在任何 IO 之前采样:resetToPackagedBundle 会递增它,本轮运行期间发生的
   // reset 必须赢过本轮的决策。
   const resetGeneration = context.getResetGeneration();
+  roundGeneration = resetGeneration;
+  roundConfigGeneration = context.getNativeConfigGeneration();
+  roundResult = nativeUpdateResult('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');
     return;
   }
   let config: NativeConfig;
   try {
     config = JSON.parse(configJson) as NativeConfig;
+    if (!config || typeof config !== 'object' || Array.isArray(config)) {
+      roundResult = nativeUpdateResult('failed', 'invalid_config');
+      return;
+    }
   } catch (e) {
+    roundResult = nativeUpdateResult('failed', 'invalid_config');
     return;
   }
   if (config.disabled) {
+    roundResult = nativeUpdateResult('skipped', 'disabled');
     return;
   }
   const appKey = config.appKey ?? '';
   if (!appKey) {
+    roundResult = nativeUpdateResult('failed', 'invalid_config');
     return;
   }
   // 从这里起本轮开始做真实工作:留下面包屑,死于轮中时下次启动零延迟续传。
@@ -267,6 +371,7 @@ async function runConfiguredRound(
   };
   const body = NativePatchCore.buildCheckRequestBody(JSON.stringify(input));
   if (!body) {
+    roundResult = nativeUpdateResult('failed', 'invalid_request');
     return;
   }
 
@@ -285,23 +390,28 @@ async function runConfiguredRound(
     config.afterDownload ?? '',
   );
   if (!decisionJson) {
+    roundResult = nativeUpdateResult('failed', 'invalid_response');
     return;
   }
   const decision = JSON.parse(decisionJson) as Decision;
   if (decision.action !== 'download') {
-    await context.commitNativeCheckResult(
+    const committed = await context.commitNativeCheckResult(
       resetGeneration,
       '',
       '',
       false,
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
+    roundResult = committed
+      ? nativeUpdateResult('noUpdate', decision.reason ?? '')
+      : nativeUpdateResult('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');
     return;
   }
 
@@ -320,13 +430,16 @@ async function runConfiguredRound(
   }
   if (!downloaded) {
     logger.warn(TAG, `all download attempts for ${hash} failed`);
-    await context.commitNativeCheckResult(
+    const committed = await context.commitNativeCheckResult(
       resetGeneration,
       '',
       '',
       false,
       buildResponseCacheJson(configJson, body, responseText, responseAtSeconds),
     );
+    roundResult = committed
+      ? nativeUpdateResult('failed', 'download_failed')
+      : nativeUpdateResult('cancelled', 'reset');
     return;
   }
 
@@ -368,6 +481,7 @@ async function runConfiguredRound(
     );
   } catch (e) {
     logger.error(TAG, `commit failed: ${getErrorMessage(e)}`);
+    roundResult = nativeUpdateResult('failed', 'commit_failed');
     return;
   }
   if (!committed) {
@@ -377,6 +491,9 @@ async function runConfiguredRound(
   } else {
     logger.info(TAG, `downloaded ${hash}, activation left to JS`);
   }
+  roundResult = committed
+    ? nativeUpdateResult('downloaded', '', hash, activate)
+    : nativeUpdateResult('cancelled', 'reset');
 }
 
 function buildResponseCacheJson(

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

@@ -0,0 +1,102 @@
+/** Options accepted by PushyFileJSBundleProvider.configure(). */
+export interface NativeUpdateConfig {
+  appKey: string;
+  /** Omitted: Pushy's built-in endpoints. Custom endpoints never inherit discovery URLs. */
+  endpoints?: string[];
+  queryUrls?: string[];
+  /** Default: none. setNeedUpdate selects a downloaded bundle for the NEXT launch. */
+  afterDownload?: 'none' | 'setNeedUpdate';
+  disabled?: boolean;
+  /** Omit to use the installed application's version. */
+  packageVersion?: string;
+  /** Optional telemetry version strings; not required to check or install an update. */
+  rnu?: string;
+  rn?: string;
+}
+
+interface PersistedNativeUpdateConfig {
+  appKey: string;
+  endpoints: string[];
+  queryUrls: string[];
+  afterDownload: string;
+  disabled: boolean;
+  packageVersion?: string;
+  rnu: string;
+  rn: string;
+}
+
+const DEFAULT_ENDPOINTS: string[] = [
+  'https://update.react-native.cn/api',
+  'https://update.reactnative.cn/api',
+];
+const DEFAULT_QUERY_URLS: string[] = [
+  'https://gitee.com/sunnylqm/react-native-pushy/raw/master/endpoints.json',
+  'https://cdn.jsdelivr.net/gh/reactnativecn/react-native-update@master/endpoints.json',
+];
+const CONFIG_KEYS: string[] = [
+  'appKey', 'endpoints', 'queryUrls', 'afterDownload', 'disabled',
+  'packageVersion', 'rnu', 'rn',
+];
+
+function configString(value: string, name: string, allowEmpty: boolean): string {
+  if (typeof value !== 'string' || (!allowEmpty && value.trim().length === 0)) {
+    throw new Error(`Invalid native configuration: ${name} must be a string${allowEmpty ? '' : ' and must not be blank'}`);
+  }
+  return value;
+}
+
+function configUrls(values: string[], name: string, base: boolean): string[] {
+  if (!Array.isArray(values) || (base && values.length === 0)) {
+    throw new Error(`Invalid native configuration: ${name} must be ${base ? 'a non-empty' : 'an'} array`);
+  }
+  const result: string[] = [];
+  for (const value of values) {
+    const url = configString(value, name, false).trim();
+    // Restrict the authority and scheme, without relying on browser URL globals
+    // unavailable in ArkTS. Platform networking performs the final URL parsing.
+    if (!/^https?:\/\/(\[[0-9a-fA-F:]+\]|[a-zA-Z0-9.-]+)(:[0-9]+)?([/?#]|$)/.test(url)
+        || /\s|\\/.test(url) || (base && /[?#]/.test(url))) {
+      throw new Error(`Invalid native configuration: ${name} requires absolute HTTP(S) URLs without credentials${base ? ', queries or fragments' : ''}`);
+    }
+    const normalized = base ? url.replace(/\/+$/, '') : url;
+    if (!result.includes(normalized)) {
+      result.push(normalized);
+    }
+  }
+  return result;
+}
+
+/** Pure validation, before any native state is touched. Does not mutate options. */
+export function normalizeNativeUpdateConfig(options: NativeUpdateConfig): string {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) {
+    throw new Error('Invalid native configuration: expected an object');
+  }
+  for (const key of Object.keys(options)) {
+    if (!CONFIG_KEYS.includes(key)) {
+      throw new Error(`Invalid native configuration: unknown option ${key}`);
+    }
+  }
+  const appKey = configString(options.appKey, 'appKey', false);
+  const customEndpoints = options.endpoints !== undefined;
+  const endpoints = configUrls(customEndpoints ? options.endpoints! : DEFAULT_ENDPOINTS, 'endpoints', true);
+  const queryUrls = configUrls(
+    options.queryUrls !== undefined ? options.queryUrls : (customEndpoints ? [] : DEFAULT_QUERY_URLS),
+    'queryUrls', false,
+  );
+  const afterDownload = options.afterDownload === undefined ? 'none' : options.afterDownload;
+  if (afterDownload !== 'none' && afterDownload !== 'setNeedUpdate') {
+    throw new Error('Invalid native configuration: afterDownload must be none or setNeedUpdate');
+  }
+  if (options.disabled !== undefined && typeof options.disabled !== 'boolean') {
+    throw new Error('Invalid native configuration: disabled must be a boolean');
+  }
+  const result: PersistedNativeUpdateConfig = {
+    appKey, endpoints, queryUrls, afterDownload, disabled: options.disabled ?? false,
+    rnu: options.rnu === undefined ? '' : configString(options.rnu, 'rnu', true),
+    rn: options.rn === undefined ? '' : configString(options.rn, 'rn', true),
+  };
+  if (options.packageVersion !== undefined) {
+    result.packageVersion = configString(options.packageVersion, 'packageVersion', false);
+  }
+  return JSON.stringify(result);
+}

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

@@ -0,0 +1,32 @@
+/** A native round snapshot, not the current state of the running RN instance. */
+export interface NativeUpdateResult {
+  /** skipped, noUpdate, downloaded, failed, or cancelled. */
+  status: string;
+  reason: string;
+  hash: string;
+  /** The version was selected for the next launch; no reload is performed. */
+  activated: boolean;
+}
+
+export function nativeUpdateResult(
+  status: string,
+  reason: string = '',
+  hash: string = '',
+  activated: boolean = false,
+): NativeUpdateResult {
+  return { status, reason, hash, activated };
+}
+
+/** Internal gate shared by the delayed check and the native host API. */
+export class NativeUpdateRound {
+  private task: Promise<NativeUpdateResult> | undefined;
+
+  run(operation: () => Promise<NativeUpdateResult>): Promise<NativeUpdateResult> {
+    if (this.task !== undefined) {
+      return this.task;
+    }
+    // Defer invocation until the promise is stored, including reentrant callers.
+    this.task = Promise.resolve().then(operation);
+    return this.task;
+  }
+}

package/harmony/pushy/src/main/ets/PushyFileJSBundleProvider.ets

@@ -6,6 +6,10 @@ import {
 import common from '@ohos.app.ability.common';
 import fs from '@ohos.file.fs';
 import { UpdateContext } from './UpdateContext';
+import { checkAndUpdateNative } from './NativeCheckOrchestrator';
+import type { NativeUpdateResult } from './NativeUpdateResult';
+import { normalizeNativeUpdateConfig } from './NativeUpdateConfig';
+import type { NativeUpdateConfig } from './NativeUpdateConfig';
 
 export class PushyFileJSBundleProvider extends JSBundleProvider {
   private updateContext: UpdateContext;
@@ -43,6 +47,17 @@ export class PushyFileJSBundleProvider extends JSBundleProvider {
     }
   }
 
+  /** Configure before normal bundle resolution; no JS or network work is required. */
+  async configure(options: NativeUpdateConfig): Promise<void> {
+    const config = normalizeNativeUpdateConfig(options);
+    await this.updateContext.setNativeConfig(config);
+  }
+
+  /** Call after the host's real bundle resolution; never resolves it again. */
+  checkAndUpdate(): Promise<NativeUpdateResult> {
+    return checkAndUpdateNative(this.updateContext);
+  }
+
   getAppKeys(): string[] {
     return [];
   }

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

@@ -273,7 +273,7 @@ export class PushyTurboModule extends UITurboModule {
       );
     }
     try {
-      await this.context.setKv(KEY_CONFIG, config);
+      await this.context.setNativeConfig(config);
     } catch (error) {
       throw toUpdateError(error, ERROR_FILE_OPERATION_FAILED);
     }

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

@@ -12,7 +12,9 @@ import { bundleManager } from '@kit.AbilityKit';
 import { util } from '@kit.ArkTS';
 import logger from './Logger';
 import {
+  KEY_CONFIG,
   KEY_RESP_CACHE,
+  markJsCheckCompleted,
   scheduleNativeCheck,
 } from './NativeCheckOrchestrator';
 import NativePatchCore, {
@@ -458,6 +460,29 @@ export class UpdateContext {
   }
 
   /** 写入并落盘;flushSync 不可用时以 flush() 的结果拒绝。 */
+  /** Shared JS/native configuration writer; all mutations precede the first await. */
+  private static nativeConfigGeneration: number = 0;
+
+  public getNativeConfigGeneration(): number {
+    return UpdateContext.nativeConfigGeneration;
+  }
+
+  public setNativeConfig(config: string): Promise<void> {
+    if (!this.getKv('uuid')) {
+      this.preferences.putSync('uuid', util.generateRandomUUID());
+    }
+    if (this.getKv(KEY_CONFIG) !== config) {
+      // Also guards A -> B -> A replacements and late download commits.
+      UpdateContext.resetGeneration += 1;
+      UpdateContext.nativeConfigGeneration += 1;
+      this.preferences.putSync(KEY_CONFIG, config);
+      this.preferences.deleteSync(KEY_RESP_CACHE);
+      markJsCheckCompleted('');
+    }
+    // Flush even an equal value so a retry after a storage error can succeed.
+    return this.flushPreferences('configure native update');
+  }
+
   public setKv(key: string, value: string): Promise<void> {
     this.preferences.putSync(key, value);
     return this.flushPreferences(`set key ${key}`);

package/ios/RCTPushy/RCTPushy.h

@@ -1,9 +1,33 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
 
+typedef void (^RCTPushyNativeConfigurationCompletion)(NSError * _Nullable error);
+
+typedef void (^RCTPushyNativeUpdateCompletion)(NSDictionary<NSString *, id> * _Nonnull result);
 
 @interface RCTPushy : RCTEventEmitter<RCTBridgeModule>
 
 + (NSURL *)bundleURL;
 
+/** Validate and persist native options without JS, network work or bundle resolution.
+ * Completion is on the main queue; nil error means success. Call before the
+ * normal launch bundle resolution for first-install native-only provisioning.
+ */
++ (void)configure:(NSDictionary<NSString *, id> * _Nonnull)options
+       completion:(RCTPushyNativeConfigurationCompletion _Nullable)completion
+    NS_SWIFT_NAME(configure(_:completion:));
+
+/**
+ * Start, join, or reuse this process's native update round. Call after the
+ * host's real bundleURL resolution; this method never resolves the bundle
+ * again, reloads React Native, or displays UI. Configuration is the one
+ * persisted by the JS SDK. The optional completion runs on the main queue.
+ *
+ * Result keys: status (skipped/noUpdate/downloaded/failed/cancelled), reason,
+ * hash (empty when nothing was installed), activated (selected for NEXT
+ * launch, not a reload of the running instance).
+ */
++ (void)checkAndUpdateWithCompletion:(RCTPushyNativeUpdateCompletion _Nullable)completion
+    NS_SWIFT_NAME(checkAndUpdate(completion:));
+
 @end