react-native-custom-ota 0.0.0-stage → 1.0.0

package/lib/typescript/storage.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMP_DIR = exports.BACKUP_DIR = exports.CURRENT_DIR = exports.OTA_ROOT = void 0;
+exports.ensureOTADirs = ensureOTADirs;
+exports.readState = readState;
+exports.writeState = writeState;
+const react_native_fs_1 = __importDefault(require("react-native-fs"));
+exports.OTA_ROOT = `${react_native_fs_1.default.DocumentDirectoryPath}/ota`;
+exports.CURRENT_DIR = `${exports.OTA_ROOT}/current`;
+exports.BACKUP_DIR = `${exports.OTA_ROOT}/backup`;
+exports.TEMP_DIR = `${exports.OTA_ROOT}/temp`;
+const STATE_FILE = `${exports.OTA_ROOT}/state.json`;
+async function ensureOTADirs() {
+    await react_native_fs_1.default.mkdir(exports.OTA_ROOT).catch(() => { });
+    await react_native_fs_1.default.mkdir(exports.TEMP_DIR).catch(() => { });
+}
+async function readState() {
+    await ensureOTADirs();
+    if (!(await react_native_fs_1.default.exists(STATE_FILE))) {
+        return {
+            currentVersion: "0.0.0",
+            previousVersion: null,
+            pending: false,
+            ready: true,
+            failedVersions: []
+        };
+    }
+    try {
+        const content = await react_native_fs_1.default.readFile(STATE_FILE, "utf8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {
+            currentVersion: "0.0.0",
+            previousVersion: null,
+            pending: false,
+            ready: true,
+            failedVersions: []
+        };
+    }
+}
+async function writeState(state) {
+    await ensureOTADirs();
+    await react_native_fs_1.default.writeFile(STATE_FILE, JSON.stringify(state, null, 2), "utf8");
+}

package/lib/typescript/types.d.ts

@@ -0,0 +1,60 @@
+export declare enum SyncStatus {
+    UP_TO_DATE = 0,
+    UPDATE_AVAILABLE = 1,
+    DOWNLOADING_PACKAGE = 2,
+    INSTALLING_UPDATE = 3,
+    UPDATE_INSTALLED = 4,
+    ERROR = -1
+}
+export declare enum CheckFrequency {
+    ON_APP_START = "ON_APP_START",
+    ON_APP_RESUME = "ON_APP_RESUME",
+    MANUAL = "MANUAL"
+}
+export declare enum InstallMode {
+    IMMEDIATE = "IMMEDIATE",
+    ON_NEXT_RESTART = "ON_NEXT_RESTART"
+}
+export interface UpdateDialogOptions {
+    title?: string;
+    optionalUpdateMessage?: string;
+    mandatoryUpdateMessage?: string;
+    optionalInstallButtonLabel?: string;
+    optionalIgnoreButtonLabel?: string;
+}
+export interface SyncOptions {
+    serverUrl: string;
+    appId?: string;
+    apiKey?: string;
+    nativeVersion?: string;
+    channel?: string;
+    installMode?: InstallMode;
+    mandatoryInstallMode?: InstallMode;
+    updateDialog?: boolean | UpdateDialogOptions;
+    checkFrequency?: CheckFrequency;
+}
+export interface RemotePackage {
+    updateAvailable: boolean;
+    appId?: string;
+    platform?: string;
+    otaVersion?: string;
+    version?: string;
+    bundle?: string;
+    sha256?: string;
+    channel?: string;
+    minNativeVersion?: string;
+    mandatory?: boolean;
+    isMandatory?: boolean;
+    releaseNotes?: string;
+    downloadUrl?: string;
+    size?: number;
+    reason?: string;
+}
+export interface LocalPackage {
+    currentVersion: string;
+    previousVersion: string | null;
+    pending: boolean;
+    trial?: boolean;
+    ready: boolean;
+    failedVersions: string[];
+}

