react-native-update 10.59.2 → 10.60.0

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

@@ -1,8 +1,9 @@
 import preferences from '@ohos.data.preferences';
 import fileIo from '@ohos.file.fs';
 import {
+  HARMONY_BUNDLE_FILE_NAME,
   isInstallComplete,
-  readInstallRecord,
+  recordedBundleSha256,
   verifyInstallForActivation,
 } from './InstallRecord';
 import { DownloadTask } from './DownloadTask';
@@ -18,7 +19,6 @@ import {
   scheduleNativeSync,
 } from './SyncCoordinator';
 import NativePatchCore, {
-  STATE_OP_CLEAR_FIRST_TIME,
   STATE_OP_CLEAR_ROLLBACK_MARK,
   STATE_OP_MARK_SUCCESS,
   STATE_OP_RESOLVE_LAUNCH,
@@ -27,9 +27,9 @@ import NativePatchCore, {
   StateCoreResult,
 } from './NativePatchCore';
 import { assertSafePathComponent } from './PathUtils';
+import { withRawFd } from './SaveFile';
 import {
   ERROR_SWITCH_VERSION_FAILED,
-  createPushyError,
   getErrorMessage,
   toPushyError,
 } from './ErrorCodes';
@@ -41,11 +41,18 @@ const TAG = 'PushyContext';
 // 常规清理保留最近 3 天内触碰过的条目(续传 partial、staging 同样按 mtime)。
 const CLEANUP_MAX_AGE_DAYS = 3;
 
-// Preferences.flushSync 是 API 14 才有、getAllSync 老 SDK 声明里没有:HAR 兼容
-// API 12,按结构化视图探测(不用交叉类型——ArkTS 不支持)。
+// Preferences.flushSync 是 API 14 才有:HAR 兼容 API 12,按结构化视图探测
+// (不用交叉类型——ArkTS 不支持)。
 interface OptionalPreferencesApi {
   flushSync?: () => void;
-  getAllSync?: () => Record<string, unknown>;
+}
+
+// C1 配置等价(cpp/update_flow_core ConfigsEquivalent,与 Android/iOS 共用):
+// 缺省键补默认值、端点/发现地址去尾斜杠并保序去重、忽略键序。等价的配置不算
+// "变更"——宿主重复 configure、或 JS 同步一份只差格式的同一配置,都不应取消
+// 在飞轮次或丢弃响应缓存。任一缺省即不等价。
+function nativeConfigsEquivalent(a: string | undefined, b: string | undefined): boolean {
+  return NativePatchCore.configsEquivalent(a, b);
 }
 
 interface PersistOptions {
@@ -320,7 +327,7 @@ export class UpdateContext {
   }
 
   private getBundlePath(hash: string): string {
-    return `${this.rootDir}/${hash}/bundle.harmony.js`;
+    return `${this.rootDir}/${hash}/${HARMONY_BUNDLE_FILE_NAME}`;
   }
 
   private getStateSnapshot(): StateCoreResult {
@@ -415,13 +422,9 @@ export class UpdateContext {
 
   private async executeTask(params: DownloadTaskParams): Promise<void> {
     await this.enqueueSerialTask(() => {
-      const isPatchTask =
-        params.type === DownloadTaskParams.TASK_TYPE_PATCH_FULL ||
-        params.type === DownloadTaskParams.TASK_TYPE_PATCH_FROM_APP ||
-        params.type === DownloadTaskParams.TASK_TYPE_PATCH_FROM_PPK;
       // Re-check only when this queued job actually starts. A JS download may
       // have completed while the cold-start duplicate waited behind it.
-      if (isPatchTask && this.hasDownloadedVersion(params.hash)) {
+      if (this.hasDownloadedVersion(params.hash)) {
         return Promise.resolve();
       }
       const downloadTask = new DownloadTask(this.context);
@@ -460,19 +463,29 @@ export class UpdateContext {
     this.flushInBackground('sync binary version');
   }
 
-  /** 写入并落盘;flushSync 不可用时以 flush() 的结果拒绝。 */
-  /** Shared JS/native configuration writer; all mutations precede the first await. */
   private static nativeConfigGeneration: number = 0;
 
   public getNativeConfigGeneration(): number {
     return UpdateContext.nativeConfigGeneration;
   }
 
+  /** 与持久化的配置是否等价(C1)。 */
+  public isStoredNativeConfig(config: string | undefined): boolean {
+    return nativeConfigsEquivalent(config, this.getKv(KEY_CONFIG));
+  }
+
+  /**
+   * Shared JS/native configuration writer; all mutations precede the first
+   * await. An equivalent configuration (C1) is not a change: the stored string,
+   * response cache and generations stay as they are.
+   */
   public setNativeConfig(config: string): Promise<void> {
     if (!this.getKv('uuid')) {
       this.preferences.putSync('uuid', util.generateRandomUUID());
     }
-    if (this.getKv(KEY_CONFIG) !== config) {
+    const current = this.getKv(KEY_CONFIG);
+    // Byte-identical is trivially no change, even for a value C1 cannot parse.
+    if (!current || (current !== config && !nativeConfigsEquivalent(current, config))) {
       // Also guards A -> B -> A replacements and late download commits.
       UpdateContext.resetGeneration += 1;
       UpdateContext.nativeConfigGeneration += 1;
@@ -484,6 +497,7 @@ export class UpdateContext {
     return this.flushPreferences('persist configuration');
   }
 
+  /** 写入并落盘;flushSync 不可用时以 flush() 的结果拒绝。 */
   public setKv(key: string, value: string): Promise<void> {
     this.preferences.putSync(key, value);
     return this.flushPreferences(`set key ${key}`);
@@ -498,10 +512,6 @@ export class UpdateContext {
     return this.flushPreferences(`remove key ${key}`);
   }
 
-  public isFirstTime(): boolean {
-    return this.getStateSnapshot().firstTime;
-  }
-
   public rolledBackVersion(): string {
     return this.getStateSnapshot().rolledBackVersion || '';
   }
@@ -518,14 +528,6 @@ export class UpdateContext {
     await this.flushPreferences('mark success');
   }
 
-  public async clearFirstTime(): Promise<void> {
-    this.runStateOperation(STATE_OP_CLEAR_FIRST_TIME, '', {
-      cleanUp: true,
-      clearFirstLoadMarker: true,
-    });
-    await this.flushPreferences('clear first time');
-  }
-
   /** getConstants(同步)里调用:落盘失败只记日志。 */
   public clearRollbackMark(): void {
     this.runStateOperation(STATE_OP_CLEAR_ROLLBACK_MARK, '', {
@@ -561,23 +563,20 @@ export class UpdateContext {
     let flushed: Promise<void> = Promise.resolve();
     try {
       // 删除已下载版本的 hash_* 元信息（不走 clear()：它是异步的，且会连带清掉
-      // uuid —— 见 syncStateWithBinaryVersion 的注释）。getAllSync 在旧 SDK 上
-      // 可能不存在，此时残留的 hash_* 只是无害孤儿数据，不影响 reset 语义。
-      const api = this.optionalPreferencesApi();
-      if (typeof api.getAllSync === 'function') {
-        try {
-          const all = api.getAllSync();
-          for (const key of Object.keys(all)) {
-            if (key.startsWith('hash_')) {
-              this.preferences.deleteSync(key);
-            }
+      // uuid —— 见 syncStateWithBinaryVersion 的注释）。读取失败时残留的
+      // hash_* 只是无害孤儿数据，不影响 reset 语义。
+      try {
+        const all = this.preferences.getAllSync();
+        for (const key of Object.keys(all)) {
+          if (key.startsWith('hash_')) {
+            this.preferences.deleteSync(key);
           }
-        } catch (e) {
-          logger.error(
-            TAG,
-            `Failed to clear hash info on reset: ${getErrorMessage(e)}`,
-          );
         }
+      } catch (e) {
+        logger.error(
+          TAG,
+          `Failed to clear hash info on reset: ${getErrorMessage(e)}`,
+        );
       }
       this.writeState(resetState, { clearFirstLoadMarker: true });
       // 缓存里的响应仍在宣告本次 reset 刚删掉的版本,一并丢弃,避免 JS 侧复用。
@@ -658,20 +657,15 @@ export class UpdateContext {
     hash: string,
     deadlineUptimeMs: number = 0,
   ): Promise<void> {
-    try {
-      const params = this.createTaskParams(
-        DownloadTaskParams.TASK_TYPE_PATCH_FULL,
-        url,
-        hash,
-      );
-      params.targetFile = `${this.rootDir}/${hash}.ppk`;
-      params.unzipDirectory = `${this.rootDir}/${hash}`;
-      params.deadlineUptimeMs = deadlineUptimeMs;
-      await this.executeTask(params);
-    } catch (e) {
-      logger.error(TAG, `Failed to download full package: ${getErrorMessage(e)}`);
-      throw e;
-    }
+    const params = this.createTaskParams(
+      DownloadTaskParams.TASK_TYPE_PATCH_FULL,
+      url,
+      hash,
+    );
+    params.targetFile = `${this.rootDir}/${hash}.ppk`;
+    params.unzipDirectory = `${this.rootDir}/${hash}`;
+    params.deadlineUptimeMs = deadlineUptimeMs;
+    await this.executeTask(params);
   }
 
   public async downloadPatchFromPpk(
@@ -698,23 +692,15 @@ export class UpdateContext {
     hash: string,
     deadlineUptimeMs: number = 0,
   ): Promise<void> {
-    try {
-      const params = this.createTaskParams(
-        DownloadTaskParams.TASK_TYPE_PATCH_FROM_APP,
-        url,
-        hash,
-      );
-      params.targetFile = `${this.rootDir}/${hash}${APP_DELTA_SUFFIX}`;
-      params.unzipDirectory = `${this.rootDir}/${hash}`;
-      params.deadlineUptimeMs = deadlineUptimeMs;
-      return await this.executeTask(params);
-    } catch (e) {
-      logger.error(
-        TAG,
-        `Failed to download package delta: ${getErrorMessage(e)}`,
-      );
-      throw e;
-    }
+    const params = this.createTaskParams(
+      DownloadTaskParams.TASK_TYPE_PATCH_FROM_APP,
+      url,
+      hash,
+    );
+    params.targetFile = `${this.rootDir}/${hash}${APP_DELTA_SUFFIX}`;
+    params.unzipDirectory = `${this.rootDir}/${hash}`;
+    params.deadlineUptimeMs = deadlineUptimeMs;
+    await this.executeTask(params);
   }
 
   // 运行中热更版本安装记录里的 bundleSha256(崩溃归因用);内置 bundle /
@@ -724,10 +710,9 @@ export class UpdateContext {
       return '';
     }
     try {
-      const record = readInstallRecord(
+      return recordedBundleSha256(
         `${this.rootDir}/${assertSafePathComponent(hash)}`,
       );
-      return record?.bundleSha256 ?? '';
     } catch (e) {
       return '';
     }
@@ -738,51 +723,26 @@ export class UpdateContext {
   public hasDownloadedVersion(hash: string): boolean {
     try {
       const safeHash = assertSafePathComponent(hash);
-      return fileIo.accessSync(this.getBundlePath(safeHash))
-        && isInstallComplete(`${this.rootDir}/${safeHash}`, safeHash);
+      return isInstallComplete(`${this.rootDir}/${safeHash}`, safeHash);
     } catch (e) {
       return false;
     }
   }
 
   /**
-   * 激活前置校验(同步,不写任何东西):bundle 在盘上,且要么是本 SDK 记录为
-   * 完整安装的版本(bundle + 记录),要么是标记机制之前就激活过的历史版本
-   * (current/last 里有它)。其他无记录的目录可能是崩溃留下的半成品。
-   * 返回是否还需复核安装记录里的 bundle 摘要(历史版本无记录可核)。
-   */
-  private assertActivatable(safeHash: string): boolean {
-    if (!fileIo.accessSync(this.getBundlePath(safeHash))) {
-      throw createPushyError(
-        ERROR_SWITCH_VERSION_FAILED,
-        `Bundle version ${safeHash} not found.`,
-      );
-    }
-    const legacyActivated =
-      this.readString('currentVersion') === safeHash ||
-      this.readString('lastVersion') === safeHash;
-    if (!this.hasDownloadedVersion(safeHash) && !legacyActivated) {
-      throw createPushyError(
-        ERROR_SWITCH_VERSION_FAILED,
-        `Bundle version ${safeHash} is incomplete.`,
-      );
-    }
-    return !legacyActivated;
-  }
-
-  /**
-   * 完整的激活校验(含 native 工作线程上的 bundle 摘要复核),不写状态。
-   * 记录里的 bundle 摘要必须与盘上字节一致,才能把下次启动指向它。
+   * 完整的激活校验(含 native 工作线程上的 bundle 摘要复核),不写状态:
+   * bundle 在盘上,且记录里的 bundle 摘要与盘上字节一致,才能把下次启动指向
+   * 它。标记机制之前就激活过、目录里没有记录文件的历史版本(current/last
+   * 里有它)免检;有记录文件的目录即便是 current/last 也照常复核。
    */
   public async verifyActivation(hash: string): Promise<void> {
     const safeHash = assertSafePathComponent(hash);
-    if (this.assertActivatable(safeHash)) {
-      await verifyInstallForActivation(
-        `${this.rootDir}/${safeHash}`,
-        safeHash,
-        this.getBundlePath(safeHash),
-      );
-    }
+    await verifyInstallForActivation(
+      `${this.rootDir}/${safeHash}`,
+      safeHash,
+      this.readString('currentVersion') === safeHash ||
+        this.readString('lastVersion') === safeHash,
+    );
   }
 
   /** 内存里切换状态(不落盘);调用方负责 flush。 */
@@ -952,29 +912,56 @@ export class UpdateContext {
     }
   }
 
+  // 进行中的摘要计算:JS getBundleHash 与原生轮次可能同时要它,共用一次。
+  private bundleHashTask: Promise<string> | null = null;
+
   /**
    * bundleHash = 二进制内嵌 JS bundle 的 sha256 —— 标识二进制本身,与当前运行
    * 的热更版本无关。哈希对象与 pdiff 的源读取完全一致:rawfile 的
    * bundle.harmony.js(DownloadTask.doPatchFromApp 同一读法)。懒计算 + 缓存;
    * 永不失败——空串表示"未知",服务端回退 buildTime 启发式。
    */
-  public async getBundleHash(): Promise<string> {
+  public getBundleHash(): Promise<string> {
     if (UpdateContext.DEBUG) {
       // debug 下 bundle 由 metro 提供,与 dev 删 buildTime 的行为对齐。
-      return '';
+      return Promise.resolve('');
     }
     const cachePrefix = `${this.getPackageVersion()}|${this.getBundleModifiedTime()}|`;
     const cached = this.readString(UpdateContext.KEY_BUNDLE_HASH_CACHE);
     if (cached.startsWith(cachePrefix)) {
-      return cached.slice(cachePrefix.length);
+      return Promise.resolve(cached.slice(cachePrefix.length));
+    }
+    if (!this.bundleHashTask) {
+      const task = this.computeBundleHash(cachePrefix);
+      this.bundleHashTask = task;
+      task.then(
+        () => {
+          this.bundleHashTask = null;
+        },
+        () => {
+          this.bundleHashTask = null;
+        },
+      );
     }
+    return this.bundleHashTask;
+  }
+
+  private async computeBundleHash(cachePrefix: string): Promise<string> {
     let hash = '';
     try {
-      // 异步读:TurboModule 跑在 UI 线程,同步读几 MB 会卡主线程一次。C++
-      // 哈希本身毫秒级,同步无妨。
-      const content =
-        await this.context.resourceManager.getRawFileContent('bundle.harmony.js');
-      hash = NativePatchCore.sha256Hex(content);
+      // 内嵌 bundle 有几 MB:不读进内存,也不在 UI 线程(TurboModule 所在)
+      // 哈希——native 工作线程按 rawfile descriptor 的区间 pread 流式计算。
+      // fd 在 promise 落定后才关闭(withRawFd)。
+      hash = await withRawFd(
+        this.context.resourceManager,
+        HARMONY_BUNDLE_FILE_NAME,
+        descriptor =>
+          NativePatchCore.sha256HexRawFdAsync(
+            descriptor.fd,
+            descriptor.offset,
+            descriptor.length,
+          ),
+      );
     } catch (error) {
       // rawfile 缺 bundle(未打包 release bundle)是合法的"未知",不是错误。
       logger.info(TAG, `Cannot hash embedded bundle: ${getErrorMessage(error)}`);

package/ios/RCTPushy/RCTPushy+Launch.mm

@@ -0,0 +1,185 @@
+// Launch bundle resolution and the identity of the running binary: which
+// bundle this launch loads, where downloaded versions live, and the
+// packageVersion/buildTime pair that detects a rebuilt binary.
+#import "RCTPushyInternal.h"
+
+// The version whose bundle this process actually loaded (resolved in
+// +bundleURL). resetToPackagedBundle must not delete its directory: update
+// assets (images/fonts) are read from it on demand at runtime, so wiping it
+// under a silent (no-restart) reset would break every image the running app
+// has not loaded yet. Guarded by the state lock.
+PUSHY_HIDDEN NSString *pushyLaunchVersion = nil;
+
+#if !DEBUG
+static NSString *PushyReadBuildTime(void) {
+    // The podspec's s.resource lands in the app bundle for a static
+    // library but inside this pod's own framework bundle under
+    // use_frameworks!; look in both.
+    NSString *stampPath =
+        [[NSBundle mainBundle] pathForResource:@"pushy_build_time" ofType:@"txt"]
+        ?: [[NSBundle bundleForClass:[RCTPushy class]] pathForResource:@"pushy_build_time"
+                                                               ofType:@"txt"];
+    NSString *stamp = stampPath == nil ? nil
+        : [[NSString stringWithContentsOfFile:stampPath encoding:NSUTF8StringEncoding error:nil]
+              stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
+    if (stamp.length == 0) {
+        // Never empty: with "" SyncBinaryVersion would miss a rebuilt
+        // binary that kept its CFBundleShortVersionString, and a stale
+        // hot update would outlive an App Store update. Every build
+        // rewrites Info.plist, so its mtime (integer seconds) stands in.
+        RCTLogWarn(@"RCTPushy -- pushy_build_time.txt %@; using the Info.plist mtime as buildTime",
+                   stampPath == nil ? @"not found in the main or framework bundle" : @"is empty");
+        NSString *infoPlist =
+            [[NSBundle mainBundle].bundlePath stringByAppendingPathComponent:@"Info.plist"];
+        NSDate *modified = [[NSFileManager defaultManager] attributesOfItemAtPath:infoPlist
+                                                                            error:nil].fileModificationDate;
+        stamp = [NSString stringWithFormat:@"%lld", (long long)[modified timeIntervalSince1970]];
+    }
+    return stamp;
+}
+#endif
+
+@implementation RCTPushy (Launch)
+
+// Resolves the bundle to launch from the persisted state; nil means the
+// packaged bundle. Consumes the launch's one-shot state (first_time), so a
+// second call is only valid after something re-armed it (a switchVersion).
+// purgedVersion is set on tvOS when the installed version's files are gone.
++ (NSURL *)resolveLaunchBundleURL:(NSString **)launchRolledBackVersionOut
+                    purgedVersion:(NSString **)purgedVersionOut
+{
+    __block NSURL *resolvedURL = nil;
+    __block NSString *launchRolledBackVersion = nil;
+    __block NSString *purgedVersion = nil;
+    @try {
+        PushyWithStateLock(^{
+            NSUserDefaults *defaults = PushyDefaults();
+
+            NSString *curPackageVersion = [RCTPushy packageVersion];
+            NSString *curBuildTime = [RCTPushy buildTime];
+
+            pushy::state::State state = PushyStateFromDefaults(defaults);
+            pushy::state::BinaryVersionSyncResult sync = pushy::state::SyncBinaryVersion(
+                state,
+                PushyToStdString(curPackageVersion),
+                PushyToStdString(curBuildTime)
+            );
+            if (sync.changed) {
+                [defaults setObject:@(YES) forKey:KeyPackageUpdatedMarked()];
+                state = sync.state;
+                PushyApplyStateToDefaults(defaults, state);
+            }
+
+            if (!state.current_version.empty()) {
+                std::string const versionBeforeLaunch = state.current_version;
+                pushy::state::LaunchDecision decision = pushy::state::ResolveLaunchState(
+                    state,
+                    ignoreRollback.load(),
+                    true
+                );
+                state = decision.state;
+
+                if (decision.did_rollback) {
+                    // The crash-protection rollback: the new version never called
+                    // markSuccess. Keep this visible in release logs.
+                    RCTLogWarn(@"RCTPushy -- version %@ was not marked as successful, rolled back to %@",
+                        PushyFromStdString(versionBeforeLaunch),
+                        PushyFromStdString(state.current_version));
+                }
+                if (decision.did_rollback || decision.consumed_first_time) {
+                    PushyApplyStateToDefaults(defaults, state);
+                }
+                if (decision.consumed_first_time) {
+                    // bundleURL may be called many times, ignore rollbacks before process restarted again.
+                    ignoreRollback = true;
+                    [defaults setObject:@(YES) forKey:keyFirstLoadMarked];
+                }
+
+                NSString *loadVersion = PushyFromStdString(decision.load_version);
+                // Guard the rollback chain against cycles: a corrupted state
+                // returning an already-visited version would otherwise spin this
+                // loop forever during startup (Android has the same guard).
+                NSMutableSet<NSString *> *visitedVersions = [NSMutableSet set];
+                while (loadVersion.length && ![visitedVersions containsObject:loadVersion]) {
+                    [visitedVersions addObject:loadVersion];
+                    NSString *bundlePath = [PushyVersionDir(loadVersion) stringByAppendingPathComponent:BUNDLE_FILE_NAME];
+                    if ([[NSFileManager defaultManager] fileExistsAtPath:bundlePath isDirectory:NULL]) {
+                        pushyLaunchVersion = loadVersion;
+                        resolvedURL = [NSURL fileURLWithPath:bundlePath];
+                        break;
+                    } else {
+#if TARGET_OS_TV
+                        // Caches is purgeable on tvOS: a missing bundle is the OS
+                        // reclaiming space, not a bad release. Everything under
+                        // rctpushy went with it, so walking back to last_version
+                        // is pointless, and a rollback mark would make this
+                        // launch's check refuse to reinstall the version.
+                        RCTLogWarn(@"RCTPushy -- bundle version %@ was purged by the system", loadVersion);
+                        purgedVersion = loadVersion;
+                        state = pushy::state::ForgetPurgedVersions(state);
+                        PushyApplyStateToDefaults(defaults, state);
+                        if (decision.consumed_first_time) {
+                            // The first load being consumed never happens: the
+                            // packaged bundle must not report isFirstTime.
+                            ignoreRollback = false;
+                            [defaults removeObjectForKey:keyFirstLoadMarked];
+                        }
+                        break;
+#else
+                        RCTLogError(@"RCTPushy -- bundle version %@ not found, rolling back", loadVersion);
+                        state = pushy::state::Rollback(state);
+                        PushyApplyStateToDefaults(defaults, state);
+                        loadVersion = PushyFromStdString(state.current_version);
+#endif
+                    }
+                }
+            }
+            // Capture before constantsToExport consumes this one-shot marker.
+            // The delayed native check must never forceBoot the version that this
+            // launch just rolled back.
+            launchRolledBackVersion = PushyFromStdString(state.rolled_back_version);
+        });
+    } @finally {
+        *launchRolledBackVersionOut = launchRolledBackVersion;
+        *purgedVersionOut = purgedVersion;
+    }
+    return resolvedURL;
+}
+
++ (NSString *)downloadDir
+{
+#if TARGET_OS_TV
+    // tvOS apps cannot write Application Support; Caches is the only
+    // writable, non-temporary location, and the system may purge it while
+    // the app is not running (see the purged-version path in +bundleURL).
+    NSSearchPathDirectory base = NSCachesDirectory;
+#else
+    NSSearchPathDirectory base = NSApplicationSupportDirectory;
+#endif
+    NSString *directory = [NSSearchPathForDirectoriesInDomains(base, NSUserDomainMask, YES) firstObject];
+    return [directory stringByAppendingPathComponent:@"rctpushy"];
+}
+
++ (NSURL *)binaryBundleURL
+{
+    return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+}
+
++ (NSString *)packageVersion
+{
+    static NSString *version =
+        [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleShortVersionString"];
+    return version;
+}
+
++ (NSString *)buildTime
+{
+#if DEBUG
+    return @"0";
+#else
+    static NSString *buildTime = PushyReadBuildTime();
+    return buildTime;
+#endif
+}
+
+@end

package/ios/RCTPushy/RCTPushy.h

@@ -26,8 +26,20 @@ typedef void (^RCTPushyBundlePreparationCompletion)(NSDictionary<NSString *, id>
  * 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).
+ *
+ * Waits at most 30 minutes for the round (longer than any round takes).
  */
 + (void)prepareBundleWithCompletion:(RCTPushyBundlePreparationCompletion _Nullable)completion
     NS_SWIFT_NAME(prepareBundle(completion:));
 
+/**
+ * Same as prepareBundleWithCompletion:, but the completion runs after at most
+ * `timeout` seconds. On expiry the result is status failed, reason timeout;
+ * the round keeps running in the background and its result still applies to
+ * the next launch.
+ */
++ (void)prepareBundleWithTimeout:(NSTimeInterval)timeout
+                      completion:(RCTPushyBundlePreparationCompletion _Nullable)completion
+    NS_SWIFT_NAME(prepareBundle(timeout:completion:));
+
 @end