@hot-updater/react-native 0.10.2 → 0.12.0

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

@@ -26,26 +26,6 @@ class HotUpdater : ReactPackage {
         listOf(HotUpdaterModule(context)).toMutableList()
 
     companion object {
-        private fun convertFileSystemPathFromBasePath(
-            context: Context,
-            basePath: String,
-        ): String {
-            val documentsDir =
-                context.getExternalFilesDir(null)?.absolutePath ?: context.filesDir.absolutePath
-            val separator = if (basePath.startsWith("/")) "" else "/"
-            return "$documentsDir$separator$basePath"
-        }
-
-        private fun stripPrefixFromPath(
-            prefix: String,
-            path: String,
-        ): String =
-            if (path.startsWith("/$prefix/")) {
-                path.replaceFirst("/$prefix/", "")
-            } else {
-                path
-            }
-
         fun getAppVersion(context: Context): String? {
             val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
             return packageInfo.versionName
@@ -146,17 +126,46 @@ class HotUpdater : ReactPackage {
                 return true
             }
 
-            val downloadUrl = URL(zipUrl)
-            val basePath = stripPrefixFromPath(bundleId, downloadUrl.path)
-            val path = convertFileSystemPathFromBasePath(context, basePath)
+            val baseDir = context.getExternalFilesDir(null)
+            val bundleStoreDir = File(baseDir, "bundle-store")
+            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()
+                }
+            }
+
+            val tempDir = File(baseDir, "bundle-temp")
+            if (tempDir.exists()) {
+                tempDir.deleteRecursively()
+            }
+            tempDir.mkdirs()
+
+            val tempZipFile = File(tempDir, "build.zip")
+            val extractedDir = File(tempDir, "extracted")
+            extractedDir.mkdirs()
 
             val isSuccess =
                 withContext(Dispatchers.IO) {
+                    val downloadUrl = URL(zipUrl)
                     val conn =
                         try {
                             downloadUrl.openConnection() as HttpURLConnection
                         } catch (e: Exception) {
                             Log.d("HotUpdater", "Failed to open connection: ${e.message}")
+                            tempDir.deleteRecursively()
                             return@withContext false
                         }
 
@@ -165,14 +174,11 @@ class HotUpdater : ReactPackage {
                         val totalSize = conn.contentLength
                         if (totalSize <= 0) {
                             Log.d("HotUpdater", "Invalid content length: $totalSize")
+                            tempDir.deleteRecursively()
                             return@withContext false
                         }
-
-                        val file = File(path)
-                        file.parentFile?.mkdirs()
-
                         conn.inputStream.use { input ->
-                            file.outputStream().use { output ->
+                            tempZipFile.outputStream().use { output ->
                                 val buffer = ByteArray(8 * 1024)
                                 var bytesRead: Int
                                 var totalRead = 0L
@@ -182,46 +188,91 @@ class HotUpdater : ReactPackage {
                                     output.write(buffer, 0, bytesRead)
                                     totalRead += bytesRead
                                     val currentTime = System.currentTimeMillis()
-                                    if (currentTime - lastProgressTime >= 100) { // Check every 100ms
+                                    if (currentTime - lastProgressTime >= 100) {
                                         val progress = totalRead.toDouble() / totalSize
                                         progressCallback.invoke(progress)
                                         lastProgressTime = currentTime
                                     }
                                 }
-                                // Send final progress (100%) after download completes
                                 progressCallback.invoke(1.0)
                             }
                         }
                     } catch (e: Exception) {
                         Log.d("HotUpdater", "Failed to download data from URL: $zipUrl, Error: ${e.message}")
+                        tempDir.deleteRecursively()
                         return@withContext false
                     } finally {
                         conn.disconnect()
                     }
 
-                    val extractedPath = File(path).parentFile?.path ?: return@withContext false
-
-                    if (!extractZipFileAtPath(path, extractedPath)) {
+                    if (!extractZipFileAtPath(tempZipFile.absolutePath, extractedDir.absolutePath)) {
                         Log.d("HotUpdater", "Failed to extract zip file.")
+                        tempDir.deleteRecursively()
                         return@withContext false
                     }
+                    true
+                }
 
-                    val extractedDirectory = File(extractedPath)
-                    val indexFile = extractedDirectory.walk().find { it.name == "index.android.bundle" }
+            if (!isSuccess) {
+                tempDir.deleteRecursively()
+                return false
+            }
 
-                    if (indexFile != null) {
-                        val bundlePath = indexFile.path
-                        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)
+
+            // 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()
                 }
-            return isSuccess
+            }
         }
     }
 }

package/dist/index.js