package/lib/typescript/types.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallMode = exports.CheckFrequency = exports.SyncStatus = void 0;
+var SyncStatus;
+(function (SyncStatus) {
+    SyncStatus[SyncStatus["UP_TO_DATE"] = 0] = "UP_TO_DATE";
+    SyncStatus[SyncStatus["UPDATE_AVAILABLE"] = 1] = "UPDATE_AVAILABLE";
+    SyncStatus[SyncStatus["DOWNLOADING_PACKAGE"] = 2] = "DOWNLOADING_PACKAGE";
+    SyncStatus[SyncStatus["INSTALLING_UPDATE"] = 3] = "INSTALLING_UPDATE";
+    SyncStatus[SyncStatus["UPDATE_INSTALLED"] = 4] = "UPDATE_INSTALLED";
+    SyncStatus[SyncStatus["ERROR"] = -1] = "ERROR";
+})(SyncStatus || (exports.SyncStatus = SyncStatus = {}));
+var CheckFrequency;
+(function (CheckFrequency) {
+    CheckFrequency["ON_APP_START"] = "ON_APP_START";
+    CheckFrequency["ON_APP_RESUME"] = "ON_APP_RESUME";
+    CheckFrequency["MANUAL"] = "MANUAL";
+})(CheckFrequency || (exports.CheckFrequency = CheckFrequency = {}));
+var InstallMode;
+(function (InstallMode) {
+    InstallMode["IMMEDIATE"] = "IMMEDIATE";
+    InstallMode["ON_NEXT_RESTART"] = "ON_NEXT_RESTART";
+})(InstallMode || (exports.InstallMode = InstallMode = {}));

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "react-native-custom-ota",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Self-hosted OTA (Over-The-Air) update library for React Native with automatic rollback, similar to react-native-code-push",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "bin": {
+    "custom-ota": "bin/custom-ota.js"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android/src",
+    "android/build.gradle",
+    "ios",
+    "bin",
+    "react-native.config.js",
+    "RNCustomOTA.podspec",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "npx tsc --declaration --outDir lib/typescript && npx tsc --module commonjs --outDir lib/commonjs && npx tsc --module esnext --outDir lib/module",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "ota",
+    "code-push",
+    "hot-update",
+    "live-update",
+    "self-hosted",
+    "rollback"
+  ],
+  "author": "Custom OTA Team",
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "dependencies": {
+    "react-native-fs": "^2.20.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0 || ^19.0.0",
+    "@types/react-native": "^0.72.0",
+    "typescript": "^5.0.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        packageImportPath: 'import com.customota.OTAUpdaterPackage;',
+        packageInstance: 'new OTAUpdaterPackage()'
+      },
+      ios: {}
+    }
+  }
+};

package/src/hoc.tsx

