react-native-update 10.37.15 → 10.37.16

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

@@ -1,50 +1,135 @@
 import preferences from '@ohos.data.preferences';
 import bundleManager from '@ohos.bundle.bundleManager';
 import fileIo from '@ohos.file.fs';
-import { DownloadTask } from './DownloadTask';
 import common from '@ohos.app.ability.common';
+import { util } from '@kit.ArkTS';
+import { DownloadTask } from './DownloadTask';
 import { DownloadTaskParams } from './DownloadTaskParams';
 
+type LaunchMarks = {
+  isFirstTime: boolean;
+  rolledBackVersion: string;
+};
+
 export class UpdateContext {
+  private static instances: Map<string, UpdateContext> = new Map();
+  private static isUsingBundleUrl: boolean = false;
+  private static ignoreRollbackInCurrentProcess: boolean = false;
+
+  static getInstance(context: common.UIAbilityContext): UpdateContext {
+    const key = context.filesDir;
+    const cached = UpdateContext.instances.get(key);
+    if (cached) {
+      return cached;
+    }
+
+    const instance = new UpdateContext(context);
+    UpdateContext.instances.set(key, instance);
+    return instance;
+  }
+
   private context: common.UIAbilityContext;
   private rootDir: string;
   private preferences: preferences.Preferences;
-  private static DEBUG: boolean = false;
-  private static isUsingBundleUrl: boolean = false;
 
-  constructor(context: common.UIAbilityContext) {
+  private constructor(context: common.UIAbilityContext) {
     this.context = context;
-    this.rootDir = context.filesDir + '/_update';
+    this.rootDir = `${context.filesDir}/_update`;
+    this.ensureRootDir();
+    this.initPreferences();
+  }
 
+  private ensureRootDir(): void {
     try {
       if (!fileIo.accessSync(this.rootDir)) {
         fileIo.mkdirSync(this.rootDir);
       }
-    } catch (e) {
-      console.error('Failed to create root directory:', e);
+    } catch (error) {
+      console.error('Failed to create root directory:', error);
     }
-    this.initPreferences();
   }
 
-  private initPreferences() {
+  private initPreferences(): void {
     try {
       this.preferences = preferences.getPreferencesSync(this.context, {
         name: 'update',
       });
+
       const packageVersion = this.getPackageVersion();
-      const storedVersion = this.preferences.getSync('packageVersion', '');
-      if (!storedVersion) {
-        this.preferences.putSync('packageVersion', packageVersion);
-        this.preferences.flush();
-      } else if (storedVersion && packageVersion !== storedVersion) {
-        this.cleanUp();
+      const buildTime = this.getBuildTime();
+      const storedPackageVersion = this.getStringPreference('packageVersion');
+      const storedBuildTime = this.getStringPreference('buildTime');
+      const packageVersionChanged =
+        !!storedPackageVersion && packageVersion !== storedPackageVersion;
+      const buildTimeChanged =
+        !!storedBuildTime && buildTime !== storedBuildTime;
+
+      if (packageVersionChanged || buildTimeChanged) {
+        this.scheduleCleanUp();
         this.preferences.clear();
+        UpdateContext.ignoreRollbackInCurrentProcess = false;
+      }
+
+      let shouldFlush = packageVersionChanged || buildTimeChanged;
+      if (this.getStringPreference('packageVersion') !== packageVersion) {
         this.preferences.putSync('packageVersion', packageVersion);
+        shouldFlush = true;
+      }
+      if (this.getStringPreference('buildTime') !== buildTime) {
+        this.preferences.putSync('buildTime', buildTime);
+        shouldFlush = true;
+      }
+
+      if (shouldFlush) {
         this.preferences.flush();
       }
-    } catch (e) {
-      console.error('Failed to init preferences:', e);
+    } catch (error) {
+      console.error('Failed to init preferences:', error);
+    }
+  }
+
+  private getStringPreference(key: string, fallback: string = ''): string {
+    const value = this.preferences.getSync(key, fallback);
+    if (typeof value === 'string') {
+      return value;
+    }
+    if (value === null || value === undefined) {
+      return fallback;
+    }
+    return String(value);
+  }
+
+  private getBooleanPreference(
+    key: string,
+    fallback: boolean = false,
+  ): boolean {
+    const value = this.preferences.getSync(key, fallback);
+    if (typeof value === 'boolean') {
+      return value;
+    }
+    if (typeof value === 'string') {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === 'true') {
+        return true;
+      }
+      if (normalized === 'false' || normalized === '') {
+        return false;
+      }
     }
+    if (typeof value === 'number') {
+      return value !== 0;
+    }
+    return fallback;
+  }
+
+  private scheduleCleanUp(): void {
+    void this.cleanUp().catch(error => {
+      console.error('Failed to clean up updates:', error);
+    });
+  }
+
+  public getRootDir(): string {
+    return this.rootDir;
   }
 
   public setKv(key: string, value: string): void {
@@ -53,40 +138,62 @@ export class UpdateContext {
   }
 
   public getKv(key: string): string {
-    return this.preferences.getSync(key, '') as string;
+    return this.getStringPreference(key);
   }
 
   public isFirstTime(): boolean {
-    return this.preferences.getSync('firstTime', false) as boolean;
+    return this.getBooleanPreference('firstTime', false);
   }
 
   public rolledBackVersion(): string {
-    return this.preferences.getSync('rolledBackVersion', '') as string;
+    return this.getStringPreference('rolledBackVersion');
+  }
+
+  public consumeLaunchMarks(): LaunchMarks {
+    const marks = {
+      isFirstTime: this.getBooleanPreference('firstTimeMarked', false),
+      rolledBackVersion: this.rolledBackVersion(),
+    };
+
+    if (marks.isFirstTime) {
+      this.preferences.deleteSync('firstTimeMarked');
+    }
+    if (marks.rolledBackVersion) {
+      this.preferences.deleteSync('rolledBackVersion');
+    }
+    if (marks.isFirstTime || marks.rolledBackVersion) {
+      this.preferences.flush();
+      this.scheduleCleanUp();
+    }
+
+    return marks;
   }
 
   public markSuccess(): void {
     this.preferences.putSync('firstTimeOk', true);
-    const lastVersion = this.preferences.getSync('lastVersion', '') as string;
-    const curVersion = this.preferences.getSync('currentVersion', '') as string;
+    const lastVersion = this.getStringPreference('lastVersion');
+    const currentVersion = this.getStringPreference('currentVersion');
 
-    if (lastVersion && lastVersion !== curVersion) {
+    if (lastVersion && lastVersion !== currentVersion) {
       this.preferences.deleteSync('lastVersion');
       this.preferences.deleteSync(`hash_${lastVersion}`);
     }
+
     this.preferences.flush();
-    this.cleanUp();
+    this.scheduleCleanUp();
   }
 
   public clearFirstTime(): void {
     this.preferences.putSync('firstTime', false);
+    this.preferences.deleteSync('firstTimeMarked');
     this.preferences.flush();
-    this.cleanUp();
+    this.scheduleCleanUp();
   }
 
   public clearRollbackMark(): void {
-    this.preferences.putSync('rolledBackVersion', null);
+    this.preferences.deleteSync('rolledBackVersion');
     this.preferences.flush();
-    this.cleanUp();
+    this.scheduleCleanUp();
   }
 
   public async downloadFullUpdate(url: string, hash: string): Promise<void> {
@@ -99,9 +206,9 @@ export class UpdateContext {
       params.unzipDirectory = `${this.rootDir}/${hash}`;
       const downloadTask = new DownloadTask(this.context);
       await downloadTask.execute(params);
-    } catch (e) {
-      console.error('Failed to download full update:', e);
-      throw e;
+    } catch (error) {
+      console.error('Failed to download full update:', error);
+      throw error;
     }
   }
 
@@ -114,7 +221,7 @@ export class UpdateContext {
     params.type = DownloadTaskParams.TASK_TYPE_PLAIN_DOWNLOAD;
     params.url = url;
     params.hash = hash;
-    params.targetFile = this.rootDir + '/' + fileName;
+    params.targetFile = `${this.rootDir}/${fileName}`;
 
     const downloadTask = new DownloadTask(this.context);
     await downloadTask.execute(params);
@@ -151,10 +258,10 @@ export class UpdateContext {
       params.unzipDirectory = `${this.rootDir}/${hash}`;
 
       const downloadTask = new DownloadTask(this.context);
-      return await downloadTask.execute(params);
-    } catch (e) {
-      console.error('Failed to download package patch:', e);
-      throw e;
+      await downloadTask.execute(params);
+    } catch (error) {
+      console.error('Failed to download package patch:', error);
+      throw error;
     }
   }
 
@@ -165,33 +272,47 @@ export class UpdateContext {
         throw Error(`Bundle version ${hash} not found.`);
       }
 
-      const lastVersion = this.getKv('currentVersion');
-      this.setKv('currentVersion', hash);
+      const lastVersion = this.getCurrentVersion();
+      this.preferences.putSync('currentVersion', hash);
       if (lastVersion && lastVersion !== hash) {
-        this.setKv('lastVersion', lastVersion);
+        this.preferences.putSync('lastVersion', lastVersion);
+      } else {
+        this.preferences.deleteSync('lastVersion');
       }
-
-      this.setKv('firstTime', 'true');
-      this.setKv('firstTimeOk', 'false');
-      this.setKv('rolledBackVersion', '');
-    } catch (e) {
-      console.error('Failed to switch version:', e);
-      throw e;
+      this.preferences.putSync('firstTime', true);
+      this.preferences.putSync('firstTimeOk', false);
+      this.preferences.deleteSync('firstTimeMarked');
+      this.preferences.deleteSync('rolledBackVersion');
+      this.preferences.flush();
+      UpdateContext.ignoreRollbackInCurrentProcess = false;
+    } catch (error) {
+      console.error('Failed to switch version:', error);
+      throw error;
     }
   }
 
-  public getBundleUrl() {
+  public getBundleUrl(): string {
     UpdateContext.isUsingBundleUrl = true;
-    const currentVersion = this.getCurrentVersion();
-    if (!currentVersion) {
+    let version = this.getCurrentVersion();
+    if (!version) {
       return '';
     }
-    if (!this.isFirstTime()) {
-      if (!this.preferences.getSync('firstTimeOk', true)) {
-        return this.rollBack();
-      }
+
+    const isFirstTime = this.isFirstTime();
+    const isFirstTimeOk = this.getBooleanPreference('firstTimeOk', true);
+    if (
+      !UpdateContext.ignoreRollbackInCurrentProcess &&
+      !isFirstTime &&
+      !isFirstTimeOk
+    ) {
+      version = this.rollBack();
+    } else if (isFirstTime && !UpdateContext.ignoreRollbackInCurrentProcess) {
+      UpdateContext.ignoreRollbackInCurrentProcess = true;
+      this.preferences.putSync('firstTime', false);
+      this.preferences.putSync('firstTimeMarked', true);
+      this.preferences.flush();
     }
-    let version = currentVersion;
+
     while (version) {
       const bundleFile = `${this.rootDir}/${version}/bundle.harmony.js`;
       try {
@@ -201,38 +322,52 @@ export class UpdateContext {
           continue;
         }
         return bundleFile;
-      } catch (e) {
-        console.error('Failed to access bundle file:', e);
+      } catch (error) {
+        console.error('Failed to access bundle file:', error);
         version = this.rollBack();
       }
     }
+
     return '';
   }
 
-  getPackageVersion(): string {
-    let bundleFlags =
-      bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
+  public getPackageVersion(): string {
     let packageVersion = '';
     try {
-      const bundleInfo = bundleManager.getBundleInfoForSelfSync(bundleFlags);
+      const bundleInfo = bundleManager.getBundleInfoForSelfSync(
+        bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION,
+      );
       packageVersion = bundleInfo?.versionName || 'Unknown';
     } catch (error) {
-      console.error('获取包信息失败:', error);
+      console.error('Failed to get bundle info:', error);
     }
     return packageVersion;
   }
 
+  public getBuildTime(): string {
+    try {
+      const content =
+        this.context.resourceManager.getRawFileContentSync('meta.json');
+      const metaData = JSON.parse(
+        new util.TextDecoder().decodeToString(content),
+      ) as {
+        pushy_build_time?: string | number;
+      };
+      if (metaData.pushy_build_time !== undefined) {
+        return String(metaData.pushy_build_time);
+      }
+    } catch {}
+    return '';
+  }
+
   public getCurrentVersion(): string {
-    const currentVersion = this.getKv('currentVersion');
-    return currentVersion;
+    return this.getStringPreference('currentVersion');
   }
 
   private rollBack(): string {
-    const lastVersion = this.preferences.getSync('lastVersion', '') as string;
-    const currentVersion = this.preferences.getSync(
-      'currentVersion',
-      '',
-    ) as string;
+    const lastVersion = this.getStringPreference('lastVersion');
+    const currentVersion = this.getCurrentVersion();
+
     if (!lastVersion) {
       this.preferences.deleteSync('currentVersion');
     } else {
@@ -241,16 +376,17 @@ export class UpdateContext {
     }
     this.preferences.putSync('firstTimeOk', true);
     this.preferences.putSync('firstTime', false);
+    this.preferences.deleteSync('firstTimeMarked');
     this.preferences.putSync('rolledBackVersion', currentVersion);
     this.preferences.flush();
     return lastVersion;
   }
 
-  public async cleanUp() {
+  public async cleanUp(): Promise<void> {
     const params = new DownloadTaskParams();
     params.type = DownloadTaskParams.TASK_TYPE_CLEANUP;
-    params.hash = this.preferences.getSync('currentVersion', '') as string;
-    params.originHash = this.preferences.getSync('lastVersion', '') as string;
+    params.hash = this.getCurrentVersion();
+    params.originHash = this.getStringPreference('lastVersion');
     params.unzipDirectory = this.rootDir;
     const downloadTask = new DownloadTask(this.context);
     await downloadTask.execute(params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update",
-  "version": "10.37.15",
+  "version": "10.37.16",
   "description": "react-native hot update",
   "main": "src/index",
   "scripts": {
@@ -10,6 +10,7 @@
     "lint": "eslint \"src/*.@(ts|tsx|js|jsx)\" && tsc --noEmit",
     "submodule": "git submodule update --init --recursive",
     "test": "echo \"Error: no test specified\" && exit 1",
+    "build:harmony-har": "node scripts/build-harmony-har.js",
     "build:so": "bun submodule && $ANDROID_HOME/ndk/28.2.13676358/ndk-build NDK_PROJECT_PATH=android APP_BUILD_SCRIPT=android/jni/Android.mk NDK_APPLICATION_MK=android/jni/Application.mk NDK_LIBS_OUT=android/lib",
     "build:ios-debug": "cd Example/testHotUpdate && bun && detox build --configuration ios.sim.debug",
     "build:ios-release": "cd Example/testHotUpdate && bun && detox build --configuration ios.sim.release",