react-native-ota-hot-update 2.3.6 → 2.4.0-rc.2

package/android/generated/java/com/otahotupdate/NativeOtaHotUpdateSpec.java

@@ -19,6 +19,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.turbomodule.core.interfaces.TurboModule;
 import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 public abstract class NativeOtaHotUpdateSpec extends ReactContextBaseJavaModule implements TurboModule {
   public static final String NAME = "OtaHotUpdate";
@@ -34,7 +35,7 @@ public abstract class NativeOtaHotUpdateSpec extends ReactContextBaseJavaModule
 
   @ReactMethod
   @DoNotStrip
-  public abstract void setupBundlePath(String path, String extension, Promise promise);
+  public abstract void setupBundlePath(String path, String extension, @Nullable Double version, @Nullable Double maxVersions, @Nullable String metadata, Promise promise);
 
   @ReactMethod
   @DoNotStrip
@@ -67,4 +68,16 @@ public abstract class NativeOtaHotUpdateSpec extends ReactContextBaseJavaModule
   @ReactMethod
   @DoNotStrip
   public abstract void rollbackToPreviousBundle(double a, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void getBundleList(double a, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void deleteBundleById(String id, Promise promise);
+
+  @ReactMethod
+  @DoNotStrip
+  public abstract void clearAllBundles(double a, Promise promise);
 }

package/android/generated/jni/RNOtaHotUpdateSpec-generated.cpp

@@ -14,7 +14,7 @@ namespace facebook::react {
 
 static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_setupBundlePath(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
   static jmethodID cachedMethodId = nullptr;
-  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "setupBundlePath", "(Ljava/lang/String;Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "setupBundlePath", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Double;Ljava/lang/Double;Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
 static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_setExactBundlePath(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
@@ -57,9 +57,24 @@ static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_rollbackToP
   return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "rollbackToPreviousBundle", "(DLcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
 }
 
+static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_getBundleList(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "getBundleList", "(DLcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_deleteBundleById(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "deleteBundleById", "(Ljava/lang/String;Lcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeOtaHotUpdateSpecJSI_clearAllBundles(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, PromiseKind, "clearAllBundles", "(DLcom/facebook/react/bridge/Promise;)V", args, count, cachedMethodId);
+}
+
 NativeOtaHotUpdateSpecJSI::NativeOtaHotUpdateSpecJSI(const JavaTurboModule::InitParams &params)
   : JavaTurboModule(params) {
-  methodMap_["setupBundlePath"] = MethodMetadata {2, __hostFunction_NativeOtaHotUpdateSpecJSI_setupBundlePath};
+  methodMap_["setupBundlePath"] = MethodMetadata {5, __hostFunction_NativeOtaHotUpdateSpecJSI_setupBundlePath};
   methodMap_["setExactBundlePath"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_setExactBundlePath};
   methodMap_["deleteBundle"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_deleteBundle};
   methodMap_["restart"] = MethodMetadata {0, __hostFunction_NativeOtaHotUpdateSpecJSI_restart};
@@ -68,6 +83,9 @@ NativeOtaHotUpdateSpecJSI::NativeOtaHotUpdateSpecJSI(const JavaTurboModule::Init
   methodMap_["setCurrentVersion"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_setCurrentVersion};
   methodMap_["setUpdateMetadata"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_setUpdateMetadata};
   methodMap_["rollbackToPreviousBundle"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_rollbackToPreviousBundle};
+  methodMap_["getBundleList"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_getBundleList};
+  methodMap_["deleteBundleById"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_deleteBundleById};
+  methodMap_["clearAllBundles"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateSpecJSI_clearAllBundles};
 }
 
 std::shared_ptr<TurboModule> RNOtaHotUpdateSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {

package/android/generated/jni/react/renderer/components/RNOtaHotUpdateSpec/RNOtaHotUpdateSpecJSI-generated.cpp

@@ -15,7 +15,10 @@ static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setupBundlePath(js
   return static_cast<NativeOtaHotUpdateCxxSpecJSI *>(&turboModule)->setupBundlePath(
     rt,
     count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt),
-    count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asString(rt)
+    count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asString(rt),
+    count <= 2 || args[2].isUndefined() ? std::nullopt : std::make_optional(args[2].asNumber()),
+    count <= 3 || args[3].isUndefined() ? std::nullopt : std::make_optional(args[3].asNumber()),
+    count <= 4 || args[4].isUndefined() ? std::nullopt : std::make_optional(args[4].asString(rt))
   );
 }
 static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setExactBundlePath(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
@@ -66,10 +69,28 @@ static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_rollbackToPrevious
     count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber()
   );
 }
+static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_getBundleList(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeOtaHotUpdateCxxSpecJSI *>(&turboModule)->getBundleList(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber()
+  );
+}
+static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_deleteBundleById(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeOtaHotUpdateCxxSpecJSI *>(&turboModule)->deleteBundleById(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+}
+static jsi::Value __hostFunction_NativeOtaHotUpdateCxxSpecJSI_clearAllBundles(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativeOtaHotUpdateCxxSpecJSI *>(&turboModule)->clearAllBundles(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber()
+  );
+}
 
 NativeOtaHotUpdateCxxSpecJSI::NativeOtaHotUpdateCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
   : TurboModule("OtaHotUpdate", jsInvoker) {
-  methodMap_["setupBundlePath"] = MethodMetadata {2, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setupBundlePath};
+  methodMap_["setupBundlePath"] = MethodMetadata {5, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setupBundlePath};
   methodMap_["setExactBundlePath"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setExactBundlePath};
   methodMap_["deleteBundle"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_deleteBundle};
   methodMap_["restart"] = MethodMetadata {0, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_restart};
@@ -78,6 +99,9 @@ NativeOtaHotUpdateCxxSpecJSI::NativeOtaHotUpdateCxxSpecJSI(std::shared_ptr<CallI
   methodMap_["setCurrentVersion"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setCurrentVersion};
   methodMap_["setUpdateMetadata"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_setUpdateMetadata};
   methodMap_["rollbackToPreviousBundle"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_rollbackToPreviousBundle};
+  methodMap_["getBundleList"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_getBundleList};
+  methodMap_["deleteBundleById"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_deleteBundleById};
+  methodMap_["clearAllBundles"] = MethodMetadata {1, __hostFunction_NativeOtaHotUpdateCxxSpecJSI_clearAllBundles};
 }
 
 

package/android/generated/jni/react/renderer/components/RNOtaHotUpdateSpec/RNOtaHotUpdateSpecJSI.h

@@ -20,7 +20,7 @@ protected:
   NativeOtaHotUpdateCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
 
 public:
-  virtual jsi::Value setupBundlePath(jsi::Runtime &rt, jsi::String path, jsi::String extension) = 0;
+  virtual jsi::Value setupBundlePath(jsi::Runtime &rt, jsi::String path, jsi::String extension, std::optional<double> version, std::optional<double> maxVersions, std::optional<jsi::String> metadata) = 0;
   virtual jsi::Value setExactBundlePath(jsi::Runtime &rt, jsi::String path) = 0;
   virtual jsi::Value deleteBundle(jsi::Runtime &rt, double i) = 0;
   virtual void restart(jsi::Runtime &rt) = 0;
@@ -29,6 +29,9 @@ public:
   virtual jsi::Value setCurrentVersion(jsi::Runtime &rt, jsi::String version) = 0;
   virtual jsi::Value setUpdateMetadata(jsi::Runtime &rt, jsi::String metadata) = 0;
   virtual jsi::Value rollbackToPreviousBundle(jsi::Runtime &rt, double a) = 0;
+  virtual jsi::Value getBundleList(jsi::Runtime &rt, double a) = 0;
+  virtual jsi::Value deleteBundleById(jsi::Runtime &rt, jsi::String id) = 0;
+  virtual jsi::Value clearAllBundles(jsi::Runtime &rt, double a) = 0;
 
 };
 
@@ -55,13 +58,13 @@ private:
 
     }
 
-    jsi::Value setupBundlePath(jsi::Runtime &rt, jsi::String path, jsi::String extension) override {
+    jsi::Value setupBundlePath(jsi::Runtime &rt, jsi::String path, jsi::String extension, std::optional<double> version, std::optional<double> maxVersions, std::optional<jsi::String> metadata) override {
       static_assert(
-          bridging::getParameterCount(&T::setupBundlePath) == 3,
-          "Expected setupBundlePath(...) to have 3 parameters");
+          bridging::getParameterCount(&T::setupBundlePath) == 6,
+          "Expected setupBundlePath(...) to have 6 parameters");
 
       return bridging::callFromJs<jsi::Value>(
-          rt, &T::setupBundlePath, jsInvoker_, instance_, std::move(path), std::move(extension));
+          rt, &T::setupBundlePath, jsInvoker_, instance_, std::move(path), std::move(extension), std::move(version), std::move(maxVersions), std::move(metadata));
     }
     jsi::Value setExactBundlePath(jsi::Runtime &rt, jsi::String path) override {
       static_assert(
@@ -127,6 +130,30 @@ private:
       return bridging::callFromJs<jsi::Value>(
           rt, &T::rollbackToPreviousBundle, jsInvoker_, instance_, std::move(a));
     }
+    jsi::Value getBundleList(jsi::Runtime &rt, double a) override {
+      static_assert(
+          bridging::getParameterCount(&T::getBundleList) == 2,
+          "Expected getBundleList(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::getBundleList, jsInvoker_, instance_, std::move(a));
+    }
+    jsi::Value deleteBundleById(jsi::Runtime &rt, jsi::String id) override {
+      static_assert(
+          bridging::getParameterCount(&T::deleteBundleById) == 2,
+          "Expected deleteBundleById(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::deleteBundleById, jsInvoker_, instance_, std::move(id));
+    }
+    jsi::Value clearAllBundles(jsi::Runtime &rt, double a) override {
+      static_assert(
+          bridging::getParameterCount(&T::clearAllBundles) == 2,
+          "Expected clearAllBundles(...) to have 2 parameters");
+
+      return bridging::callFromJs<jsi::Value>(
+          rt, &T::clearAllBundles, jsInvoker_, instance_, std::move(a));
+    }
 
   private:
     friend class NativeOtaHotUpdateCxxSpec;

package/android/src/main/java/com/otahotupdate/OtaHotUpdateModule.kt

@@ -6,12 +6,15 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.jakewharton.processphoenix.ProcessPhoenix
 import com.otahotupdate.OtaHotUpdate.Companion.getVersionCode
+import com.rnhotupdate.Common
 import com.rnhotupdate.Common.CURRENT_VERSION_CODE
 import com.rnhotupdate.Common.PATH
 import com.rnhotupdate.Common.PREVIOUS_PATH
 import com.rnhotupdate.Common.VERSION
 import com.rnhotupdate.Common.PREVIOUS_VERSION
 import com.rnhotupdate.Common.METADATA
+import com.rnhotupdate.Common.BUNDLE_HISTORY
+import com.rnhotupdate.Common.DEFAULT_MAX_BUNDLE_VERSIONS
 import com.rnhotupdate.SharedPrefs
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -20,6 +23,15 @@ import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import java.io.File
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class BundleVersion(
+  val version: Int,
+  val path: String,
+  val timestamp: Long,
+  val metadata: String? = null
+)
 
 class OtaHotUpdateModule internal constructor(context: ReactApplicationContext) :
   OtaHotUpdateSpec(context) {
@@ -35,20 +47,173 @@ class OtaHotUpdateModule internal constructor(context: ReactApplicationContext)
     scope.cancel()
   }
 
-  private fun processBundleFile(path: String?, extension: String?): Boolean {
+  private fun loadBundleHistory(): List<BundleVersion> {
+    val sharedPrefs = SharedPrefs(reactApplicationContext)
+    val historyJson = sharedPrefs.getString(BUNDLE_HISTORY)
+    
+    // If history exists, load it
+    if (!historyJson.isNullOrEmpty()) {
+      return try {
+        val jsonArray = JSONArray(historyJson)
+        (0 until jsonArray.length()).map { i ->
+          val obj = jsonArray.getJSONObject(i)
+          BundleVersion(
+            version = obj.getInt("version"),
+            path = obj.getString("path"),
+            timestamp = obj.getLong("timestamp"),
+            metadata = if (obj.has("metadata") && !obj.isNull("metadata")) obj.getString("metadata") else null
+          )
+        }
+      } catch (e: Exception) {
+        emptyList()
+      }
+    }
+    
+    // Migration: If history is empty but PATH exists, migrate from old system
+    val currentPath = sharedPrefs.getString(PATH)
+    val currentVersion = sharedPrefs.getString(VERSION)
+    val previousPath = sharedPrefs.getString(PREVIOUS_PATH)
+    val previousVersion = sharedPrefs.getString(PREVIOUS_VERSION)
+    
+    if (currentPath.isNullOrEmpty()) {
+      return emptyList()
+    }
+    
+    // Migrate current bundle
+    val migratedHistory = mutableListOf<BundleVersion>()
+    
+    // Add current bundle if has version
+    if (!currentVersion.isNullOrEmpty()) {
+      try {
+        val version = currentVersion.toInt()
+        val bundleFile = File(currentPath)
+        if (bundleFile.exists()) {
+          migratedHistory.add(
+            BundleVersion(
+              version = version,
+              path = currentPath,
+              timestamp = bundleFile.lastModified(), // Use file modification time
+              metadata = null
+            )
+          )
+        }
+      } catch (e: Exception) {
+        // Version is not a number, skip
+      }
+    }
+    
+    // Add previous bundle if exists
+    if (!previousPath.isNullOrEmpty() && !previousVersion.isNullOrEmpty()) {
+      try {
+        val version = previousVersion.toInt()
+        val bundleFile = File(previousPath)
+        if (bundleFile.exists()) {
+          migratedHistory.add(
+            BundleVersion(
+              version = version,
+              path = previousPath,
+              timestamp = bundleFile.lastModified(),
+              metadata = null
+            )
+          )
+        }
+      } catch (e: Exception) {
+        // Version is not a number, skip
+      }
+    }
+    
+    // Save migrated history if any
+    if (migratedHistory.isNotEmpty()) {
+      saveBundleHistory(migratedHistory.sortedByDescending { it.version })
+    }
+    
+    return migratedHistory.sortedByDescending { it.version }
+  }
+
+  private fun saveBundleHistory(history: List<BundleVersion>) {
+    val sharedPrefs = SharedPrefs(reactApplicationContext)
+    val jsonArray = JSONArray()
+    history.forEach { bundle ->
+      val obj = JSONObject()
+      obj.put("version", bundle.version)
+      obj.put("path", bundle.path)
+      obj.put("timestamp", bundle.timestamp)
+      if (bundle.metadata != null) {
+        obj.put("metadata", bundle.metadata)
+      } else {
+        obj.put("metadata", JSONObject.NULL)
+      }
+      jsonArray.put(obj)
+    }
+    sharedPrefs.putString(BUNDLE_HISTORY, jsonArray.toString())
+  }
+
+  private fun extractFolderName(path: String): String {
+    val file = File(path)
+    return file.parentFile?.name ?: ""
+  }
+
+  private fun saveBundleVersion(
+    newPath: String,
+    version: Int,
+    maxVersions: Int,
+    metadata: String?
+  ) {
+    val sharedPrefs = SharedPrefs(reactApplicationContext)
+    val history = loadBundleHistory()
+
+    // Add new version
+    val newBundle = BundleVersion(
+      version = version,
+      path = newPath,
+      timestamp = System.currentTimeMillis(),
+      metadata = metadata
+    )
+
+    // Combine and sort by version descending
+    val updatedHistory = (listOf(newBundle) + history)
+      .sortedByDescending { it.version }
+      .distinctBy { it.version } // Remove duplicates by version
+
+    // Keep only maxVersions most recent
+    val finalHistory = updatedHistory.take(maxVersions)
+
+    // Delete old versions beyond limit
+    val versionsToKeep = finalHistory.map { it.version }.toSet()
+    updatedHistory.forEach { bundle ->
+      if (bundle.version !in versionsToKeep) {
+        utils.deleteOldBundleIfneeded(bundle.path)
+      }
+    }
+
+    // Save updated history
+    saveBundleHistory(finalHistory)
+
+    // Set current path
+    sharedPrefs.putString(PATH, newPath)
+    sharedPrefs.putString(VERSION, version.toString())
+  }
+
+  private fun processBundleFile(path: String?, extension: String?, version: Int?, maxVersions: Int?, metadata: String?): Boolean {
     if (path != null) {
       val file = File(path)
       if (file.exists() && file.isFile) {
-        val fileUnzip = utils.extractZipFile(file, extension ?: ".bundle")
+        val fileUnzip = utils.extractZipFile(file, extension ?: ".bundle", version)
         if (fileUnzip != null) {
           file.delete()
           utils.deleteOldBundleIfneeded(null)
           val sharedPrefs = SharedPrefs(reactApplicationContext)
           val oldPath = sharedPrefs.getString(PATH)
-          if (!oldPath.isNullOrEmpty()) {
-            sharedPrefs.putString(PREVIOUS_PATH, oldPath)
+          
+          // If version is provided, save to history system
+          if (version != null) {
+            val maxVersionsToKeep = maxVersions ?: Common.DEFAULT_MAX_BUNDLE_VERSIONS
+            saveBundleVersion(fileUnzip, version, maxVersionsToKeep, metadata)
+          } else {
+            // No version (e.g., Git update) - just set path, no history
+            sharedPrefs.putString(PATH, fileUnzip)
           }
-          sharedPrefs.putString(PATH, fileUnzip)
+          
           sharedPrefs.putString(
             CURRENT_VERSION_CODE,
             reactApplicationContext.getVersionCode()
@@ -66,10 +231,12 @@ class OtaHotUpdateModule internal constructor(context: ReactApplicationContext)
     }
   }
   @ReactMethod
-  override fun setupBundlePath(path: String?, extension: String?, promise: Promise) {
+  override fun setupBundlePath(path: String?, extension: String?, version: Double?, maxVersions: Double?, metadata: String?, promise: Promise) {
     scope.launch {
       try {
-        val result = processBundleFile(path, extension)
+        val versionInt = version?.toInt()
+        val maxVersionsInt = maxVersions?.toInt()
+        val result = processBundleFile(path, extension, versionInt, maxVersionsInt, metadata)
         withContext(Dispatchers.Main) {
           promise.resolve(result)
         }
@@ -83,11 +250,34 @@ class OtaHotUpdateModule internal constructor(context: ReactApplicationContext)
 
   @ReactMethod
   override fun deleteBundle(i: Double, promise: Promise) {
-    val isDeleted = utils.deleteOldBundleIfneeded(PATH)
-    val isDeletedOldPath = utils.deleteOldBundleIfneeded(PREVIOUS_PATH)
-    val sharedPrefs = SharedPrefs(reactApplicationContext)
-    sharedPrefs.putString(VERSION, "0")
-    promise.resolve(isDeleted && isDeletedOldPath)
+    scope.launch {
+      try {
+        val sharedPrefs = SharedPrefs(reactApplicationContext)
+        val currentPath = sharedPrefs.getString(PATH)
+        
+        // Delete current bundle from file system
+        val isDeleted = utils.deleteOldBundleIfneeded(PATH)
+        
+        // Remove current bundle from history if exists
+        if (currentPath != null && currentPath.isNotEmpty()) {
+          val history = loadBundleHistory()
+          val updatedHistory = history.filter { it.path != currentPath }
+          saveBundleHistory(updatedHistory)
+        }
+        
+        // Clear paths and version (no longer clear PREVIOUS_PATH, use history instead)
+        sharedPrefs.putString(PATH, "")
+        sharedPrefs.putString(VERSION, "0")
+        
+        withContext(Dispatchers.Main) {
+          promise.resolve(isDeleted)
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise.reject("DELETE_BUNDLE_ERROR", e)
+        }
+      }
+    }
   }
 
   @ReactMethod
@@ -110,12 +300,7 @@ class OtaHotUpdateModule internal constructor(context: ReactApplicationContext)
   @ReactMethod
   override fun setCurrentVersion(version: String?, promise: Promise) {
     val sharedPrefs = SharedPrefs(reactApplicationContext)
-
-    val currentVersion = sharedPrefs.getString(VERSION)
-    if (currentVersion != "" && currentVersion != version) {
-      sharedPrefs.putString(PREVIOUS_VERSION, currentVersion)
-    }
-
+    // No longer save PREVIOUS_VERSION, use history instead
     sharedPrefs.putString(VERSION, version)
     promise.resolve(true)
   }
@@ -157,31 +342,175 @@ class OtaHotUpdateModule internal constructor(context: ReactApplicationContext)
 
   @ReactMethod
   override fun rollbackToPreviousBundle(a: Double, promise: Promise) {
-    val sharedPrefs = SharedPrefs(reactApplicationContext)
-    val oldPath = sharedPrefs.getString(PREVIOUS_PATH)
-    val previousVersion = sharedPrefs.getString(PREVIOUS_VERSION)
+    scope.launch {
+      try {
+        val sharedPrefs = SharedPrefs(reactApplicationContext)
+        val currentPath = sharedPrefs.getString(PATH)
 
-    if (oldPath != "") {
-      val isDeleted = utils.deleteOldBundleIfneeded(PATH)
-      if (isDeleted) {
-        sharedPrefs.putString(PATH, oldPath)
-        sharedPrefs.putString(PREVIOUS_PATH, "")
+        // Use history to find previous version (closest to current)
+        val history = loadBundleHistory()
+        if (history.isNotEmpty() && currentPath != null && currentPath.isNotEmpty()) {
+          // Find current bundle in history
+          val currentBundle = history.find { it.path == currentPath }
+          if (currentBundle != null) {
+            // Find previous version (version < current, max version = closest to current)
+            val previousBundle = history
+              .filter { it.version < currentBundle.version }
+              .maxByOrNull { it.version }
 
-        if (previousVersion != "") {
-          sharedPrefs.putString(VERSION, previousVersion)
-          sharedPrefs.putString(PREVIOUS_VERSION, "")
-        } else {
-          sharedPrefs.putString(VERSION, "")
+            if (previousBundle != null && File(previousBundle.path).exists()) {
+              // Rollback to previous bundle from history
+              val isDeleted = utils.deleteOldBundleIfneeded(PATH)
+              if (isDeleted) {
+                sharedPrefs.putString(PATH, previousBundle.path)
+                sharedPrefs.putString(VERSION, previousBundle.version.toString())
+                
+                withContext(Dispatchers.Main) {
+                  promise.resolve(true)
+                }
+                return@launch
+              }
+            }
+          }
         }
 
-        promise.resolve(true)
-      } else {
-        promise.resolve(false)
+        withContext(Dispatchers.Main) {
+          promise.resolve(false)
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise.reject("ROLLBACK_ERROR", e)
+        }
       }
-    } else {
-      promise.resolve(false)
     }
   }
+
+  @ReactMethod
+  override fun getBundleList(a: Double, promise: Promise) {
+    scope.launch {
+      try {
+        val history = loadBundleHistory()
+        val sharedPrefs = SharedPrefs(reactApplicationContext)
+        val activePath = sharedPrefs.getString(PATH)
+
+        val bundleList = history.map { bundle ->
+          val folderName = extractFolderName(bundle.path)
+          val bundleObj = JSONObject()
+          bundleObj.put("id", folderName)
+          bundleObj.put("version", bundle.version)
+          bundleObj.put("date", bundle.timestamp)
+          bundleObj.put("path", bundle.path)
+          bundleObj.put("isActive", bundle.path == activePath)
+          if (bundle.metadata != null) {
+            try {
+              // Try to parse as JSON, if fails use as string
+              val metadataJson = JSONObject(bundle.metadata)
+              bundleObj.put("metadata", metadataJson)
+            } catch (e: Exception) {
+              bundleObj.put("metadata", bundle.metadata)
+            }
+          } else {
+            bundleObj.put("metadata", JSONObject.NULL)
+          }
+          bundleObj
+        }
+
+        val jsonArray = JSONArray()
+        bundleList.forEach { jsonArray.put(it) }
+
+        withContext(Dispatchers.Main) {
+          promise.resolve(jsonArray.toString())
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise.reject("GET_BUNDLE_LIST_ERROR", e)
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun deleteBundleById(id: String, promise: Promise) {
+    scope.launch {
+      try {
+        val history = loadBundleHistory()
+        val sharedPrefs = SharedPrefs(reactApplicationContext)
+        val activePath = sharedPrefs.getString(PATH)
+
+        val bundleToDelete = history.find { extractFolderName(it.path) == id }
+        if (bundleToDelete == null) {
+          withContext(Dispatchers.Main) {
+            promise.resolve(false)
+          }
+          return@launch
+        }
+
+        // If deleting active bundle, rollback to oldest remaining bundle or clear
+        if (bundleToDelete.path == activePath) {
+          val remainingBundles = history.filter { it.path != bundleToDelete.path }
+          if (remainingBundles.isNotEmpty()) {
+            val oldestBundle = remainingBundles.minByOrNull { it.version }
+            if (oldestBundle != null) {
+              sharedPrefs.putString(PATH, oldestBundle.path)
+              sharedPrefs.putString(VERSION, oldestBundle.version.toString())
+            } else {
+              sharedPrefs.putString(PATH, "")
+              sharedPrefs.putString(VERSION, "")
+            }
+          } else {
+            sharedPrefs.putString(PATH, "")
+            sharedPrefs.putString(VERSION, "")
+          }
+        }
+
+        // Delete bundle folder
+        val isDeleted = utils.deleteOldBundleIfneeded(bundleToDelete.path)
+
+        // Remove from history
+        val updatedHistory = history.filter { it.path != bundleToDelete.path }
+        saveBundleHistory(updatedHistory)
+
+        withContext(Dispatchers.Main) {
+          promise.resolve(isDeleted)
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise.reject("DELETE_BUNDLE_ERROR", e)
+        }
+      }
+    }
+  }
+
+  @ReactMethod
+  override fun clearAllBundles(a: Double, promise: Promise) {
+    scope.launch {
+      try {
+        val history = loadBundleHistory()
+        val sharedPrefs = SharedPrefs(reactApplicationContext)
+
+        // Delete all bundle folders
+        history.forEach { bundle ->
+          utils.deleteOldBundleIfneeded(bundle.path)
+        }
+
+        // Clear history
+        saveBundleHistory(emptyList())
+
+        // Clear current path and version
+        sharedPrefs.putString(PATH, "")
+        sharedPrefs.putString(VERSION, "")
+
+        withContext(Dispatchers.Main) {
+          promise.resolve(true)
+        }
+      } catch (e: Exception) {
+        withContext(Dispatchers.Main) {
+          promise.reject("CLEAR_ALL_BUNDLES_ERROR", e)
+        }
+      }
+    }
+  }
+
   companion object {
     const val NAME = "OtaHotUpdate"
   }