react-native-update 10.38.3 → 10.38.4

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

@@ -0,0 +1,52 @@
+import hilog from '@ohos.hilog';
+
+class Logger {
+  private domain: number;
+  private prefix: string;
+  private format: string = '%{public}s,%{public}s';
+  private isDebug: boolean;
+
+  constructor(
+    prefix: string = 'MyApp',
+    domain: number = 0xff00,
+    isDebug = false,
+  ) {
+    this.prefix = prefix;
+    this.domain = domain;
+    this.isDebug = isDebug;
+  }
+
+  private normalizeArgs(args: string[]): [string, string] {
+    if (args.length === 0) {
+      return ['', ''];
+    }
+    if (args.length === 1) {
+      return [args[0], ''];
+    }
+    return [args[0], args.slice(1).join(' ')];
+  }
+
+  debug(...args: string[]): void {
+    if (this.isDebug) {
+      const [tag, message] = this.normalizeArgs(args);
+      hilog.debug(this.domain, this.prefix, this.format, tag, message);
+    }
+  }
+
+  info(...args: string[]): void {
+    const [tag, message] = this.normalizeArgs(args);
+    hilog.info(this.domain, this.prefix, this.format, tag, message);
+  }
+
+  warn(...args: string[]): void {
+    const [tag, message] = this.normalizeArgs(args);
+    hilog.warn(this.domain, this.prefix, this.format, tag, message);
+  }
+
+  error(...args: string[]): void {
+    const [tag, message] = this.normalizeArgs(args);
+    hilog.error(this.domain, this.prefix, this.format, tag, message);
+  }
+}
+
+export default new Logger('pushy', 0xff00, false);

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

@@ -0,0 +1,87 @@
+import NativeUpdateCore from 'librnupdate.so';
+
+export const STATE_OP_SWITCH_VERSION = 1;
+export const STATE_OP_MARK_SUCCESS = 2;
+export const STATE_OP_ROLLBACK = 3;
+export const STATE_OP_CLEAR_FIRST_TIME = 4;
+export const STATE_OP_CLEAR_ROLLBACK_MARK = 5;
+export const STATE_OP_RESOLVE_LAUNCH = 6;
+
+export const ARCHIVE_PATCH_TYPE_FULL = 1;
+export const ARCHIVE_PATCH_TYPE_FROM_PACKAGE = 2;
+export const ARCHIVE_PATCH_TYPE_FROM_PPK = 3;
+
+export interface StateCoreResult {
+  packageVersion?: string;
+  buildTime?: string;
+  currentVersion?: string;
+  lastVersion?: string;
+  firstTime: boolean;
+  firstTimeOk: boolean;
+  rolledBackVersion?: string;
+  changed?: boolean;
+  staleVersionToDelete?: string;
+  loadVersion?: string;
+  didRollback?: boolean;
+  consumedFirstTime?: boolean;
+}
+
+export interface ArchivePatchPlanResult {
+  mergeSourceSubdir?: string;
+  enableMerge: boolean;
+}
+
+export interface CopyGroupResult {
+  from: string;
+  toPaths: string[];
+}
+
+export interface FileSourcePatchRequest {
+  copyFroms: string[];
+  copyTos: string[];
+  deletes: string[];
+  sourceRoot: string;
+  targetRoot: string;
+  originBundlePath: string;
+  bundlePatchPath: string;
+  bundleOutputPath: string;
+  mergeSourceSubdir?: string;
+  enableMerge?: boolean;
+}
+
+interface NativePatchCoreBindings {
+  hdiffPatch(
+    origin: Uint8Array,
+    patch: Uint8Array,
+  ): ArrayBuffer | Uint8Array;
+  syncStateWithBinaryVersion(
+    packageVersion: string,
+    buildTime: string,
+    state: StateCoreResult,
+  ): StateCoreResult;
+  runStateCore(
+    operation: number,
+    state: StateCoreResult,
+    stringArg?: string,
+    flagA?: boolean,
+    flagB?: boolean,
+  ): StateCoreResult;
+  buildArchivePatchPlan(
+    patchType: number,
+    entryNames: string[],
+    copyFroms: string[],
+    copyTos: string[],
+    deletes: string[],
+    bundlePatchEntryName?: string,
+  ): ArchivePatchPlanResult;
+  buildCopyGroups(copyFroms: string[], copyTos: string[]): CopyGroupResult[];
+  applyPatchFromFileSource(options: FileSourcePatchRequest): void;
+  cleanupOldEntries(
+    rootDir: string,
+    keepCurrent: string,
+    keepPrevious: string,
+    maxAgeDays: number,
+  ): void;
+}
+
+export default NativeUpdateCore as unknown as NativePatchCoreBindings;

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