@@ -1689,14 +1689,13 @@ var __webpack_exports__ = {};
     const updateBundle = (bundleId, zipUrl)=>HotUpdaterNative.updateBundle(bundleId, zipUrl);
     const getAppVersion = ()=>HotUpdaterNative.getAppVersion();
     const reload = ()=>{
-        HotUpdaterNative.reload();
+        requestAnimationFrame(()=>{
+            HotUpdaterNative.reload();
+        });
     };
     const getBundleId = ()=>HotUpdater.HOT_UPDATER_BUNDLE_ID;
     async function checkForUpdate(config) {
-        if (__DEV__) {
-            console.warn("[HotUpdater] __DEV__ is true, HotUpdater is only supported in production");
-            return null;
-        }
+        if (__DEV__) return null;
         if (![
             "ios",
             "android"

package/dist/index.mjs

@@ -1658,14 +1658,13 @@ const addListener = (eventName, listener)=>{
 const updateBundle = (bundleId, zipUrl)=>HotUpdaterNative.updateBundle(bundleId, zipUrl);
 const getAppVersion = ()=>HotUpdaterNative.getAppVersion();
 const reload = ()=>{
-    HotUpdaterNative.reload();
+    requestAnimationFrame(()=>{
+        HotUpdaterNative.reload();
+    });
 };
 const getBundleId = ()=>HotUpdater.HOT_UPDATER_BUNDLE_ID;
 async function checkForUpdate(config) {
-    if (__DEV__) {
-        console.warn("[HotUpdater] __DEV__ is true, HotUpdater is only supported in production");
-        return null;
-    }
+    if (__DEV__) return null;
     if (![
         "ios",
         "android"

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/ios/HotUpdater/HotUpdater.mm

@@ -7,6 +7,9 @@
     bool hasListeners;
 }
 
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
 
 - (instancetype)init {
     self = [super init];
@@ -20,7 +23,6 @@ RCT_EXPORT_MODULE();
 
 #pragma mark - Bundle URL Management
 
-
 - (NSString *)getAppVersion {
     NSString *appVersion = [[NSBundle mainBundle] objectForInfoDictionaryKey:@"CFBundleShortVersionString"];
     return appVersion;
@@ -47,7 +49,6 @@ RCT_EXPORT_MODULE();
 }
 
 + (NSURL *)fallbackURL {
-    // This Support React Native 0.72.6
 #if DEBUG
     return [[RCTBundleURLProvider sharedSettings] jsBundleURLForBundleRoot:@"index"];
 #else
@@ -61,17 +62,6 @@ RCT_EXPORT_MODULE();
 
 #pragma mark - Utility Methods
 
-- (NSString *)convertFileSystemPathFromBasePath:(NSString *)basePath {
-    return [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject] stringByAppendingPathComponent:basePath];
-}
-
-- (NSString *)stripPrefixFromPath:(NSString *)prefix path:(NSString *)path {
-    if ([path hasPrefix:[NSString stringWithFormat:@"/%@/", prefix]]) {
-        return [path stringByReplacingOccurrencesOfString:[NSString stringWithFormat:@"/%@/", prefix] withString:@""];
-    }
-    return path;
-}
-
 - (BOOL)extractZipFileAtPath:(NSString *)filePath toDestination:(NSString *)destinationPath {
     NSError *error = nil;
     BOOL success = [SSZipArchive unzipFileAtPath:filePath toDestination:destinationPath overwrite:YES password:nil error:&error];
@@ -81,6 +71,50 @@ 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 {
     if (!zipUrl) {
         dispatch_async(dispatch_get_main_queue(), ^{
@@ -89,105 +123,182 @@ RCT_EXPORT_MODULE();
         });
         return;
     }
-
-    NSString *basePath = [self stripPrefixFromPath:bundleId path:[zipUrl path]];
-    NSString *path = [self convertFileSystemPathFromBasePath:basePath];
-
+    
+    // Set document directory path and bundle store path
+    NSString *documentsPath = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
+    NSString *bundleStoreDir = [documentsPath stringByAppendingPathComponent:@"bundle-store"];
+    
+    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];
-        NSError *folderError;
-
-        // Ensure directory exists
-        if (![fileManager createDirectoryAtPath:[path stringByDeletingLastPathComponent]
-                    withIntermediateDirectories:YES
-                                     attributes:nil
-                                          error:&folderError]) {
-            NSLog(@"Failed to create folder: %@", folderError);
-            if (completion) completion(NO);
-            return;
-        }
-
-        // Check if file already exists and remove it
-        if ([fileManager fileExistsAtPath:path]) {
-            NSError *removeError;
-            if (![fileManager removeItemAtPath:path error:&removeError]) {
-                NSLog(@"Failed to remove existing file: %@", removeError);
-                if (completion) completion(NO);
-                return;
-            }
+        
+        // Save temporary zip file
+        if ([fileManager fileExistsAtPath:tempZipFile]) {
+            [fileManager removeItemAtPath:tempZipFile error:nil];
         }
-
-        NSError *moveError;
-        if (![fileManager moveItemAtURL:location toURL:[NSURL fileURLWithPath:path] 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;
         }
-
-        NSString *extractedPath = [path stringByDeletingLastPathComponent];
-        if (![self extractZipFileAtPath:path toDestination:extractedPath]) {
+        
+        // Extract zip
+        if (![self extractZipFileAtPath:tempZipFile toDestination:extractedDir]) {
             NSLog(@"Failed to extract zip file.");
             if (completion) completion(NO);
             return;
         }
-
-        NSDirectoryEnumerator *enumerator = [fileManager enumeratorAtPath:extractedPath];
-        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 = [extractedPath 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];
     }];
+    
     [downloadTask resume];
+}
+
+#pragma mark - Folder Deletion Utility
 
+- (void)deleteFolderIfExists:(NSString *)path {
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if ([fileManager fileExistsAtPath:path]) {
+        NSError *error;
+        [fileManager removeItemAtPath:path error:&error];
+        if (error) {
+            NSLog(@"Failed to delete existing folder: %@", error);
+        } else {
+            NSLog(@"Successfully deleted existing folder: %@", path);
+        }
+    }
 }
 
 #pragma mark - Progress Updates
 
-
 - (void)removeObserversForTask:(NSURLSessionDownloadTask *)task {
     @try {
         if ([task observationInfo]) {
@@ -200,53 +311,41 @@ RCT_EXPORT_MODULE();
     }
 }
 
-
 - (void)observeValueForKeyPath:(NSString *)keyPath
                       ofObject:(id)object
                         change:(NSDictionary<NSKeyValueChangeKey, id> *)change
                        context:(void *)context {
     if ([keyPath isEqualToString:@"countOfBytesReceived"] || [keyPath isEqualToString:@"countOfBytesExpectedToReceive"]) {
         NSURLSessionDownloadTask *task = (NSURLSessionDownloadTask *)object;
-        
         if (task.countOfBytesExpectedToReceive > 0) {
             double progress = (double)task.countOfBytesReceived / (double)task.countOfBytesExpectedToReceive;
-            
-            // Get current timestamp
-            NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970] * 1000; // Convert to milliseconds
-            
-            // Send event only if 100ms has passed OR progress is 100%
+            NSTimeInterval currentTime = [[NSDate date] timeIntervalSince1970] * 1000; // In milliseconds
             if ((currentTime - self.lastUpdateTime) >= 100 || progress >= 1.0) {
-                self.lastUpdateTime = currentTime; // Update last event timestamp
-
-                // Send progress to React Native
+                self.lastUpdateTime = currentTime;
                 [self sendEventWithName:@"onProgress" body:@{@"progress": @(progress)}];
             }
         }
     }
 }
 
-
 #pragma mark - React Native Events
+
 - (NSArray<NSString *> *)supportedEvents {
     return @[@"onProgress"];
 }
 
-- (void)startObserving
-{
+- (void)startObserving {
     hasListeners = YES;
 }
 
-- (void)stopObserving
-{
+- (void)stopObserving {
     hasListeners = NO;
 }
 
-
 - (void)sendEventWithName:(NSString * _Nonnull)name result:(NSDictionary *)result {
     [self sendEventWithName:name body:result];
 }
 
-
 #pragma mark - React Native Exports
 
 RCT_EXPORT_METHOD(reload) {
@@ -257,8 +356,7 @@ RCT_EXPORT_METHOD(reload) {
     });
 }
 
-RCT_EXPORT_METHOD(getAppVersion:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
+RCT_EXPORT_METHOD(getAppVersion:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject) {
     NSString *version = [self getAppVersion];
     resolve(version ?: [NSNull null]);
 }
@@ -268,7 +366,6 @@ RCT_EXPORT_METHOD(updateBundle:(NSString *)bundleId zipUrl:(NSString *)zipUrlStr
     if (![zipUrlString isEqualToString:@""]) {
         zipUrl = [NSURL URLWithString:zipUrlString];
     }
-
     [self updateBundle:bundleId zipUrl:zipUrl completion:^(BOOL success) {
         dispatch_async(dispatch_get_main_queue(), ^{
             resolve(@[@(success)]);
@@ -276,14 +373,10 @@ RCT_EXPORT_METHOD(updateBundle:(NSString *)bundleId zipUrl:(NSString *)zipUrlStr
     }];
 }
 
-
-// Don't compile this code when we build for the old architecture.
 #ifdef RCT_NEW_ARCH_ENABLED
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-(const facebook::react::ObjCTurboModule::InitParams &)params
-{
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params {
     return std::make_shared<facebook::react::NativeHotUpdaterSpecJSI>(params);
 }
 #endif
 
-@end
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hot-updater/react-native",
-  "version": "0.10.2",
+  "version": "0.12.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.10.2",
-    "@hot-updater/core": "0.10.2"
+    "@hot-updater/js": "0.12.0",
+    "@hot-updater/core": "0.12.0"
   },
   "scripts": {
     "build": "rslib build",

package/src/checkUpdate.ts

@@ -12,9 +12,6 @@ export interface CheckForUpdateConfig {
 
 export async function checkForUpdate(config: CheckForUpdateConfig) {
   if (__DEV__) {
-    console.warn(
-      "[HotUpdater] __DEV__ is true, HotUpdater is only supported in production",
-    );
     return null;
   }
 

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.
  */
@@ -74,7 +74,9 @@ export const getAppVersion = (): Promise<string | null> => {
  * Reloads the app.
  */
 export const reload = () => {
-  HotUpdaterNative.reload();
+  requestAnimationFrame(() => {
+    HotUpdaterNative.reload();
+  });
 };
 
 /**