react-native-ota-hot-update 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Avishay Bar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# react-native-ota-hot-update
+
+A React Native module that allows you to control hot update same as Code Push, you can control version manager, hosting bundle js by your self, this library just control install the hot update after bundle js downloaded from your side. As we know, Code push is going to retirement in next year, that why i create that library for you can control bundle js from your backend side.
+
+
+iOS GIF             | Android GIF
+:-------------------------:|:-------------------------:
+<img src="./ioshotupdate.gif" title="iOS GIF" width="250"> | <img src="./androidhotupdate.gif" title="Android GIF" width="250">
+
+[![npm downloads](https://img.shields.io/npm/dw/react-native-ota-hot-update)](https://img.shields.io/npm/dw/react-native-ota-hot-update)
+[![npm package](https://img.shields.io/npm/v/react-native-ota-hot-update?color=red)](https://img.shields.io/npm/v/react-native-ota-hot-update?color=red)
+
+## Installation
+
+if you don't want to manage the download progress, need to install blob util together:
+
+```bash
+yarn add react-native-ota-hot-update && react-native-blob-util
+```
+Auto linking already, need pod install for ios:
+```bash
+cd ios && pod install
+```
+
+## That's it, can check the example code
+
+Here is the guideline to control bundle js by yourself, in here i am using Firebase storage to store bundlejs file and a json file that announce new version is comming:
+
+#### 1.Add these script into your package.json to export bundlejs file:
+```bash
+"scripts": {
+   "export-android": "mkdir -p android/output && react-native bundle --platform android --dev false --entry-file index.js --bundle-output android/output/index.android.bundle --assets-dest android/app/src/main/res  && zip -j android/output/index.android.bundle.zip android/output/index.android.bundle && rm -rf android/output/index.android.bundle",
+   "export-ios": "mkdir -p ios/output && react-native bundle --platform ios --dev false --entry-file index.js --bundle-output ios/output/main.jsbundle && zip -j ios/output/main.jsbundle.zip ios/output/main.jsbundle && rm -rf ios/output/main.jsbundle"
+}
+```
+These commands are export bundle file and compress it as a zip file, one for android and one for ios. You can create your own script that export and auto upload to your server.
+
+Then create an json file: `update.json` like that:
+```bash
+{
+  "version": 1,
+  "downloadAndroidUrl": "https://firebasestorage.googleapis.com/v0/b/ota-demo-68f38.appspot.com/o/index.android.bundle.zip?alt=media",
+  "downloadIosUrl": "https://firebasestorage.googleapis.com/v0/b/ota-demo-68f38.appspot.com/o/main.jsbundle.zip?alt=media"
+}
+```
+
+Then upload your bundlejs files to firebase storage, totally will look like that:
+
+![](https://github.com/vantuan88291/react-native-ota-hot-update/raw/main/scr1.png)
+
+After you have done everything related to version manager, you just handle the way to update new version like fetch update.json as api to get download url and call this function:
+
+```bash
+    import hotUpdate from 'react-native-ota-hot-update';
+    
+    
+    hotUpdate.downloadBundleUri(url, version, {
+      updateSuccess: () => {
+        console.log('update success!');
+      },
+      updateFail(message?: string) {
+        Alert.alert('Update failed!', message, [
+          {
+            text: 'Cancel',
+            onPress: () => console.log('Cancel Pressed'),
+            style: 'cancel',
+          },
+        ]);
+      },
+      restartAfterInstall: true,
+    });
+```
+
+The important thing: this library will control `version` by it self, need always pass version as parameter in `downloadBundleUri`, it will storage as a cache and use this to check whether need update version in the next time. Default of `version` is **0**
+
+
+## Functions
+
+| key          | Return | Action                                                                                                           | Parameters                                                         |
+| ------------ |--------|------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
+| downloadBundleUri    | void   | Download bundle and install it                                                                                   | (uri: string, version: number, option?: **UpdateOption**)          |
+| setupBundlePath    | boolean | Install your bundle path if you control the downloading by your self, ignore that if you use `downloadBundleUri` | path: string, the path of bundlejs file that you downloaded before |
+| removeUpdate | void   | Remove you update and use the previos version                                                                    | restartAfterRemoved?: boolean, restart to apply your changing      |
+| resetApp       | void   | Restart the app to apply the changing                                                                            | empty                                                              |
+| getCurrentVersion       | number | Get the current version that let you use to compare and control the logic updating                               | empty                                                              |
+| setCurrentVersion       | boolean       | Set the current version that let you use to compare and control the logic updating                               | version: number                                                              |
+
+
+## UpdateOption
+
+| Option                  | Required | Type     | Description                                                                                                                                                                     |
+|-------------------------|----------|----------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| headers                 | No       | Object   | The header to down load your uri bundle file if need token/authentication...                                                                                                    |
+| updateSuccess           | No       | Callback | Will trigger when install update success                                                                                                                                        |
+| updateFail(message: string)               | No       | Callback       | Will trigger when install update failed                                                                                                                                         |
+| restartAfterInstall            | No       | boolean       | default is `false`, if `true` will restart the app after install success to apply the new change                                                                                |
+
+
+
+## License
+
+[MIT](LICENSE.md)

package/android/build.gradle

@@ -0,0 +1,99 @@
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RNhotupdate_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RNhotupdate_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNhotupdate_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+android {
+  if (supportsNamespace()) {
+    namespace "com.rnhotupdate"
+
+    sourceSets {
+      main {
+        manifest.srcFile "src/main/AndroidManifestNew.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}
+

package/android/gradle.properties

@@ -0,0 +1,5 @@
+RNhotupdate_kotlinVersion=1.7.0
+RNhotupdate_minSdkVersion=21
+RNhotupdate_targetSdkVersion=31
+RNhotupdate_compileSdkVersion=31
+RNhotupdate_ndkversion=21.4.7075529

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.rnhotupdate">
+</manifest>

package/android/src/main/AndroidManifestNew.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

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

@@ -0,0 +1,142 @@
+package com.rnhotupdate;
+
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import android.os.Process;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import androidx.annotation.NonNull;
+public class HotUpdateModule extends ReactContextBaseJavaModule {
+    public HotUpdateModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    private boolean deleteOldBundleIfneeded() {
+        SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+        String path = sharedPrefs.getString(Common.INSTANCE.getPATH());
+        File file = new File(path);
+        if (file.exists() && file.isFile()) {
+            boolean isDeleted = file.delete();
+            sharedPrefs.clear();
+            return isDeleted;
+        } else {
+            return false;
+        }
+    }
+    private String unzip(File zipFile) {
+        File destDir = zipFile.getParentFile(); // Directory of the zip file
+
+        String filePathExtracted = null;
+        if (!destDir.exists()) {
+            destDir.mkdirs();
+        }
+
+        try (InputStream is = new FileInputStream(zipFile);
+             ZipInputStream zis = new ZipInputStream(is)) {
+
+            ZipEntry zipEntry;
+            while ((zipEntry = zis.getNextEntry()) != null) {
+                File newFile = new File(destDir, zipEntry.getName());
+                if (zipEntry.isDirectory()) {
+                    newFile.mkdirs();
+                } else {
+                    // Create directories if they do not exist
+                    new File(newFile.getParent()).mkdirs();
+                    // Extract the file
+                    try (OutputStream os = new FileOutputStream(newFile)) {
+                        byte[] buffer = new byte[1024];
+                        int len;
+                        while ((len = zis.read(buffer)) > 0) {
+                            os.write(buffer, 0, len);
+                        }
+                    }
+                }
+                filePathExtracted = newFile.getAbsolutePath();
+                zis.closeEntry();
+            }
+        } catch (Exception e) {
+            return null;
+        }
+        return filePathExtracted;
+    }
+
+    @ReactMethod
+    public void setupBundlePath(String path, Promise promise) {
+        if (path != null) {
+            File file = new File(path);
+            if (file.exists() && file.isFile()) {
+                String fileUnzip = unzip(file);
+                Log.d("setupBundlePath: ", fileUnzip);
+                if (fileUnzip != null) {
+                    file.delete();
+                    deleteOldBundleIfneeded();
+                    SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+                    sharedPrefs.putString(Common.INSTANCE.getPATH(), fileUnzip);
+                    promise.resolve(true);
+                } else {
+                    promise.resolve(false);
+                }
+            } else {
+                promise.resolve(false);
+            }
+        } else {
+            promise.resolve(false);
+        }
+    }
+
+    @ReactMethod
+    public void deleteBundle(Promise promise) {
+        boolean isDeleted = deleteOldBundleIfneeded();
+        promise.resolve(isDeleted);
+    }
+    @ReactMethod
+    public void restart() {
+        Context context = getCurrentActivity();
+        Intent intent = context.getPackageManager()
+                .getLaunchIntentForPackage(context.getPackageName());
+        if (intent != null) {
+            intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP |
+                    Intent.FLAG_ACTIVITY_NEW_TASK |
+                    Intent.FLAG_ACTIVITY_CLEAR_TASK);
+
+            context.startActivity(intent);
+            Process.killProcess(Process.myPid());
+            System.exit(0);
+        }
+    }
+    @ReactMethod
+    public void getCurrentVersion(Promise promise) {
+        SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+        String version = sharedPrefs.getString(Common.INSTANCE.getVERSION());
+        if (!version.equals("")) {
+            promise.resolve(version);
+        } else {
+            promise.resolve("0");
+        }
+
+    }
+    @ReactMethod
+    public void setCurrentVersion(String version, Promise promise) {
+         SharedPrefs sharedPrefs = new SharedPrefs(getReactApplicationContext());
+         sharedPrefs.putString(Common.INSTANCE.getVERSION(), version);
+         promise.resolve(true);
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "RNhotupdate";
+    }
+}

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

@@ -0,0 +1,45 @@
+package com.rnhotupdate;
+
+import android.content.Context;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+
+public class OtaHotUpdate  implements ReactPackage {
+    private static Context mContext;
+    public OtaHotUpdate(Context context) {
+        mContext = context;
+    }
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactApplicationContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new HotUpdateModule(reactApplicationContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactApplicationContext) {
+        return Collections.emptyList();
+    }
+    public static String getBundleJS() {
+        if (mContext == null) {
+            return Common.INSTANCE.getDEFAULT_BUNDLE();
+        }
+        SharedPrefs sharedPrefs = new SharedPrefs(mContext);
+        String pathBundle = sharedPrefs.getString(Common.INSTANCE.getPATH());
+        if (pathBundle.equals("")) {
+            return Common.INSTANCE.getDEFAULT_BUNDLE();
+        }
+        return pathBundle;
+    }
+}

package/android/src/main/java/com/rnhotupdate/SharedPrefs.kt

@@ -0,0 +1,31 @@
+package com.rnhotupdate
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.SharedPreferences
+
+class SharedPrefs internal constructor(context: Context) {
+    private val mSharedPreferences: SharedPreferences =
+        context.getSharedPreferences(Common.SHARED_PREFERENCE_NAME, Context.MODE_PRIVATE)
+
+    fun getString(key: String?): String? {
+        return mSharedPreferences.getString(key, "")
+    }
+
+    @SuppressLint("CommitPrefEdits")
+    fun putString(key: String?, value: String?) {
+        val editor = mSharedPreferences.edit()
+        editor.putString(key, value)
+        editor.apply()
+    }
+
+    fun clear() {
+        mSharedPreferences.edit().clear().apply()
+    }
+}
+object Common {
+    val PATH = "PATH"
+    val VERSION = "VERSION"
+    val SHARED_PREFERENCE_NAME = "HOT-UPDATE-REACT_NATIVE"
+    val DEFAULT_BUNDLE = "assets://index.android.bundle"
+}

package/ios/RNhotupdate.h

@@ -0,0 +1,12 @@
+#import <React/RCTReloadCommand.h>
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "RNRNhotupdateSpec.h"
+
+@interface RNhotupdate : NSObject <NativeRNhotupdateSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface RNhotupdate : NSObject <RCTBridgeModule>
+#endif
++ (NSURL *)getBundle;
+@end

package/ios/RNhotupdate.mm

@@ -0,0 +1,160 @@
+#import "RNhotupdate.h"
+#import <React/RCTLog.h>
+#import <SSZipArchive/SSZipArchive.h>
+
+@implementation RNhotupdate
+RCT_EXPORT_MODULE()
+
+// Check if a file path is valid
+- (BOOL)isFilePathValid:(NSString *)path {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    return [fileManager fileExistsAtPath:path];
+}
+
+- (BOOL)removeBundleIfNeeded {
+    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSString *retrievedString = [defaults stringForKey:@"PATH"];
+    if (retrievedString && [self isFilePathValid:retrievedString]) {
+        BOOL isDeleted = [self deleteFileAtPath:retrievedString];
+        [defaults removeObjectForKey:@"PATH"];
+        [defaults synchronize];
+        return isDeleted;
+    } else {
+        return NO;
+    }
+}
+
+// Delete a file at the specified path
+- (BOOL)deleteFileAtPath:(NSString *)path {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+    BOOL success = [fileManager removeItemAtPath:path error:&error];
+    if (!success) {
+        RCTLogError(@"Error deleting file: %@", [error localizedDescription]);
+    }
+    return success;
+}
++ (BOOL)isFilePathExist:(NSString *)path {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    return [fileManager fileExistsAtPath:path];
+}
+
++ (NSURL *)getBundle {
+    NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+    NSString *retrievedString = [defaults stringForKey:@"PATH"];
+    if (retrievedString && [self isFilePathExist:retrievedString]) {
+       NSURL *fileURL = [NSURL fileURLWithPath:retrievedString];
+       return fileURL;
+    } else {
+        return [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
+    }
+}
+
+- (NSString *)unzipFileAtPath:(NSString *)zipFilePath {
+    // Define the directory where the files will be extracted
+    NSString *extractedFolderPath = [[zipFilePath stringByDeletingPathExtension] stringByAppendingPathExtension:@"unzip"];
+
+    // Create the directory if it does not exist
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if (![fileManager fileExistsAtPath:extractedFolderPath]) {
+        NSError *error = nil;
+        [fileManager createDirectoryAtPath:extractedFolderPath withIntermediateDirectories:YES attributes:nil error:&error];
+        if (error) {
+            [self deleteFileAtPath:zipFilePath];
+            NSLog(@"Failed to create directory: %@", error.localizedDescription);
+            return nil;
+        }
+    }
+
+    // Unzip the file
+    BOOL success = [SSZipArchive unzipFileAtPath:zipFilePath toDestination:extractedFolderPath];
+    if (!success) {
+        [self deleteFileAtPath:zipFilePath];
+        NSLog(@"Failed to unzip file");
+        return nil;
+    }
+
+    // Find the extracted file (assuming only one file in the zip)
+    NSArray *contents = [fileManager contentsOfDirectoryAtPath:extractedFolderPath error:nil];
+    if (contents.count == 1) {
+        NSString *filePath = [extractedFolderPath stringByAppendingPathComponent:contents.firstObject];
+
+        // Delete the zip file after extraction
+        NSError *removeError = nil;
+        [fileManager removeItemAtPath:zipFilePath error:&removeError];
+        if (removeError) {
+            NSLog(@"Failed to delete zip file: %@", removeError.localizedDescription);
+        }
+
+        // Return the exact file path
+        return filePath;
+    } else {
+        [self deleteFileAtPath:zipFilePath];
+        NSLog(@"Expected one file in the zip but found %lu", (unsigned long)contents.count);
+        return nil;
+    }
+}
+
+// Expose setupBundlePath method to JavaScript
+RCT_EXPORT_METHOD(setupBundlePath:(NSString *)path withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+    if ([self isFilePathValid:path]) {
+        //Unzip file
+        NSString *extractedFilePath = [self unzipFileAtPath:path];
+        NSLog(@"file extraction----- %@", extractedFilePath);
+        if (extractedFilePath) {
+            [self removeBundleIfNeeded];
+            NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+            [defaults setObject:extractedFilePath forKey:@"PATH"];
+            [defaults synchronize];
+            resolve(@(YES));
+        } else {
+            resolve(@(NO));
+        }
+    } else {
+        resolve(@(NO));
+    }
+}
+
+// Expose deleteBundle method to JavaScript
+RCT_EXPORT_METHOD(deleteBundle:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+    BOOL isDeleted = [self removeBundleIfNeeded];
+    resolve(@(isDeleted));
+}
+
+RCT_EXPORT_METHOD(getCurrentVersion:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+     NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+     NSString *version = [defaults stringForKey:@"VERSION"];
+        if (version) {
+            resolve(version);
+        } else {
+            resolve(@("0"));
+        }
+}
+
+RCT_EXPORT_METHOD(setCurrentVersion:(NSString *)version withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject) {
+    if (version) {
+        NSUserDefaults *defaults = [NSUserDefaults standardUserDefaults];
+        [defaults setObject:version forKey:@"VERSION"];
+        [defaults synchronize];
+        resolve(@(YES));
+    } else {
+        resolve(@(NO));
+    }
+}
+
+- (void)loadBundle
+{
+    RCTTriggerReloadCommandListeners(@"rn-hotupdate: Restart");
+}
+RCT_EXPORT_METHOD(restart) {
+    if ([NSThread isMainThread]) {
+        [self loadBundle];
+    } else {
+        dispatch_sync(dispatch_get_main_queue(), ^{
+            [self loadBundle];
+        });
+    }
+    return;
+}
+
+@end

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "react-native-ota-hot-update",
+  "version": "1.0.0",
+  "description": "Hot update for react native",
+  "main": "src/index",
+  "repository": "https://github.com/vantuan88291/react-native-ota-hot-update",
+  "author": "vantuan88291 <vantuan88291@gmail.com> (https://github.com/vantuan88291)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/vantuan88291/react-native-ota-hot-update/issues"
+  },
+  "homepage": "https://github.com/vantuan88291/react-native-ota-hot-update",
+  "peerDependencies": {
+    "react-native-blob-util": ">=0.19.11",
+    "react-native": ">=0.63.4"
+  },
+  "create-react-native-library": {
+    "type": "module-legacy",
+    "languages": "kotlin-objc",
+    "version": "0.41.0"
+  },
+  "rnpm": {
+    "android": {
+      "packageInstance": "new OtaHotUpdate(getApplicationContext())"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+    dependency: {
+        platforms: {
+            android: {
+                packageInstance: 'new OtaHotUpdate(getApplicationContext())',
+            },
+        },
+    },
+};

package/rn-hotupdate.podspec

@@ -0,0 +1,41 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
+
+Pod::Spec.new do |s|
+  s.name         = "rn-hotupdate"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => ".git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+  s.dependency 'SSZipArchive', '~> 2.4.3'
+  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
+  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
+  if respond_to?(:install_modules_dependencies, true)
+    install_modules_dependencies(s)
+  else
+    s.dependency "React-Core"
+
+    # Don't install the dependencies when we run `pod install` in the old architecture.
+    if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
+      s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
+      s.pod_target_xcconfig    = {
+          "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
+          "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
+          "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+      }
+      s.dependency "React-Codegen"
+      s.dependency "RCT-Folly"
+      s.dependency "RCTRequired"
+      s.dependency "RCTTypeSafety"
+      s.dependency "ReactCommon/turbomodule/core"
+    end
+  end
+end

package/src/Utils.ts

@@ -0,0 +1,14 @@
+import {
+  Platform,
+} from 'react-native';
+import ReactNativeBlobUtil from 'react-native-blob-util';
+export const downloadBundleFile = async (uri: string, headers?: object) => {
+  const res = await  ReactNativeBlobUtil
+    .config({
+      fileCache: Platform.OS === 'android',
+    })
+    .fetch('GET', uri, {
+      ...headers,
+    });
+  return res.path();
+};

package/src/index.tsx

@@ -0,0 +1,106 @@
+import { NativeModules, Platform } from 'react-native';
+import {downloadBundleFile} from './Utils.ts';
+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
+  updateSuccess?(): void
+  updateFail?(message?: string): void
+  restartAfterInstall?: boolean
+}
+const RNhotupdate = NativeModules.RNhotupdate
+  ? NativeModules.RNhotupdate
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+function setupBundlePath(path: string): Promise<boolean> {
+  return RNhotupdate.setupBundlePath(path);
+}
+function deleteBundlePath(): Promise<boolean> {
+  return RNhotupdate.deleteBundle();
+}
+function getCurrentVersion(): Promise<string> {
+  return RNhotupdate.getCurrentVersion();
+}
+async function getVersionAsNumber() {
+  const rawVersion = await getCurrentVersion();
+  return +rawVersion;
+}
+function setCurrentVersion(version: number): Promise<boolean> {
+  return RNhotupdate.setCurrentVersion(version + '');
+}
+async function resetApp() {
+  RNhotupdate.restart();
+}
+function removeBundle(restartAfterRemoved?: boolean) {
+  deleteBundlePath().then(data => {
+    if (data && restartAfterRemoved) {
+      setTimeout(() => {
+        resetApp();
+      }, 300);
+      if (data) {
+        setCurrentVersion(0);
+      }
+    }
+  });
+}
+const installFail = (option?: UpdateOption, e?: any) => {
+  option?.updateFail?.(JSON.stringify(e));
+  console.error('Download bundle fail', JSON.stringify(e));
+};
+async function downloadBundleUri(uri: string, version: number, option?: UpdateOption) {
+  if (!uri) {
+    installFail(option, 'Please give a valid URL!');
+    return;
+  }
+  if (!version) {
+    installFail(option, 'Please give a valid version!');
+    return;
+  }
+  const currentVersion = await getVersionAsNumber();
+  if (version <= currentVersion) {
+    installFail(option, 'Please give a bigger version than the current version, the current version now has setted by: ' + currentVersion);
+    return;
+  }
+  try {
+    const path = await downloadBundleFile(uri, option?.headers);
+    if (path) {
+      setupBundlePath(path).then(success => {
+        if (success) {
+          setCurrentVersion(version);
+          option?.updateSuccess?.();
+          if (option?.restartAfterInstall) {
+            setTimeout(() => {
+              resetApp();
+            }, 300);
+          }
+        } else {
+          installFail(option);
+        }
+      });
+    } else {
+      installFail(option);
+    }
+  } catch (e) {
+    installFail(option, e);
+  }
+}
+
+export default {
+  setupBundlePath,
+  removeUpdate: removeBundle,
+  downloadBundleUri,
+  resetApp,
+  getCurrentVersion: getVersionAsNumber,
+  setCurrentVersion,
+};