@@ -0,0 +1,50 @@
+import {
+  FileJSBundle,
+  JSBundleProvider,
+  JSBundleProviderError,
+} from '@rnoh/react-native-openharmony';
+import common from '@ohos.app.ability.common';
+import fs from '@ohos.file.fs';
+import { UpdateContext } from './UpdateContext';
+
+export class PushyFileJSBundleProvider extends JSBundleProvider {
+  private updateContext: UpdateContext;
+  private path: string = '';
+
+  constructor(context: common.UIAbilityContext) {
+    super();
+    this.updateContext = new UpdateContext(context);
+    this.path = this.updateContext.getBundleUrl();
+  }
+
+  getURL(): string {
+    return this.path;
+  }
+
+  async getBundle(): Promise<FileJSBundle> {
+    if (!this.path) {
+      throw new JSBundleProviderError({
+        whatHappened: 'No pushy bundle found. using default bundle',
+        howCanItBeFixed: [''],
+      });
+    }
+    try {
+      await fs.access(this.path, fs.OpenMode.READ_ONLY);
+      return {
+        filePath: this.path,
+      };
+    } catch (error) {
+      throw new JSBundleProviderError({
+        whatHappened: `Couldn't load JSBundle from ${this.path}`,
+        extraData: error,
+        howCanItBeFixed: [
+          `Check if a bundle exists at "${this.path}" on your device.`,
+        ],
+      });
+    }
+  }
+
+  getAppKeys(): string[] {
+    return [];
+  }
+}

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

@@ -0,0 +1,22 @@
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { PushyTurboModule } from './PushyTurboModule';
+
+class PushyTurboModulesFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (name === 'Pushy') {
+      return new PushyTurboModule(this.ctx);
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === 'Pushy';
+  }
+}
+
+export class PushyPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new PushyTurboModulesFactory(ctx);
+  }
+}

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

