@hot-updater/react-native 0.11.0 → 0.12.1-0

package/android/src/main/java/com/hotupdater/HotUpdater.kt

@@ -128,13 +128,34 @@ class HotUpdater : ReactPackage {
 
             val baseDir = context.getExternalFilesDir(null)
             val bundleStoreDir = File(baseDir, "bundle-store")
-            val zipFilePath = File(bundleStoreDir, "build.zip")
+            if (!bundleStoreDir.exists()) {
+                bundleStoreDir.mkdirs()
+            }
+
+            val finalBundleDir = File(bundleStoreDir, bundleId)
+            if (finalBundleDir.exists()) {
+                Log.d("HotUpdater", "Bundle for bundleId $bundleId already exists. Using cached bundle.")
+                val existingIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
+                if (existingIndexFile != null) {
+                    // Update directory modification time to current time after update
+                    finalBundleDir.setLastModified(System.currentTimeMillis())
+                    setBundleURL(context, existingIndexFile.absolutePath)
+                    cleanupOldBundles(bundleStoreDir)
+                    return true
+                } else {
+                    finalBundleDir.deleteRecursively()
+                }
+            }
 
-            // Delete existing folder logic
-            if (bundleStoreDir.exists()) {
-                bundleStoreDir.deleteRecursively()
+            val tempDir = File(baseDir, "bundle-temp")
+            if (tempDir.exists()) {
+                tempDir.deleteRecursively()
             }
-            bundleStoreDir.mkdirs()
+            tempDir.mkdirs()
+
+            val tempZipFile = File(tempDir, "build.zip")
+            val extractedDir = File(tempDir, "extracted")
+            extractedDir.mkdirs()
 
             val isSuccess =
                 withContext(Dispatchers.IO) {
@@ -144,6 +165,7 @@ class HotUpdater : ReactPackage {
                             downloadUrl.openConnection() as HttpURLConnection
                         } catch (e: Exception) {
                             Log.d("HotUpdater", "Failed to open connection: ${e.message}")
+                            tempDir.deleteRecursively()
                             return@withContext false
                         }
 
@@ -152,12 +174,11 @@ class HotUpdater : ReactPackage {
                         val totalSize = conn.contentLength
                         if (totalSize <= 0) {
                             Log.d("HotUpdater", "Invalid content length: $totalSize")
+                            tempDir.deleteRecursively()
                             return@withContext false
                         }
-
-                        // File download
                         conn.inputStream.use { input ->
-                            zipFilePath.outputStream().use { output ->
+                            tempZipFile.outputStream().use { output ->
                                 val buffer = ByteArray(8 * 1024)
                                 var bytesRead: Int
                                 var totalRead = 0L
@@ -178,34 +199,80 @@ class HotUpdater : ReactPackage {
                         }
                     } catch (e: Exception) {
                         Log.d("HotUpdater", "Failed to download data from URL: $zipUrl, Error: ${e.message}")
+                        tempDir.deleteRecursively()
                         return@withContext false
                     } finally {
                         conn.disconnect()
                     }
 
-                    // Extract zip
-                    if (!extractZipFileAtPath(zipFilePath.absolutePath, bundleStoreDir.absolutePath)) {
+                    if (!extractZipFileAtPath(tempZipFile.absolutePath, extractedDir.absolutePath)) {
                         Log.d("HotUpdater", "Failed to extract zip file.")
+                        tempDir.deleteRecursively()
                         return@withContext false
                     }
+                    true
+                }
 
-                    // Find index.android.bundle
-                    val indexFile = bundleStoreDir.walk().find { it.name == "index.android.bundle" }
+            if (!isSuccess) {
+                tempDir.deleteRecursively()
+                return false
+            }
 
-                    if (indexFile != null) {
-                        val bundlePath = indexFile.absolutePath
-                        Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
-                        setBundleURL(context, bundlePath)
-                    } else {
-                        Log.d("HotUpdater", "index.android.bundle not found.")
-                        return@withContext false
-                    }
+            val indexFileExtracted = extractedDir.walk().find { it.name == "index.android.bundle" }
+            if (indexFileExtracted == null) {
+                Log.d("HotUpdater", "index.android.bundle not found in extracted files.")
+                tempDir.deleteRecursively()
+                return false
+            }
 
-                    Log.d("HotUpdater", "Downloaded and extracted file successfully.")
-                    true
-                }
+            // Move (or copy) contents from temp folder to finalBundleDir
+            if (finalBundleDir.exists()) {
+                finalBundleDir.deleteRecursively()
+            }
+            if (!extractedDir.renameTo(finalBundleDir)) {
+                extractedDir.copyRecursively(finalBundleDir, overwrite = true)
+                extractedDir.deleteRecursively()
+            }
+
+            val finalIndexFile = finalBundleDir.walk().find { it.name == "index.android.bundle" }
+            if (finalIndexFile == null) {
+                Log.d("HotUpdater", "index.android.bundle not found in final directory.")
+                tempDir.deleteRecursively()
+                return false
+            }
+
+            // Update final bundle directory modification time to current time after bundle update
+            finalBundleDir.setLastModified(System.currentTimeMillis())
+
+            val bundlePath = finalIndexFile.absolutePath
+            Log.d("HotUpdater", "Setting bundle URL: $bundlePath")
+            setBundleURL(context, bundlePath)
+
+            // Clean up old bundles in the bundle store to keep only up to 2 bundles
+            cleanupOldBundles(bundleStoreDir)
 
-            return isSuccess
+            // Clean up temp directory
+            tempDir.deleteRecursively()
+
+            Log.d("HotUpdater", "Downloaded and extracted file successfully.")
+            return true
+        }
+
+        // Helper function to delete old bundles, keeping only up to 2 bundles in the bundle-store folder
+        private fun cleanupOldBundles(bundleStoreDir: File) {
+            // Get list of all directories in bundle-store folder
+            val bundles = bundleStoreDir.listFiles { file -> file.isDirectory }?.toList() ?: return
+
+            // Sort by last modified time in descending order to keep most recently updated bundles at the top
+            val sortedBundles = bundles.sortedByDescending { it.lastModified() }
+
+            // Delete all bundles except the top 2
+            if (sortedBundles.size > 2) {
+                sortedBundles.drop(2).forEach { oldBundle ->
+                    Log.d("HotUpdater", "Removing old bundle: ${oldBundle.name}")
+                    oldBundle.deleteRecursively()
+                }
+            }
         }
     }
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { checkForUpdate } from "./checkUpdate";
+import { checkForUpdate } from "./checkForUpdate";
 import { wrap } from "./wrap";
 export type { HotUpdaterConfig } from "./wrap";
 export type { HotUpdaterEvent } from "./native";

package/dist/native.d.ts

@@ -7,7 +7,7 @@ export declare const addListener: <T extends keyof HotUpdaterEvent>(eventName: T
 /**
  * Downloads files from given URLs.
  *
- * @param {string} bundleId - identifier for the bundle version.
+ * @param {string} bundleId - identifier for the bundle id.
  * @param {string | null} zipUrl - zip file URL. If null, it means rolling back to the built-in bundle
  * @returns {Promise<boolean>} Resolves with true if download was successful, otherwise rejects with an error.
  */

package/dist/runUpdateProcess.d.ts

@@ -1,4 +1,4 @@
-import { type CheckForUpdateConfig } from "./checkUpdate";
+import { type CheckForUpdateConfig } from "./checkForUpdate";
 export type RunUpdateProcessResponse = {
     status: "ROLLBACK" | "UPDATE";
     shouldForceUpdate: boolean;

package/dist/wrap.d.ts

@@ -1,5 +1,5 @@
 import type React from "react";
-import { type CheckForUpdateConfig } from "./checkUpdate";
+import { type CheckForUpdateConfig } from "./checkForUpdate";
 import { HotUpdaterError } from "./error";
 import type { RunUpdateProcessResponse } from "./runUpdateProcess";
 type UpdateStatus = "CHECK_FOR_UPDATE" | "UPDATING" | "UPDATE_PROCESS_COMPLETED";

package/ios/HotUpdater/HotUpdater.mm

@@ -49,7 +49,6 @@ RCT_EXPORT_MODULE();
 }
 
 + (NSURL *)fallbackURL {
-    // This supports React Native 0.72.6
 #if DEBUG
     return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
 #else
@@ -72,6 +71,48 @@ RCT_EXPORT_MODULE();
     return success;
 }
 
+#pragma mark - Cleanup Old Bundles
+
+- (void)cleanupOldBundlesAtDirectory:(NSString *)bundleStoreDir {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    NSError *error = nil;
+    NSArray *contents = [fileManager contentsOfDirectoryAtPath:bundleStoreDir error:&error];
+    if (error) {
+        NSLog(@"Failed to list bundle store directory: %@", error);
+        return;
+    }
+    
+    NSMutableArray *bundleDirs = [NSMutableArray array];
+    for (NSString *item in contents) {
+        NSString *fullPath = [bundleStoreDir stringByAppendingPathComponent:item];
+        BOOL isDir = NO;
+        if ([fileManager fileExistsAtPath:fullPath isDirectory:&isDir] && isDir) {
+            [bundleDirs addObject:fullPath];
+        }
+    }
+    
+    // Sort in descending order by modification time (keep latest 2)
+    [bundleDirs sortUsingComparator:^NSComparisonResult(NSString *path1, NSString *path2) {
+        NSDictionary *attr1 = [fileManager attributesOfItemAtPath:path1 error:nil];
+        NSDictionary *attr2 = [fileManager attributesOfItemAtPath:path2 error:nil];
+        NSDate *date1 = attr1[NSFileModificationDate] ?: [NSDate dateWithTimeIntervalSince1970:0];
+        NSDate *date2 = attr2[NSFileModificationDate] ?: [NSDate dateWithTimeIntervalSince1970:0];
+        return [date2 compare:date1];
+    }];
+    
+    if (bundleDirs.count > 2) {
+        NSArray *oldBundles = [bundleDirs subarrayWithRange:NSMakeRange(2, bundleDirs.count - 2)];
+        for (NSString *oldBundle in oldBundles) {
+            NSError *delError = nil;
+            if ([fileManager removeItemAtPath:oldBundle error:&delError]) {
+                NSLog(@"Removed old bundle: %@", oldBundle);
+            } else {
+                NSLog(@"Failed to remove old bundle %@: %@", oldBundle, delError);
+            }
+        }
+    }
+}
+
 #pragma mark - Update Bundle Method
 
 - (void)updateBundle:(NSString *)bundleId zipUrl:(NSURL *)zipUrl completion:(void (^)(BOOL success))completion {
@@ -83,88 +124,158 @@ RCT_EXPORT_MODULE();
         return;
     }
     
-    // Set app-specific path (dynamically using NSSearchPathForDirectoriesInDomains)
+    // Set document directory path and bundle store path
     NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
     NSString *bundleStoreDir = [documentsPath stringByAppendingPathComponent:@"bundle-store"];
-    NSString *zipFilePath = [bundleStoreDir stringByAppendingPathComponent:@"build.zip"];
     
-    // Delete existing folder
-    [self deleteFolderIfExists:bundleStoreDir];
-    // Create download folder
-    [[NSFileManager defaultManager] createDirectoryAtPath:bundleStoreDir withIntermediateDirectories:YES attributes:nil error:nil];
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if (![fileManager fileExistsAtPath:bundleStoreDir]) {
+        [fileManager createDirectoryAtPath:bundleStoreDir withIntermediateDirectories:YES attributes:nil error:nil];
+    }
+    
+    // Final bundle path (bundle-store/<bundleId>)
+    NSString *finalBundleDir = [bundleStoreDir stringByAppendingPathComponent:bundleId];
+    
+    // Check if cached bundle exists
+    if ([fileManager fileExistsAtPath:finalBundleDir]) {
+        NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:finalBundleDir];
+        NSString *foundBundle = nil;
+        for (NSString *file in enumerator) {
+            if ([file isEqualToString:@"index.ios.bundle"]) {
+                foundBundle = file;
+                break;
+            }
+        }
+        if (foundBundle) {
+            // Update modification time of final bundle
+            NSDictionary *attributes = @{NSFileModificationDate: [NSDate date]};
+            [fileManager setAttributes:attributes ofItemAtPath:finalBundleDir error:nil];
+            NSString *bundlePath = [finalBundleDir stringByAppendingPathComponent:foundBundle];
+            NSLog(@"Using cached bundle at path: %@", bundlePath);
+            [self setBundleURL:bundlePath];
+            [self cleanupOldBundlesAtDirectory:bundleStoreDir];
+            dispatch_async(dispatch_get_main_queue(), ^{
+                if (completion) completion(YES);
+            });
+            return;
+        } else {
+            [fileManager removeItemAtPath:finalBundleDir error:nil];
+        }
+    }
+    
+    // Set up temporary folder (for download and extraction)
+    NSString *tempDir = [documentsPath stringByAppendingPathComponent:@"bundle-temp"];
+    if ([fileManager fileExistsAtPath:tempDir]) {
+        [fileManager removeItemAtPath:tempDir error:nil];
+    }
+    [fileManager createDirectoryAtPath:tempDir withIntermediateDirectories:YES attributes:nil error:nil];
+    
+    NSString *tempZipFile = [tempDir stringByAppendingPathComponent:@"build.zip"];
+    NSString *extractedDir = [tempDir stringByAppendingPathComponent:@"extracted"];
+    [fileManager createDirectoryAtPath:extractedDir withIntermediateDirectories:YES attributes:nil error:nil];
     
     NSURLSessionConfiguration *configuration = [NSURLSessionConfiguration defaultSessionConfiguration];
     NSURLSession *session = [NSURLSession sessionWithConfiguration:configuration];
     
-    NSURLSessionDownloadTask *downloadTask = [session downloadTaskWithURL:zipUrl
-                                                        completionHandler:^(NSURL *location, NSURLResponse *response, NSError *error) {
+    NSURLSessionDownloadTask *downloadTask = [session downloadTaskWithURL:zipUrl completionHandler:^(NSURL *location, NSURLResponse *response, NSError *error) {
         if (error) {
             NSLog(@"Failed to download data from URL: %@, error: %@", zipUrl, error);
             if (completion) completion(NO);
             return;
         }
         
-        NSFileManager *fileManager = [NSFileManager defaultManager];
-        
-        // Remove existing file
-        if ([fileManager fileExistsAtPath:zipFilePath]) {
-            [fileManager removeItemAtPath:zipFilePath error:nil];
+        // Save temporary zip file
+        if ([fileManager fileExistsAtPath:tempZipFile]) {
+            [fileManager removeItemAtPath:tempZipFile error:nil];
         }
         
-        // Move downloaded file
-        NSError *moveError;
-        if (![fileManager moveItemAtURL:location toURL:[NSURL fileURLWithPath:zipFilePath] error:&moveError]) {
-            NSLog(@"Failed to save data: %@", moveError);
+        NSError *moveError = nil;
+        if (![fileManager moveItemAtURL:location toURL:[NSURL fileURLWithPath:tempZipFile] error:&moveError]) {
+            NSLog(@"Failed to save downloaded file: %@", moveError);
             if (completion) completion(NO);
             return;
         }
         
         // Extract zip
-        if (![self extractZipFileAtPath:zipFilePath toDestination:bundleStoreDir]) {
+        if (![self extractZipFileAtPath:tempZipFile toDestination:extractedDir]) {
             NSLog(@"Failed to extract zip file.");
             if (completion) completion(NO);
             return;
         }
         
-        // Search for bundle file (index.ios.bundle)
-        NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:bundleStoreDir];
-        NSString *filename = nil;
+        // Search for index.ios.bundle in extracted folder
+        NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:extractedDir];
+        NSString *foundBundle = nil;
         for (NSString *file in enumerator) {
             if ([file isEqualToString:@"index.ios.bundle"]) {
-                filename = file;
+                foundBundle = file;
                 break;
             }
         }
         
-        if (filename) {
-            NSString *bundlePath = [bundleStoreDir stringByAppendingPathComponent:filename];
-            NSLog(@"Setting bundle URL: %@", bundlePath);
-            dispatch_async(dispatch_get_main_queue(), ^{
-                [self setBundleURL:bundlePath];
-                if (completion) completion(YES);
-            });
-        } else {
-            NSLog(@"index.ios.bundle not found.");
+        if (!foundBundle) {
+            NSLog(@"index.ios.bundle not found in extracted files.");
+            if (completion) completion(NO);
+            return;
+        }
+        
+        // Move extracted folder to final bundle folder
+        if ([fileManager fileExistsAtPath:finalBundleDir]) {
+            [fileManager removeItemAtPath:finalBundleDir error:nil];
+        }
+        NSError *moveFinalError = nil;
+        BOOL moved = [fileManager moveItemAtPath:extractedDir toPath:finalBundleDir error:&moveFinalError];
+        if (!moved) {
+            // Try copy and delete if move fails
+            BOOL copied = [fileManager copyItemAtPath:extractedDir toPath:finalBundleDir error:&moveFinalError];
+            if (copied) {
+                [fileManager removeItemAtPath:extractedDir error:nil];
+            } else {
+                NSLog(@"Failed to move or copy extracted bundle: %@", moveFinalError);
+                if (completion) completion(NO);
+                return;
+            }
+        }
+        
+        // Recheck index.ios.bundle in final folder
+        NSDirectoryEnumerator *finalEnum = [fileManager enumeratorAtPath:finalBundleDir];
+        NSString *finalFoundBundle = nil;
+        for (NSString *file in finalEnum) {
+            if ([file isEqualToString:@"index.ios.bundle"]) {
+                finalFoundBundle = file;
+                break;
+            }
+        }
+        
+        if (!finalFoundBundle) {
+            NSLog(@"index.ios.bundle not found in final directory.");
             if (completion) completion(NO);
+            return;
         }
+        
+        // Update modification time of final bundle
+        NSDictionary *attributes = @{NSFileModificationDate: [NSDate date]};
+        [fileManager setAttributes:attributes ofItemAtPath:finalBundleDir error:nil];
+        
+        NSString *bundlePath = [finalBundleDir stringByAppendingPathComponent:finalFoundBundle];
+        NSLog(@"Setting bundle URL: %@", bundlePath);
+        dispatch_async(dispatch_get_main_queue(), ^{
+            [self setBundleURL:bundlePath];
+            [self cleanupOldBundlesAtDirectory:bundleStoreDir];
+            [fileManager removeItemAtPath:tempDir error:nil];
+            if (completion) completion(YES);
+        });
     }];
-
-
-    // Add observer for progress updates
-    [downloadTask addObserver:self
-                forKeyPath:@"countOfBytesReceived"
-                    options:NSKeyValueObservingOptionNew
-                    context:nil];
-    [downloadTask addObserver:self
-                forKeyPath:@"countOfBytesExpectedToReceive"
-                    options:NSKeyValueObservingOptionNew
-                    context:nil];
-
-    __block HotUpdater *weakSelf = self;
+    
+    // Register KVO for progress updates
+    [downloadTask addObserver:self forKeyPath:@"countOfBytesReceived" options:NSKeyValueObservingOptionNew context:nil];
+    [downloadTask addObserver:self forKeyPath:@"countOfBytesExpectedToReceive" options:NSKeyValueObservingOptionNew context:nil];
+    
+    __weak HotUpdater *weakSelf = self;
     [[NSNotificationCenter defaultCenter] addObserverForName:@"NSURLSessionDownloadTaskDidFinishDownloading"
-        object:downloadTask
-        queue:[NSOperationQueue mainQueue]
-    usingBlock:^(NSNotification * _Nonnull note) {
+                                                      object:downloadTask
+                                                       queue:[NSOperationQueue mainQueue]
+                                                  usingBlock:^(NSNotification * _Nonnull note) {
         [weakSelf removeObserversForTask:downloadTask];
     }];
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.11.0",
+  "version": "0.12.1-0",
   "description": "React Native OTA solution for self-hosted",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -78,8 +78,8 @@
     "react-native-builder-bob": "^0.33.1"
   },
   "dependencies": {
-    "@hot-updater/js": "0.11.0",
-    "@hot-updater/core": "0.11.0"
+    "@hot-updater/js": "0.12.1-0",
+    "@hot-updater/core": "0.12.1-0"
   },
   "scripts": {
     "build": "rslib build",

package/src/index.ts

@@ -1,4 +1,4 @@
-import { checkForUpdate } from "./checkUpdate";
+import { checkForUpdate } from "./checkForUpdate";
 import {
   addListener,
   getAppVersion,

package/src/native.ts

@@ -52,7 +52,7 @@ export const addListener = <T extends keyof HotUpdaterEvent>(
 /**
  * Downloads files from given URLs.
  *
- * @param {string} bundleId - identifier for the bundle version.
+ * @param {string} bundleId - identifier for the bundle id.
  * @param {string | null} zipUrl - zip file URL. If null, it means rolling back to the built-in bundle
  * @returns {Promise<boolean>} Resolves with true if download was successful, otherwise rejects with an error.
  */

package/src/runUpdateProcess.ts

@@ -1,4 +1,4 @@
-import { type CheckForUpdateConfig, checkForUpdate } from "./checkUpdate";
+import { type CheckForUpdateConfig, checkForUpdate } from "./checkForUpdate";
 import { reload, updateBundle } from "./native";
 
 export type RunUpdateProcessResponse =

package/src/wrap.tsx

@@ -1,6 +1,6 @@
 import type React from "react";
 import { useEffect, useLayoutEffect, useState } from "react";
-import { type CheckForUpdateConfig, checkForUpdate } from "./checkUpdate";
+import { type CheckForUpdateConfig, checkForUpdate } from "./checkForUpdate";
 import { HotUpdaterError } from "./error";
 import { useEventCallback } from "./hooks/useEventCallback";
 import { reload, updateBundle } from "./native";