react-native-ota-hot-update 1.1.2 → 1.1.4

package/android/src/main/java/com/rnhotupdate/HotUpdateModule.java

@@ -92,17 +92,21 @@ public class HotUpdateModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void setupBundlePath(String path, String extension, Promise promise) {
         if (path != null) {
-            deleteOldBundleIfneeded();
             File file = new File(path);
             if (file.exists() && file.isFile()) {
+                deleteOldBundleIfneeded();
                 String fileUnzip = unzip(file, extension != null ? extension : ".bundle");
-                Log.d("setupBundlePath: ", fileUnzip);
                 if (fileUnzip != null) {
+                    Log.d("setupBundlePath: ", fileUnzip);
                     file.delete();
                     SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
                     sharedPrefs.putString(Common.INSTANCE.getPATH(), fileUnzip);
                     promise.resolve(true);
                 } else {
+                    file.delete();
+                    deleteDirectory(file.getParentFile());
+                    SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+                    sharedPrefs.putString(Common.INSTANCE.getPATH(), "");
                     promise.resolve(false);
                 }
             } else {
@@ -153,6 +157,13 @@ public class HotUpdateModule extends ReactContextBaseJavaModule {
          promise.resolve(true);
     }
 
+    @ReactMethod
+     public void setExactBundlePath(String path, Promise promise) {
+        SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+        sharedPrefs.putString(Common.INSTANCE.getPATH(), path);
+        promise.resolve(true);
+     }
+
     @NonNull
     @Override
     public String getName() {

package/ios/RNhotupdate.m

@@ -170,8 +170,8 @@ RCT_EXPORT_METHOD(setupBundlePath:(NSString *)path extension:(NSString *)extensi
         [self removeBundleIfNeeded];
         //Unzip file
         NSString *extractedFilePath = [self unzipFileAtPath:path extension:(extension != nil) ? extension : @".jsbundle"];
-        NSLog(@"file extraction----- %@", extractedFilePath);
         if (extractedFilePath) {
+            NSLog(@"file extraction----- %@", extractedFilePath);
             NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
             [defaults setObject:extractedFilePath forKey:@"PATH"];
             [defaults synchronize];
@@ -211,6 +211,19 @@ RCT_EXPORT_METHOD(setCurrentVersion:(NSString *)version withResolver:(RCTPromise
     }
 }
 
+RCT_EXPORT_METHOD(setExactBundlePath:(NSString *)path
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    if (path) {
+        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+        [defaults setObject:path forKey:@"PATH"];
+        [defaults synchronize];
+        resolve(@(YES));
+    } else {
+        resolve(@(NO));
+    }
+}
+
 - (void)loadBundle
 {
     RCTTriggerReloadCommandListeners(@"rn-hotupdate: Restart");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ota-hot-update",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Hot update for react native",
   "main": "src/index",
   "repository": "https://github.com/vantuan88291/react-native-ota-hot-update",
@@ -10,8 +10,13 @@
     "url": "https://github.com/vantuan88291/react-native-ota-hot-update/issues"
   },
   "homepage": "https://github.com/vantuan88291/react-native-ota-hot-update",
+  "dependencies": {
+    "buffer": "^6.0.3",
+    "isomorphic-git": "git+https://github.com/vantuan88291/isomorphic-git.git"
+  },
   "peerDependencies": {
-    "react-native": ">=0.63.4"
+    "react-native": ">=0.63.4",
+    "react-native-fs": "*"
   },
   "create-react-native-library": {
     "type": "module-legacy",

package/src/gits/helper/fileReader.js

@@ -0,0 +1,44 @@
+/**
+ * @format
+ */
+FileReader.prototype.readAsArrayBuffer = function (blob) {
+  if (this.readyState === this.LOADING) throw new Error('InvalidStateError');
+  this._setReadyState(this.LOADING);
+  this._result = null;
+  this._error = null;
+  const fr = new FileReader();
+  fr.onloadend = () => {
+    const content = atob(fr.result.replace(/data:[^;]+;base64,/, ''));
+    const buffer = new ArrayBuffer(content.length);
+    const view = new Uint8Array(buffer);
+    view.set(Array.from(content).map((c) => c.charCodeAt(0)));
+    this._result = buffer;
+    this._setReadyState(this.DONE);
+  };
+  fr.readAsDataURL(blob);
+};
+
+// from: https://stackoverflow.com/questions/42829838/react-native-atob-btoa-not-working-without-remote-js-debugging
+const chars =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+const atob = (input = '') => {
+  let str = input.replace(/[=]+$/, '');
+  let output = '';
+
+  if (str.length % 4 == 1) {
+    throw new Error(
+      "'atob' failed: The string to be decoded is not correctly encoded."
+    );
+  }
+  for (
+    let bc = 0, bs = 0, buffer, i = 0;
+    (buffer = str.charAt(i++));
+    ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4)
+      ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
+      : 0
+  ) {
+    buffer = chars.indexOf(buffer);
+  }
+
+  return output;
+};

package/src/gits/helper/fs.ts

@@ -0,0 +1,154 @@
+import { Buffer } from 'buffer';
+
+let RNFS = {
+  unlink: console.log,
+  readdir: console.log,
+  mkdir: console.log,
+  readFile: console.log,
+  writeFile: console.log,
+  stat: console.log,
+};
+try {
+  RNFS = require('react-native-fs');
+} catch {}
+
+function Err(name: string) {
+  return class extends Error {
+    public code = name;
+    constructor(...args: any) {
+      super(...args);
+      if (this.message) {
+        this.message = name + ': ' + this.message;
+      } else {
+        this.message = name;
+      }
+    }
+  };
+}
+
+// const EEXIST = Err('EEXIST'); // <-- Unused because RNFS's mkdir never throws
+const ENOENT = Err('ENOENT');
+const ENOTDIR = Err('ENOTDIR');
+// const ENOTEMPTY = Err('ENOTEMPTY'); // <-- Unused because RNFS's unlink is recursive by default
+
+export const readdir = async (path: string) => {
+  try {
+    return await RNFS.readdir(path);
+  } catch (err: any) {
+    switch (err.message) {
+      case 'Attempt to get length of null array': {
+        throw new ENOTDIR(path);
+      }
+      case 'Folder does not exist': {
+        throw new ENOENT(path);
+      }
+      default:
+        throw err;
+    }
+  }
+};
+
+export const mkdir = async (path: string) => {
+  return RNFS.mkdir(path);
+};
+
+export const readFile = async (
+  path: string,
+  opts?: string | { [key: string]: string }
+) => {
+  let encoding;
+
+  if (typeof opts === 'string') {
+    encoding = opts;
+  } else if (typeof opts === 'object') {
+    encoding = opts.encoding;
+  }
+
+  // @ts-ignore
+  let result: string | Uint8Array = await RNFS.readFile(
+    path,
+    encoding || 'base64'
+  );
+
+  if (!encoding) {
+    // @ts-ignore
+    result = Buffer.from(result, 'base64');
+  }
+
+  return result;
+};
+export const writeFile = async (
+  path: string,
+  content: string | Uint8Array,
+  opts?: string | { [key: string]: string }
+) => {
+  let encoding;
+
+  if (typeof opts === 'string') {
+    encoding = opts;
+  } else if (typeof opts === 'object') {
+    encoding = opts.encoding;
+  }
+
+  if (typeof content === 'string') {
+    encoding = encoding || 'utf8';
+  } else {
+    encoding = 'base64';
+    content = Buffer.from(content).toString('base64');
+  }
+
+  await RNFS.writeFile(path, content as string, encoding);
+};
+
+export const stat = async (path: string) => {
+  try {
+    const r = await RNFS.stat(path);
+    // we monkeypatch the result with a `isSymbolicLink` method because isomorphic-git needs it.
+    // Since RNFS doesn't appear to support symlinks at all, we'll just always return false.
+    // @ts-ignore
+    r.isSymbolicLink = () => false;
+    return r;
+  } catch (err: any) {
+    switch (err.message) {
+      case 'File does not exist': {
+        throw new ENOENT(path);
+      }
+      default:
+        throw err;
+    }
+  }
+};
+
+// Since there are no symbolic links, lstat and stat are equivalent
+export const lstat = stat;
+
+export const unlink = async (path: string) => {
+  try {
+    await RNFS.unlink(path);
+  } catch (err: any) {
+    switch (err.message) {
+      case 'File does not exist': {
+        throw new ENOENT(path);
+      }
+      default:
+        throw err;
+    }
+  }
+};
+
+// RNFS doesn't have a separate rmdir method, so we can use unlink for deleting directories too
+export const rmdir = unlink;
+
+// These are optional, which is good because there is no equivalent in RNFS
+export const readlink = async () => {
+  throw new Error('not implemented');
+};
+export const symlink = async () => {
+  throw new Error('not implemented');
+};
+
+// Technically we could pull this off by using `readFile` + `writeFile` with the `mode` option
+// However, it's optional, because isomorphic-git will do exactly that (a readFile and a writeFile with the new mode)
+export const chmod = async () => {
+  throw new Error('not implemented');
+};

package/src/gits/index.ts

@@ -0,0 +1,118 @@
+import './helper/fileReader.js';
+
+// @ts-ignore
+import git, { PromiseFsClient } from 'isomorphic-git/index.umd.min.js';
+import http from 'isomorphic-git/http/web/index.js';
+import * as promises from './helper/fs';
+import type { CloneOption, PullOption } from '../type';
+
+const fs: PromiseFsClient = { promises };
+const getFolder = (folderName?: string) => {
+  try {
+    const { DocumentDirectoryPath } = require('react-native-fs');
+    return DocumentDirectoryPath + (folderName || '/git_hot_update');
+  } catch (e) {}
+  return '';
+};
+/**
+ * Should set config after clone success, otherwise cannot pull
+ */
+const setConfig = async (
+  folderName?: string,
+  options?: {
+    userName?: string;
+    email?: string;
+  }
+) => {
+  await git.setConfig({
+    fs,
+    dir: getFolder(folderName),
+    path: options?.userName || 'user.name',
+    value: options?.email || 'hotupdate',
+  });
+};
+const cloneRepo = async (options: CloneOption) => {
+  try {
+    await git.clone({
+      fs,
+      http,
+      dir: getFolder(options?.folderName),
+      url: options?.url,
+      singleBranch: true,
+      depth: 1,
+      ref: options?.branch,
+      onProgress({ loaded, total }: { loaded: number; total: number }) {
+        if (options?.onProgress && total > 0) {
+          options?.onProgress(loaded, total);
+        }
+      },
+    });
+    await setConfig(options?.folderName, {
+      email: options?.email,
+      userName: options?.userName,
+    });
+    return {
+      success: true,
+      msg: null,
+      bundle: `${getFolder(options?.folderName)}/${options.bundlePath}`,
+    };
+  } catch (e: any) {
+    return {
+      success: false,
+      msg: e.toString(),
+      bundle: null,
+    };
+  }
+};
+const pullUpdate = async (options: PullOption) => {
+  try {
+    let count = 0;
+    await git.pull({
+      fs,
+      http,
+      dir: getFolder(options?.folderName),
+      ref: options?.branch,
+      singleBranch: true,
+      onProgress({ loaded, total }: { loaded: number; total: number }) {
+        if (total > 0) {
+          count = total;
+          if (options?.onProgress) {
+            options?.onProgress(loaded, total);
+          }
+        }
+      },
+    });
+    return {
+      success: count > 0,
+      msg: count > 0 ? 'Pull success' : 'No updated',
+    };
+  } catch (e: any) {
+    console.log(e.toString());
+    return {
+      success: false,
+      msg: e.toString(),
+    };
+  }
+};
+const getBranchName = async (folderName?: string) => {
+  try {
+    return await git.currentBranch({
+      fs,
+      dir: getFolder(folderName),
+      fullname: false,
+    });
+  } catch (e: any) {
+    console.log(e.toString());
+    return null;
+  }
+};
+const removeGitUpdate = (folderName?: string) => {
+  fs.promises.unlink(getFolder(folderName));
+};
+export default {
+  cloneRepo,
+  pullUpdate,
+  getBranchName,
+  setConfig,
+  removeGitUpdate,
+};

package/src/index.tsx

@@ -1,19 +1,14 @@
 import { NativeModules, Platform } from 'react-native';
 import {DownloadManager} from './download';
+import { UpdateGitOption, UpdateOption } from './type';
+import git from './gits';
+
 const LINKING_ERROR =
     'The package \'rn-hotupdate\' doesn\'t seem to be linked. Make sure: \n\n' +
     Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
     '- You rebuilt the app after installing the package\n' +
     '- You are not using Expo Go\n';
 
-export interface UpdateOption {
-  headers?: object
-  progress?(received: string, total: string): void
-  updateSuccess?(): void
-  updateFail?(message?: string): void
-  restartAfterInstall?: boolean
-  extensionBundle?: string,
-}
 const RNhotupdate = NativeModules.RNhotupdate
     ? NativeModules.RNhotupdate
     : new Proxy(
@@ -42,6 +37,9 @@ const downloadBundleFile = async (downloadManager: DownloadManager, uri: string,
 function setupBundlePath(path: string, extension?: string): Promise<boolean> {
   return RNhotupdate.setupBundlePath(path, extension);
 }
+function setupExactBundlePath(path: string): Promise<boolean> {
+  return RNhotupdate.setExactBundlePath(path);
+}
 function deleteBundlePath(): Promise<boolean> {
   return RNhotupdate.deleteBundle();
 }
@@ -111,12 +109,71 @@ async function downloadBundleUri(downloadManager: DownloadManager, uri: string,
     installFail(option, e);
   }
 }
-
+const checkForGitUpdate = async (options: UpdateGitOption) => {
+  try {
+    if (!options.url || !options.bundlePath) {
+      throw new Error(`url or bundlePath should not be null`);
+    }
+    const branch = await git.getBranchName();
+    if (branch) {
+      const pull = await git.pullUpdate({
+        branch,
+        onProgress: options?.onProgress,
+        folderName: options?.folderName,
+      });
+      if (pull.success) {
+        options?.onPullSuccess?.();
+        if (options?.restartAfterInstall) {
+          setTimeout(() => {
+            resetApp();
+          }, 300);
+        }
+      } else {
+        options?.onPullFailed?.(pull.msg);
+      }
+    } else {
+      const clone = await git.cloneRepo({
+        onProgress: options?.onProgress,
+        folderName: options?.folderName,
+        url: options.url,
+        branch: options?.branch,
+        bundlePath: options.bundlePath,
+      });
+      if (clone.success) {
+        await git.setConfig();
+        if (clone.bundle) {
+          await setupExactBundlePath(clone.bundle);
+          options?.onCloneSuccess?.();
+          if (options?.restartAfterInstall) {
+            setTimeout(() => {
+              resetApp();
+            }, 300);
+          }
+        }
+      } else {
+        options?.onCloneFailed?.(clone.msg);
+      }
+    }
+  } catch (e: any) {
+    options?.onCloneFailed?.(e.toString());
+  } finally {
+    options?.onFinishProgress?.();
+  }
+};
 export default {
   setupBundlePath,
+  setupExactBundlePath,
   removeUpdate: removeBundle,
   downloadBundleUri,
   resetApp,
   getCurrentVersion: getVersionAsNumber,
   setCurrentVersion,
+  git: {
+    checkForGitUpdate,
+    ...git,
+    removeGitUpdate: (folder?: string) => {
+      RNhotupdate.setExactBundlePath('');
+      git.removeGitUpdate(folder);
+    },
+  },
 };

package/src/type.ts

@@ -0,0 +1,82 @@
+export interface UpdateOption {
+  headers?: object;
+  progress?(received: string, total: string): void;
+  updateSuccess?(): void;
+  updateFail?(message?: string): void;
+  restartAfterInstall?: boolean;
+  extensionBundle?: string;
+}
+
+/**
+ * Options for updating a Git repository.
+ */
+export interface UpdateGitOption {
+  /**
+   * The URL of the Git repository to check update.
+   */
+  url: string;
+
+  /**
+   * Optional callback to monitor the progress of the update.
+   * @param received - The number of bytes received so far.
+   * @param total - The total number of bytes to be received.
+   */
+  onProgress?(received: number, total: number): void;
+
+  /**
+   * Optional branch name to update or switch to.
+   * If not specified, the default branch will be main.
+   */
+  branch?: string;
+
+  /**
+   * Optional name of the folder where the repository will be cloned or updated.
+   * If not specified, a default folder name will be git_hot_update.
+   */
+  folderName?: string;
+  /**
+   * Optional callback when pull success, should handle for case update.
+   */
+  onPullSuccess?(): void;
+  /**
+   * Optional callback when pull failed.
+   */
+  onPullFailed?(msg: string): void;
+  /**
+   * Optional callback when clone success, handle it in the first time clone.
+   */
+  onCloneSuccess?(): void;
+  /**
+   * Optional callback when clone failed.
+   */
+  onCloneFailed?(msg: string): void;
+  /**
+   * The bundle path of the Git repository, it should place at root.
+   * Eg: the folder name is git_hot_update, bundle file place at git_hot_update/output/main.jsbundle, so bundlePath should be: "output/main.jsbundle".
+   */
+  bundlePath: string;
+  /**
+   * Optional restart app after clone / pull success for apply the new bundle.
+   */
+  restartAfterInstall?: boolean;
+  /**
+   * Optional when all process success, use for set loading false.
+   */
+  onFinishProgress?(): void;
+}
+
+export interface CloneOption {
+  url: string;
+  folderName?: string;
+  onProgress?(received: number, total: number): void;
+  branch?: string;
+  bundlePath: string;
+  userName?: string;
+  email?: string;
+}
+
+export interface PullOption {
+  folderName?: string;
+  onProgress?(received: number, total: number): void;
+  branch: string;
+}