@@ -0,0 +1,34 @@
+import React, { ComponentType, useEffect } from "react";
+import { AppState, AppStateStatus } from "react-native";
+import { CustomOTAManager } from "./manager";
+import { CheckFrequency, SyncOptions } from "./types";
+
+export function withCustomOTA(options: SyncOptions) {
+  return function <P extends object>(WrappedComponent: ComponentType<P>): ComponentType<P> {
+    return function CustomOTAWrapper(props: P) {
+      useEffect(() => {
+        // Tự động kiểm tra cập nhật khi app khởi động
+        if (options.checkFrequency !== CheckFrequency.MANUAL) {
+          CustomOTAManager.sync(options);
+        }
+
+        // Nếu bật kiểm tra khi App Resume từ background
+        if (options.checkFrequency === CheckFrequency.ON_APP_RESUME) {
+          const subscription = AppState.addEventListener(
+            "change",
+            (nextAppState: AppStateStatus) => {
+              if (nextAppState === "active") {
+                CustomOTAManager.sync(options);
+              }
+            }
+          );
+          return () => {
+            subscription.remove();
+          };
+        }
+      }, []);
+
+      return <WrappedComponent {...props} />;
+    };
+  };
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+import { CustomOTAManager } from "./manager";
+import { withCustomOTA } from "./hoc";
+
+export * from "./types";
+export * from "./manager";
+export * from "./hoc";
+export * from "./storage";
+
+const CustomOTA = {
+  sync: CustomOTAManager.sync.bind(CustomOTAManager),
+  checkForUpdate: CustomOTAManager.checkForUpdate.bind(CustomOTAManager),
+  downloadAndInstall: CustomOTAManager.downloadAndInstall.bind(CustomOTAManager),
+  restartApp: CustomOTAManager.restartApp.bind(CustomOTAManager),
+  getUpdateMetadata: CustomOTAManager.getUpdateMetadata.bind(CustomOTAManager),
+  markReady: CustomOTAManager.markReady.bind(CustomOTAManager),
+  wrap: withCustomOTA
+};
+
+export default CustomOTA;

package/src/manager.ts

@@ -0,0 +1,328 @@
+import { Alert, Platform } from "react-native";
+import RNFS from "react-native-fs";
+import { OTAUpdater } from "./native";
+import { BACKUP_DIR, CURRENT_DIR, TEMP_DIR, ensureOTADirs, readState, writeState } from "./storage";
+import {
+  InstallMode,
+  LocalPackage,
+  RemotePackage,
+  SyncOptions,
+  SyncStatus,
+  UpdateDialogOptions
+} from "./types";
+
+export class CustomOTAManager {
+  private static defaultDialog: UpdateDialogOptions = {
+    title: "Có bản cập nhật mới",
+    optionalUpdateMessage: "Đã có bản cập nhật ứng dụng mới. Bạn có muốn cài đặt ngay bây giờ?",
+    mandatoryUpdateMessage: "Đã có bản cập nhật bắt buộc. Vui lòng cài đặt để tiếp tục sử dụng.",
+    optionalInstallButtonLabel: "Cập nhật",
+    optionalIgnoreButtonLabel: "Để sau"
+  };
+
+  /**
+   * Đánh dấu bản build OTA hiện tại đã khởi động thành công.
+   * Xóa bản backup trước đó và tắt cờ pending.
+   */
+  static async markReady(): Promise<void> {
+    try {
+      const state = await readState();
+      state.pending = false;
+      state.ready = true;
+      state.trial = false;
+      await writeState(state);
+    } catch (e) {
+      console.warn("[CustomOTA] Error updating state in markReady:", e);
+    }
+
+    if (OTAUpdater?.markReady) {
+      try {
+        await OTAUpdater.markReady();
+      } catch (e) {
+        console.warn("[CustomOTA] Error calling native markReady:", e);
+      }
+    }
+  }
+
+  /**
+   * Khởi động lại ứng dụng để nạp ngay bản OTA mới.
+   */
+  static async restartApp(): Promise<void> {
+    if (OTAUpdater?.restart) {
+      await OTAUpdater.restart();
+    }
+  }
+
+  /**
+   * Lấy thông tin phiên bản OTA hiện hành trên máy.
+   */
+  static async getUpdateMetadata(): Promise<LocalPackage> {
+    return readState();
+  }
+
+  /**
+   * Kiểm tra xem server có bản cập nhật mới hay không.
+   */
+  static async checkForUpdate(options: {
+    serverUrl: string;
+    appId?: string;
+    apiKey?: string;
+    nativeVersion?: string;
+    channel?: string;
+  }): Promise<RemotePackage | null> {
+    await ensureOTADirs();
+
+    const state = await readState();
+    const platform = Platform.OS === "ios" ? "ios" : "android";
+    const nativeVersion = options.nativeVersion || "1.0.0";
+    const channel = options.channel || "production";
+
+    const params = new URLSearchParams({
+      platform,
+      nativeVersion,
+      otaVersion: state.currentVersion,
+      channel
+    });
+
+    if (options.appId) {
+      params.append("appId", options.appId);
+    }
+    if (options.apiKey) {
+      params.append("apiKey", options.apiKey);
+    }
+
+    const headers: Record<string, string> = {};
+    if (options.apiKey) {
+      headers["X-OTA-API-KEY"] = options.apiKey;
+    }
+
+    const response = await fetch(`${options.serverUrl.replace(/\/$/, "")}/ota/check?${params}`, {
+      headers
+    });
+
+    if (!response.ok) {
+      throw new Error(`OTA Check failed: HTTP ${response.status}`);
+    }
+
+    const rawData = await response.json();
+    if (!rawData.updateAvailable) {
+      return null;
+    }
+
+    const targetVersion = rawData.otaVersion || rawData.version;
+
+    // Không báo cập nhật nếu phiên bản đã được cài đặt trên máy
+    if (targetVersion && state.currentVersion === targetVersion) {
+      return null;
+    }
+
+    // Không báo cập nhật nếu phiên bản này từng bị crash và tự rollback
+    if (targetVersion && state.failedVersions?.includes(targetVersion)) {
+      return null;
+    }
+
+    const serverUrlClean = options.serverUrl.replace(/\/$/, "");
+    const rawUrl = rawData.downloadUrl || "";
+    const fullDownloadUrl = rawUrl.startsWith("http")
+      ? rawUrl
+      : `${serverUrlClean}${rawUrl.startsWith("/") ? "" : "/"}${rawUrl}`;
+
+    const data: RemotePackage = {
+      ...rawData,
+      updateAvailable: true,
+      version: targetVersion,
+      otaVersion: targetVersion,
+      downloadUrl: fullDownloadUrl,
+      mandatory: Boolean(rawData.mandatory || rawData.isMandatory),
+      isMandatory: Boolean(rawData.mandatory || rawData.isMandatory)
+    };
+    return data;
+  }
+
+  /**
+   * Tải và cài đặt bản cập nhật.
+   */
+  static async downloadAndInstall(
+    update: RemotePackage,
+    onProgress?: (progress: number) => void,
+    installMode?: InstallMode
+  ): Promise<boolean> {
+    const version = update.otaVersion || update.version;
+    if (!update.downloadUrl || !version || !update.sha256) {
+      const missingFields = [
+        !update.downloadUrl && "downloadUrl",
+        !version && "version",
+        !update.sha256 && "sha256"
+      ].filter(Boolean).join(", ");
+      throw new Error(`Invalid update package metadata: missing ${missingFields}`);
+    }
+
+    const zipPath = `${TEMP_DIR}/update-${version}.zip`;
+    await RNFS.unlink(zipPath).catch(() => {});
+
+    // Download zip file
+    const downloadRes = RNFS.downloadFile({
+      fromUrl: update.downloadUrl.startsWith("http") ? update.downloadUrl : `${update.downloadUrl}`,
+      toFile: zipPath,
+      progressDivider: 1,
+      progress: ({ bytesWritten, contentLength }) => {
+        if (contentLength > 0 && onProgress) {
+          onProgress(bytesWritten / contentLength);
+        }
+      }
+    });
+
+    const res = await downloadRes.promise;
+    if (res.statusCode < 200 || res.statusCode >= 300) {
+      throw new Error(`Download failed with status ${res.statusCode}`);
+    }
+
+    // SHA-256 verification
+    const actualHash = await RNFS.hash(zipPath, "sha256");
+    if (actualHash.toLowerCase() !== update.sha256.toLowerCase()) {
+      await RNFS.unlink(zipPath).catch(() => {});
+      throw new Error(`SHA-256 Checksum mismatch! Expected ${update.sha256}, got ${actualHash}`);
+    }
+
+    // Unpack temp directory
+    const tempDir = `${TEMP_DIR}/${version}`;
+    await RNFS.unlink(tempDir).catch(() => {});
+    await RNFS.mkdir(tempDir);
+
+    await OTAUpdater.unzip(zipPath, tempDir);
+
+    const bundleName = Platform.OS === "ios" ? "main.jsbundle" : "index.android.bundle";
+    const bundleFile = `${tempDir}/${bundleName}`;
+
+    if (!(await RNFS.exists(bundleFile))) {
+      throw new Error(`Bundle missing after unzip: ${bundleName}`);
+    }
+
+    // Atomic move & backup
+    await RNFS.unlink(BACKUP_DIR).catch(() => {});
+    if (await RNFS.exists(CURRENT_DIR)) {
+      await RNFS.moveFile(CURRENT_DIR, BACKUP_DIR);
+    }
+    await RNFS.moveFile(tempDir, CURRENT_DIR);
+
+    // Save state
+    const oldState = await readState();
+    await writeState({
+      currentVersion: version,
+      previousVersion: oldState.currentVersion !== "0.0.0" ? oldState.currentVersion : null,
+      pending: true,
+      ready: false,
+      trial: false,
+      failedVersions: oldState.failedVersions || []
+    });
+
+    await RNFS.unlink(zipPath).catch(() => {});
+
+    if (installMode === InstallMode.IMMEDIATE) {
+      await this.restartApp();
+    }
+
+    return true;
+  }
+
+  /**
+   * Phương thức đồng bộ tự động như CodePush.sync()
+   */
+  static async sync(
+    options: SyncOptions,
+    syncStatusCallback?: (status: SyncStatus) => void,
+    downloadProgressCallback?: (progress: number) => void
+  ): Promise<SyncStatus> {
+    try {
+      // 1. Tự động markReady khi khởi động
+      await this.markReady();
+
+      // 2. Kiểm tra update
+      const update = await this.checkForUpdate({
+        serverUrl: options.serverUrl,
+        appId: options.appId,
+        apiKey: options.apiKey,
+        nativeVersion: options.nativeVersion,
+        channel: options.channel
+      });
+
+      if (!update || !update.updateAvailable) {
+        syncStatusCallback?.(SyncStatus.UP_TO_DATE);
+        return SyncStatus.UP_TO_DATE;
+      }
+
+      syncStatusCallback?.(SyncStatus.UPDATE_AVAILABLE);
+
+      const proceedWithInstall = async () => {
+        syncStatusCallback?.(SyncStatus.DOWNLOADING_PACKAGE);
+
+        const serverUrlClean = options.serverUrl.replace(/\/$/, "");
+        const fullDownloadUrl = update.downloadUrl?.startsWith("http")
+          ? update.downloadUrl
+          : `${serverUrlClean}${update.downloadUrl}`;
+
+        await this.downloadAndInstall(
+          { ...update, downloadUrl: fullDownloadUrl },
+          downloadProgressCallback
+        );
+
+        syncStatusCallback?.(SyncStatus.INSTALLING_UPDATE);
+        syncStatusCallback?.(SyncStatus.UPDATE_INSTALLED);
+
+        const effectiveInstallMode = (update.mandatory && options.mandatoryInstallMode)
+          ? options.mandatoryInstallMode
+          : (options.installMode || InstallMode.ON_NEXT_RESTART);
+
+        if (effectiveInstallMode === InstallMode.ON_NEXT_RESTART) {
+          return SyncStatus.UPDATE_INSTALLED;
+        }
+
+        // Restart immediate
+        await this.restartApp();
+        return SyncStatus.UPDATE_INSTALLED;
+      };
+
+      // 3. Nếu cấu hình hiển thị Update Dialog
+      if (options.updateDialog) {
+        const dialogOpts: UpdateDialogOptions =
+          typeof options.updateDialog === "object"
+            ? { ...this.defaultDialog, ...options.updateDialog }
+            : this.defaultDialog;
+
+        const isMandatory = Boolean(update.mandatory);
+        const message = isMandatory
+          ? `${dialogOpts.mandatoryUpdateMessage}\n\nPhiên bản: ${update.otaVersion}\n${update.releaseNotes || ""}`
+          : `${dialogOpts.optionalUpdateMessage}\n\nPhiên bản: ${update.otaVersion}\n${update.releaseNotes || ""}`;
+
+        const buttons: any[] = [];
+
+        if (!isMandatory) {
+          buttons.push({
+            text: dialogOpts.optionalIgnoreButtonLabel,
+            style: "cancel"
+          });
+        }
+
+        buttons.push({
+          text: dialogOpts.optionalInstallButtonLabel,
+          onPress: () => {
+            proceedWithInstall();
+          }
+        });
+
+        Alert.alert(dialogOpts.title || "Cập nhật ứng dụng", message, buttons, {
+          cancelable: !isMandatory
+        });
+
+        return SyncStatus.UPDATE_AVAILABLE;
+      }
+
+      // Tự động tải ngầm không hiện dialog
+      return await proceedWithInstall();
+    } catch (error) {
+      console.error("[react-native-custom-ota] Sync error:", error);
+      syncStatusCallback?.(SyncStatus.ERROR);
+      return SyncStatus.ERROR;
+    }
+  }
+}

package/src/native.ts

@@ -0,0 +1,17 @@
+import { NativeModules } from "react-native";
+
+interface OTAUpdaterInterface {
+  unzip(zipPath: string, targetDir: string): Promise<void>;
+  markReady(): Promise<void>;
+  getCurrentVersion(): Promise<string>;
+  restart(): Promise<void>;
+}
+
+export const OTAUpdater = NativeModules.OTAUpdater as OTAUpdaterInterface;
+
+if (!OTAUpdater) {
+  console.warn(
+    "[react-native-custom-ota] NativeModule.OTAUpdater is null! " +
+    "Make sure you have linked the library and rebuilt the native binary."
+  );
+}

package/src/storage.ts

@@ -0,0 +1,45 @@
+import RNFS from "react-native-fs";
+import { LocalPackage } from "./types";
+
+export const OTA_ROOT = `${RNFS.DocumentDirectoryPath}/ota`;
+export const CURRENT_DIR = `${OTA_ROOT}/current`;
+export const BACKUP_DIR = `${OTA_ROOT}/backup`;
+export const TEMP_DIR = `${OTA_ROOT}/temp`;
+const STATE_FILE = `${OTA_ROOT}/state.json`;
+
+export async function ensureOTADirs(): Promise<void> {
+  await RNFS.mkdir(OTA_ROOT).catch(() => {});
+  await RNFS.mkdir(TEMP_DIR).catch(() => {});
+}
+
+export async function readState(): Promise<LocalPackage> {
+  await ensureOTADirs();
+
+  if (!(await RNFS.exists(STATE_FILE))) {
+    return {
+      currentVersion: "0.0.0",
+      previousVersion: null,
+      pending: false,
+      ready: true,
+      failedVersions: []
+    };
+  }
+
+  try {
+    const content = await RNFS.readFile(STATE_FILE, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      currentVersion: "0.0.0",
+      previousVersion: null,
+      pending: false,
+      ready: true,
+      failedVersions: []
+    };
+  }
+}
+
+export async function writeState(state: LocalPackage): Promise<void> {
+  await ensureOTADirs();
+  await RNFS.writeFile(STATE_FILE, JSON.stringify(state, null, 2), "utf8");
+}