@@ -0,0 +1,139 @@
+import {
+  TurboModule,
+  TurboModuleContext,
+} from '@rnoh/react-native-openharmony/ts';
+import common from '@ohos.app.ability.common';
+import { bundleManager } from '@kit.AbilityKit';
+import logger from './Logger';
+import { UpdateModuleImpl } from './UpdateModuleImpl';
+import { UpdateContext } from './UpdateContext';
+import { EventHub } from './EventHub';
+import { util } from '@kit.ArkTS';
+
+const TAG = 'PushyTurboModule';
+
+export class PushyTurboModule extends TurboModule {
+  mUiCtx: common.UIAbilityContext;
+  context: UpdateContext;
+
+  constructor(protected ctx: TurboModuleContext) {
+    super(ctx);
+    logger.debug(TAG, ',PushyTurboModule constructor');
+    this.mUiCtx = ctx.uiAbilityContext;
+    this.context = new UpdateContext(this.mUiCtx);
+    EventHub.getInstance().setRNInstance(ctx.rnInstance);
+  }
+
+  getConstants(): Object {
+    logger.debug(TAG, ',call getConstants');
+    const context = this.mUiCtx;
+    let bundleFlags =
+      bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_REQUESTED_PERMISSION;
+    let packageVersion = '';
+    try {
+      const bundleInfo = bundleManager.getBundleInfoForSelfSync(bundleFlags);
+      packageVersion = bundleInfo?.versionName || 'Unknown';
+    } catch (error) {
+      console.error('Failed to get bundle info:', error);
+    }
+    let buildTime = '';
+    try {
+      const resourceManager = this.mUiCtx.resourceManager;
+      const content = resourceManager.getRawFileContentSync('meta.json');
+      const metaData = JSON.parse(
+        new util.TextDecoder().decodeToString(content),
+      );
+      if (metaData.pushy_build_time) {
+        buildTime = String(metaData.pushy_build_time);
+      }
+    } catch {}
+    this.context.syncStateWithBinaryVersion(packageVersion, buildTime);
+
+    const currentVersion = this.context.getCurrentVersion();
+    const currentVersionInfo = currentVersion
+      ? this.context.getKv(`hash_${currentVersion}`)
+      : '';
+    const isFirstTime = this.context.isFirstTime();
+    const rolledBackVersion = this.context.rolledBackVersion();
+    const uuid = this.context.getKv('uuid');
+    const isUsingBundleUrl = this.context.getIsUsingBundleUrl();
+
+    if (rolledBackVersion) {
+      this.context.clearRollbackMark();
+    }
+
+    return {
+      downloadRootDir: `${context.filesDir}/_update`,
+      currentVersionInfo,
+      packageVersion,
+      currentVersion,
+      buildTime,
+      isUsingBundleUrl,
+      isFirstTime,
+      rolledBackVersion,
+      uuid,
+    };
+  }
+
+  setLocalHashInfo(hash: string, info: string): boolean {
+    logger.debug(TAG, ',call setLocalHashInfo');
+    return UpdateModuleImpl.setLocalHashInfo(this.context, hash, info);
+  }
+
+  getLocalHashInfo(hash: string): string {
+    return UpdateModuleImpl.getLocalHashInfo(this.context, hash);
+  }
+
+  async setUuid(uuid: string): Promise<void> {
+    logger.debug(TAG, ',call setUuid');
+    return UpdateModuleImpl.setUuid(this.context, uuid);
+  }
+
+  async reloadUpdate(options: { hash: string }): Promise<void> {
+    logger.debug(TAG, ',call reloadUpdate');
+    return UpdateModuleImpl.reloadUpdate(this.context, this.mUiCtx, options);
+  }
+
+  async setNeedUpdate(options: { hash: string }): Promise<boolean> {
+    logger.debug(TAG, ',call setNeedUpdate');
+    return UpdateModuleImpl.setNeedUpdate(this.context, options);
+  }
+
+  async markSuccess(): Promise<boolean> {
+    logger.debug(TAG, ',call markSuccess');
+    return UpdateModuleImpl.markSuccess(this.context);
+  }
+
+  async downloadPatchFromPpk(options: {
+    updateUrl: string;
+    hash: string;
+    originHash: string;
+  }): Promise<void> {
+    logger.debug(TAG, ',call downloadPatchFromPpk');
+    return UpdateModuleImpl.downloadPatchFromPpk(this.context, options);
+  }
+
+  async downloadPatchFromPackage(options: {
+    updateUrl: string;
+    hash: string;
+  }): Promise<void> {
+    logger.debug(TAG, ',call downloadPatchFromPackage');
+    return UpdateModuleImpl.downloadPatchFromPackage(this.context, options);
+  }
+
+  async downloadFullUpdate(options: {
+    updateUrl: string;
+    hash: string;
+  }): Promise<void> {
+    logger.debug(TAG, ',call downloadFullUpdate');
+    return UpdateModuleImpl.downloadFullUpdate(this.context, options);
+  }
+
+  addListener(_eventName: string): void {
+    logger.debug(TAG, ',call addListener');
+  }
+
+  removeListeners(_count: number): void {
+    logger.debug(TAG, ',call removeListeners');
+  }
+}

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

@@ -0,0 +1,34 @@
+import resourceManager from '@ohos.resourceManager';
+import fs, { ReadOptions } from '@ohos.file.fs';
+
+const COPY_BUFFER_SIZE = 64 * 1024;
+
+export const saveFileToSandbox = (
+  from: resourceManager.RawFileDescriptor,
+  toPath: string,
+) => {
+  let to = fs.openSync(toPath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+
+  const buffer = new ArrayBuffer(COPY_BUFFER_SIZE);
+  let currentOffset = from.offset;
+  let remaining = from.length;
+
+  try {
+    while (remaining > 0) {
+      const readOption: ReadOptions = {
+        offset: currentOffset,
+        length: Math.min(COPY_BUFFER_SIZE, remaining),
+      };
+      const readLength = fs.readSync(from.fd, buffer, readOption);
+      if (readLength <= 0) {
+        throw new Error(`Unexpected EOF while copying resource to ${toPath}`);
+      }
+
+      fs.writeSync(to.fd, buffer, { length: readLength });
+      currentOffset += readLength;
+      remaining -= readLength;
+    }
+  } finally {
+    fs.close(to);
+  }
+};